diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_gspo_token_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_gspo_token_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..25e3179209165d00b27dcb8dd45e483cdf3f4551 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_gspo_token_trainer.py @@ -0,0 +1,60 @@ +# Copyright 2020-2026 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 torch +from datasets import load_dataset +from transformers.utils import is_peft_available + +from trl import GRPOConfig +from trl.experimental.gspo_token import GRPOTrainer as GSPOTokenTrainer + +from ..testing_utils import TrlTestCase + + +if is_peft_available(): + pass + + +class TestGSPOTokenTrainer(TrlTestCase): + def test_train(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + num_iterations=2, # the importance sampling weights won't be 0 in this case + importance_sampling_level="sequence_token", + report_to="none", + ) + trainer = GSPOTokenTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_harbor.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_harbor.py new file mode 100644 index 0000000000000000000000000000000000000000..f59497c8062c2755dbe1064408a70d28be37f08c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_harbor.py @@ -0,0 +1,138 @@ +# Copyright 2020-2026 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. + +"""Tests for the Harbor x TRL integration that don't need a running Harbor sandbox. + +`harbor` is imported lazily (only when an env is *started*), so spec construction, agent resolution, dataset building, +and the reward function are all testable without `harbor` / a sandbox backend. +""" + +from pathlib import Path + +import pytest + +from trl.experimental.harbor import AGENTS, HarborBashEnv, HarborEnv, HarborSpec +from trl.experimental.harbor._spec import _outcome_reward_func, _resolve_agent + +from ..testing_utils import TrlTestCase + + +def _write_task(tasks_dir: Path, task_id: str, gold: str, difficulty: int) -> None: + d = tasks_dir / task_id + (d / "environment").mkdir(parents=True) + (d / "tests").mkdir() + (d / "instruction.md").write_text(f"Solve task {task_id}.") + # Built from a joined list (not a triple-quoted block) so doc-builder doesn't reflow the TOML. + lines = [ + "[task]", + f'name = "{task_id}"', + "[metadata]", + f'gold_answer = "{gold}"', + 'reward_mode_initial = "exact_short"', + f"difficulty_level = {difficulty}", + f'kaggle_dataset_name = "owner/{task_id}"', + ] + (d / "task.toml").write_text("\n".join(lines)) + + +class TestResolveAgent(TrlTestCase): + def test_builtin_name(self): + assert _resolve_agent("bash") is HarborBashEnv + assert AGENTS["bash"] is HarborBashEnv + + def test_class_passthrough(self): + assert _resolve_agent(HarborBashEnv) is HarborBashEnv + + def test_import_path(self): + assert _resolve_agent("trl.experimental.harbor:HarborBashEnv") is HarborBashEnv + + def test_file_path(self): + path = Path(self.tmp_dir) / "my_harness.py" + path.write_text( + "from trl.experimental.harbor import HarborEnv\n" + "class MyEnv(HarborEnv):\n" + " def run_cmd(self, command: str) -> str:\n" + " 'Run a command.\\n\\nArgs:\\n command: cmd.'\n" + " return self._exec(command)\n" + ) + cls = _resolve_agent(f"{path}:MyEnv") + assert issubclass(cls, HarborEnv) and cls.__name__ == "MyEnv" + + def test_unknown_name_raises(self): + with pytest.raises(ValueError): + _resolve_agent("not-a-harness") + + def test_non_harborenv_raises(self): + with pytest.raises(TypeError): + _resolve_agent("trl.experimental.harbor:HarborSpec") # not a HarborEnv subclass + + +class TestHarborSpecDataset(TrlTestCase): + def _suite(self) -> str: + tasks = Path(self.tmp_dir) / "tasks" + tasks.mkdir() + _write_task(tasks, "0001_a", "alpha", 0) + _write_task(tasks, "0002_b", "beta", 3) + return str(self.tmp_dir) + + def test_train_dataset_columns_and_metadata(self): + ds = HarborSpec(self._suite()).train_dataset + assert len(ds) == 2 + assert ds[0]["prompt"] == [{"role": "user", "content": ""}] # env appends instruction at reset + assert ds[0]["task_dir"].endswith("0001_a") + assert ds[0]["task_index"] == 0 + assert ds[0]["gold_answer"] == "alpha" + assert ds[1]["difficulty_level"] == 3 + + def test_num_tasks_cap(self): + ds = HarborSpec(self._suite(), num_tasks=1).train_dataset + assert len(ds) == 1 + + def test_indices_selection(self): + ds = HarborSpec(self._suite(), indices=[1]).train_dataset + assert len(ds) == 1 and ds[0]["task_dir"].endswith("0002_b") + + def test_num_tasks_and_indices_mutually_exclusive(self): + with pytest.raises(ValueError): + HarborSpec(self._suite(), num_tasks=1, indices=[0]) + + def test_environment_factory_returns_fresh_envs(self): + factory = HarborSpec(self._suite(), agent="bash").environment_factory + e1, e2 = factory(), factory() + assert isinstance(e1, HarborBashEnv) and e1 is not e2 + + +class TestRewardFunc(TrlTestCase): + def test_outcome_reward_reads_env_reward(self): + class _Env: + def __init__(self, r): + self.reward = r + + assert _outcome_reward_func([_Env(1.0), _Env(0.0)]) == [1.0, 0.0] + + def test_outcome_reward_uses_environment_reward_when_passed(self): + # AsyncGRPOTrainer captures rewards in its rollout worker and passes them as a list, with no + # live env instances. The reward func must use them directly. + assert _outcome_reward_func(environment_reward=[0.25, 0.75]) == [0.25, 0.75] + + def test_fresh_env_reward_is_zero_without_backend(self): + # The trainer discovers tool methods via `inspect.getmembers`, which evaluates properties. A fresh + # env (never `reset`) must expose its tools and return 0.0 from `reward` WITHOUT starting the + # Harbor backend or importing `harbor` (not installed in the trainer env). + import inspect + + env = HarborBashEnv() + names = {n for n, _ in inspect.getmembers(env, predicate=inspect.ismethod)} + assert {"bash", "reset"} <= names + assert env.reward == 0.0 diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_kto_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_kto_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..9ae94950b1ce22fb4a5de5093adc91f9d6490dad --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_kto_trainer.py @@ -0,0 +1,774 @@ +# Copyright 2020-2026 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 multiprocess +import pytest +import torch +import transformers +from datasets import Dataset, load_dataset +from packaging.version import Version +from transformers import AutoModelForCausalLM, AutoTokenizer + +from trl.experimental.kto import KTOConfig, KTOTrainer +from trl.experimental.kto.kto_trainer import ( + DataCollatorForUnpairedPreference, + DataCollatorForVisionUnpairedPreference, + _get_kl_completion_ids, +) + +from ..testing_utils import TrlTestCase, require_liger_kernel, require_peft, require_vision + + +@require_vision +class TestDataCollatorForVisionUnpairedPreference(TrlTestCase): + @pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="mm_token_type_ids are returned by default since transformers-5.3.0 (see transformers#43972)", + ) + def test_mm_token_type_ids_shape(self): + # Regression guard: when the processor returns mm_token_type_ids (Qwen2.5-VL after transformers#43972), + # the collator must produce a KL_completion_token_type_ids whose width matches KL_completion_input_ids, + # not the main completion's width (the two differ whenever their text lengths differ). + from PIL import Image + from transformers import AutoProcessor + + processor = AutoProcessor.from_pretrained("trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration") + collator = DataCollatorForVisionUnpairedPreference(processor, calculate_kl=True) + image = Image.new("RGB", (16, 16)) + examples = [ + { + "images": [image], + "prompt": [{"role": "user", "content": "What is this?"}], + "completion": [{"role": "assistant", "content": "A red square."}], + "label": True, + }, + { + "images": [image], + "prompt": [{"role": "user", "content": "Describe it."}], + "completion": [{"role": "assistant", "content": "An image."}], + "label": False, + }, + ] + output = collator(examples) + + assert "mm_token_type_ids" in output + assert output["mm_token_type_ids"].shape == output["completion_input_ids"].shape, ( + f"mm_token_type_ids shape {output['mm_token_type_ids'].shape} != " + f"completion_input_ids shape {output['completion_input_ids'].shape}" + ) + assert "KL_completion_mm_token_type_ids" in output + assert output["KL_completion_mm_token_type_ids"].shape == output["KL_completion_input_ids"].shape, ( + f"KL_completion_mm_token_type_ids shape {output['KL_completion_mm_token_type_ids'].shape} != " + f"KL_completion_input_ids shape {output['KL_completion_input_ids'].shape}" + ) + + def test_output_keys(self): + from PIL import Image + from transformers import AutoProcessor + + processor = AutoProcessor.from_pretrained("trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration") + image = Image.new("RGB", (16, 16)) + + def make_examples(): + return [ + { + "images": [image], + "prompt": [{"role": "user", "content": "What is this?"}], + "completion": [{"role": "assistant", "content": "A red square."}], + "label": True, + }, + { + "images": [image], + "prompt": [{"role": "user", "content": "Describe it."}], + "completion": [{"role": "assistant", "content": "An image."}], + "label": False, + }, + ] + + # With KL + collator = DataCollatorForVisionUnpairedPreference(processor, calculate_kl=True) + output = collator(make_examples()) + for key in ["completion_input_ids", "completion_attention_mask", "completion_mask", "pixel_values", "label"]: + assert key in output, f"Missing key: {key}" + for key in ["KL_completion_input_ids", "KL_completion_attention_mask", "KL_completion_mask"]: + assert key in output, f"Missing KL key: {key}" + + # Without KL + collator_no_kl = DataCollatorForVisionUnpairedPreference(processor, calculate_kl=False) + output_no_kl = collator_no_kl(make_examples()) + assert "completion_input_ids" in output_no_kl + assert "KL_completion_input_ids" not in output_no_kl + + def test_kl_cycling(self): + # The KL completion for example i must be the completion from example i-1 (cycled by +1). + from PIL import Image + from transformers import AutoProcessor + + processor = AutoProcessor.from_pretrained("trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration") + collator = DataCollatorForVisionUnpairedPreference(processor, calculate_kl=True) + image = Image.new("RGB", (16, 16)) + # Two distinct completions so that cycling is detectable + examples = [ + { + "images": [image], + "prompt": [{"role": "user", "content": "Q1"}], + "completion": [{"role": "assistant", "content": "Answer one."}], + "label": True, + }, + { + "images": [image], + "prompt": [{"role": "user", "content": "Q2"}], + "completion": [{"role": "assistant", "content": "Answer two."}], + "label": False, + }, + ] + output = collator(examples) + # KL completions are cycled: KL[0] = completion[-1], KL[1] = completion[0] + # They must differ from the matching main completion (unless both are identical strings, which they aren't here) + assert not torch.equal(output["completion_input_ids"][0], output["KL_completion_input_ids"][0]) + assert not torch.equal(output["completion_input_ids"][1], output["KL_completion_input_ids"][1]) + + +class TestDataCollatorForUnpairedPreference(TrlTestCase): + def test_padding_and_masks(self): + collator = DataCollatorForUnpairedPreference(pad_token_id=0) + examples = [ + {"prompt_ids": [1, 2, 3], "completion_ids": [4, 5], "KL_completion_ids": [6], "label": True}, + {"prompt_ids": [7, 8], "completion_ids": [9, 10], "KL_completion_ids": [11, 12, 13], "label": False}, + ] + result = collator(examples) + + expected_completion_input_ids = torch.tensor( + [ + [1, 2, 3, 4, 5], # prompt + completion (example 1) + [7, 8, 9, 10, 0], # prompt + completion (example 2, padded) + ] + ) + expected_completion_attention_mask = torch.tensor( + [ + [1, 1, 1, 1, 1], + [1, 1, 1, 1, 0], + ] + ) + expected_completion_mask = torch.tensor( + [ + [0, 0, 0, 1, 1], # completion (example 1) + [0, 0, 1, 1, 0], # completion (example 2, padded) + ] + ) + expected_kl_completion_input_ids = torch.tensor( + [ + [1, 2, 3, 6, 0], # prompt + KL completion (example 1, padded) + [7, 8, 11, 12, 13], # prompt + KL completion (example 2) + ] + ) + expected_kl_completion_attention_mask = torch.tensor( + [ + [1, 1, 1, 1, 0], + [1, 1, 1, 1, 1], + ] + ) + expected_kl_completion_mask = torch.tensor( + [ + [0, 0, 0, 1, 0], # KL completion (example 1, padded) + [0, 0, 1, 1, 1], # KL completion (example 2) + ] + ) + + assert set(result.keys()) == { + "completion_input_ids", + "completion_attention_mask", + "completion_mask", + "KL_completion_input_ids", + "KL_completion_attention_mask", + "KL_completion_mask", + "label", + } + torch.testing.assert_close(result["completion_input_ids"], expected_completion_input_ids) + torch.testing.assert_close(result["completion_attention_mask"], expected_completion_attention_mask) + torch.testing.assert_close(result["completion_mask"], expected_completion_mask) + torch.testing.assert_close(result["KL_completion_input_ids"], expected_kl_completion_input_ids) + torch.testing.assert_close(result["KL_completion_attention_mask"], expected_kl_completion_attention_mask) + torch.testing.assert_close(result["KL_completion_mask"], expected_kl_completion_mask) + assert result["label"] == [True, False] + + def test_optional_reference_logps(self): + collator = DataCollatorForUnpairedPreference(pad_token_id=0) + examples = [ + { + "prompt_ids": [1, 2], + "completion_ids": [3], + "KL_completion_ids": [4], + "ref_logps": 0.1, + "ref_KL_logps": 0.2, + "label": True, + }, + { + "prompt_ids": [5], + "completion_ids": [6, 7], + "KL_completion_ids": [8, 9], + "ref_logps": 0.3, + "ref_KL_logps": 0.4, + "label": False, + }, + ] + result = collator(examples) + + expected_ref_logps = torch.tensor([0.1, 0.3]) + expected_ref_kl_logps = torch.tensor([0.2, 0.4]) + + assert set(result.keys()) == { + "completion_input_ids", + "completion_attention_mask", + "completion_mask", + "KL_completion_input_ids", + "KL_completion_attention_mask", + "KL_completion_mask", + "ref_logps", + "ref_KL_logps", + "label", + } + torch.testing.assert_close(result["ref_logps"], expected_ref_logps) + torch.testing.assert_close(result["ref_KL_logps"], expected_ref_kl_logps) + + def test_with_pad_to_multiple_of(self): + collator = DataCollatorForUnpairedPreference(pad_token_id=0, pad_to_multiple_of=5) + examples = [ + {"prompt_ids": [1], "completion_ids": [2], "KL_completion_ids": [3], "label": True}, + {"prompt_ids": [4, 5], "completion_ids": [6, 7], "KL_completion_ids": [8, 9], "label": False}, + ] + result = collator(examples) + + expected_completion_input_ids = torch.tensor( + [ + [1, 2, 0, 0, 0], # prompt + completion (example 1, padded to multiple of 5) + [4, 5, 6, 7, 0], # prompt + completion (example 2) + ] + ) + expected_kl_completion_input_ids = torch.tensor( + [ + [1, 3, 0, 0, 0], # prompt + KL completion (example 1, padded to multiple of 5) + [4, 5, 8, 9, 0], # prompt + KL completion (example 2) + ] + ) + + assert set(result.keys()) == { + "completion_input_ids", + "completion_attention_mask", + "completion_mask", + "KL_completion_input_ids", + "KL_completion_attention_mask", + "KL_completion_mask", + "label", + } + torch.testing.assert_close(result["completion_input_ids"], expected_completion_input_ids) + torch.testing.assert_close(result["KL_completion_input_ids"], expected_kl_completion_input_ids) + + +class TestKTOTrainer(TrlTestCase): + def setup_method(self): + self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32") + self.ref_model = AutoModelForCausalLM.from_pretrained(self.model_id) + self.tokenizer = AutoTokenizer.from_pretrained(self.model_id) + self.tokenizer.pad_token = self.tokenizer.eos_token + + @pytest.mark.parametrize( + "config_name, loss_type, pre_compute, eval_dataset", + [ + ("standard_preference", "kto", True, True), + ("standard_unpaired_preference", "kto", False, True), + ("conversational_implicit_prompt_preference", "apo_zero_unpaired", True, True), + ("standard_unpaired_preference", "apo_zero_unpaired", False, True), + ], + ) + def test_kto_trainer(self, config_name, loss_type, pre_compute, eval_dataset): + training_args = KTOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + gradient_accumulation_steps=1, + learning_rate=9e-1, + eval_strategy="steps" if eval_dataset else "no", + beta=0.1, + precompute_ref_log_probs=pre_compute, + loss_type=loss_type, + report_to="none", + ) + + dataset = load_dataset("trl-internal-testing/zen", config_name) + + trainer = KTOTrainer( + model=self.model, + ref_model=self.ref_model, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset["train"], + eval_dataset=dataset["test"] if eval_dataset else None, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if param.sum() != 0: # ignore 0 biases + assert not torch.equal(param, new_param) + + def test_trust_remote_code(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train") + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + + with pytest.raises(ValueError, match="custom code"): + KTOTrainer( + model=model_id, + args=KTOConfig(output_dir=self.tmp_dir, report_to="none"), + train_dataset=dataset, + ) + + trainer = KTOTrainer( + model=model_id, + args=KTOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + train_dataset=dataset, + ) + assert type(trainer.model).__name__ == "RemoteForCausalLM" + + def test_kto_trainer_with_ref_model_is_model(self): + training_args = KTOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + report_to="none", + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train") + + with pytest.raises(ValueError): + KTOTrainer( + model=self.model, + ref_model=self.model, # ref_model can't be the same as model + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset, + ) + + def test_tokenize_and_process_tokens(self): + # Pytest/CI often starts background threads before tests run. Under Python 3.12+, + # using "fork" in a multi-threaded process emits a DeprecationWarning and may deadlock. + # Force "spawn" to keep this multiprocessing test safe while still exercising `num_proc=2`. + multiprocess.set_start_method("spawn", force=True) + + training_args = KTOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + gradient_accumulation_steps=1, + learning_rate=9e-1, + eval_strategy="steps", + beta=0.1, + report_to="none", + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference") + train_dataset = dataset["train"] + + trainer = KTOTrainer( + model=self.model, + ref_model=self.ref_model, + args=training_args, + processing_class=self.tokenizer, + train_dataset=train_dataset, + eval_dataset=dataset["test"], + ) + + # Verify the tokenization step: dataset stores raw token IDs (aligned with DPO style). + # prompt_ids must start with the tokenized prompt text. + prompt_ids = self.tokenizer(train_dataset["prompt"][0])["input_ids"] + assert trainer.train_dataset[0]["prompt_ids"][: len(prompt_ids)] == prompt_ids + # completion_ids are the raw answer tokens (no prompt prefix, no BOS/EOS added yet). + assert len(trainer.train_dataset[0]["completion_ids"]) > 0 + + # Verify the collator output (assembly, BOS/EOS insertion, labels). + example = trainer.train_dataset[0] + batch = trainer.data_collator([example]) + # completion_input_ids ends with EOS + assert batch["completion_input_ids"][0, -1].item() == self.tokenizer.eos_token_id + # completion_mask: prompt tokens are 0, completion tokens are 1; at least the prompt is masked + assert "completion_mask" in batch + completion_mask = batch["completion_mask"][0].tolist() + assert 0 in completion_mask and 1 in completion_mask + first_completion = next(i for i, m in enumerate(completion_mask) if m == 1) + assert first_completion > 0 # at least the prompt is masked + assert all(m == 0 for m in completion_mask[:first_completion]) + + # Test corruption of (prompt, completion) pairs for KL dataset. + # _get_kl_completion_ids shifts completion_ids by one within each batch; prompt_ids are unchanged. + synthetic = Dataset.from_dict( + { + "prompt_ids": [[1, 2], [3, 4], [5, 6]], + "completion_ids": [[10, 11], [20, 21], [30, 31]], + "label": [True, False, True], + } + ) + for batch_size in [2, 3]: + rotated = synthetic.map(_get_kl_completion_ids, batched=True, batch_size=batch_size) + + # Verify that completion_ids have been rotated (differ from original). When the dataset length + # modulo batch_size equals 1, the last batch is unaltered: exclude it from the check. + for i in range(len(rotated) - 1): + assert synthetic["prompt_ids"][i] == rotated["prompt_ids"][i] + assert synthetic["completion_ids"][i] != rotated["completion_ids"][i] + + def test_kto_trainer_without_providing_ref_model(self): + training_args = KTOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + gradient_accumulation_steps=4, + learning_rate=9e-1, + eval_strategy="steps", + beta=0.1, + report_to="none", + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference") + + trainer = KTOTrainer( + model=self.model, + ref_model=None, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if param.sum() != 0: # ignore 0 biases + assert not torch.equal(param, new_param) + + @require_peft + def test_kto_trainer_without_providing_ref_model_with_lora(self): + from peft import LoraConfig + + lora_config = LoraConfig( + r=16, + lora_alpha=32, + lora_dropout=0.05, + bias="none", + task_type="CAUSAL_LM", + ) + + training_args = KTOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + gradient_accumulation_steps=4, + learning_rate=9e-1, + eval_strategy="steps", + beta=0.1, + report_to="none", + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference") + + trainer = KTOTrainer( + model=self.model, + ref_model=None, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + peft_config=lora_config, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + if "lora" in n: + new_param = trainer.model.get_parameter(n) + if param.sum() != 0: # ignore 0 biases + assert not torch.equal(param, new_param) + + @require_liger_kernel + def test_kto_trainer_with_liger(self): + """Test KTO trainer with Liger kernel enabled.""" + training_args = KTOConfig( + output_dir=self.tmp_dir, + report_to="none", + use_liger_kernel=True, # Enable Liger kernel + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference", split="train") + + trainer = KTOTrainer( + model=self.model, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # check the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + # check the params have changed - ignore 0 biases + if param.sum() != 0: + assert not torch.equal(param, new_param) + + def test_compute_metrics(self): + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + ref_model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + tokenizer.pad_token = tokenizer.eos_token + + dataset = load_dataset("trl-internal-testing/zen", "standard_unpaired_preference") + + def dummy_compute_metrics(*args, **kwargs): + return {"test": 0.0} + + training_args = KTOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + do_eval=True, + eval_strategy="steps", + eval_steps=1, + per_device_eval_batch_size=2, + report_to="none", + ) + + trainer = KTOTrainer( + model=model, + ref_model=ref_model, + args=training_args, + processing_class=tokenizer, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + compute_metrics=dummy_compute_metrics, + ) + + trainer.train() + + assert trainer.state.log_history[-2]["eval_test"] == 0.0 + + +@require_vision +class TestKTOTrainerVLM(TrlTestCase): + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2VLForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + # "trl-internal-testing/tiny-SmolVLMForConditionalGeneration", seems not to support bf16 properly + pytest.param( + "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", + marks=[ + pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Qwen3-VL series were introduced in transformers-4.57.0", + ), + ], + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + ], + ) + def test_train_vlm(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train") + training_args = KTOConfig( + output_dir=self.tmp_dir, + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + report_to="none", + ) + trainer = KTOTrainer(model=model_id, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + # LLaVA & LLaVA-Next: vision_feature_layer=-2 leaves the last encoder layer (layers.1) and + # post_layernorm (pooler-only path) without gradient by design. Assert they stay frozen — if they + # ever start training, the feature-selection plumbing has likely regressed. + if model_id in ( + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + ) and ("encoder.layers.1" in n or "post_layernorm" in n): + assert torch.equal(param, new_param), f"Param {n} expected frozen by LLaVA design, but changed" + else: + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + def test_train_vlm_apo_zero_unpaired(self): + # apo_zero_unpaired does not need the KL term: verify that calculate_kl=False path works end-to-end. + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train") + training_args = KTOConfig( + output_dir=self.tmp_dir, + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + loss_type="apo_zero_unpaired", + report_to="none", + ) + trainer = KTOTrainer( + model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + args=training_args, + train_dataset=dataset, + ) + trainer.train() + assert trainer.state.log_history[-1]["train_loss"] is not None + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + @pytest.mark.parametrize( + "dataset_config", + ["conversational_unpaired_preference", "standard_unpaired_preference"], + ) + def test_train_vlm_text_only_data(self, model_id, dataset_config): + dataset = load_dataset("trl-internal-testing/zen", dataset_config, split="train") + training_args = KTOConfig(output_dir=self.tmp_dir, report_to="none") + trainer = KTOTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n.startswith("model.visual"): + torch.testing.assert_close(param, new_param, rtol=1e-12, atol=1e-12, msg=f"Param {n} is updated") + else: + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + def test_train_vlm_with_max_length(self): + # Regression test: mm_token_type_ids (and KL_completion_mm_token_type_ids) must be truncated alongside + # input_ids when max_length is set, otherwise a shape mismatch crashes the model forward pass. + # max_length=37 truncates 1 completion token (total_len=38) while keeping all image tokens (prompt_len=34) safe. + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train") + training_args = KTOConfig( + output_dir=self.tmp_dir, + max_length=37, # total_len=38, prompt_len=34 — truncates completion, not image tokens + per_device_train_batch_size=2, + report_to="none", + ) + trainer = KTOTrainer( + model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + args=training_args, + train_dataset=dataset, + ) + trainer.train() + assert trainer.state.log_history[-1]["train_loss"] is not None + + def test_vision_dataset_with_text_model_raises(self): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train") + training_args = KTOConfig(output_dir=self.tmp_dir, report_to="none") + with pytest.raises(ValueError, match="vision-related.*vision-language model"): + KTOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + def test_precompute_ref_log_probs_raises_for_vision(self): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train") + training_args = KTOConfig(output_dir=self.tmp_dir, report_to="none", precompute_ref_log_probs=True) + with pytest.raises(ValueError, match="precompute_ref_log_probs.*not supported for vision datasets"): + KTOTrainer( + model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + args=training_args, + train_dataset=dataset, + ) + + @require_liger_kernel + def test_train_vlm_liger(self): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train") + training_args = KTOConfig( + output_dir=self.tmp_dir, + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + use_liger_kernel=True, + report_to="none", + ) + trainer = KTOTrainer( + model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Param {n} is not updated" diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_merge_model_callback.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_merge_model_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..fb63ac40c448dc560f132933984d38ed77eb9fc3 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_merge_model_callback.py @@ -0,0 +1,84 @@ +# Copyright 2020-2026 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import os + +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoTokenizer +from transformers.trainer_utils import get_last_checkpoint + +from trl import DPOConfig, DPOTrainer +from trl.experimental.merge_model_callback import MergeConfig, MergeModelCallback + +from ..testing_utils import TrlTestCase, require_mergekit + + +@require_mergekit +class TestMergeModelCallback(TrlTestCase): + def setup_method(self): + self.model = AutoModelForCausalLM.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32" + ) + self.tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + self.dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + def test_callback(self): + training_args = DPOConfig( + output_dir=self.tmp_dir, + num_train_epochs=1, + report_to="none", + save_strategy="steps", + save_steps=1, + ) + config = MergeConfig() + merge_callback = MergeModelCallback(config) + trainer = DPOTrainer( + model=self.model, + args=training_args, + train_dataset=self.dataset, + processing_class=self.tokenizer, + callbacks=[merge_callback], + ) + trainer.train() + last_checkpoint = get_last_checkpoint(self.tmp_dir) + merged_path = os.path.join(last_checkpoint, "merged") + assert os.path.isdir(merged_path), "Merged folder does not exist in the last checkpoint." + + def test_every_checkpoint(self): + training_args = DPOConfig( + output_dir=self.tmp_dir, + num_train_epochs=1, + report_to="none", + save_strategy="steps", + save_steps=1, + ) + config = MergeConfig() + merge_callback = MergeModelCallback(config, merge_at_every_checkpoint=True) + trainer = DPOTrainer( + model=self.model, + args=training_args, + train_dataset=self.dataset, + processing_class=self.tokenizer, + callbacks=[merge_callback], + ) + trainer.train() + + checkpoints = sorted( + [os.path.join(self.tmp_dir, cp) for cp in os.listdir(self.tmp_dir) if cp.startswith("checkpoint-")] + ) + + for checkpoint in checkpoints: + merged_path = os.path.join(checkpoint, "merged") + assert os.path.isdir(merged_path), f"Merged folder does not exist in checkpoint {checkpoint}." diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_minillm_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_minillm_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..27b32af550453c05924d0e4e69cb59de715f029f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_minillm_trainer.py @@ -0,0 +1,52 @@ +# Copyright 2020-2026 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 pytest +import torch +from datasets import load_dataset + +from trl.experimental.minillm import MiniLLMConfig, MiniLLMTrainer + +from ..testing_utils import TrlTestCase + + +@pytest.mark.low_priority +class TestMiniLLMTrainer(TrlTestCase): + def test_train(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = MiniLLMConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=32, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = MiniLLMTrainer( + model="trl-internal-testing/small-Qwen3ForCausalLM", + teacher_model="trl-internal-testing/tiny-Qwen3ForCausalLM", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_modeling_value_head.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_modeling_value_head.py new file mode 100644 index 0000000000000000000000000000000000000000..f69570f093b133f4877feeead5de172f6b5158ac --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_modeling_value_head.py @@ -0,0 +1,112 @@ +# Copyright 2020-2026 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 torch + +from trl.experimental.ppo import AutoModelForCausalLMWithValueHead +from trl.experimental.utils import create_reference_model + +from ..testing_utils import TrlTestCase + + +class TestReferenceModel(TrlTestCase): + def setup_method(self): + self.model = AutoModelForCausalLMWithValueHead.from_pretrained("trl-internal-testing/tiny-GPT2LMHeadModel") + self.test_input = torch.tensor([[0, 1, 2, 3]]) + self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=1) + self.layer_format = "pretrained_model.transformer.h.{layer}.attn.c_attn.weight" + + def test_independent_reference(self): + layer_0 = self.layer_format.format(layer=0) + layer_1 = self.layer_format.format(layer=1) + + ref_model = create_reference_model(self.model) + + first_layer_before = self.model.get_parameter(layer_0).data.clone() + last_layer_before = self.model.get_parameter(layer_1).data.clone() # the model only has 2 layers + + first_ref_layer_before = ref_model.get_parameter(layer_0).data.clone() + last_ref_layer_before = ref_model.get_parameter(layer_1).data.clone() + + output = self.model(input_ids=self.test_input, labels=self.test_input) + output[1].backward() + self.optimizer.step() + + first_layer_after = self.model.get_parameter(layer_0).data.clone() + last_layer_after = self.model.get_parameter(layer_1).data.clone() + + first_ref_layer_after = ref_model.get_parameter(layer_0).data.clone() + last_ref_layer_after = ref_model.get_parameter(layer_1).data.clone() + + # before optimization ref and model are identical + assert (first_layer_before == first_ref_layer_before).all() + assert (last_layer_before == last_ref_layer_before).all() + + # ref model stays identical after optimization + assert (first_ref_layer_before == first_ref_layer_after).all() + assert (last_ref_layer_before == last_ref_layer_after).all() + + # optimized model changes + assert not (first_layer_before == first_layer_after).all() + assert not (last_layer_before == last_layer_after).all() + + def test_shared_layers(self): + layer_0 = self.layer_format.format(layer=0) + layer_1 = self.layer_format.format(layer=1) + + ref_model = create_reference_model(self.model, num_shared_layers=1) + + first_layer_before = self.model.get_parameter(layer_0).data.clone() + second_layer_before = self.model.get_parameter(layer_1).data.clone() + + first_ref_layer_before = ref_model.get_parameter(layer_0).data.clone() + second_ref_layer_before = ref_model.get_parameter(layer_1).data.clone() + + output = self.model(input_ids=self.test_input, labels=self.test_input) + output[1].backward() + self.optimizer.step() + + first_layer_after = self.model.get_parameter(layer_0).data.clone() + second_layer_after = self.model.get_parameter(layer_1).data.clone() + + first_ref_layer_after = ref_model.get_parameter(layer_0).data.clone() + second_ref_layer_after = ref_model.get_parameter(layer_1).data.clone() + + # before optimization ref and model are identical + assert (first_layer_before == first_ref_layer_before).all() + assert (second_layer_before == second_ref_layer_before).all() + + # ref model stays identical after optimization + assert (first_ref_layer_before == first_ref_layer_after).all() + assert (second_ref_layer_before == second_ref_layer_after).all() + + # first layer of optimized model stays the same + assert (first_layer_before == first_layer_after).all() + + # other layers in optimized model change + assert not (second_layer_before == second_layer_after).all() + + def test_shared_layers_share_memory(self): + # Shared layers must reference the same storage as the source model, not a `deepcopy` duplicate, + # so they are held in memory only once (see issue #2904). + layer_0 = self.layer_format.format(layer=0) + layer_1 = self.layer_format.format(layer=1) + + ref_model = create_reference_model(self.model, num_shared_layers=1) + + # the shared layer points at the same storage as the source model + assert ref_model.get_parameter(layer_0).data_ptr() == self.model.get_parameter(layer_0).data_ptr() + # an unshared layer is an independent copy + assert ref_model.get_parameter(layer_1).data_ptr() != self.model.get_parameter(layer_1).data_ptr() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_nash_md_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_nash_md_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..5c5496b3243d65c7ce0eff0474cb13b038175994 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_nash_md_trainer.py @@ -0,0 +1,195 @@ +# Copyright 2020-2026 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 pytest +import torch +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer, GenerationConfig +from transformers.utils import is_peft_available + +from trl.experimental.nash_md import NashMDConfig, NashMDTrainer +from trl.experimental.nash_md.nash_md_trainer import GeometricMixtureWrapper +from trl.experimental.utils import create_reference_model + +from ..testing_utils import TrlTestCase, require_peft + + +if is_peft_available(): + from peft import LoraConfig, get_peft_model + + +class TestGeometricMixtureWrapper(TrlTestCase): + def setup_method(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + self.device = "cuda" if torch.cuda.is_available() else "cpu" + self.model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32").to(self.device) + self.ref_model = create_reference_model(self.model).to(self.device) + self.generation_config = GenerationConfig.from_pretrained(model_id) + self.mixture_coef = 0.5 + self.wrapper = GeometricMixtureWrapper( + self.model, self.ref_model, self.generation_config, mixture_coef=self.mixture_coef + ) + + def test_forward(self): + input_ids = torch.tensor([[1, 2, 3, 4, 5]], device=self.device) + attention_mask = torch.ones_like(input_ids) + + output = self.wrapper(input_ids=input_ids, attention_mask=attention_mask) + + assert output is not None + assert hasattr(output, "logits") + assert output.logits.shape == (1, 5, self.model.config.vocab_size) + + def test_mixture_coefficient(self): + input_ids = torch.tensor([[1, 2, 3, 4, 5]], device=self.device) + attention_mask = torch.ones_like(input_ids) + + with torch.no_grad(): + model_output = self.model(input_ids=input_ids, attention_mask=attention_mask) + ref_model_output = self.ref_model(input_ids=input_ids, attention_mask=attention_mask) + wrapper_output = self.wrapper(input_ids=input_ids, attention_mask=attention_mask) + + expected_logits = torch.nn.functional.log_softmax( + self.mixture_coef * ref_model_output.logits + (1 - self.mixture_coef) * model_output.logits, dim=-1 + ) + + torch.testing.assert_close(wrapper_output.logits, expected_logits) + + def test_prepare_inputs_for_generation(self): + input_ids = torch.tensor([[1, 2, 3, 4, 5]], device=self.device) + attention_mask = torch.ones_like(input_ids) + + inputs = self.wrapper.prepare_inputs_for_generation(input_ids, attention_mask=attention_mask, use_cache=True) + + assert "input_ids" in inputs + assert "attention_mask" in inputs + assert not inputs.get("use_cache", False) + + +class TestNashMDTrainer(TrlTestCase): + def setup_method(self): + self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32") + self.ref_model = AutoModelForCausalLM.from_pretrained(self.model_id) + self.reward_model = AutoModelForSequenceClassification.from_pretrained(self.model_id, num_labels=1) + self.tokenizer = AutoTokenizer.from_pretrained(self.model_id) + self.tokenizer.pad_token = self.tokenizer.eos_token + + @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"]) + def test_nash_md_trainer_training(self, config_name): + training_args = NashMDConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + remove_unused_columns=False, + gradient_accumulation_steps=1, + learning_rate=9e-1, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", config_name, split="train") + + trainer = NashMDTrainer( + model=self.model, + ref_model=self.ref_model, + reward_funcs=self.reward_model, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset, + ) + + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + @require_peft + def test_train_with_peft(self): + lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM") + training_args = NashMDConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + learning_rate=5.0e-7, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = NashMDTrainer( + model=self.model, + reward_funcs=self.reward_model, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset, + peft_config=lora_config, + ) + + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + @require_peft + def test_train_with_peft_and_ref_model(self): + lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM") + training_args = NashMDConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + learning_rate=5.0e-7, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = NashMDTrainer( + model=self.model, + ref_model=self.ref_model, + reward_funcs=self.reward_model, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset, + peft_config=lora_config, + ) + + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + @require_peft + def test_train_pre_pefted_model_implicit_ref_with_reward_model(self): + lora_config = LoraConfig(r=8, lora_alpha=16, lora_dropout=0.1, bias="none", task_type="CAUSAL_LM") + # self.model from setUp is a base AutoModelForCausalLM + peft_model_instance = get_peft_model(self.model, lora_config) + + training_args = NashMDConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, # Keep small for quick test + max_steps=2, # Few steps + learning_rate=5.0e-7, + eval_strategy="no", + report_to="none", + remove_unused_columns=False, # Important for the dummy dataset + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = NashMDTrainer( + model=peft_model_instance, # Pass the already PEFT model + ref_model=None, # Implicit reference from peft_model_instance's base + reward_funcs=self.reward_model, # To trigger GeometricMixtureWrapper path + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset, + # peft_config is not passed, as model is already PEFT + ) + + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_online_dpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_online_dpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..355d20f272218df5626468afc89907bfad515e57 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_online_dpo_trainer.py @@ -0,0 +1,461 @@ +# Copyright 2020-2026 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 pytest +from datasets import Dataset, features, load_dataset +from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer +from transformers.utils import is_peft_available, is_vision_available + +from trl.experimental.online_dpo import OnlineDPOConfig, OnlineDPOTrainer + +from ..testing_utils import TrlTestCase, require_peft, require_torch_accelerator, require_vision, require_vllm + + +if is_peft_available(): + from peft import LoraConfig + +if is_vision_available(): + import numpy as np + from PIL import Image + from transformers import AutoModelForImageTextToText, AutoProcessor + + +class TestOnlineDPOTrainer(TrlTestCase): + def setup_method(self): + self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32") + self.ref_model = AutoModelForCausalLM.from_pretrained(self.model_id) + self.tokenizer = AutoTokenizer.from_pretrained(self.model_id) + self.tokenizer.pad_token = self.tokenizer.eos_token + + self.reward_model_id = "trl-internal-testing/tiny-LlamaForCausalLM-3.2" + self.reward_model = AutoModelForSequenceClassification.from_pretrained(self.reward_model_id, num_labels=1) + self.reward_tokenizer = AutoTokenizer.from_pretrained(self.reward_model_id) + self.reward_tokenizer.pad_token = self.reward_tokenizer.eos_token + + def test_trust_remote_code(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True) + + with pytest.raises(ValueError, match="custom code"): + OnlineDPOTrainer( + model=model_id, + reward_funcs=self.reward_model, + args=OnlineDPOConfig(output_dir=self.tmp_dir, report_to="none"), + train_dataset=dataset, + processing_class=tokenizer, + reward_processing_classes=self.reward_tokenizer, + ) + + trainer = OnlineDPOTrainer( + model=model_id, + reward_funcs=self.reward_model, + args=OnlineDPOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + train_dataset=dataset, + processing_class=tokenizer, + reward_processing_classes=self.reward_tokenizer, + ) + assert type(trainer.model).__name__ == "RemoteForCausalLM" + + @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"]) + def test_train(self, config_name): + training_args = OnlineDPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + learning_rate=5.0e-7, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", config_name, split="train") + + trainer = OnlineDPOTrainer( + model=self.model, + reward_funcs=self.reward_model, + args=training_args, + train_dataset=dataset, + processing_class=self.tokenizer, + reward_processing_classes=self.reward_tokenizer, + ) + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + def test_train_model_str(self): + training_args = OnlineDPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + learning_rate=5.0e-7, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = OnlineDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=self.reward_model, + args=training_args, + train_dataset=dataset, + processing_class=self.tokenizer, + reward_processing_classes=self.reward_tokenizer, + ) + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + def test_train_with_ref_model(self): + training_args = OnlineDPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + learning_rate=5.0e-7, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = OnlineDPOTrainer( + model=self.model, + ref_model=self.ref_model, + reward_funcs=self.reward_model, + args=training_args, + train_dataset=dataset, + processing_class=self.tokenizer, + reward_processing_classes=self.reward_tokenizer, + ) + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + def test_ref_model_is_model(self): + training_args = OnlineDPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + report_to="none", + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + with pytest.raises(ValueError): + OnlineDPOTrainer( + model=self.model, + ref_model=self.model, # ref_model can't be the same as model + reward_funcs=self.reward_model, + args=training_args, + train_dataset=dataset, + processing_class=self.tokenizer, + reward_processing_classes=self.reward_tokenizer, + ) + + @require_peft + def test_train_with_peft(self): + lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM") + training_args = OnlineDPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + learning_rate=5.0e-7, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = OnlineDPOTrainer( + model=self.model, + reward_funcs=self.reward_model, + args=training_args, + train_dataset=dataset, + processing_class=self.tokenizer, + reward_processing_classes=self.reward_tokenizer, + peft_config=lora_config, + ) + + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + @require_peft + def test_train_with_peft_and_ref_model(self): + lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM") + training_args = OnlineDPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + learning_rate=5.0e-7, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = OnlineDPOTrainer( + model=self.model, + ref_model=self.ref_model, + reward_funcs=self.reward_model, + args=training_args, + train_dataset=dataset, + processing_class=self.tokenizer, + reward_processing_classes=self.reward_tokenizer, + peft_config=lora_config, + ) + + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"]) + @require_torch_accelerator + @require_vllm + @pytest.mark.slow + def test_train_with_vllm_server(self, config_name): + def cleanup_vllm_communicator(trainer): + """Clean up vLLM communicator to avoid conflicts between test runs""" + try: + if hasattr(trainer, "vllm_client") and trainer.vllm_client is not None: + trainer.vllm_client.close_communicator() + except Exception: + pass # Continue if cleanup fails + + model_id = "trl-internal-testing/small-Qwen2ForCausalLM-2.5" # We need a bigger model + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + tokenizer = AutoTokenizer.from_pretrained(model_id) + tokenizer.pad_token = tokenizer.eos_token + + training_args = OnlineDPOConfig( + output_dir=self.tmp_dir, + use_vllm=True, + vllm_mode="server", + vllm_gpu_memory_utilization=0.2, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", config_name, split="train") + + trainer = OnlineDPOTrainer( + model=model, + reward_funcs=self.reward_model, + args=training_args, + train_dataset=dataset, + processing_class=tokenizer, + reward_processing_classes=self.reward_tokenizer, + ) + + # Ensure cleanup of vLLM communicator after the test + try: + trainer.train() + # Check if training loss is available + assert "train_loss" in trainer.state.log_history[-1] + finally: + cleanup_vllm_communicator(trainer) + + @require_vllm + def test_train_with_vllm_colocate(self): + """Test vLLM colocate mode with our refactored implementation""" + model_id = "trl-internal-testing/small-Qwen2ForCausalLM-2.5" # We need a bigger model + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + tokenizer = AutoTokenizer.from_pretrained(model_id) + tokenizer.pad_token = tokenizer.eos_token + + training_args = OnlineDPOConfig( + output_dir=self.tmp_dir, + use_vllm=True, + vllm_mode="colocate", + vllm_gpu_memory_utilization=0.2, + per_device_train_batch_size=1, + max_steps=2, + report_to="none", + # Test generation parameters + temperature=0.9, + top_p=0.95, + top_k=50, + repetition_penalty=1.1, + max_new_tokens=32, + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = OnlineDPOTrainer( + model=model, + reward_funcs=self.reward_model, + args=training_args, + train_dataset=dataset, + processing_class=tokenizer, + reward_processing_classes=self.reward_tokenizer, + ) + + # Verify vLLM setup + assert trainer.use_vllm + assert trainer.vllm_mode == "colocate" + assert trainer.llm is not None + # self.assertIsNone(trainer.vllm_client) + # self.assertEqual(trainer.vllm_gpu_memory_utilization, 0.2) + + # Verify generation parameters + assert trainer.temperature == 0.9 + assert trainer.top_p == 0.95 + assert trainer.top_k == 50 + assert trainer.repetition_penalty == 1.1 + + # Verify generation config + assert trainer.generation_config is not None + assert trainer.generation_config.temperature == 0.9 + assert trainer.generation_config.top_p == 0.95 + assert trainer.generation_config.top_k == 50 + assert trainer.generation_config.repetition_penalty == 1.1 + assert trainer.generation_config.max_tokens == 32 + + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + def test_vllm_config_validation(self): + """Test vLLM configuration validation""" + # Test valid vllm_mode values + config = OnlineDPOConfig(use_vllm=True, vllm_mode="server") + assert config.vllm_mode == "server" + + config = OnlineDPOConfig(use_vllm=True, vllm_mode="colocate") + assert config.vllm_mode == "colocate" + + # Test default values + config = OnlineDPOConfig() + assert config.vllm_mode == "colocate" + assert config.vllm_server_base_url is None + assert config.vllm_server_host == "0.0.0.0" + assert config.vllm_server_port == 8000 + assert config.vllm_server_timeout == 240.0 + assert config.vllm_gpu_memory_utilization == 0.55 + + # Test generation parameters + assert config.top_p == 1.0 + assert config.top_k == 0 + assert config.min_p is None + assert config.repetition_penalty == 1.0 + assert config.cache_implementation is None + assert config.generation_kwargs is None + + def test_generation_config_setup(self): + """Test that generation configuration is properly set up for both vLLM and transformers""" + training_args = OnlineDPOConfig( + output_dir=self.tmp_dir, + use_vllm=False, + temperature=0.8, + top_p=0.9, + top_k=40, + repetition_penalty=1.2, + max_new_tokens=64, + generation_kwargs={"do_sample": False}, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = OnlineDPOTrainer( + model=self.model, + reward_funcs=self.reward_model, + args=training_args, + train_dataset=dataset, + processing_class=self.tokenizer, + reward_processing_classes=self.reward_tokenizer, + ) + + # Verify transformers generation config + assert not trainer.use_vllm + # When not using vLLM, these attributes should not be set + assert not (hasattr(trainer, "llm") and trainer.llm is not None) + assert not (hasattr(trainer, "vllm_client") and trainer.vllm_client is not None) + assert trainer.generation_config is not None + assert trainer.generation_config.temperature == 0.8 + assert trainer.generation_config.top_p == 0.9 + assert trainer.generation_config.top_k == 40 + assert trainer.generation_config.repetition_penalty == 1.2 + assert trainer.generation_config.max_new_tokens == 64 + assert not trainer.generation_config.do_sample # From generation_kwargs + + @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"]) + def test_train_with_reward_funcs(self, config_name): + def simple_reward_func(prompts, completions, completion_ids, **kwargs): + return [0.5 for _ in prompts] + + training_args = OnlineDPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + learning_rate=5.0e-7, + reward_weights=[0.7, 0.3], + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", config_name, split="train") + + trainer = OnlineDPOTrainer( + model=self.model, + reward_funcs=[simple_reward_func, simple_reward_func], + args=training_args, + train_dataset=dataset, + processing_class=self.tokenizer, + ) + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + assert len(trainer.reward_funcs) == 2 + assert trainer.reward_weights is not None + assert round(abs(trainer.reward_weights[0].item() - 0.7), 5) == 0 + assert round(abs(trainer.reward_weights[1].item() - 0.3), 5) == 0 + + +@require_vision +class TestOnlineDPOVisionTrainer(TrlTestCase): + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Idefics2ForConditionalGeneration", + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + ], + ) + def test_online_dpo_vlm_trainer(self, model_id): + dataset_dict = { + "prompt": [ + [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "Describe the image."}]}], + [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What do you see?"}]}], + ], + "images": [ + [Image.fromarray(np.random.randint(0, 255, (64, 64, 3), dtype=np.uint8))], + [Image.fromarray(np.random.randint(0, 255, (64, 64, 3), dtype=np.uint8))], + ], + } + dataset = Dataset.from_dict(dataset_dict) + dataset = dataset.cast_column("images", features.Sequence(features.Image())) + + model = AutoModelForImageTextToText.from_pretrained(model_id, dtype="float32") + reward_model = AutoModelForSequenceClassification.from_pretrained( + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", num_labels=1 + ) + processor = AutoProcessor.from_pretrained(model_id) + reward_tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-LlamaForCausalLM-3.2") + reward_tokenizer.pad_token = reward_tokenizer.eos_token + + training_args = OnlineDPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, + max_steps=2, + learning_rate=0.01, + report_to="none", + ) + trainer = OnlineDPOTrainer( + model=model, + reward_funcs=reward_model, + args=training_args, + processing_class=processor, + train_dataset=dataset, + eval_dataset=dataset, + reward_processing_classes=reward_tokenizer, + ) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_openreward.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_openreward.py new file mode 100644 index 0000000000000000000000000000000000000000..0db62ae2ec8b18784551e7e15a4d1e8d5e3048c9 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_openreward.py @@ -0,0 +1,252 @@ +# Copyright 2020-2026 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. + +"""Tests for `trl.experimental.openreward`. + +A class-scoped fixture spawns ``_openreward_echo_env.py`` as a uvicorn subprocess on a free port and points the +openreward SDK at it via the ``OPENREWARD_API_URL`` / ``OPENREWARD_SESSION_URL`` overrides. Tests then exercise the +adapter end-to-end against real HTTP — no mocks, no network. + +The same env definition is published at ``trl-internal-testing/openreward-echo-env`` if you want to point at the hosted +Space directly. +""" + +import os +import socket +import subprocess +import sys +import time +from pathlib import Path + +import pytest +import requests + +from trl.experimental.openreward import OpenRewardSpec + +from ..testing_utils import TrlTestCase, require_openreward + + +_HERE = Path(__file__).parent +_ECHO_ENV_SCRIPT = _HERE / "_openreward_echo_env.py" + + +def _free_port() -> int: + with socket.socket() as s: + s.bind(("127.0.0.1", 0)) + return s.getsockname()[1] + + +@pytest.fixture(scope="class") +def echo_env_url(): + """Spawn the echo env on a free port; tear down on teardown.""" + port = _free_port() + proc = subprocess.Popen( + [sys.executable, str(_ECHO_ENV_SCRIPT)], + env={**os.environ, "PORT": str(port)}, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + url = f"http://127.0.0.1:{port}" + deadline = time.time() + 30.0 + while time.time() < deadline: + try: + r = requests.get(f"{url}/health", timeout=1.0) + if r.status_code == 200: + break + except requests.RequestException: + pass + time.sleep(0.2) + else: + proc.terminate() + raise RuntimeError(f"echo env did not become ready at {url}") + + # The openreward SDK by default rewrites base_url into api. / + # sessions.; for a single-host self-hosted server these env vars + # bypass that two-subdomain layout. + saved = {k: os.environ.get(k) for k in ("OPENREWARD_API_URL", "OPENREWARD_SESSION_URL", "OPENREWARD_API_KEY")} + os.environ["OPENREWARD_API_URL"] = url + os.environ["OPENREWARD_SESSION_URL"] = url + os.environ.setdefault("OPENREWARD_API_KEY", "test") + + yield url + + for k, v in saved.items(): + if v is None: + os.environ.pop(k, None) + else: + os.environ[k] = v + proc.terminate() + try: + proc.wait(timeout=5.0) + except subprocess.TimeoutExpired: + proc.kill() + + +@require_openreward +@pytest.mark.usefixtures("echo_env_url") +class TestOpenRewardSpec(TrlTestCase): + """Exercises the public `OpenRewardSpec` surface against a real ORS server.""" + + def test_construction_is_lazy(self, echo_env_url): + # Construction must not perform any HTTP — `train_dataset` / + # `environment_factory` are `cached_property` and only fire on access. + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2) + # Touching only private attributes should not have hit the network. + assert spec._target == echo_env_url + assert spec._is_url is True + assert spec._num_tasks == 2 + + def test_train_dataset_derives_from_env(self, echo_env_url): + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2) + ds = spec.train_dataset + assert len(ds) == 2 + assert "prompt" in ds.column_names + assert "task_index" in ds.column_names + # Per-task metadata folded in (id, target) when include_metadata=True. + assert "target" in ds.column_names + assert ds[0]["task_index"] == 0 + assert ds[0]["target"] == "hello" + assert ds[1]["target"] == "world" + + def test_train_dataset_with_indices(self, echo_env_url): + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", indices=[0, 2]) + ds = spec.train_dataset + assert [row["target"] for row in ds] == ["hello", "trl"] + + def test_num_tasks_and_indices_are_mutually_exclusive(self, echo_env_url): + with pytest.raises(ValueError): + OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2, indices=[0]) + + def test_environment_factory_returns_rollout_env_with_bound_tools(self, echo_env_url): + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2) + env = spec.environment_factory() + # Shared + task-scoped ORS tools (ORS /tools vs /task_tools) are both bound for GRPO. + assert callable(env.echo) + sig = env.echo.__annotations__ + assert sig["text"] is str + assert sig["return"] is str + assert callable(env.hint) + + def test_discover_task_tools_false_skips_task_scoped_binding(self, echo_env_url): + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1, discover_task_tools=False) + env = spec.environment_factory() + assert callable(env.echo) + assert not hasattr(env, "hint") + + def test_reset_returns_prompt_and_opens_session(self, echo_env_url): + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1) + env = spec.environment_factory() + prompt = env.reset(**spec.train_dataset[0]) + assert "echo" in prompt and "hello" in prompt + env._close() + + def test_correct_echo_returns_match_with_reward_and_finished(self, echo_env_url): + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1) + env = spec.environment_factory() + env.reset(**spec.train_dataset[0]) + out = env.echo(text="hello") + assert "match" in out + assert env.reward == 1.0 + assert env.finished is True + env._close() + + def test_wrong_echo_returns_no_match_with_zero_reward(self, echo_env_url): + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1) + env = spec.environment_factory() + env.reset(**spec.train_dataset[0]) + out = env.echo(text="goodbye") + assert "no match" in out + assert env.reward == 0.0 + assert env.finished is False + env._close() + + def test_reward_func_reads_last_non_null_per_environment(self, echo_env_url): + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2) + env_a = spec.environment_factory() + env_b = spec.environment_factory() + env_a.reset(**spec.train_dataset[0]) + env_b.reset(**spec.train_dataset[1]) + env_a.echo(text="hello") # match → reward=1.0 + env_b.echo(text="oops") # no match → reward=0.0 + rewards = spec.reward_funcs(environments=[env_a, env_b]) + assert rewards == [1.0, 0.0] + env_a._close() + env_b._close() + + def test_factory_produces_isolated_sessions(self, echo_env_url): + # GRPO opens N concurrent envs; mutating one must not leak into another. + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=2) + env_a = spec.environment_factory() + env_b = spec.environment_factory() + env_a.reset(**spec.train_dataset[0]) + env_b.reset(**spec.train_dataset[1]) + env_a.echo(text="hello") + assert env_a.reward == 1.0 + assert env_b.reward == 0.0 # untouched + env_a._close() + env_b._close() + + def test_metadata_does_not_overwrite_reserved_columns(self, echo_env_url): + # If a task spec ever shipped a `prompt` key, the metadata loop must + # not clobber our chat-format `prompt` column. Same for `task_index`. + # We assert the shape directly — the echo env's task spec doesn't + # currently have either, but the guard is what we're testing. + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1) + ds = spec.train_dataset + # `prompt` is a list-of-message-dicts, not a string from task spec. + assert isinstance(ds[0]["prompt"], list) + assert ds[0]["prompt"][0]["role"] == "user" + # `task_index` is the int we set, not anything from the spec. + assert isinstance(ds[0]["task_index"], int) + + def test_task_tools_discovery_index_probes_single_task(self, echo_env_url): + # task_tools_discovery_index=0 tells the spec to probe only task 0 for + # tool discovery (ORS /task_tools), regardless of how many tasks are in + # the dataset. This is the Toolathlon pattern: all tasks expose the same + # meta-tools, so probing one is sufficient and avoids N sessions. + spec = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=4, task_tools_discovery_index=0) + env = spec.environment_factory() + # Shared tool (echo) and task-specific tool (hint) are both bound. + assert callable(env.echo) + assert callable(env.hint) + # Dataset still has 4 tasks even though discovery only probed index 0. + assert len(spec.train_dataset) == 4 + env._close() + + def test_task_tools_discovery_index_with_indices(self, echo_env_url): + # When indices= is set AND task_tools_discovery_index is set, discovery + # uses only the explicit discovery index (not all indices for probing). + spec = OpenRewardSpec( + echo_env_url, env_name="echoenvironment", indices=[0, 1, 2, 3], task_tools_discovery_index=2 + ) + env = spec.environment_factory() + # Task tools are still discovered (via index 2). + assert callable(env.hint) + assert len(spec.train_dataset) == 4 + env._close() + + def test_two_specs_get_isolated_rollout_subclasses(self, echo_env_url): + # Two specs (potentially against different envs with different tool + # sets) must each produce rollout instances with their own subclass, + # so neither side's bound tools clobber or shadow the other's. + spec_a = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1) + spec_b = OpenRewardSpec(echo_env_url, env_name="echoenvironment", num_tasks=1) + env_a = spec_a.environment_factory() + env_b = spec_b.environment_factory() + # Each rollout is a distinct subclass of _RolloutEnvironment. + assert type(env_a) is not type(env_b) + # Both subclasses still get their own `echo` method. + assert callable(env_a.echo) and callable(env_b.echo) + env_a._close() + env_b._close() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_orpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_orpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..cf07073b06d2329dbc7ac0fdcf656061f7087a08 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_orpo_trainer.py @@ -0,0 +1,198 @@ +# Copyright 2020-2026 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 pytest +import torch +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer + +from trl.experimental.orpo import ORPOConfig, ORPOTrainer + +from ..testing_utils import TrlTestCase, require_peft + + +class TestORPOTrainer(TrlTestCase): + def setup_method(self): + self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32") + self.tokenizer = AutoTokenizer.from_pretrained(self.model_id) + self.tokenizer.pad_token = self.tokenizer.eos_token + + # get t5 as seq2seq example: + model_id = "trl-internal-testing/tiny-T5ForConditionalGeneration" + self.t5_model = AutoModelForSeq2SeqLM.from_pretrained(model_id, dtype="float32") + self.t5_tokenizer = AutoTokenizer.from_pretrained(model_id) + + def test_trust_remote_code(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True) + + with pytest.raises(ValueError, match="custom code"): + ORPOTrainer( + model=model_id, + args=ORPOConfig(output_dir=self.tmp_dir, report_to="none"), + processing_class=tokenizer, + train_dataset=dataset, + ) + + trainer = ORPOTrainer( + model=model_id, + args=ORPOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + processing_class=tokenizer, + train_dataset=dataset, + ) + assert type(trainer.model).__name__ == "RemoteForCausalLM" + + @pytest.mark.parametrize( + "name, config_name", + [ + ("qwen", "standard_preference"), + ("t5", "standard_implicit_prompt_preference"), + ("qwen", "conversational_preference"), + ], + ) + def test_orpo_trainer(self, name, config_name): + training_args = ORPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + remove_unused_columns=False, + gradient_accumulation_steps=1, + learning_rate=9e-1, + eval_strategy="steps", + beta=0.1, + report_to="none", + ) + + dataset = load_dataset("trl-internal-testing/zen", config_name) + + if name == "qwen": + model = self.model + tokenizer = self.tokenizer + elif name == "t5": + model = self.t5_model + tokenizer = self.t5_tokenizer + training_args.is_encoder_decoder = True + + trainer = ORPOTrainer( + model=model, + args=training_args, + processing_class=tokenizer, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if param.sum() != 0: # ignore 0 biases + assert not torch.equal(param, new_param) + + @pytest.mark.parametrize( + "config_name", + [ + "standard_preference", + "standard_implicit_prompt_preference", + "conversational_preference", + "conversational_implicit_prompt_preference", + ], + ) + @require_peft + def test_orpo_trainer_with_lora(self, config_name): + from peft import LoraConfig + + lora_config = LoraConfig( + r=16, + lora_alpha=32, + lora_dropout=0.05, + bias="none", + task_type="CAUSAL_LM", + ) + + training_args = ORPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + remove_unused_columns=False, + gradient_accumulation_steps=4, + learning_rate=9e-1, + eval_strategy="steps", + beta=0.1, + report_to="none", + ) + + dataset = load_dataset("trl-internal-testing/zen", config_name) + + trainer = ORPOTrainer( + model=self.model, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + peft_config=lora_config, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + if "lora" in n: + new_param = trainer.model.get_parameter(n) + if param.sum() != 0: # ignore 0 biases + assert not torch.equal(param, new_param) + + def test_compute_metrics(self): + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + tokenizer.pad_token = tokenizer.eos_token + + dataset = load_dataset("trl-internal-testing/zen", "standard_preference") + + def dummy_compute_metrics(*args, **kwargs): + return {"test": 0.0} + + training_args = ORPOConfig( + output_dir=self.tmp_dir, + remove_unused_columns=False, + per_device_train_batch_size=2, + do_eval=True, + eval_strategy="steps", + eval_steps=1, + per_device_eval_batch_size=2, + report_to="none", + ) + + trainer = ORPOTrainer( + model=model, + args=training_args, + processing_class=tokenizer, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + compute_metrics=dummy_compute_metrics, + ) + + trainer.train() + + assert trainer.state.log_history[-2]["eval_test"] == 0.0 diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_ppo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_ppo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..45a0e0b60bf5e1ebe7068b7305161aceb6b88755 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_ppo_trainer.py @@ -0,0 +1,829 @@ +# Copyright 2020-2026 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 gc +import os + +import pytest +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoModelForSeq2SeqLM, + AutoModelForSequenceClassification, + AutoTokenizer, + GenerationConfig, +) +from transformers.utils import is_peft_available + +from trl.experimental.ppo import ( + AutoModelForCausalLMWithValueHead, + AutoModelForSeq2SeqLMWithValueHead, + PPOConfig, + PPOTrainer, +) +from trl.experimental.ppo.ppo_trainer import batch_generation, masked_mean, masked_var, masked_whiten + +from ..testing_utils import ( + TrlTestCase, + require_bitsandbytes, + require_peft, + require_torch_gpu_if_bnb_not_multi_backend_enabled, +) + + +if is_peft_available(): + from peft import LoraConfig, get_peft_model + + +ALL_CAUSAL_LM_MODELS = [ + "trl-internal-testing/tiny-BloomForCausalLM", + "trl-internal-testing/tiny-CohereForCausalLM", + # "trl-internal-testing/tiny-FalconMambaForCausalLM", # FalconMambaForCausalLM modeling seems to be broken for now + "trl-internal-testing/tiny-Gemma2ForCausalLM", + "trl-internal-testing/tiny-GemmaForCausalLM", + "trl-internal-testing/tiny-GPT2LMHeadModel", + "trl-internal-testing/tiny-GPTNeoXForCausalLM", + "trl-internal-testing/tiny-LlamaForCausalLM-3.1", + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-LlamaForCausalLM-3", + "trl-internal-testing/tiny-MistralForCausalLM-0.1", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + "trl-internal-testing/tiny-OPTForCausalLM", + "trl-internal-testing/tiny-Phi3ForCausalLM-3", + "trl-internal-testing/tiny-Phi3ForCausalLM-3.5", + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", +] + +ALL_SEQ2SEQ_MODELS = [ + "trl-internal-testing/tiny-T5ForConditionalGeneration", + "trl-internal-testing/tiny-BartModel", +] + + +class TestBatchGeneration(TrlTestCase): + def setup_method(self): + # Initialize the tokenizer + self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + self.device = "cuda" if torch.cuda.is_available() else "cpu" + self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32").to(self.device) + self.tokenizer = AutoTokenizer.from_pretrained(self.model_id) + + self.generation_config = GenerationConfig( + max_new_tokens=128, + temperature=0.5, + do_sample=True, + top_k=0, + pad_token_id=self.tokenizer.pad_token_id, + ) + + # Example input + dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train") + self.examples = dataset["messages"] + self.mini_batch_size = 3 + + def test_mini_batch_generation(self): + batch = [ + self.tokenizer.apply_chat_template(example[:-1], add_generation_prompt=True, tokenize=False) + for example in self.examples + ] + queries = self.tokenizer(batch, padding=True, return_tensors="pt")["input_ids"].to(self.device) + bs, context_length = queries.shape + + query_responses, logits = batch_generation( + self.model, queries, self.mini_batch_size, self.tokenizer.pad_token_id, self.generation_config + ) + + max_length_query = query_responses.shape[1] + max_length_logits = max_length_query - context_length + + assert max_length_query > context_length + assert query_responses.shape == (bs, max_length_query) + assert logits.shape == (bs, max_length_logits, self.model.config.vocab_size) + + def test_single_batch_generation(self): + batch = [ + self.tokenizer.apply_chat_template(example[:-1], add_generation_prompt=True, tokenize=False) + for example in self.examples + ] + queries = self.tokenizer(batch, padding=True, return_tensors="pt")["input_ids"].to(self.device) + bs, context_length = queries.shape + + query_responses, logits = batch_generation( + self.model, queries, bs, self.tokenizer.pad_token_id, self.generation_config + ) + + max_length_query = query_responses.shape[1] + max_length_logits = max_length_query - context_length + + assert max_length_query > context_length + assert query_responses.shape == (bs, max_length_query) + assert logits.shape == (bs, max_length_logits, self.model.config.vocab_size) + + +class BaseTester: + class VHeadModelTester(TrlTestCase): + all_model_names = None + trl_model_class = None + transformers_model_class = None + + def setup_method(self): + self.device = "cuda" if torch.cuda.is_available() else "cpu" + + def test_value_head(self): + r""" + Test if the v-head is added to the model successfully + """ + for model_name in self.all_model_names: + model = self.trl_model_class.from_pretrained(model_name) + assert hasattr(model, "v_head") + + def test_value_head_shape(self): + r""" + Test if the v-head has the correct shape + """ + for model_name in self.all_model_names: + model = self.trl_model_class.from_pretrained(model_name) + assert model.v_head.summary.weight.shape[0] == 1 + + def test_value_head_init_random(self): + r""" + Test if the v-head has been randomly initialized. We can check that by making sure the bias is different + than zeros by default. + """ + for model_name in self.all_model_names: + model = self.trl_model_class.from_pretrained(model_name) + assert not torch.allclose(model.v_head.summary.bias, torch.zeros_like(model.v_head.summary.bias)) + + def test_value_head_not_str(self): + r""" + Test if the v-head is added to the model successfully, by passing a non `PretrainedModel` as an argument to + `from_pretrained`. + """ + for model_name in self.all_model_names: + pretrained_model = self.transformers_model_class.from_pretrained(model_name) + model = self.trl_model_class.from_pretrained(pretrained_model) + assert hasattr(model, "v_head") + + def test_from_save_trl(self): + """ + Test if the model can be saved and loaded from a directory and get the same weights, including the + additional modules (e.g. v_head) + """ + for model_name in self.all_model_names: + model = self.trl_model_class.from_pretrained(model_name) + + model.save_pretrained(self.tmp_dir) + + model_from_save = self.trl_model_class.from_pretrained(self.tmp_dir) + + # Check if the weights are the same + for key in model_from_save.state_dict(): + torch.testing.assert_close(model_from_save.state_dict()[key], model.state_dict()[key]) + + def test_from_save_trl_sharded(self): + """ + Test if the model can be saved and loaded from a directory and get the same weights - sharded case + """ + for model_name in self.all_model_names: + model = self.trl_model_class.from_pretrained(model_name) + + model.save_pretrained(self.tmp_dir) + + model_from_save = self.trl_model_class.from_pretrained(self.tmp_dir) + + # Check if the weights are the same + for key in model_from_save.state_dict(): + torch.testing.assert_close(model_from_save.state_dict()[key], model.state_dict()[key]) + + def test_from_save_transformers_sharded(self): + """ + Test if the model can be saved and loaded using transformers and get the same weights - sharded case + """ + for model_name in self.all_model_names: + transformers_model = self.trl_model_class.transformers_parent_class.from_pretrained(model_name) + + trl_model = self.trl_model_class.from_pretrained(model_name) + + trl_model.save_pretrained(self.tmp_dir, max_shard_size="1MB") + transformers_model_from_save = self.trl_model_class.transformers_parent_class.from_pretrained( + self.tmp_dir + ) + + # Check if the weights are the same + for key in transformers_model.state_dict(): + torch.testing.assert_close( + transformers_model_from_save.state_dict()[key], transformers_model.state_dict()[key] + ) + + def test_from_save_transformers(self): + """ + Test if the model can be saved and loaded using transformers and get the same weights. We override the test + of the super class to check if the weights are the same. + """ + for model_name in self.all_model_names: + transformers_model = self.trl_model_class.transformers_parent_class.from_pretrained(model_name) + + trl_model = self.trl_model_class.from_pretrained(model_name) + + trl_model.save_pretrained(self.tmp_dir) + transformers_model_from_save = self.trl_model_class.transformers_parent_class.from_pretrained( + self.tmp_dir + ) + + # Check if the weights are the same + for key in transformers_model.state_dict(): + torch.testing.assert_close( + transformers_model_from_save.state_dict()[key], transformers_model.state_dict()[key] + ) + + # Check if the trl model has the same keys as the transformers model + # except the v_head + for key in trl_model.state_dict(): + if "v_head" not in key: + assert key in transformers_model.state_dict() + # check if the weights are the same + torch.testing.assert_close(trl_model.state_dict()[key], transformers_model.state_dict()[key]) + + # check if they have the same modules + assert set(transformers_model_from_save.state_dict().keys()) == set( + transformers_model.state_dict().keys() + ) + + +class TestCausalLMValueHeadModel(BaseTester.VHeadModelTester, TrlTestCase): + """ + Testing suite for v-head models. + """ + + all_model_names = ALL_CAUSAL_LM_MODELS + trl_model_class = AutoModelForCausalLMWithValueHead + transformers_model_class = AutoModelForCausalLM + + def teardown_method(self): + # free memory + gc.collect() + + def test_inference(self): + r""" + Test if the model can be used for inference and outputs 3 values + - logits, loss, and value states + """ + EXPECTED_OUTPUT_SIZE = 3 + + for model_name in self.all_model_names: + model = self.trl_model_class.from_pretrained(model_name).to(self.device) + input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device) + outputs = model(input_ids) + + # Check if the outputs are of the right size - here + # we always output 3 values - logits, loss, and value states + assert len(outputs) == EXPECTED_OUTPUT_SIZE + + def test_dropout_config(self): + r""" + Test if we instantiate a model by adding `summary_drop_prob` to the config it will be added to the v_head + """ + for model_name in self.all_model_names: + pretrained_model = self.transformers_model_class.from_pretrained(model_name) + pretrained_model.config.summary_dropout_prob = 0.5 + model = self.trl_model_class.from_pretrained(pretrained_model) + + # Check if v head of the model has the same dropout as the config + assert model.v_head.dropout.p == pretrained_model.config.summary_dropout_prob + + def test_dropout_kwargs(self): + r""" + Test if we instantiate a model by adding `summary_drop_prob` to the config it will be added to the v_head + """ + for model_name in self.all_model_names: + v_head_kwargs = {"summary_dropout_prob": 0.5} + + model = self.trl_model_class.from_pretrained(model_name, **v_head_kwargs) + + # Check if v head of the model has the same dropout as the config + assert model.v_head.dropout.p == 0.5 + + model = self.trl_model_class.from_pretrained(model_name, summary_dropout_prob=0.5) + + # Check if v head of the model has the same dropout as the config + assert model.v_head.dropout.p == 0.5 + + @pytest.mark.parametrize("model_name", ALL_CAUSAL_LM_MODELS) + def test_generate(self, model_name): + r""" + Test if `generate` works for every model + """ + generation_config = GenerationConfig(max_new_tokens=9) + model = self.trl_model_class.from_pretrained(model_name).to(self.device) + input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device) + + # Just check if the generation works + _ = model.generate(input_ids, generation_config=generation_config) + + def test_transformers_bf16_kwargs(self): + r""" + Test if the transformers kwargs are correctly passed. Here we check that loading a model in half precision + works as expected, i.e. the weights of the `pretrained_model` attribute is loaded in half precision and you can + run a dummy forward pass without any issue. + """ + for model_name in self.all_model_names: + trl_model = self.trl_model_class.from_pretrained(model_name, dtype=torch.bfloat16).to(self.device) + + lm_head_namings = ["lm_head", "embed_out", "output_layer"] + + assert any(hasattr(trl_model.pretrained_model, lm_head_naming) for lm_head_naming in lm_head_namings), ( + "Can't test the model because it doesn't have any of the expected lm_head namings" + ) + + for lm_head_naming in lm_head_namings: + if hasattr(trl_model.pretrained_model, lm_head_naming): + assert getattr(trl_model.pretrained_model, lm_head_naming).weight.dtype == torch.bfloat16 + + dummy_input = torch.LongTensor([[0, 1, 0, 1]]).to(self.device) + + # check dummy forward pass works in half precision + _ = trl_model(dummy_input) + + @pytest.mark.skip(reason="This test needs to be run manually due to HF token issue.") + def test_push_to_hub(self): + for model_name in self.all_model_names: + model = AutoModelForCausalLMWithValueHead.from_pretrained(model_name) + if "sharded" in model_name: + model.push_to_hub(model_name + "-ppo", use_auth_token=True, max_shard_size="1MB") + else: + model.push_to_hub(model_name + "-ppo", use_auth_token=True) + + model_from_pretrained = AutoModelForCausalLMWithValueHead.from_pretrained(model_name + "-ppo") + # check all keys + assert model.state_dict().keys() == model_from_pretrained.state_dict().keys() + + for name, param in model.state_dict().items(): + ( + torch.testing.assert_close(param, model_from_pretrained.state_dict()[name]), + (f"Parameter {name} is not the same after push_to_hub and from_pretrained"), + ) + + +class TestSeq2SeqValueHeadModel(BaseTester.VHeadModelTester, TrlTestCase): + """ + Testing suite for v-head models. + """ + + all_model_names = ALL_SEQ2SEQ_MODELS + trl_model_class = AutoModelForSeq2SeqLMWithValueHead + transformers_model_class = AutoModelForSeq2SeqLM + + def teardown_method(self): + # free memory + gc.collect() + + def test_inference(self): + r""" + Test if the model can be used for inference and outputs 3 values + - logits, loss, and value states + """ + EXPECTED_OUTPUT_SIZE = 3 + + for model_name in self.all_model_names: + model = self.trl_model_class.from_pretrained(model_name).to(self.device) + input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device) + decoder_input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device) + outputs = model(input_ids, decoder_input_ids=decoder_input_ids) + + # Check if the outputs are of the right size - here + # we always output 3 values - logits, loss, and value states + assert len(outputs) == EXPECTED_OUTPUT_SIZE + + def test_dropout_config(self): + r""" + Test if we instantiate a model by adding `summary_drop_prob` to the config it will be added to the v_head + """ + for model_name in self.all_model_names: + pretrained_model = self.transformers_model_class.from_pretrained(model_name) + pretrained_model.config.summary_dropout_prob = 0.5 + model = self.trl_model_class.from_pretrained(pretrained_model) + + # Check if v head of the model has the same dropout as the config + assert model.v_head.dropout.p == pretrained_model.config.summary_dropout_prob + + def test_dropout_kwargs(self): + r""" + Test if we instantiate a model by adding `summary_drop_prob` to the config it will be added to the v_head + """ + for model_name in self.all_model_names: + v_head_kwargs = {"summary_dropout_prob": 0.5} + + model = self.trl_model_class.from_pretrained(model_name, **v_head_kwargs) + + # Check if v head of the model has the same dropout as the config + assert model.v_head.dropout.p == 0.5 + + model = self.trl_model_class.from_pretrained(model_name, summary_dropout_prob=0.5) + + # Check if v head of the model has the same dropout as the config + assert model.v_head.dropout.p == 0.5 + + @pytest.mark.parametrize("model_name", ALL_SEQ2SEQ_MODELS) + def test_generate(self, model_name): + r""" + Test if `generate` works for every model + """ + generation_config = GenerationConfig(max_new_tokens=9) + model = self.trl_model_class.from_pretrained(model_name).to(self.device) + input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device) + decoder_input_ids = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], device=self.device) + + # Just check if the generation works + _ = model.generate(input_ids, decoder_input_ids=decoder_input_ids, generation_config=generation_config) + + @pytest.mark.skip(reason="This test needs to be run manually due to HF token issue.") + def test_push_to_hub(self): + for model_name in self.all_model_names: + model = self.trl_model_class.from_pretrained(model_name) + if "sharded" in model_name: + model.push_to_hub(model_name + "-ppo", use_auth_token=True, max_shard_size="1MB") + else: + model.push_to_hub(model_name + "-ppo", use_auth_token=True) + + model_from_pretrained = self.trl_model_class.from_pretrained(model_name + "-ppo") + # check all keys + assert model.state_dict().keys() == model_from_pretrained.state_dict().keys() + + for name, param in model.state_dict().items(): + ( + torch.testing.assert_close(param, model_from_pretrained.state_dict()[name]), + (f"Parameter {name} is not the same after push_to_hub and from_pretrained"), + ) + + def test_transformers_bf16_kwargs(self): + r""" + Test if the transformers kwargs are correctly passed. Here we check that loading a model in half precision + works as expected, i.e. the weights of the `pretrained_model` attribute is loaded in half precision and you can + run a dummy forward pass without any issue. + """ + for model_name in self.all_model_names: + trl_model = self.trl_model_class.from_pretrained(model_name, dtype=torch.bfloat16).to(self.device) + + lm_head_namings = self.trl_model_class.lm_head_namings + + assert any(hasattr(trl_model.pretrained_model, lm_head_naming) for lm_head_naming in lm_head_namings) + + for lm_head_naming in lm_head_namings: + if hasattr(trl_model.pretrained_model, lm_head_naming): + assert getattr(trl_model.pretrained_model, lm_head_naming).weight.dtype == torch.bfloat16 + + dummy_input = torch.LongTensor([[0, 1, 0, 1]]).to(self.device) + + # check dummy forward pass works in half precision + _ = trl_model(input_ids=dummy_input, decoder_input_ids=dummy_input) + + +@require_peft +class TestPeftModel(TrlTestCase): + def setup_method(self): + self.causal_lm_model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + self.lora_config = LoraConfig( + r=16, + lora_alpha=32, + lora_dropout=0.05, + bias="none", + task_type="CAUSAL_LM", + ) + + def test_create_peft_model(self): + r""" + Simply creates a peft model and checks that it can be loaded. + """ + causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id) + pretrained_model = get_peft_model(causal_lm_model, self.lora_config) + + _ = AutoModelForCausalLMWithValueHead.from_pretrained(pretrained_model) + + def test_peft_requires_grad(self): + r""" + Check that the value head of the returned model has requires_grad=True. + """ + causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id) + pretrained_model = get_peft_model(causal_lm_model, self.lora_config) + + model = AutoModelForCausalLMWithValueHead.from_pretrained(pretrained_model) + + # Check that the value head has requires_grad=True + assert model.v_head.summary.weight.requires_grad + + def test_check_peft_model_nb_trainable_params(self): + r""" + Check that the number of trainable parameters is correct. + """ + causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id) + pretrained_model = get_peft_model(causal_lm_model, self.lora_config) + + model = AutoModelForCausalLMWithValueHead.from_pretrained(pretrained_model) + + # Check that the number of trainable parameters is correct + nb_trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad) + assert nb_trainable_params == 905 + + # Check that the number of trainable param for the non-peft model is correct + non_peft_model = AutoModelForCausalLMWithValueHead.from_pretrained(self.causal_lm_model_id) + nb_trainable_params = sum(p.numel() for p in non_peft_model.parameters() if p.requires_grad) + assert nb_trainable_params == 2428641 + + def test_create_peft_model_from_config(self): + r""" + Simply creates a peft model and checks that it can be loaded. + """ + trl_model = AutoModelForCausalLMWithValueHead.from_pretrained( + self.causal_lm_model_id, peft_config=self.lora_config + ) + # Check that the number of trainable parameters is correct + nb_trainable_params = sum(p.numel() for p in trl_model.parameters() if p.requires_grad) + assert nb_trainable_params == 905 + + causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id) + trl_model = AutoModelForCausalLMWithValueHead.from_pretrained(causal_lm_model, peft_config=self.lora_config) + # Check that the number of trainable parameters is correct + nb_trainable_params = sum(p.numel() for p in trl_model.parameters() if p.requires_grad) + assert nb_trainable_params == 905 + + @require_bitsandbytes + @require_torch_gpu_if_bnb_not_multi_backend_enabled + def test_create_bnb_peft_model_from_config(self): + r""" + Simply creates a peft model and checks that it can be loaded. + """ + from bitsandbytes.nn import Linear8bitLt + from transformers import BitsAndBytesConfig + + trl_model = AutoModelForCausalLMWithValueHead.from_pretrained( + self.causal_lm_model_id, + peft_config=self.lora_config, + quantization_config=BitsAndBytesConfig(load_in_8bit=True), + ) + # Check that the number of trainable parameters is correct + nb_trainable_params = sum(p.numel() for p in trl_model.parameters() if p.requires_grad) + assert nb_trainable_params == 905 + assert isinstance(trl_model.pretrained_model.model.model.layers[0].mlp.gate_proj, Linear8bitLt) + + causal_lm_model = AutoModelForCausalLM.from_pretrained( + self.causal_lm_model_id, quantization_config=BitsAndBytesConfig(load_in_8bit=True), device_map="auto" + ) + trl_model = AutoModelForCausalLMWithValueHead.from_pretrained(causal_lm_model, peft_config=self.lora_config) + # Check that the number of trainable parameters is correct + nb_trainable_params = sum(p.numel() for p in trl_model.parameters() if p.requires_grad) + assert nb_trainable_params == 905 + assert isinstance(trl_model.pretrained_model.model.model.layers[0].mlp.gate_proj, Linear8bitLt) + + def test_save_pretrained_peft(self): + r""" + Check that the model can be saved and loaded properly. + """ + causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id) + pretrained_model = get_peft_model(causal_lm_model, self.lora_config) + + model = AutoModelForCausalLMWithValueHead.from_pretrained(pretrained_model) + + model.save_pretrained(self.tmp_dir) + + # check that the files `adapter_model.safetensors` and `adapter_config.json` are in the directory + assert os.path.isfile(f"{self.tmp_dir}/adapter_model.safetensors"), ( + f"{self.tmp_dir}/adapter_model.safetensors does not exist" + ) + assert os.path.exists(f"{self.tmp_dir}/adapter_config.json"), ( + f"{self.tmp_dir}/adapter_config.json does not exist" + ) + + # check also for `pytorch_model.bin` and make sure it only contains `v_head` weights + assert os.path.exists(f"{self.tmp_dir}/pytorch_model.bin"), f"{self.tmp_dir}/pytorch_model.bin does not exist" + + # check that only keys that starts with `v_head` are in the dict + maybe_v_head = torch.load(f"{self.tmp_dir}/pytorch_model.bin", weights_only=True) + assert all(k.startswith("v_head") for k in maybe_v_head.keys()), ( + f"keys in {self.tmp_dir}/pytorch_model.bin do not start with `v_head`" + ) + + model_from_pretrained = AutoModelForCausalLMWithValueHead.from_pretrained(self.tmp_dir) + + # check all the weights are the same + for p1, p2 in zip(model.named_parameters(), model_from_pretrained.named_parameters(), strict=True): + torch.testing.assert_close(p1[1], p2[1], msg=f"{p1[0]} != {p2[0]}") + + def test_load_pretrained_peft(self): + r""" + Check that the model saved with peft class interface can be loaded properly. + """ + causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id) + pretrained_model = get_peft_model(causal_lm_model, self.lora_config) + + model = AutoModelForCausalLMWithValueHead.from_pretrained(pretrained_model) + + pretrained_model.save_pretrained(self.tmp_dir) + model_from_pretrained = AutoModelForCausalLMWithValueHead.from_pretrained(self.tmp_dir) + + # check that the files `adapter_model.safetensors` and `adapter_config.json` are in the directory + assert os.path.isfile(f"{self.tmp_dir}/adapter_model.safetensors"), ( + f"{self.tmp_dir}/adapter_model.safetensors does not exist" + ) + assert os.path.exists(f"{self.tmp_dir}/adapter_config.json"), ( + f"{self.tmp_dir}/adapter_config.json does not exist" + ) + + # check all the weights are the same + for p1, p2 in zip(model.named_parameters(), model_from_pretrained.named_parameters(), strict=True): + if p1[0] not in ["v_head.summary.weight", "v_head.summary.bias"]: + torch.testing.assert_close(p1[1], p2[1], msg=f"{p1[0]} != {p2[0]}") + + def test_continue_training_peft_model(self): + r""" + Load peft and checks that it can continue training. + """ + causal_lm_model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id) + pretrained_model = get_peft_model(causal_lm_model, self.lora_config) + + pretrained_model.save_pretrained(self.tmp_dir) + # set is_trainable to True + model = AutoModelForCausalLMWithValueHead.from_pretrained(self.tmp_dir, is_trainable=True) + # Check that the number of trainable parameters is correct + nb_trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad) + assert nb_trainable_params == 905 + + +class TestCore(TrlTestCase): + """ + A wrapper class for testing core utils functions + """ + + def setup_method(self): + self.test_input = torch.Tensor([1, 2, 3, 4]) + self.test_mask = torch.Tensor([0, 1, 1, 0]) + self.test_input_unmasked = self.test_input[1:3] + + def test_masked_mean(self): + assert torch.mean(self.test_input_unmasked) == masked_mean(self.test_input, self.test_mask) + + def test_masked_var(self): + assert torch.var(self.test_input_unmasked) == masked_var(self.test_input, self.test_mask) + + def test_masked_whiten(self): + def whiten(values: torch.Tensor) -> torch.Tensor: + mean, var = torch.mean(values), torch.var(values) + return (values - mean) * torch.rsqrt(var + 1e-8) + + whiten_unmasked = whiten(self.test_input_unmasked) + whiten_masked = masked_whiten(self.test_input, self.test_mask)[1:3] + diffs = (whiten_unmasked - whiten_masked).sum() + assert abs(diffs.item()) < 0.00001 + + +class TestPPOTrainer(TrlTestCase): + def setup_method(self): + # Set up the models and tokenizer using the test model + self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32") + self.ref_model = AutoModelForCausalLM.from_pretrained(self.model_id) + self.tokenizer = AutoTokenizer.from_pretrained(self.model_id, padding_side="left") + self.tokenizer.add_special_tokens({"pad_token": "[PAD]"}) + + # Add reward and value models as in ppo.py + reward_model_id = "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5" + self.value_model = AutoModelForSequenceClassification.from_pretrained(reward_model_id, num_labels=1) + self.reward_model = AutoModelForSequenceClassification.from_pretrained(reward_model_id, num_labels=1) + + # Load dataset + raw_dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only") + + def tokenize(example, tokenizer): + tokenized = tokenizer(text=example["prompt"]) + if tokenizer.eos_token_id is not None and tokenized["input_ids"][-1] != tokenizer.eos_token_id: + tokenized["input_ids"] = tokenized["input_ids"] + [tokenizer.eos_token_id] + tokenized["attention_mask"] = tokenized["attention_mask"] + [1] + return tokenized + + self.raw_dataset = raw_dataset.map(tokenize, fn_kwargs={"tokenizer": self.tokenizer}, remove_columns="prompt") + + def test_basic_training(self): + """Test basic PPO training configuration and verify model updates.""" + # Capture initial weights + initial_critic_weights = {} + initial_policy_weights = {} + for name, param in self.value_model.named_parameters(): + initial_critic_weights[name] = param.clone().detach() + for name, param in self.model.named_parameters(): + initial_policy_weights[name] = param.clone().detach() + + # Configure training args similar to example script + training_args = PPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=4, + per_device_eval_batch_size=2, + num_ppo_epochs=2, # Decrease number of PPO epochs to speed up test + report_to="none", + ) + + # Create trainer + trainer = PPOTrainer( + args=training_args, + processing_class=self.tokenizer, + model=self.model, + ref_model=self.ref_model, + reward_model=self.reward_model, + value_model=self.value_model, + train_dataset=self.raw_dataset["train"], + eval_dataset=self.raw_dataset["test"], + ) + + # Train + trainer.train() + + # Check if critic weights have been updated + critic_weights_updated = False + for name, param in trainer.model.value_model.named_parameters(): + if not torch.equal(initial_critic_weights[name], param.to("cpu")): + critic_weights_updated = True + break + + # Check if policy weights have been updated + policy_weights_updated = False + for name, param in trainer.model.policy.named_parameters(): + if not torch.equal(initial_policy_weights[name], param.to("cpu")): + policy_weights_updated = True + break + + assert critic_weights_updated, "Critic weights were not updated during training" + assert policy_weights_updated, "Policy weights were not updated during training" + + @require_peft + def test_peft_training(self): + """Test PPO training with PEFT configuration and verify model updates.""" + # Capture initial weights + initial_critic_weights = {} + initial_policy_weights = {} + for name, param in self.value_model.named_parameters(): + initial_critic_weights[name] = param.clone().detach() + for name, param in self.model.named_parameters(): + initial_policy_weights[name] = param.clone().detach() + + # Configure training args + training_args = PPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=4, + per_device_eval_batch_size=2, + num_ppo_epochs=2, # Decrease number of PPO epochs to speed up test + report_to="none", + ) + + # Configure PEFT + peft_config = LoraConfig( + r=32, + lora_alpha=16, + lora_dropout=0.05, + bias="none", + task_type="CAUSAL_LM", + ) + + # Create trainer with PEFT + trainer = PPOTrainer( + args=training_args, + processing_class=self.tokenizer, + model=self.model, + ref_model=None, + reward_model=self.reward_model, + value_model=self.value_model, + train_dataset=self.raw_dataset["train"], + eval_dataset=self.raw_dataset["test"], + peft_config=peft_config, + ) + + # Train + trainer.train() + + # Check if critic weights have been updated + critic_weights_updated = False + for name, param in trainer.model.value_model.named_parameters(): + if name in initial_critic_weights and not torch.equal(initial_critic_weights[name], param.to("cpu")): + critic_weights_updated = True + break + + # Check if policy weights have been updated - for PEFT we check the LoRA weights + policy_weights_updated = False + for name, param in trainer.model.policy.named_parameters(): + if "lora" in name.lower() and param.requires_grad: # Only check LoRA weights + # New weights should be non-zero if they've been updated + if not torch.allclose(param, torch.zeros_like(param)): + policy_weights_updated = True + break + + assert critic_weights_updated, "Critic weights were not updated during training" + assert policy_weights_updated, "Policy LoRA weights were not updated during training" diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_prm_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_prm_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..fa139e28da9d5dfc83d09d3dd88fb269530fcbe7 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_prm_trainer.py @@ -0,0 +1,376 @@ +# Copyright 2020-2026 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. + +from unittest.mock import MagicMock + +import numpy as np +import pytest +import torch +from datasets import Dataset, load_dataset +from transformers import AutoModelForTokenClassification, AutoTokenizer, PreTrainedTokenizerBase +from transformers.utils import is_peft_available + +from trl.experimental.prm import PRMConfig, PRMTrainer +from trl.experimental.prm.prm_trainer import compute_accuracy + +from ..testing_utils import TrlTestCase, require_peft + + +if is_peft_available(): + from peft import LoraConfig, TaskType + + +class TestComputeAccuracy(TrlTestCase): + def test_token_classification_task(self): + eval_pred = ( + np.array( + [ + [[0.1, 0.9], [0.8, 0.2]], # Batch 1 + [[0.3, 0.7], [0.6, 0.4]], # Batch 2 + ] + ), + np.array([[0, 1], [1, 0]]), + ) + expected_accuracy = 0.5 # 2 matches, 2 mismatches + result = compute_accuracy(eval_pred) + assert round(abs(result["accuracy"] - expected_accuracy), 7) == 0 + + def test_token_classification_task_with_ignored_tokens_0(self): + eval_pred = ( + np.array( + [ + [[0.1, 0.9], [0.8, 0.2]], # Batch 1 + [[0.3, 0.7], [0.6, 0.4]], # Batch 2 + ] + ), + np.array([[1, 0], [1, -100]]), + ) + expected_accuracy = 1.0 # All non-ignored tokens match + result = compute_accuracy(eval_pred) + assert round(abs(result["accuracy"] - expected_accuracy), 7) == 0 + + def test_token_classification_task_with_ignored_tokens_1(self): + eval_pred = ( + np.array( + [ + [[0.1, 0.9], [0.8, 0.2]], # Batch 1 + [[0.3, 0.7], [0.6, 0.4]], # Batch 2 + ] + ), + np.array([[1, 1], [0, -100]]), + ) + expected_accuracy = 1 / 3 # 1 match, 2 mismatch, 1 ignored + result = compute_accuracy(eval_pred) + assert round(abs(result["accuracy"] - expected_accuracy), 7) == 0 + + def test_rewards_comparison_task(self, caplog): + eval_pred = ( + np.array( + [ + [0.9, 0.1], # Batch 1 + [0.6, 0.4], # Batch 2 + [0.5, 0.5], # Batch 3 (equal) + ] + ), + np.array([0, 1, 1]), + ) + expected_accuracy = 0.5 # 1 match, 1 mismatch, 1 equal (ignored) + + with caplog.at_level("WARNING", logger="trl.trainer.utils"): + result = compute_accuracy(eval_pred) + + assert round(abs(result["accuracy"] - expected_accuracy), 7) == 0 + expected_warning = ( + "There are 1 out of 3 instances where the predictions for both options are equal. " + "These instances are ignored in the accuracy computation." + ) + assert expected_warning in caplog.text + + +class TestTokenizeRow(TrlTestCase): + def setup_method(self): + # Set up the mock tokenizer with specific behaviors + self.tokenizer = MagicMock(spec=PreTrainedTokenizerBase) + self.tokenizer.bos_token_id = 0 + self.tokenizer.eos_token_id = 2 + + def mock_encode(text, add_special_tokens): + token_map = { + "Which number is larger, 9.8 or 9.11?": [465, 6766, 318, 298], + "11 is greater than 8.": [4, 322, 12], + "Hence, 9.11 > 9.8.": [4995, 11, 22], + "\n": [1030], + "\n\n": [1030, 1030], + } + + return token_map[text] + + def mock_tokenizer_call(text, add_special_tokens): + return {"input_ids": mock_encode(text, add_special_tokens)} + + self.tokenizer.encode.side_effect = mock_encode + self.tokenizer.side_effect = mock_tokenizer_call + + def test_tokenize_row_no_truncation(self): + # Define the input features + features = { + "prompt": "Which number is larger, 9.8 or 9.11?", + "completions": ["11 is greater than 8.", "Hence, 9.11 > 9.8."], + "labels": [True, False], + } + + # Call the method with no truncation + result = PRMTrainer.tokenize_row( + features=features, + tokenizer=self.tokenizer, + step_separator="\n", + max_length=None, + max_completion_length=None, + train_on_last_step_only=False, + is_eval=False, + ) + + assert result == { + "input_ids": [0, 465, 6766, 318, 298, 4, 322, 12, 1030, 4995, 11, 22, 1030], + "labels": [-100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100, -100, 0], + } + + def test_tokenize_row_train_on_last_step_only(self): + # Define the input features + features = { + "prompt": "Which number is larger, 9.8 or 9.11?", + "completions": ["11 is greater than 8.", "Hence, 9.11 > 9.8."], + "labels": [True, False], + } + + result = PRMTrainer.tokenize_row( + features=features, + tokenizer=self.tokenizer, + step_separator="\n", + max_length=None, + max_completion_length=None, + train_on_last_step_only=True, + is_eval=False, + ) + + assert result == { + "input_ids": [0, 465, 6766, 318, 298, 4, 322, 12, 1030, 4995, 11, 22, 1030], + "labels": [-100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, 0], + } + + def test_tokenize_row_completion_truncation(self): + # Define the input features + features = { + "prompt": "Which number is larger, 9.8 or 9.11?", + "completions": ["11 is greater than 8.", "Hence, 9.11 > 9.8."], + "labels": [True, False], + } + + # Call the method with truncation on the completion + result = PRMTrainer.tokenize_row( + features=features, + tokenizer=self.tokenizer, + step_separator="\n", + max_length=None, + max_completion_length=6, + train_on_last_step_only=False, + is_eval=False, + ) + + assert result == { + "input_ids": [0, 465, 6766, 318, 298, 4, 322, 12, 1030, 4995, 11], + "labels": [-100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100], + } + + def test_tokenize_row_prompt_completion_truncation(self): + # Define the input features + features = { + "prompt": "Which number is larger, 9.8 or 9.11?", + "completions": ["11 is greater than 8.", "Hence, 9.11 > 9.8."], + "labels": [True, False], + } + + # Call the method with truncation on the prompt and completion + result = PRMTrainer.tokenize_row( + features=features, + tokenizer=self.tokenizer, + step_separator="\n", + max_length=9, + max_completion_length=None, + train_on_last_step_only=False, + is_eval=False, + ) + + assert result == { + "input_ids": [0, 465, 6766, 318, 298, 4, 322, 12, 1030], + "labels": [-100, -100, -100, -100, -100, -100, -100, -100, 1], + } + + def test_tokenize_row_multi_token_separator(self): + # Define the input features + features = { + "prompt": "Which number is larger, 9.8 or 9.11?", + "completions": ["11 is greater than 8.", "Hence, 9.11 > 9.8."], + "labels": [True, False], + } + + # Call the method using multiple tokens as step_separator + result = PRMTrainer.tokenize_row( + features=features, + tokenizer=self.tokenizer, + step_separator="\n\n", + max_length=None, + max_completion_length=None, + train_on_last_step_only=False, + is_eval=False, + ) + + assert result == { + "input_ids": [0, 465, 6766, 318, 298, 4, 322, 12, 1030, 1030, 4995, 11, 22, 1030, 1030], + "labels": [-100, -100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100, -100, -100, 0], + } + + +class TestPRMTrainer(TrlTestCase): + def setup_method(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + self.model = AutoModelForTokenClassification.from_pretrained(model_id, dtype="float32") + self.tokenizer = AutoTokenizer.from_pretrained(model_id) + + @pytest.mark.parametrize("train_on_last_step_only", [True, False]) + def test_train_full(self, train_on_last_step_only): + dataset = load_dataset("trl-internal-testing/zen", "standard_stepwise_supervision", split="train") + training_args = PRMConfig( + output_dir=self.tmp_dir, + report_to="none", + train_on_last_step_only=train_on_last_step_only, + ) + trainer = PRMTrainer( + model=self.model, args=training_args, processing_class=self.tokenizer, train_dataset=dataset + ) + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if param.sum() != 0: # ignore 0 biases + assert not torch.equal(param, new_param) + + def test_train_full_pretokenized(self): + dataset = Dataset.from_dict( + { + "labels": [ + [-100, -100, -100, -100, -100, -100, -100, -100, -100, 0, -100, -100, 1], + [-100, -100, -100, -100, -100, -100, -100, -100, 0, -100, -100, 1, -100, -100, -100, -100, 0], + [-100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, 0, -100, -100, 1], + [-100, -100, -100, -100, -100, -100, -100, 1, -100, -100, 1], + [-100, -100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100, 0], + [-100, -100, -100, -100, -100, -100, -100, -100, -100, 1], + [-100, -100, -100, -100, -100, -100, -100, -100, -100, 0], + [-100, -100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100, -100, -100, -100, 0], + [-100, -100, -100, -100, -100, -100, -100, -100, 0, -100, -100, 0], + [-100, -100, -100, -100, -100, -100, 0, -100, -100, -100, -100, 0], + [-100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, 1], + [-100, -100, -100, -100, -100, -100, 0], + [-100, -100, -100, -100, -100, -100, -100, -100, 1], + [-100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, 0], + ], + "input_ids": [ + [46518, 374, 2664, 1091, 11, 1077, 752, 1744, 1112, 198, 27261, 13, 198], + [98923, 374, 2664, 1091, 11, 315, 3308, 11, 198, 17995, 13, 198, 1576, 31273, 12850, 13, 198], + [16374, 374, 2664, 1091, 1112, 1077, 594, 2506, 432, 6770, 11, 198, 6351, 13, 198], + [31137, 374, 2664, 1091, 979, 4362, 11, 198, 16965, 13, 198], + [31019, 374, 2664, 1091, 304, 3793, 315, 5944, 11, 198, 24034, 13, 198], + [98491, 374, 2664, 1091, 1112, 5310, 369, 91494, 13, 198], + [4418, 2897, 14579, 5310, 979, 3800, 1349, 432, 13, 198], + [20366, 5048, 7629, 944, 3281, 3322, 11, 7241, 1112, 198, 807, 1795, 279, 5601, 13, 198], + [15802, 14976, 487, 33327, 1045, 31787, 63443, 11, 198, 52400, 13, 198], + [13877, 1265, 2581, 1494, 49394, 11, 198, 7241, 20975, 91681, 13, 198], + [641, 279, 3579, 315, 71768, 11, 25066, 279, 61361, 311, 7942, 13, 198], + [7039, 374, 2664, 1091, 2937, 13, 198], + [26155, 374, 3545, 2664, 1091, 34933, 26537, 13, 198], + [2679, 279, 8129, 374, 4135, 311, 10339, 11, 432, 2578, 387, 264, 1661, 2884, 13, 198], + ], + } + ) + + training_args = PRMConfig(output_dir=self.tmp_dir, report_to="none") + trainer = PRMTrainer( + model=self.model, args=training_args, processing_class=self.tokenizer, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if param.sum() != 0: # ignore 0 biases + assert not torch.equal(param, new_param) + + @require_peft + def test_train_lora(self): + peft_config = LoraConfig( + task_type=TaskType.TOKEN_CLS, + inference_mode=False, + r=8, + lora_alpha=32, + lora_dropout=0.1, + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_stepwise_supervision", split="train") + training_args = PRMConfig(output_dir=self.tmp_dir, max_steps=3, report_to="none") + trainer = PRMTrainer( + model=self.model, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset, + peft_config=peft_config, + ) + previous_trainable_params = {} + previous_non_trainable_params = {} + + # due to a change in the way the modules to save are dealt in PEFT. + trainable_params_name = ["lora", "modules_to_save"] + + # check gradients are not None + for n, param in trainer.model.named_parameters(): + if any(t in n for t in trainable_params_name): + previous_trainable_params[n] = param.clone() + else: + previous_non_trainable_params[n] = param.clone() + + trainer.train() + + assert trainer.state.log_history[(-1)]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param) + + # Check that the non trainable parameters have not changed + for n, param in previous_non_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + torch.testing.assert_close(param, new_param, atol=1e-12, rtol=1e-12) + + def test_tags(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_stepwise_supervision", split="train") + training_args = PRMConfig(output_dir=self.tmp_dir, report_to="none") + trainer = PRMTrainer( + model=self.model, args=training_args, processing_class=self.tokenizer, train_dataset=dataset + ) + assert trainer.model.model_tags == trainer._tag_names diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_sdft_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_sdft_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..32a25c9b70a093458be7a54460f81d539cf922cd --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_sdft_trainer.py @@ -0,0 +1,524 @@ +# Copyright 2020-2026 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 pytest +import torch +from datasets import Dataset +from transformers import TrainerCallback +from transformers.utils import is_peft_available + +from trl.experimental.sdft import SDFTConfig, SDFTTrainer + +from ..testing_utils import TrlTestCase, require_liger_kernel, require_peft, require_torch_accelerator + + +if is_peft_available(): + from peft import LoraConfig + + +class SelfDistillationCaptureCallback(TrainerCallback): + def __init__(self): + self.captured_generation_prompts = None + self.captured_old_per_token_logps = None + self.captured_prompt_ids = None + self.generation_batch_build_count = 0 + + def on_generation_prompts_selected(self, generation_prompts=None, **kwargs): + if self.captured_generation_prompts is None and generation_prompts is not None: + self.captured_generation_prompts = generation_prompts + + def on_self_distillation_batch_prepared(self, old_per_token_logps=None, prompt_ids=None, **kwargs): + if self.captured_old_per_token_logps is None and old_per_token_logps is not None: + self.captured_old_per_token_logps = old_per_token_logps.detach().cpu() + if self.captured_prompt_ids is None and prompt_ids is not None: + self.captured_prompt_ids = prompt_ids.detach().cpu() + + def on_generation_batch_built(self, **kwargs): + self.generation_batch_build_count += 1 + + +class RecordingTeacherClient: + """Stands in for the vLLM server client and records scoring requests.""" + + def __init__(self, response): + self.response = response + self.calls = [] + + def get_sequence_logprobs(self, **kwargs): + self.calls.append(kwargs) + return self.response + + +class TestSDFTTrainer(TrlTestCase): + @staticmethod + def _trainable_param_snapshot(model): + return {name: param.detach().clone() for name, param in model.named_parameters() if param.requires_grad} + + @staticmethod + def _assert_any_trainable_param_changed(model, previous_trainable_params): + assert any( + not torch.allclose(previous_param, model.get_parameter(name), rtol=1e-12, atol=1e-12) + for name, previous_param in previous_trainable_params.items() + ) + + def test_trust_remote_code(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve 2+2.", "Name the capital of France."], + "privileged_context": ["Example answer: 4.", "Example answer: Paris."], + } + ) + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + + with pytest.raises(ValueError, match="custom code"): + SDFTTrainer( + model=model_id, + args=SDFTConfig(output_dir=self.tmp_dir, report_to="none"), + train_dataset=dataset, + ) + + trainer = SDFTTrainer( + model=model_id, + args=SDFTConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + train_dataset=dataset, + ) + assert type(trainer.model).__name__ == "RemoteForCausalLM" + + def test_train(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve 2+2.", "Name the capital of France."], + "privileged_context": [ + "Example answer: 4.", + "Example answer: Paris.", + ], + } + ) + + training_args = SDFTConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + num_generations=1, + report_to="none", + ) + + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + previous_trainable_params = self._trainable_param_snapshot(trainer.model) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + self._assert_any_trainable_param_changed(trainer.model, previous_trainable_params) + + @require_liger_kernel + @require_torch_accelerator + def test_liger_loss_matches_non_liger_loss(self): + dataset = Dataset.from_dict({"prompt": ["Solve 2+2."], "privileged_context": ["Example answer: 4."]}) + common = dict( + output_dir=self.tmp_dir, + report_to="none", + per_device_train_batch_size=1, + max_completion_length=3, + num_generations=1, + distillation_mode="full_logits", + distillation_is_clip=None, + num_loss_tokens_to_skip=1, + ) + + ref_trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=SDFTConfig(use_liger_kernel=False, **common), + train_dataset=dataset, + ) + liger_trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=SDFTConfig(use_liger_kernel=True, **common), + train_dataset=dataset, + ) + + liger_trainer.model.load_state_dict(ref_trainer.model.state_dict()) + torch.manual_seed(0) + with torch.no_grad(): + for param in ref_trainer.teacher_model.parameters(): + param.add_(0.5 * torch.randn_like(param)) + liger_trainer.teacher_model.load_state_dict(ref_trainer.teacher_model.state_dict()) + + device = next(ref_trainer.model.parameters()).device + batch = { + "prompt_ids": torch.tensor([[10, 11], [12, 13]], device=device), + "prompt_mask": torch.tensor([[1, 1], [1, 1]], device=device), + "completion_ids": torch.tensor([[14, 15, 16], [17, 18, 19]], device=device), + "completion_mask": torch.tensor([[1, 1, 0], [1, 1, 1]], device=device), + "teacher_input_ids": torch.tensor([[20, 21, 22, 14, 15, 16], [23, 24, 25, 17, 18, 19]], device=device), + "teacher_attention_mask": torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1]], device=device), + } + + ref_trainer.model.eval() + liger_trainer.model.eval() + with torch.no_grad(): + ref_loss = ref_trainer.compute_loss(ref_trainer.model, batch).item() + liger_loss = liger_trainer.compute_loss(liger_trainer.model, batch).item() + + torch.testing.assert_close( + torch.tensor(liger_loss), + torch.tensor(ref_loss), + rtol=2e-2, + atol=1e-6, + ) + + def test_train_rejects_none_privileged_context(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve 2+2."], + "privileged_context": [None], + } + ) + + training_args = SDFTConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + num_generations=1, + report_to="none", + ) + + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + with pytest.raises(ValueError, match="`privileged_context` must not be None"): + trainer.train() + + def test_train_with_generate_from_teacher(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve 2+2.", "Solve 3+3."], + "privileged_context": [ + "Teacher hint: answer with 4 and explain briefly.", + "Teacher hint: answer with 6 and explain briefly.", + ], + } + ) + + training_args = SDFTConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + num_generations=1, + generate_from_teacher=True, + report_to="none", + ) + + capture_callback = SelfDistillationCaptureCallback() + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + callbacks=[capture_callback], + ) + + trainer.train() + + assert capture_callback.captured_generation_prompts == [ + "Solve 2+2.\n\nTeacher hint: answer with 4 and explain briefly." + ] + student_prompt_text = trainer.processing_class.decode( + capture_callback.captured_prompt_ids[0], + skip_special_tokens=True, + ) + assert "Teacher hint" not in student_prompt_text + assert "Solve 2+2." in student_prompt_text + + def test_train_with_chat_template_kwargs(self): + dataset = Dataset.from_dict( + { + "prompt": [ + [{"role": "user", "content": "Solve 2+2."}], + [{"role": "user", "content": "Solve 3+3."}], + ], + "privileged_context": [ + "Teacher hint: answer with 4.", + "Teacher hint: answer with 6.", + ], + } + ) + + training_args = SDFTConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + num_generations=1, + chat_template_kwargs={"enable_thinking": False}, + report_to="none", + ) + + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen3ForCausalLM", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = self._trainable_param_snapshot(trainer.model) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + self._assert_any_trainable_param_changed(trainer.model, previous_trainable_params) + + @require_peft + def test_train_with_peft_model(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve 2+2.", "Name the capital of France."], + "privileged_context": [ + "Example answer: 4.", + "Example answer: Paris.", + ], + } + ) + + training_args = SDFTConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + num_generations=1, + report_to="none", + ) + + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig( + task_type="CAUSAL_LM", + target_modules=["q_proj", "v_proj"], + ), + ) + + previous_trainable_params = self._trainable_param_snapshot(trainer.model) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + self._assert_any_trainable_param_changed(trainer.model, previous_trainable_params) + + @require_peft + def test_train_with_peft_model_and_ema_teacher_sync(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve 2+2.", "Name the capital of France."], + "privileged_context": [ + "Example answer: 4.", + "Example answer: Paris.", + ], + } + ) + + training_args = SDFTConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=2, + num_generations=1, + teacher_model_kind="ema", + teacher_update_rate=0.05, + teacher_sync_steps=1, + report_to="none", + ) + + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig( + task_type="CAUSAL_LM", + target_modules=["q_proj", "v_proj"], + ), + ) + previous_trainable_params = self._trainable_param_snapshot(trainer.model) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + self._assert_any_trainable_param_changed(trainer.model, previous_trainable_params) + + def test_train_populates_old_log_probs_for_distillation_clipping_when_misaligned(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve 2+2.", "Solve 3+3."], + "privileged_context": [ + "Example answer: 4.", + "Example answer: 6.", + ], + } + ) + + training_args = SDFTConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + gradient_accumulation_steps=3, + steps_per_generation=2, + max_completion_length=8, + max_steps=1, + num_generations=1, + report_to="none", + ) + + capture_callback = SelfDistillationCaptureCallback() + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + callbacks=[capture_callback], + ) + + trainer.train() + + assert capture_callback.captured_old_per_token_logps is not None + + def test_train_with_generate_from_teacher_skips_old_log_probs_for_distillation_clipping(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve 2+2.", "Solve 3+3."], + "privileged_context": [ + "Teacher hint: answer with 4.", + "Teacher hint: answer with 6.", + ], + } + ) + + training_args = SDFTConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + gradient_accumulation_steps=3, + steps_per_generation=2, + max_completion_length=8, + max_steps=1, + num_generations=1, + generate_from_teacher=True, + report_to="none", + ) + + capture_callback = SelfDistillationCaptureCallback() + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + callbacks=[capture_callback], + ) + + trainer.train() + + assert capture_callback.captured_old_per_token_logps is None + + def test_train_reuses_buffered_generation_batches(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve 2+2.", "Solve 3+3."], + "privileged_context": [ + "Example answer: 4.", + "Example answer: 6.", + ], + } + ) + + training_args = SDFTConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + steps_per_generation=2, + max_completion_length=8, + max_steps=2, + num_generations=1, + report_to="none", + ) + + capture_callback = SelfDistillationCaptureCallback() + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + callbacks=[capture_callback], + ) + + trainer.train() + + assert capture_callback.generation_batch_build_count == 1 + + def test_server_loss_finite_with_masked_and_padded_rows(self): + # Drives the teacher-server path through `compute_loss` with a fake server client: row 0 is fully masked + # (zero-length scored completion) and row 1 has a shorter completion than the padded batch, so the client + # response is ragged and the padded tail comes back as -inf. Neither may leak NaN or inf. + dataset = Dataset.from_dict({"prompt": ["Solve 2+2."], "privileged_context": ["Example answer: 4."]}) + training_args = SDFTConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, + max_completion_length=3, + num_generations=1, + distillation_mode="topk_logits", + distillation_topk=2, + distillation_alpha=0.5, + distillation_add_tail=True, + distillation_is_clip=None, + report_to="none", + ) + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + trainer.use_teacher_server = True + trainer.teacher_client = RecordingTeacherClient( + { + "actual_logprobs": [[], [[-1.1], [-0.4]]], + "logprobs": [[], [[-1.1, -1.5], [-0.4, -0.9]]], + "logprob_token_ids": [[], [[14, 15], [16, 17]]], + } + ) + + device = next(trainer.model.parameters()).device + batch = { + "prompt_ids": torch.tensor([[10, 11], [12, 13]], device=device), + "prompt_mask": torch.tensor([[1, 1], [1, 1]], device=device), + "completion_ids": torch.tensor([[14, 15, 16], [17, 18, 19]], device=device), + "completion_mask": torch.tensor([[0, 0, 0], [1, 1, 0]], device=device), + "teacher_input_ids": torch.tensor([[20, 21, 22, 14, 15, 16], [23, 24, 25, 17, 18, 19]], device=device), + "teacher_attention_mask": torch.tensor([[1, 1, 1, 0, 0, 0], [1, 1, 1, 1, 1, 0]], device=device), + } + + loss = trainer.compute_loss(trainer.model, batch) + + assert torch.isfinite(loss) + loss.backward() + assert all(torch.isfinite(p.grad).all() for p in trainer.model.parameters() if p.grad is not None) + assert trainer.teacher_client.calls[0]["top_logprobs"] == 2 diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_sdpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_sdpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..cd8e25373d54f8ae8d3457f109e72b7ba824a58f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_sdpo_trainer.py @@ -0,0 +1,582 @@ +# Copyright 2020-2026 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 logging + +import pytest +import torch +from datasets import Dataset, load_dataset +from transformers import TrainerCallback + +from trl.experimental.sdpo import SDPOConfig, SDPOTrainer + +from ..testing_utils import TrlTestCase, require_liger_kernel, require_torch_accelerator + + +class SelfDistillationCaptureCallback(TrainerCallback): + def __init__(self): + self.captured_teacher_input_text = None + self.captured_teacher_input_texts = [] + self.captured_self_distillation_mask = None + self.captured_teacher_attention_mask = None + self.captured_completion_mask = None + self.captured_old_per_token_logps = None + + def on_teacher_context_built( + self, + processing_class=None, + teacher_input_ids=None, + teacher_attention_mask=None, + completion_mask=None, + self_distillation_mask=None, + **kwargs, + ): + if self.captured_teacher_input_text is None and teacher_input_ids is not None: + self.captured_teacher_input_text = processing_class.decode(teacher_input_ids[0], skip_special_tokens=True) + if teacher_input_ids is not None: + self.captured_teacher_input_texts.extend( + processing_class.decode(ids, skip_special_tokens=True) for ids in teacher_input_ids + ) + if self.captured_teacher_attention_mask is None and teacher_attention_mask is not None: + self.captured_teacher_attention_mask = teacher_attention_mask.detach().cpu() + if self.captured_completion_mask is None and completion_mask is not None: + self.captured_completion_mask = completion_mask.detach().cpu() + if self.captured_self_distillation_mask is None and self_distillation_mask is not None: + self.captured_self_distillation_mask = self_distillation_mask.detach().cpu() + + def on_self_distillation_batch_prepared(self, old_per_token_logps=None, **kwargs): + if self.captured_old_per_token_logps is None and old_per_token_logps is not None: + self.captured_old_per_token_logps = old_per_token_logps.detach().cpu() + + +class RecordingTeacherClient: + """Stands in for the vLLM server client and records scoring requests.""" + + def __init__(self, response): + self.response = response + self.calls = [] + + def get_sequence_logprobs(self, **kwargs): + self.calls.append(kwargs) + return self.response + + +class TestSDPOTrainer(TrlTestCase): + def test_trust_remote_code(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve 2+2.", "Name the capital of France."], + "privileged_context": ["Example answer: 4.", "Example answer: Paris."], + } + ) + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + + with pytest.raises(ValueError, match="custom code"): + SDPOTrainer( + model=model_id, + reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]), + args=SDPOConfig(output_dir=self.tmp_dir, report_to="none"), + train_dataset=dataset, + ) + + trainer = SDPOTrainer( + model=model_id, + reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]), + args=SDPOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + train_dataset=dataset, + ) + assert type(trainer.model).__name__ == "RemoteForCausalLM" + + def test_train_with_positional_config_argument(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve 2+2."], + "privileged_context": ["Your earlier answer used the wrong format."], + } + ) + + training_args = SDPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + generation_batch_size=2, + num_generations=2, + max_completion_length=8, + include_environment_feedback=True, + max_steps=1, + report_to="none", + ) + + trainer = SDPOTrainer( + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + lambda **kwargs: [0.0] * len(kwargs["prompts"]), + training_args, + dataset, + ) + + trainer.train() + + assert trainer.args.output_dir == self.tmp_dir + assert trainer.args.include_environment_feedback is True + assert trainer.state.log_history[-1]["train_loss"] is not None + + def test_vllm_config_defaults_match_reference_trainers(self): + config = SDPOConfig(output_dir=self.tmp_dir) + + assert config.vllm_mode == "colocate" + assert config.vllm_model_impl == "vllm" + + def test_train(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = SDPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + distillation_mode="topk_logits", + distillation_topk=5, + distillation_is_clip=None, + report_to="none", + ) + trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if param.sum() != 0: + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_liger_kernel + @require_torch_accelerator + def test_liger_loss_matches_non_liger_loss(self): + dataset = Dataset.from_dict({"prompt": ["Solve 2+2."]}) + common = dict( + output_dir=self.tmp_dir, + report_to="none", + per_device_train_batch_size=1, + generation_batch_size=2, + num_generations=2, + max_completion_length=3, + distillation_mode="full_logits", + distillation_is_clip=None, + distillation_weight=1.0, + ) + + ref_trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]), + args=SDPOConfig(use_liger_kernel=False, **common), + train_dataset=dataset, + ) + liger_trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]), + args=SDPOConfig(use_liger_kernel=True, **common), + train_dataset=dataset, + ) + + liger_trainer.model.load_state_dict(ref_trainer.model.state_dict()) + torch.manual_seed(0) + with torch.no_grad(): + for param in ref_trainer.teacher_model.parameters(): + param.add_(0.5 * torch.randn_like(param)) + liger_trainer.teacher_model.load_state_dict(ref_trainer.teacher_model.state_dict()) + + device = next(ref_trainer.model.parameters()).device + batch = { + "prompt_ids": torch.tensor([[10, 11], [12, 13]], device=device), + "prompt_mask": torch.tensor([[1, 1], [1, 1]], device=device), + "completion_ids": torch.tensor([[14, 15, 16], [17, 18, 19]], device=device), + "completion_mask": torch.tensor([[1, 1, 0], [1, 1, 1]], device=device), + "teacher_input_ids": torch.tensor([[20, 21, 22, 14, 15, 16], [23, 24, 25, 17, 18, 19]], device=device), + "teacher_attention_mask": torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1]], device=device), + "self_distillation_mask": torch.tensor([1.0, 0.0], device=device), + } + + ref_trainer.model.eval() + liger_trainer.model.eval() + with torch.no_grad(): + ref_loss = ref_trainer.compute_loss(ref_trainer.model, batch).item() + liger_loss = liger_trainer.compute_loss(liger_trainer.model, batch).item() + + torch.testing.assert_close( + torch.tensor(liger_loss), + torch.tensor(ref_loss), + rtol=2e-2, + atol=1e-6, + ) + + def test_train_without_successful_rollouts(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = SDPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + distillation_is_clip=None, + report_to="none", + ) + + def zero_reward(**kwargs): + prompts = kwargs["prompts"] + return [0.0] * len(prompts) + + trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=zero_reward, + args=training_args, + train_dataset=dataset, + ) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + def test_train_populates_old_log_probs_for_distillation_clipping_when_misaligned(self): + dataset = Dataset.from_dict({"prompt": ["Solve 2+2.", "Solve 3+3."]}) + + training_args = SDPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + gradient_accumulation_steps=3, + steps_per_generation=2, + num_generations=2, + max_completion_length=8, + max_steps=1, + report_to="none", + ) + + capture_callback = SelfDistillationCaptureCallback() + trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]), + args=training_args, + train_dataset=dataset, + callbacks=[capture_callback], + ) + + trainer.train() + + assert capture_callback.captured_old_per_token_logps is not None + + def test_evaluation_uses_num_generations_eval_for_teacher_grouping(self): + eval_dataset = Dataset.from_dict({"prompt": ["Alpha prompt", "Beta prompt", "Gamma prompt", "Delta prompt"]}) + + training_args = SDPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + per_device_eval_batch_size=4, + generation_batch_size=3, + num_generations=3, + num_generations_eval=2, + max_completion_length=8, + success_reward_threshold=0.5, + dont_reprompt_on_self_success=False, + distillation_is_clip=None, + max_steps=1, + report_to="none", + ) + + def eval_rewards(**kwargs): + prompts = kwargs["prompts"] + if len(prompts) == 4 and prompts.count("Alpha prompt") == 2 and prompts.count("Beta prompt") == 2: + return [1.0, 0.0, 0.0, 0.0] + return [0.0] * len(prompts) + + capture_callback = SelfDistillationCaptureCallback() + trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=eval_rewards, + args=training_args, + train_dataset=eval_dataset.select(range(1)), + eval_dataset=eval_dataset, + callbacks=[capture_callback], + ) + + trainer.evaluate() + + assert capture_callback.captured_teacher_input_texts + alpha_teachers = [text for text in capture_callback.captured_teacher_input_texts if "Alpha prompt" in text] + beta_teachers = [text for text in capture_callback.captured_teacher_input_texts if "Beta prompt" in text] + assert alpha_teachers + assert beta_teachers + assert any("Correct solution:" in text for text in alpha_teachers) + assert all("Correct solution:" not in text for text in beta_teachers) + + def test_teacher_reprompt_preserves_curly_braces_in_solution_and_feedback(self): + dataset = Dataset.from_dict( + { + "prompt": ["Solve f(x) = {x^2}."], + "privileged_context": ['Feedback: use {"x": 2} as a check.'], + } + ) + + training_args = SDPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + generation_batch_size=2, + num_generations=2, + max_completion_length=8, + include_environment_feedback=True, + success_reward_threshold=0.5, + dont_reprompt_on_self_success=False, + max_steps=1, + report_to="none", + ) + + def reward_with_one_success(**kwargs): + prompts = kwargs["prompts"] + return [1.0, 0.0][: len(prompts)] + + capture_callback = SelfDistillationCaptureCallback() + trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_with_one_success, + args=training_args, + train_dataset=dataset, + callbacks=[capture_callback], + ) + + trainer.train() + + assert capture_callback.captured_teacher_input_text is not None + assert "Solve f(x) = {x^2}." in capture_callback.captured_teacher_input_text + assert 'Feedback: use {"x": 2} as a check.' in capture_callback.captured_teacher_input_text + assert "{{" not in capture_callback.captured_teacher_input_text + assert "}}" not in capture_callback.captured_teacher_input_text + + def test_train_with_conversational_prompts_preserves_context(self): + dataset = Dataset.from_dict( + { + "prompt": [ + [ + {"role": "system", "content": "You are a careful assistant."}, + {"role": "user", "content": "Solve 2+2."}, + ] + ] + } + ) + + training_args = SDPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + generation_batch_size=2, + num_generations=2, + max_completion_length=8, + distillation_is_clip=None, + success_reward_threshold=0.5, + max_steps=1, + report_to="none", + ) + + def first_only_reward(**kwargs): + """Only the first sample in each group succeeds — exercises dont_reprompt_on_self_success default.""" + return [1.0, 0.0][: len(kwargs["prompts"])] + + capture_callback = SelfDistillationCaptureCallback() + trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=first_only_reward, + args=training_args, + train_dataset=dataset, + callbacks=[capture_callback], + ) + + trainer.train() + + # With dont_reprompt_on_self_success=True (default), sample 0 skips itself, + # but sample 1 finds sample 0's success and gets a teacher reprompt. + assert capture_callback.captured_teacher_input_text is not None + assert "careful assistant" in capture_callback.captured_teacher_input_text + assert "Solve 2+2" in capture_callback.captured_teacher_input_text + assert capture_callback.captured_self_distillation_mask is not None + + def test_train_with_feedback_only_reprompts_teacher(self): + dataset = Dataset.from_dict( + { + "prompt": [ + [ + {"role": "system", "content": "You are a careful assistant."}, + {"role": "user", "content": "Try the puzzle again."}, + ] + ], + "privileged_context": ["Your earlier answer violated the format requirements."], + } + ) + + training_args = SDPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + generation_batch_size=2, + num_generations=2, + max_completion_length=8, + distillation_is_clip=None, + include_environment_feedback=True, + max_steps=1, + report_to="none", + ) + + def zero_reward(**kwargs): + prompts = kwargs["prompts"] + return [0.0] * len(prompts) + + capture_callback = SelfDistillationCaptureCallback() + trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=zero_reward, + args=training_args, + train_dataset=dataset, + callbacks=[capture_callback], + ) + + trainer.train() + + assert capture_callback.captured_teacher_input_text is not None + assert "format requirements" in capture_callback.captured_teacher_input_text + assert capture_callback.captured_self_distillation_mask is not None + assert capture_callback.captured_self_distillation_mask[0].item() == 1.0 + + def test_train_warns_when_sdpo_rewards_are_flat(self, caplog): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = SDPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + diagnostics_warning_interval=2, + max_steps=2, + report_to="none", + ) + + def zero_reward(**kwargs): + return [0.0] * len(kwargs["prompts"]) + + trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=zero_reward, + args=training_args, + train_dataset=dataset, + ) + + with caplog.at_level(logging.WARNING): + trainer.train() + + assert "Observed flat SDPO rewards across all sampled generations" in caplog.text + assert "SDPO self-distillation is inactive because no reprompted samples were constructed" in caplog.text + + def test_train_preserves_teacher_completion_attention_mask(self): + dataset = Dataset.from_dict({"prompt": ["Solve 2+2."]}) + + training_args = SDPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + generation_batch_size=2, + num_generations=2, + max_completion_length=8, + success_reward_threshold=0.5, + max_steps=1, + report_to="none", + ) + + def first_only_reward(**kwargs): + return [1.0, 0.0][: len(kwargs["prompts"])] + + capture_callback = SelfDistillationCaptureCallback() + trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=first_only_reward, + args=training_args, + train_dataset=dataset, + callbacks=[capture_callback], + ) + + trainer.train() + + assert capture_callback.captured_teacher_attention_mask is not None + assert capture_callback.captured_completion_mask is not None + + completion_length = capture_callback.captured_completion_mask.shape[1] + teacher_completion_attention = capture_callback.captured_teacher_attention_mask[0, -completion_length:] + assert torch.equal(teacher_completion_attention, capture_callback.captured_completion_mask[0]) + + def test_server_loss_finite_with_masked_and_padded_rows(self): + # Drives the teacher-server path through `compute_loss` with a fake server client: row 0 is fully masked + # (zero-length scored completion) and row 1 has a shorter completion than the padded batch, so the client + # response is ragged and the padded tail comes back as -inf. Neither may leak NaN or inf. + dataset = Dataset.from_dict({"prompt": ["Solve 2+2."], "privileged_context": ["Example answer: 4."]}) + training_args = SDPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, + max_completion_length=3, + num_generations=1, + distillation_mode="topk_logits", + distillation_topk=2, + distillation_alpha=0.5, + distillation_add_tail=True, + distillation_is_clip=None, + report_to="none", + ) + trainer = SDPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=lambda **kwargs: [0.0] * len(kwargs["prompts"]), + args=training_args, + train_dataset=dataset, + ) + trainer.use_teacher_server = True + trainer.teacher_client = RecordingTeacherClient( + { + "actual_logprobs": [[], [[-1.1], [-0.4]]], + "logprobs": [[], [[-1.1, -1.5], [-0.4, -0.9]]], + "logprob_token_ids": [[], [[14, 15], [16, 17]]], + } + ) + + device = next(trainer.model.parameters()).device + batch = { + "prompt_ids": torch.tensor([[10, 11], [12, 13]], device=device), + "prompt_mask": torch.tensor([[1, 1], [1, 1]], device=device), + "completion_ids": torch.tensor([[14, 15, 16], [17, 18, 19]], device=device), + "completion_mask": torch.tensor([[0, 0, 0], [1, 1, 0]], device=device), + "teacher_input_ids": torch.tensor([[20, 21, 22, 14, 15, 16], [23, 24, 25, 17, 18, 19]], device=device), + "teacher_attention_mask": torch.tensor([[1, 1, 1, 0, 0, 0], [1, 1, 1, 1, 1, 0]], device=device), + } + + loss = trainer.compute_loss(trainer.model, batch) + + assert torch.isfinite(loss) + loss.backward() + assert all(torch.isfinite(p.grad).all() for p in trainer.model.parameters() if p.grad is not None) + assert trainer.teacher_client.calls[0]["top_logprobs"] == 2 diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_self_distillation_trainer_behavior.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_self_distillation_trainer_behavior.py new file mode 100644 index 0000000000000000000000000000000000000000..d581ca26f2e028c838d349cdb56d872b20d78cc9 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_self_distillation_trainer_behavior.py @@ -0,0 +1,336 @@ +# Copyright 2020-2026 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 logging +from collections import defaultdict +from types import SimpleNamespace + +import pytest +import torch +from datasets import Dataset +from transformers import AutoModelForCausalLM, TrainerControl, TrainerState, TrainingArguments +from transformers.utils import is_peft_available + +from trl.experimental.sdft import SDFTConfig, SDFTTrainer +from trl.experimental.sdft.loss_utils import ( + apply_importance_sampling_clipping, + compute_full_logit_self_distillation_loss, + compute_sampled_token_self_distillation_loss, + compute_topk_self_distillation_loss, +) + +from ..testing_utils import TrlTestCase + + +if is_peft_available(): + from peft import LoraConfig, get_peft_model, get_peft_model_state_dict + + from trl.experimental.sdft.teacher_sync import PEFTAdapterEMACallback + + +class TestSelfDistillationTrainerBehavior(TrlTestCase): + @staticmethod + def _make_loss_test_trainer(**args_overrides): + trainer = object.__new__(SDFTTrainer) + args = { + "distillation_mode": "sampled_token", + "distillation_topk": None, + "distillation_alpha": 1.0, + "distillation_add_tail": False, + "distillation_is_clip": None, + } + args.update(args_overrides) + trainer.args = SimpleNamespace(**args) + trainer.accelerator = SimpleNamespace(gather=lambda tensor: tensor) + trainer._metrics = { + "train": defaultdict(list), + "eval": defaultdict(list), + } + trainer._name = "SDFT" + return trainer + + def test_full_logit_loss_matches_forward_kl(self): + student_probs = torch.tensor([[[0.8, 0.2]]], dtype=torch.float32) + teacher_probs = torch.tensor([[[0.5, 0.5]]], dtype=torch.float32) + + loss = compute_full_logit_self_distillation_loss( + student_probs.log(), + teacher_probs.log(), + distillation_alpha=0.0, + ) + + expected_loss = teacher_probs[0, 0, 0] * ( + teacher_probs[0, 0, 0].log() - student_probs[0, 0, 0].log() + ) + teacher_probs[0, 0, 1] * (teacher_probs[0, 0, 1].log() - student_probs[0, 0, 1].log()) + torch.testing.assert_close(loss, expected_loss.reshape(1, 1)) + + def test_sampled_token_loss_uses_selected_completion_ids(self): + student_probs = torch.tensor([[[0.1, 0.9], [0.7, 0.3]]], dtype=torch.float32) + teacher_probs = torch.tensor([[[0.4, 0.6], [0.2, 0.8]]], dtype=torch.float32) + completion_ids = torch.tensor([[1, 0]]) + + loss = compute_sampled_token_self_distillation_loss( + student_probs.log(), + teacher_probs.log(), + completion_ids, + distillation_alpha=1.0, + ) + + expected_student_logps = torch.tensor([[0.9, 0.7]], dtype=torch.float32).log() + expected_teacher_logps = torch.tensor([[0.6, 0.2]], dtype=torch.float32).log() + expected_loss = (expected_student_logps - expected_teacher_logps) * expected_student_logps + torch.testing.assert_close(loss, expected_loss) + + def test_topk_loss_renormalizes_selected_student_support(self): + student_probs = torch.tensor([[[0.5, 0.3, 0.2]]], dtype=torch.float32) + teacher_probs = torch.tensor([[[0.2, 0.6, 0.2]]], dtype=torch.float32) + + loss = compute_topk_self_distillation_loss( + student_probs.log(), + teacher_probs.log(), + distillation_topk=2, + distillation_alpha=0.0, + distillation_add_tail=False, + ) + + student_topk = torch.tensor([0.5, 0.3], dtype=torch.float32) + student_topk = student_topk / student_topk.sum() + teacher_topk = torch.tensor([0.2, 0.6], dtype=torch.float32) + teacher_topk = teacher_topk / teacher_topk.sum() + expected_loss = (teacher_topk * (teacher_topk.log() - student_topk.log())).sum() + torch.testing.assert_close(loss, expected_loss.reshape(1, 1)) + + def test_topk_loss_can_include_tail_bucket(self): + student_probs = torch.tensor([[[0.5, 0.3, 0.2]]], dtype=torch.float32) + teacher_probs = torch.tensor([[[0.2, 0.6, 0.2]]], dtype=torch.float32) + + loss = compute_topk_self_distillation_loss( + student_probs.log(), + teacher_probs.log(), + distillation_topk=2, + distillation_alpha=0.0, + distillation_add_tail=True, + ) + + student_with_tail = torch.tensor([0.5, 0.3, 0.2], dtype=torch.float32) + teacher_with_tail = torch.tensor([0.2, 0.6, 0.2], dtype=torch.float32) + expected_loss = (teacher_with_tail * (teacher_with_tail.log() - student_with_tail.log())).sum() + torch.testing.assert_close(loss, expected_loss.reshape(1, 1)) + + def test_importance_sampling_clipping_caps_token_ratio(self): + per_token_loss = torch.tensor([[1.0, 2.0]]) + student_log_probs = torch.tensor([[0.4, 0.3]], dtype=torch.float32).log() + old_log_probs = torch.tensor([[0.1, 0.2]], dtype=torch.float32).log() + + loss = apply_importance_sampling_clipping( + per_token_loss, + student_log_probs, + old_log_probs, + clip_coeff=2.0, + ) + + torch.testing.assert_close(loss, torch.tensor([[2.0, 3.0]])) + + def test_teacher_model_kind_live_uses_student_model(self): + dataset = Dataset.from_dict({"prompt": ["Solve 2+2."]}) + training_args = SDFTConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + num_generations=1, + teacher_model_kind="live", + report_to="none", + ) + + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + assert trainer.teacher_model is trainer.model + + @pytest.mark.skipif(not is_peft_available(), reason="PEFT is required for this test") + def test_warns_when_initial_student_already_has_a_peft_adapter(self, caplog): + dataset = Dataset.from_dict({"prompt": ["Solve 2+2."]}) + training_args = SDFTConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + num_generations=1, + teacher_model_kind="base", + report_to="none", + ) + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + model = get_peft_model( + model, + LoraConfig( + r=4, + lora_alpha=8, + target_modules=["q_proj", "v_proj"], + bias="none", + task_type="CAUSAL_LM", + ), + ) + + with caplog.at_level(logging.WARNING, logger="trl.experimental.sdft.sdft_trainer"): + SDFTTrainer( + model=model, + args=training_args, + train_dataset=dataset, + ) + + assert "already contains a PEFT adapter" in caplog.text + assert "`teacher_model_kind='base'` may refer to the underlying base weights" in caplog.text + + @pytest.mark.skipif(not is_peft_available(), reason="PEFT is required for this test") + def test_peft_adapter_ema_callback_updates_teacher_adapter(self): + model = AutoModelForCausalLM.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + device_map="cpu", + ) + model = get_peft_model( + model, + LoraConfig( + task_type="CAUSAL_LM", + target_modules=["q_proj", "v_proj"], + r=8, + ), + adapter_name="default", + ) + + update_rate = 0.5 + callback = PEFTAdapterEMACallback( + model=model, + teacher_adapter_name="teacher", + update_rate=update_rate, + sync_steps=1, + ) + args = TrainingArguments(output_dir=self.tmp_dir, report_to="none") + state = TrainerState(global_step=0) + control = TrainerControl() + + callback.on_train_begin(args, state, control) + + assert "teacher" in model.peft_config + assert callback.shadow_weights is not None + teacher_state = get_peft_model_state_dict(model, adapter_name="teacher") + for key, param in teacher_state.items(): + assert torch.all(param == 0), f"Teacher param {key} should be zero-initialized" + + student_state = { + key: value.clone() for key, value in get_peft_model_state_dict(model, adapter_name="default").items() + } + assert set(callback.shadow_weights.keys()) == set(student_state.keys()) + + state.global_step = 1 + callback.on_step_end(args, state, control) + + for key in callback.shadow_weights: + expected = update_rate * student_state[key] + torch.testing.assert_close(callback.shadow_weights[key], expected) + + teacher_state = get_peft_model_state_dict(model, adapter_name="teacher") + for key in teacher_state: + torch.testing.assert_close(teacher_state[key].float(), callback.shadow_weights[key]) + + @pytest.mark.parametrize("teacher_model_kind", ["base", "ema"]) + def test_teacher_model_kind_base_and_ema_use_frozen_teacher_copy(self, teacher_model_kind): + dataset = Dataset.from_dict({"prompt": ["Solve 2+2."]}) + training_args = SDFTConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + num_generations=1, + teacher_model_kind=teacher_model_kind, + report_to="none", + ) + + trainer = SDFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + assert trainer.teacher_model is not trainer.model + assert trainer.teacher_model.training is False + + student_param = next(trainer.model.parameters()) + teacher_param = next(trainer.teacher_model.parameters()) + assert teacher_param.requires_grad is False + assert teacher_param.data_ptr() != student_param.data_ptr() + + def test_compute_self_distillation_loss_ignores_masked_completion_tokens(self): + trainer = self._make_loss_test_trainer( + distillation_mode="full_logits", + distillation_alpha=0.0, + ) + model = SimpleNamespace(training=True) + + student_probs = torch.tensor([[[0.8, 0.2], [0.01, 0.99]]], dtype=torch.float32) + teacher_probs = torch.tensor([[[0.5, 0.5], [0.99, 0.01]]], dtype=torch.float32) + distillation_logits = SimpleNamespace( + completion_ids=torch.tensor([[0, 1]], dtype=torch.long), + loss_mask=torch.tensor([[1, 0]], dtype=torch.long), + student_logits=student_probs.log(), + teacher_logits=teacher_probs.log(), + ) + + loss = trainer._compute_self_distillation_loss(model, {}, distillation_logits) + + expected_active_token_loss = teacher_probs[0, 0, 0] * ( + teacher_probs[0, 0, 0].log() - student_probs[0, 0, 0].log() + ) + teacher_probs[0, 0, 1] * (teacher_probs[0, 0, 1].log() - student_probs[0, 0, 1].log()) + torch.testing.assert_close(loss, expected_active_token_loss) + torch.testing.assert_close( + torch.tensor(trainer._metrics["train"]["self_distillation/distillation_loss"]), + expected_active_token_loss.unsqueeze(0), + ) + + def test_compute_self_distillation_loss_applies_importance_sampling_clip(self): + trainer = self._make_loss_test_trainer(distillation_is_clip=2.0) + model = SimpleNamespace(training=True) + + student_token_probs = torch.tensor([[0.2, 0.4]], dtype=torch.float32) + teacher_token_probs = torch.tensor([[0.5, 0.5]], dtype=torch.float32) + old_token_probs = torch.tensor([[0.05, 0.4]], dtype=torch.float32) + clip_coeff = trainer.args.distillation_is_clip + + distillation_logits = SimpleNamespace( + completion_ids=torch.tensor([[0, 1]], dtype=torch.long), + loss_mask=torch.tensor([[1, 1]], dtype=torch.long), + student_logits=torch.log(torch.tensor([[[0.2, 0.8], [0.6, 0.4]]], dtype=torch.float32)), + teacher_logits=torch.log(torch.tensor([[[0.5, 0.5], [0.5, 0.5]]], dtype=torch.float32)), + ) + + loss = trainer._compute_self_distillation_loss( + model, + {"old_per_token_logps": old_token_probs.log()}, + distillation_logits, + ) + + raw_per_token_loss = (student_token_probs.log() - teacher_token_probs.log()) * student_token_probs.log() + clipped_ratio = torch.minimum( + student_token_probs / old_token_probs, torch.full_like(student_token_probs, clip_coeff) + ) + expected_loss = (raw_per_token_loss * clipped_ratio).mean() + + torch.testing.assert_close(loss, expected_loss) + torch.testing.assert_close( + torch.tensor(trainer._metrics["train"]["self_distillation/distillation_loss"]), + expected_loss.unsqueeze(0), + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_ssd_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_ssd_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..077357cca85f2c982202ee3350ca67578374df54 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_ssd_trainer.py @@ -0,0 +1,237 @@ +# Copyright 2020-2026 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 pytest +from datasets import load_dataset +from transformers.utils import is_peft_available + +from trl.experimental.ssd import SSDConfig, SSDTrainer + +from ..testing_utils import TrlTestCase, require_peft + + +if is_peft_available(): + from peft import LoraConfig + + +class TestSSDTrainer(TrlTestCase): + def test_vllm_config_defaults_match_reference_trainers(self): + config = SSDConfig(output_dir=self.tmp_dir) + + assert config.vllm_mode == "colocate" + assert config.vllm_model_impl == "vllm" + + def test_train_with_string_prompts(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = SSDConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + ) + + trainer = SSDTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + def test_trust_remote_code(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + + with pytest.raises(ValueError, match="custom code"): + SSDTrainer( + model=model_id, + args=SSDConfig(output_dir=self.tmp_dir, report_to="none"), + train_dataset=dataset, + ) + + trainer = SSDTrainer( + model=model_id, + args=SSDConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + train_dataset=dataset, + ) + assert type(trainer.model).__name__ == "RemoteForCausalLM" + + def test_train_with_chat_prompts(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train") + + training_args = SSDConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + ) + + trainer = SSDTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + def test_train_with_temperature_and_truncation(self): + """Test with SSD-paper-style hyperparameters: T_train=0.6, top_k=20, top_p=0.95.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = SSDConfig( + output_dir=self.tmp_dir, + learning_rate=5e-6, + per_device_train_batch_size=1, + max_completion_length=16, + max_steps=1, + temperature=0.6, + top_k=20, + top_p=0.95, + ) + + trainer = SSDTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + def test_train_reuses_buffered_generation_batches(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = SSDConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + steps_per_generation=2, + max_completion_length=8, + max_steps=2, + ) + + trainer = SSDTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + def test_train_with_filter_empty_disabled(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = SSDConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + filter_empty=False, + ) + + trainer = SSDTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + def test_train_logs_ssd_metrics(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = SSDConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + logging_steps=1, + report_to="none", + ) + + trainer = SSDTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + trainer.train() + + # The log() override merges _metrics into log_history and clears the buffer. + last_log = trainer.state.log_history[-2] + assert "ssd/cross_entropy_loss" in last_log + assert "ssd/active_sample_ratio" in last_log + assert "completions/mean_length" in last_log + + @require_peft + def test_train_with_peft_model(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = SSDConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + ) + + trainer = SSDTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig( + task_type="CAUSAL_LM", + target_modules=["q_proj", "v_proj"], + ), + ) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + def test_train_with_disable_dropout_false(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = SSDConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + per_device_train_batch_size=1, + max_completion_length=8, + max_steps=1, + disable_dropout=False, + ) + + trainer = SSDTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_tpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_tpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..be9327e0eb13b73401bc7852e3f94e5872d34874 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_tpo_trainer.py @@ -0,0 +1,332 @@ +# Copyright 2020-2026 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 pytest +import torch +from datasets import load_dataset +from transformers.utils import is_peft_available + +from trl.experimental.tpo import TPOConfig, TPOTrainer +from trl.experimental.tpo.tpo_trainer import DataCollatorForTriplePreference + +from ..testing_utils import TrlTestCase, require_peft + + +if is_peft_available(): + from peft import LoraConfig + + +def _add_reference_column(example): + """Synthesize a `reference` (gold) completion for tests by reusing the chosen completion.""" + example["reference"] = example["chosen"] + return example + + +class TestDataCollatorForTriplePreference(TrlTestCase): + def test_padding_and_masks(self): + collator = DataCollatorForTriplePreference(pad_token_id=0) + examples = [ + {"prompt_ids": [1, 2, 3], "chosen_ids": [4, 5], "rejected_ids": [6], "reference_ids": [7, 8]}, + {"prompt_ids": [9, 10], "chosen_ids": [11], "rejected_ids": [12, 13], "reference_ids": [14]}, + ] + result = collator(examples) + + expected_input_ids = torch.tensor( + [ + [1, 2, 3, 4, 5], # prompt + chosen (example 1) + [9, 10, 11, 0, 0], # prompt + chosen (example 2, padded) + [1, 2, 3, 6, 0], # prompt + rejected (example 1, padded) + [9, 10, 12, 13, 0], # prompt + rejected (example 2, padded) + [1, 2, 3, 7, 8], # prompt + reference (example 1) + [9, 10, 14, 0, 0], # prompt + reference (example 2, padded) + ] + ) + expected_attention_mask = torch.tensor( + [ + [1, 1, 1, 1, 1], + [1, 1, 1, 0, 0], + [1, 1, 1, 1, 0], + [1, 1, 1, 1, 0], + [1, 1, 1, 1, 1], + [1, 1, 1, 0, 0], + ] + ) + expected_completion_mask = torch.tensor( + [ + [0, 0, 0, 1, 1], + [0, 0, 1, 0, 0], + [0, 0, 0, 1, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 1, 1], + [0, 0, 1, 0, 0], + ] + ) + + assert set(result.keys()) == {"input_ids", "attention_mask", "completion_mask"} + torch.testing.assert_close(result["input_ids"], expected_input_ids) + torch.testing.assert_close(result["attention_mask"], expected_attention_mask) + torch.testing.assert_close(result["completion_mask"], expected_completion_mask) + + def test_exclude_reference(self): + # When `include_reference=False`, the collator only emits the chosen/rejected halves so the per-step + # compute/memory cost matches DPO's `DataCollatorForPreference`. This is the layout used by + # `TPOTrainer` when `tpo_alpha=0.0`. + collator = DataCollatorForTriplePreference(pad_token_id=0, include_reference=False) + examples = [ + {"prompt_ids": [1, 2, 3], "chosen_ids": [4, 5], "rejected_ids": [6], "reference_ids": [7, 8]}, + {"prompt_ids": [9, 10], "chosen_ids": [11], "rejected_ids": [12, 13], "reference_ids": [14]}, + ] + result = collator(examples) + + expected_input_ids = torch.tensor( + [ + [1, 2, 3, 4, 5], # prompt + chosen (example 1) + [9, 10, 11, 0, 0], # prompt + chosen (example 2, padded) + [1, 2, 3, 6, 0], # prompt + rejected (example 1, padded) + [9, 10, 12, 13, 0], # prompt + rejected (example 2, padded) + ] + ) + assert result["input_ids"].shape == (4, 5) # 2 * B rows, no reference branch + torch.testing.assert_close(result["input_ids"], expected_input_ids) + assert set(result.keys()) == {"input_ids", "attention_mask", "completion_mask"} + + +class TestTPOTrainer(TrlTestCase): + def test_train(self): + # Get the dataset and synthesize a reference (gold) completion + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + dataset = dataset.map(_add_reference_column) + + training_args = TPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + trainer = TPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_trust_remote_code(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + dataset = dataset.map(_add_reference_column) + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + + with pytest.raises(ValueError, match="custom code"): + TPOTrainer( + model=model_id, + args=TPOConfig(output_dir=self.tmp_dir, report_to="none"), + train_dataset=dataset, + ) + + trainer = TPOTrainer( + model=model_id, + args=TPOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + train_dataset=dataset, + ) + assert type(trainer.model).__name__ == "RemoteForCausalLM" + + @pytest.mark.parametrize("loss_type", ["sigmoid", "hinge", "ipo", "tpo-l"]) + def test_train_loss_types(self, loss_type): + # Get the dataset and synthesize a reference (gold) completion + dataset = load_dataset("trl-internal-testing/zen", "standard_preference") + dataset = dataset.map(_add_reference_column) + + training_args = TPOConfig( + output_dir=self.tmp_dir, + loss_type=loss_type, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + eval_strategy="steps", + eval_steps=3, + ) + trainer = TPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_conversational(self): + # Get the dataset and synthesize a reference (gold) completion + dataset = load_dataset("trl-internal-testing/zen", "conversational_preference", split="train") + dataset = dataset.map(_add_reference_column) + + training_args = TPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + report_to="none", + ) + trainer = TPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_without_nll(self): + # Setting tpo_alpha=0.0 disables the NLL term, skips the corresponding cross-entropy, and also drops the + # reference branch from the collated batch so the model doesn't pay the extra forward-pass cost. + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + dataset = dataset.map(_add_reference_column) + + training_args = TPOConfig( + output_dir=self.tmp_dir, + tpo_alpha=0.0, + learning_rate=0.1, + report_to="none", + ) + trainer = TPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + # The default collator should drop the reference branch entirely when `tpo_alpha=0.0`. + assert isinstance(trainer.data_collator, DataCollatorForTriplePreference) + assert trainer.data_collator.include_reference is False + + # Verify the collated batch is 2 * per_device_train_batch_size (chosen + rejected only), not 3 * B. + batch = trainer.data_collator(list(trainer.train_dataset.select(range(2)))) + assert batch["input_ids"].shape[0] == 4 # 2 branches * 2 examples + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_implicit_prompt(self): + # Implicit-prompt variant: no `prompt` column, the prompt is embedded in `chosen`/`rejected` and (for TPO) + # also in `reference`. Regression test for the `extract_prompt` bug where the reference column was left + # untouched, silently doubling the prompt in the reference branch. + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + # Synthesize a reference column that shares the same implicit prompt as chosen/rejected + dataset = dataset.map(_add_reference_column) + + training_args = TPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + report_to="none", + ) + trainer = TPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_implicit_prompt_mismatched_reference_raises(self): + # When the dataset has no `prompt` column and the `reference` completion does not share the implicit + # prompt prefix of `chosen`/`rejected`, the trainer must raise a clear error rather than silently + # corrupting the reference branch. + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + def _set_unrelated_reference(example): + example["reference"] = "unrelated completion without the shared prompt prefix." + return example + + dataset = dataset.map(_set_unrelated_reference) + + training_args = TPOConfig(output_dir=self.tmp_dir, report_to="none") + with pytest.raises(ValueError, match="implicit prompt"): + TPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + def test_missing_reference_column_raises(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = TPOConfig(output_dir=self.tmp_dir, report_to="none") + with pytest.raises(ValueError, match="reference"): + TPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + @require_peft + def test_train_with_peft(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + dataset = dataset.map(_add_reference_column) + + training_args = TPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, + report_to="none", + ) + trainer = TPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + for n, param in previous_trainable_params.items(): + if "lora" in n: + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b498d19eb05ab00ce809d0c3cb04384a2ab697f9 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_utils.py @@ -0,0 +1,160 @@ +# Copyright 2020-2026 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. + + +from datasets import Dataset, load_dataset +from transformers import AutoTokenizer + +from trl.experimental.utils import DataCollatorForChatML, truncate_dataset + +from ..testing_utils import TrlTestCase + + +class TestDataCollatorForChatML(TrlTestCase): + def setup_method(self): + # Initialize the tokenizer + self.tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + if self.tokenizer.pad_token is None: + self.tokenizer.pad_token = self.tokenizer.eos_token + + # Define token IDs + self.bos_token_id = self.tokenizer.bos_token_id if self.tokenizer.bos_token_id is not None else 1 + self.eos_token_id = self.tokenizer.eos_token_id if self.tokenizer.eos_token_id is not None else 2 + # Token ID for "true", the last assistant's response in the example: + self.ignore_index = -100 + self.max_length = 1024 + self.messages_key = "messages" + + # Example input + dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train") + self.examples = dataset.to_list() + + # Initialize the data collator + self.collator = DataCollatorForChatML( + tokenizer=self.tokenizer, + max_length=self.max_length, + ignore_index=self.ignore_index, + ) + + def test_data_collator_for_chatml(self): + # Process the data + data = self.collator(self.examples) + + # Verify basic shapes and types + assert "input_ids" in data + assert "attention_mask" in data + assert "labels" in data + assert "prompts" in data + assert "prompt_attention_mask" in data + + # Decode input_ids and labels for verification + input_ids = data["input_ids"][0].tolist() + labels = data["labels"][0].tolist() + prompt_only = data["prompts"][0].tolist() + + # Get the last assistant's response for comparison + last_message = self.examples[0][self.messages_key][-1] + assert last_message["role"] == "assistant", "Last message should be from assistant" + last_assistant_response = last_message["content"] + + # Verify that input_ids contain both prompt and response + decoded_input = self.tokenizer.decode(input_ids) + assert last_assistant_response in decoded_input, "Input should contain assistant's response" + + # Verify that prompts only contain the conversation up to the last response + decoded_prompt = self.tokenizer.decode(prompt_only) + assert last_assistant_response not in decoded_prompt, "Prompt should not contain assistant's response" + + # Verify labels are -100 for non-assistant parts + prompt_length = len(prompt_only) + assert all(label == self.ignore_index for label in labels[:prompt_length]), ( + "Labels should be ignore_index for prompt tokens" + ) + + # Verify labels match assistant response after prompt + # Add a filter to remove any trailing tokens after the first <|im_end|> + last_assistant_response_with_end = last_assistant_response + self.tokenizer.eos_token + last_assistant_response_tokens = self.tokenizer.encode( + last_assistant_response_with_end, add_special_tokens=False + ) + + response_labels = [] + for label in labels[prompt_length:]: + if label == self.ignore_index: + continue + response_labels.append(label) + if label == self.tokenizer.convert_tokens_to_ids("<|im_end|>"): + break + assert response_labels == last_assistant_response_tokens, "Labels should match assistant response tokens" + + # Verify there isn't a generation prompt at the end + generation_prompt = "<|im_start|>assistant" + assert not decoded_input.strip().endswith(generation_prompt), ( + f"Input should not end with generation prompt '{generation_prompt}'" + ) + + assert response_labels == last_assistant_response_tokens, "Labels should match assistant response tokens" + + +class TestTruncateExamples(TrlTestCase): + def test_with_dataset(self): + examples = { + "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]], + "attention_mask": [[0, 1, 1], [0, 0, 1, 1], [1]], + } + dataset = Dataset.from_dict(examples) + dataset = dataset.with_format("numpy", dtype="float32") + format = dataset.format + max_length = 2 + expected_output = { + "input_ids": [[1, 2], [4, 5], [8]], + "attention_mask": [[0, 1], [0, 0], [1]], + } + dataset = truncate_dataset(dataset, max_length) + assert dataset.to_dict() == expected_output + assert format == dataset.format + + def test_with_iterable_dataset(self): + examples = { + "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]], + "attention_mask": [[0, 1, 1], [0, 0, 1, 1], [1]], + } + dataset = Dataset.from_dict(examples).to_iterable_dataset() + dataset = dataset.with_format("numpy") + formatting = dataset._formatting + max_length = 2 + expected_output = { + "input_ids": [[1, 2], [4, 5], [8]], + "attention_mask": [[0, 1], [0, 0], [1]], + } + dataset = truncate_dataset(dataset, max_length) + num_examples = len(examples[next(iter(examples))]) + assert next(iter(dataset.with_format(None).batch(batch_size=num_examples))) == expected_output + assert formatting == dataset._formatting + + def test_with_extra_column(self): + examples = { + "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]], + "attention_mask": [[0, 1, 1], [0, 0, 1, 1], [1]], + "my_column": ["a", "b", "c"], + } + dataset = Dataset.from_dict(examples) + max_length = 2 + expected_output = { + "input_ids": [[1, 2], [4, 5], [8]], + "attention_mask": [[0, 1], [0, 0], [1]], + "my_column": ["a", "b", "c"], + } + dataset = truncate_dataset(dataset, max_length) + assert dataset.to_dict() == expected_output diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_xpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_xpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..2c81e1f7c474c731899321b09405c0ee9c0e6954 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/experimental/test_xpo_trainer.py @@ -0,0 +1,143 @@ +# Copyright 2020-2026 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 pytest +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer +from transformers.utils import is_peft_available + +from trl.experimental.xpo import XPOConfig, XPOTrainer + +from ..testing_utils import TrlTestCase, require_peft + + +if is_peft_available(): + from peft import LoraConfig, get_peft_model + + +@pytest.mark.low_priority +class TestXPOTrainer(TrlTestCase): + def setup_method(self): + self.model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype="float32") + self.ref_model = AutoModelForCausalLM.from_pretrained(self.model_id) + self.reward_model = AutoModelForSequenceClassification.from_pretrained(self.model_id, num_labels=1) + self.tokenizer = AutoTokenizer.from_pretrained(self.model_id) + self.tokenizer.pad_token = self.tokenizer.eos_token + + @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"]) + def test_xpo_trainer_training(self, config_name): + training_args = XPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + remove_unused_columns=False, + gradient_accumulation_steps=1, + learning_rate=9e-1, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", config_name, split="train") + + trainer = XPOTrainer( + model=self.model, + ref_model=self.ref_model, + reward_funcs=self.reward_model, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset, + ) + + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + @require_peft + def test_train_with_peft(self): + lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM") + training_args = XPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + learning_rate=5.0e-7, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = XPOTrainer( + model=self.model, + reward_funcs=self.reward_model, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset, + peft_config=lora_config, + ) + + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + @require_peft + def test_train_with_peft_and_ref_model(self): + lora_config = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM") + training_args = XPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, + max_steps=3, + learning_rate=5.0e-7, + report_to="none", + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = XPOTrainer( + model=self.model, + ref_model=self.ref_model, + reward_funcs=self.reward_model, + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset, + peft_config=lora_config, + ) + + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] + + @require_peft + def test_train_pre_pefted_model_implicit_ref(self): + lora_config = LoraConfig(r=8, lora_alpha=16, lora_dropout=0.1, bias="none", task_type="CAUSAL_LM") + peft_model_instance = get_peft_model(self.model, lora_config) + + training_args = XPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, + max_steps=2, + learning_rate=5.0e-7, + eval_strategy="no", + report_to="none", + remove_unused_columns=False, + ) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + trainer = XPOTrainer( + model=peft_model_instance, + ref_model=None, + reward_funcs=self.reward_model, # Using reward_model to ensure _generate_completions is used as expected + args=training_args, + processing_class=self.tokenizer, + train_dataset=dataset, + ) + + trainer.train() + + assert "train_loss" in trainer.state.log_history[-1] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/README.md b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6bb9d5e7809b51db3d6d411515dcec6a193810bc --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/README.md @@ -0,0 +1,57 @@ +# Training invariant tests + +Catches silent training bugs that don't fail unit tests but shift the training trajectory. Runs on real models, opt-in only. + +## How it works + +Configs are grouped into **equivalence classes**: configs in the same class must produce the same trajectory (e.g. PDB=1×GAS=8 must equal PDB=8×GAS=1, FA2 must equal eager). Each class has one **canonical** config (the first one) that owns the class's reference snapshot. Every config in the class — canonical included — is asserted to match the saved reference. This catches both invariant breakage (a non-canonical config drifting away from the canonical's pinned trajectory) and numerical regressions (the canonical itself drifting from its committed snapshot across versions). + +Recording the references is a separate concern from testing them, so it's a separate entry point (`python tests/invariant/test_invariant.py`). + +Each config is a `trl ` CLI invocation with a fixed set of args. The harness shells out (`subprocess.run(["trl", method, ...])`), the CLI runs end to end, writes `trainer_state.json` to its `--output_dir`, and the harness parses the `log_history` into a `Trajectory`. + +This means the suite tests the actual user-facing entry point, not the Python API. Catches CLI-only bugs (arg parsing, defaults, dispatch) for free. Distributed runs are an additive change: prepend `accelerate launch --config_file .yaml` to the same command. + +## Scope (initial) + +- Trainers: `trl sft`, `trl dpo` +- Model: `Qwen/Qwen2.5-0.5B-Instruct` (pinned revision) +- Equivalence classes: + - `sft`: `sft_default` (canonical), `sft_pdb1_gas8` (gradient accumulation), `sft_attn_fa2_kernels` (FA2 via kernels) + - `dpo`: `dpo_default` (canonical), `dpo_pdb1_gas8` (gradient accumulation) +- Single GPU, fp32, fixed seed, ~50 optimizer steps. + +Other axes (sharding, DDP, more trainers) are deferred and will be additive. + +## Trajectory + +Per optimizer step: `loss`, `grad_norm`. One JSON per equivalence class in `references/` (`sft.json`, `dpo.json`): + +```json +{ + "config": {"name": "sft_default", "method": "sft", "args": {...}}, + "env": {"accelerate": "...", "torch": "...", "transformers": "...", "trl": "...", "gpu": "H100-80GB"}, + "steps": [{"step": 1, "loss": 1.234, "grad_norm": 0.567}, ...] +} +``` + +## Comparison + +Scalar series with absolute tolerance + zero-mean-residual. The residual check is what flags bugs like GAS-dropping — they show up as a one-sided systematic shift in the loss curve, not as point-wise outliers. + +## Hardware + +Reference snapshots are recorded on **H100 80GB** (pinned in `references/env.lock`). + +## Running + +```bash +# test +pytest tests/invariant/ -m invariant + +# record references +python tests/invariant/test_invariant.py # all classes +python tests/invariant/test_invariant.py sft # one class +``` + +Snapshot updates must be justified in the PR description. diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d26f4482fe3969b6de2b51bd1f85fc16dad6a65 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2020-2026 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. + diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/dpo.json b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/dpo.json new file mode 100644 index 0000000000000000000000000000000000000000..b13ed4133bc29f799b936d06624e52c73ddad6cb --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/dpo.json @@ -0,0 +1,280 @@ +{ + "config": { + "name": "dpo_default", + "method": "dpo", + "args": { + "model_name_or_path": "Qwen/Qwen2.5-0.5B-Instruct", + "model_revision": "7ae557604adf67be50417f59c2c2f167def9a775", + "attn_implementation": "eager", + "dataset_name": "trl-lib/ultrafeedback_binarized", + "max_steps": "50", + "max_length": "512", + "logging_steps": "1", + "report_to": "none", + "seed": "42", + "data_seed": "42", + "full_determinism": "True", + "bf16": "False" + } + }, + "env": { + "accelerate": "1.13.0", + "torch": "2.10.0+cu128", + "transformers": "5.10.0.dev0", + "trl": "f4e94c0c10654ab57b94e7cd8096ed4f12246e03", + "python": "3.13.13", + "gpu": "NVIDIA H100 80GB HBM3" + }, + "steps": [ + { + "step": 1, + "loss": 0.6931471824645996, + "grad_norm": 157.25071716308594 + }, + { + "step": 2, + "loss": 0.6901174783706665, + "grad_norm": 108.38384246826172 + }, + { + "step": 3, + "loss": 0.6326549053192139, + "grad_norm": 140.2856903076172 + }, + { + "step": 4, + "loss": 0.7054474353790283, + "grad_norm": 151.10508728027344 + }, + { + "step": 5, + "loss": 0.7342866063117981, + "grad_norm": 157.84791564941406 + }, + { + "step": 6, + "loss": 0.6869831085205078, + "grad_norm": 137.7687530517578 + }, + { + "step": 7, + "loss": 0.7037957906723022, + "grad_norm": 130.58058166503906 + }, + { + "step": 8, + "loss": 0.671793520450592, + "grad_norm": 164.77792358398438 + }, + { + "step": 9, + "loss": 0.6760100722312927, + "grad_norm": 102.67815399169922 + }, + { + "step": 10, + "loss": 0.6628016233444214, + "grad_norm": 123.41923522949219 + }, + { + "step": 11, + "loss": 0.6634430885314941, + "grad_norm": 83.91616821289062 + }, + { + "step": 12, + "loss": 0.7321300506591797, + "grad_norm": 161.53366088867188 + }, + { + "step": 13, + "loss": 0.7024844884872437, + "grad_norm": 150.16744995117188 + }, + { + "step": 14, + "loss": 0.6837225556373596, + "grad_norm": 123.26526641845703 + }, + { + "step": 15, + "loss": 0.7167133092880249, + "grad_norm": 133.57534790039062 + }, + { + "step": 16, + "loss": 0.6835181713104248, + "grad_norm": 124.6922378540039 + }, + { + "step": 17, + "loss": 0.6272522211074829, + "grad_norm": 100.10560607910156 + }, + { + "step": 18, + "loss": 0.8025375604629517, + "grad_norm": 198.8187713623047 + }, + { + "step": 19, + "loss": 0.7497490048408508, + "grad_norm": 136.41639709472656 + }, + { + "step": 20, + "loss": 0.7327032089233398, + "grad_norm": 135.1873016357422 + }, + { + "step": 21, + "loss": 0.8468657732009888, + "grad_norm": 183.79238891601562 + }, + { + "step": 22, + "loss": 0.6504813432693481, + "grad_norm": 119.43262481689453 + }, + { + "step": 23, + "loss": 0.8200190663337708, + "grad_norm": 221.7334747314453 + }, + { + "step": 24, + "loss": 0.6116989850997925, + "grad_norm": 134.1520233154297 + }, + { + "step": 25, + "loss": 0.715190052986145, + "grad_norm": 160.9645538330078 + }, + { + "step": 26, + "loss": 0.78664231300354, + "grad_norm": 173.35397338867188 + }, + { + "step": 27, + "loss": 0.627922534942627, + "grad_norm": 118.79180145263672 + }, + { + "step": 28, + "loss": 0.6171221733093262, + "grad_norm": 143.510986328125 + }, + { + "step": 29, + "loss": 0.7258801460266113, + "grad_norm": 166.77137756347656 + }, + { + "step": 30, + "loss": 0.6643164157867432, + "grad_norm": 109.94638061523438 + }, + { + "step": 31, + "loss": 0.8424814343452454, + "grad_norm": 155.43392944335938 + }, + { + "step": 32, + "loss": 0.6372821927070618, + "grad_norm": 165.25477600097656 + }, + { + "step": 33, + "loss": 0.6878336668014526, + "grad_norm": 132.20591735839844 + }, + { + "step": 34, + "loss": 0.7095304131507874, + "grad_norm": 168.26194763183594 + }, + { + "step": 35, + "loss": 0.6994724273681641, + "grad_norm": 126.31066131591797 + }, + { + "step": 36, + "loss": 0.6479494571685791, + "grad_norm": 162.87469482421875 + }, + { + "step": 37, + "loss": 0.7106008529663086, + "grad_norm": 142.19422912597656 + }, + { + "step": 38, + "loss": 0.6147706508636475, + "grad_norm": 124.1236343383789 + }, + { + "step": 39, + "loss": 0.6274570226669312, + "grad_norm": 97.5869369506836 + }, + { + "step": 40, + "loss": 0.5677652359008789, + "grad_norm": 99.20594787597656 + }, + { + "step": 41, + "loss": 0.5417441129684448, + "grad_norm": 136.53424072265625 + }, + { + "step": 42, + "loss": 0.6146669983863831, + "grad_norm": 117.05335998535156 + }, + { + "step": 43, + "loss": 0.5652309656143188, + "grad_norm": 141.68212890625 + }, + { + "step": 44, + "loss": 0.6843374967575073, + "grad_norm": 123.86646270751953 + }, + { + "step": 45, + "loss": 0.700664758682251, + "grad_norm": 176.58290100097656 + }, + { + "step": 46, + "loss": 0.627228856086731, + "grad_norm": 93.38623046875 + }, + { + "step": 47, + "loss": 0.6068558096885681, + "grad_norm": 144.66879272460938 + }, + { + "step": 48, + "loss": 0.7041699886322021, + "grad_norm": 147.3819122314453 + }, + { + "step": 49, + "loss": 0.6936260461807251, + "grad_norm": 114.99978637695312 + }, + { + "step": 50, + "loss": 0.8024596571922302, + "grad_norm": 156.8375244140625 + } + ] +} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/sft.json b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/sft.json new file mode 100644 index 0000000000000000000000000000000000000000..f0d292b6d878793470222cebc553eb1a39cb7672 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/sft.json @@ -0,0 +1,280 @@ +{ + "config": { + "name": "sft_default", + "method": "sft", + "args": { + "model_name_or_path": "Qwen/Qwen2.5-0.5B-Instruct", + "model_revision": "7ae557604adf67be50417f59c2c2f167def9a775", + "attn_implementation": "eager", + "dataset_name": "trl-lib/Capybara", + "max_steps": "50", + "max_length": "512", + "logging_steps": "1", + "report_to": "none", + "seed": "42", + "data_seed": "42", + "full_determinism": "True", + "bf16": "False" + } + }, + "env": { + "accelerate": "1.13.0", + "torch": "2.10.0+cu128", + "transformers": "5.10.0.dev0", + "trl": "f4e94c0c10654ab57b94e7cd8096ed4f12246e03", + "python": "3.13.13", + "gpu": "NVIDIA H100 80GB HBM3" + }, + "steps": [ + { + "step": 1, + "loss": 2.3842217922210693, + "grad_norm": 28.170888900756836 + }, + { + "step": 2, + "loss": 1.4120551347732544, + "grad_norm": 16.11708641052246 + }, + { + "step": 3, + "loss": 1.6543627977371216, + "grad_norm": 9.521869659423828 + }, + { + "step": 4, + "loss": 1.548227071762085, + "grad_norm": 9.530509948730469 + }, + { + "step": 5, + "loss": 1.3084965944290161, + "grad_norm": 13.43132209777832 + }, + { + "step": 6, + "loss": 1.4568636417388916, + "grad_norm": 11.567093849182129 + }, + { + "step": 7, + "loss": 1.6642777919769287, + "grad_norm": 8.233135223388672 + }, + { + "step": 8, + "loss": 1.6268576383590698, + "grad_norm": 6.363206386566162 + }, + { + "step": 9, + "loss": 1.5339726209640503, + "grad_norm": 6.955142974853516 + }, + { + "step": 10, + "loss": 1.547467827796936, + "grad_norm": 5.978666305541992 + }, + { + "step": 11, + "loss": 1.7950178384780884, + "grad_norm": 7.241233825683594 + }, + { + "step": 12, + "loss": 1.8137775659561157, + "grad_norm": 8.63271713256836 + }, + { + "step": 13, + "loss": 1.3856267929077148, + "grad_norm": 6.400929927825928 + }, + { + "step": 14, + "loss": 1.3795125484466553, + "grad_norm": 6.382791996002197 + }, + { + "step": 15, + "loss": 1.3708516359329224, + "grad_norm": 6.692564010620117 + }, + { + "step": 16, + "loss": 1.8075040578842163, + "grad_norm": 7.801014423370361 + }, + { + "step": 17, + "loss": 1.254800796508789, + "grad_norm": 5.860067367553711 + }, + { + "step": 18, + "loss": 1.6014561653137207, + "grad_norm": 7.397754669189453 + }, + { + "step": 19, + "loss": 1.5693073272705078, + "grad_norm": 6.078225612640381 + }, + { + "step": 20, + "loss": 1.2925223112106323, + "grad_norm": 6.285624027252197 + }, + { + "step": 21, + "loss": 1.261284589767456, + "grad_norm": 5.98115348815918 + }, + { + "step": 22, + "loss": 1.016650676727295, + "grad_norm": 6.040045261383057 + }, + { + "step": 23, + "loss": 1.222269058227539, + "grad_norm": 6.034141540527344 + }, + { + "step": 24, + "loss": 1.45418381690979, + "grad_norm": 6.263362407684326 + }, + { + "step": 25, + "loss": 1.23504638671875, + "grad_norm": 5.99455451965332 + }, + { + "step": 26, + "loss": 1.2722694873809814, + "grad_norm": 5.834524631500244 + }, + { + "step": 27, + "loss": 2.2606589794158936, + "grad_norm": 7.2228522300720215 + }, + { + "step": 28, + "loss": 1.4542038440704346, + "grad_norm": 6.190547466278076 + }, + { + "step": 29, + "loss": 1.3753437995910645, + "grad_norm": 5.7064290046691895 + }, + { + "step": 30, + "loss": 1.0842117071151733, + "grad_norm": 6.300862789154053 + }, + { + "step": 31, + "loss": 1.6317358016967773, + "grad_norm": 6.022386074066162 + }, + { + "step": 32, + "loss": 1.4107545614242554, + "grad_norm": 6.697302341461182 + }, + { + "step": 33, + "loss": 1.5427740812301636, + "grad_norm": 6.703666687011719 + }, + { + "step": 34, + "loss": 1.0882741212844849, + "grad_norm": 6.260556697845459 + }, + { + "step": 35, + "loss": 2.1459619998931885, + "grad_norm": 6.938933849334717 + }, + { + "step": 36, + "loss": 1.7524574995040894, + "grad_norm": 6.392754554748535 + }, + { + "step": 37, + "loss": 1.558825135231018, + "grad_norm": 7.106125831604004 + }, + { + "step": 38, + "loss": 1.5750346183776855, + "grad_norm": 6.705704689025879 + }, + { + "step": 39, + "loss": 1.0681045055389404, + "grad_norm": 5.93332576751709 + }, + { + "step": 40, + "loss": 1.4508510828018188, + "grad_norm": 6.193344593048096 + }, + { + "step": 41, + "loss": 1.5779269933700562, + "grad_norm": 6.469877243041992 + }, + { + "step": 42, + "loss": 1.2731173038482666, + "grad_norm": 6.590377330780029 + }, + { + "step": 43, + "loss": 1.34458327293396, + "grad_norm": 5.618240833282471 + }, + { + "step": 44, + "loss": 1.5110447406768799, + "grad_norm": 5.829492092132568 + }, + { + "step": 45, + "loss": 1.9833546876907349, + "grad_norm": 6.42317533493042 + }, + { + "step": 46, + "loss": 2.0645744800567627, + "grad_norm": 7.079426288604736 + }, + { + "step": 47, + "loss": 1.0404279232025146, + "grad_norm": 5.035366535186768 + }, + { + "step": 48, + "loss": 1.3794283866882324, + "grad_norm": 5.685641288757324 + }, + { + "step": 49, + "loss": 1.4115599393844604, + "grad_norm": 6.172175407409668 + }, + { + "step": 50, + "loss": 1.3042362928390503, + "grad_norm": 5.568996906280518 + } + ] +} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/sft_fa2.json b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/sft_fa2.json new file mode 100644 index 0000000000000000000000000000000000000000..3f01f3223d3c6a7dc342518eb9542098b97f5996 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/references/sft_fa2.json @@ -0,0 +1,281 @@ +{ + "config": { + "name": "sft_fa2", + "method": "sft", + "args": { + "model_name_or_path": "Qwen/Qwen2.5-0.5B-Instruct", + "model_revision": "7ae557604adf67be50417f59c2c2f167def9a775", + "attn_implementation": "kernels-community/flash-attn2", + "dataset_name": "trl-lib/Capybara", + "max_steps": "50", + "max_length": "None", + "logging_steps": "1", + "report_to": "none", + "seed": "42", + "data_seed": "42", + "full_determinism": "True", + "bf16": "True", + "per_device_train_batch_size": "2" + } + }, + "env": { + "accelerate": "1.14.0", + "torch": "2.10.0+cu128", + "transformers": "5.12.1", + "trl": "b58947c7e3f6a3ccddc56771f4bfa65c0d72bb41", + "python": "3.13.13", + "gpu": "NVIDIA H100 80GB HBM3" + }, + "steps": [ + { + "step": 1, + "loss": 2.0777087211608887, + "grad_norm": 23.31194496154785 + }, + { + "step": 2, + "loss": 1.5329023599624634, + "grad_norm": 18.577106475830078 + }, + { + "step": 3, + "loss": 1.3667995929718018, + "grad_norm": 15.29236125946045 + }, + { + "step": 4, + "loss": 2.432100296020508, + "grad_norm": 10.477559089660645 + }, + { + "step": 5, + "loss": 1.4821819067001343, + "grad_norm": 12.838624954223633 + }, + { + "step": 6, + "loss": 1.2035114765167236, + "grad_norm": 9.587946891784668 + }, + { + "step": 7, + "loss": 1.4986138343811035, + "grad_norm": 9.106823921203613 + }, + { + "step": 8, + "loss": 1.3387559652328491, + "grad_norm": 9.543354034423828 + }, + { + "step": 9, + "loss": 1.7545020580291748, + "grad_norm": 8.437145233154297 + }, + { + "step": 10, + "loss": 1.604130744934082, + "grad_norm": 45.08439636230469 + }, + { + "step": 11, + "loss": 1.3063030242919922, + "grad_norm": 7.061337947845459 + }, + { + "step": 12, + "loss": 1.4820657968521118, + "grad_norm": 7.337648391723633 + }, + { + "step": 13, + "loss": 1.0585386753082275, + "grad_norm": 9.335886001586914 + }, + { + "step": 14, + "loss": 1.2921745777130127, + "grad_norm": 6.186776161193848 + }, + { + "step": 15, + "loss": 1.3104896545410156, + "grad_norm": 9.37338924407959 + }, + { + "step": 16, + "loss": 1.5219330787658691, + "grad_norm": 9.168572425842285 + }, + { + "step": 17, + "loss": 1.5855588912963867, + "grad_norm": 14.43403148651123 + }, + { + "step": 18, + "loss": 0.731721818447113, + "grad_norm": 12.131467819213867 + }, + { + "step": 19, + "loss": 1.6662267446517944, + "grad_norm": 6.035709381103516 + }, + { + "step": 20, + "loss": 1.0886207818984985, + "grad_norm": 9.489429473876953 + }, + { + "step": 21, + "loss": 1.1482083797454834, + "grad_norm": 8.50695514678955 + }, + { + "step": 22, + "loss": 1.0655895471572876, + "grad_norm": 6.936838150024414 + }, + { + "step": 23, + "loss": 1.3867775201797485, + "grad_norm": 9.368760108947754 + }, + { + "step": 24, + "loss": 1.888922095298767, + "grad_norm": 19.709505081176758 + }, + { + "step": 25, + "loss": 1.9733335971832275, + "grad_norm": 7.740928649902344 + }, + { + "step": 26, + "loss": 2.064484119415283, + "grad_norm": 6.624837398529053 + }, + { + "step": 27, + "loss": 0.67816162109375, + "grad_norm": 5.390377521514893 + }, + { + "step": 28, + "loss": 1.41758131980896, + "grad_norm": 11.643660545349121 + }, + { + "step": 29, + "loss": 2.0091347694396973, + "grad_norm": 8.343645095825195 + }, + { + "step": 30, + "loss": 1.5923049449920654, + "grad_norm": 7.833315849304199 + }, + { + "step": 31, + "loss": 1.4399499893188477, + "grad_norm": 6.47890567779541 + }, + { + "step": 32, + "loss": 1.1694945096969604, + "grad_norm": 7.235599517822266 + }, + { + "step": 33, + "loss": 1.8836697340011597, + "grad_norm": 16.655620574951172 + }, + { + "step": 34, + "loss": 1.7419353723526, + "grad_norm": 10.752205848693848 + }, + { + "step": 35, + "loss": 1.484404444694519, + "grad_norm": 7.342534065246582 + }, + { + "step": 36, + "loss": 1.2079955339431763, + "grad_norm": 9.161640167236328 + }, + { + "step": 37, + "loss": 1.4994128942489624, + "grad_norm": 6.655267238616943 + }, + { + "step": 38, + "loss": 1.1862525939941406, + "grad_norm": 6.461650848388672 + }, + { + "step": 39, + "loss": 1.463683009147644, + "grad_norm": 8.37391185760498 + }, + { + "step": 40, + "loss": 1.8926860094070435, + "grad_norm": 6.237414836883545 + }, + { + "step": 41, + "loss": 1.6285597085952759, + "grad_norm": 8.78761100769043 + }, + { + "step": 42, + "loss": 1.6035821437835693, + "grad_norm": 8.460630416870117 + }, + { + "step": 43, + "loss": 1.4722487926483154, + "grad_norm": 8.564600944519043 + }, + { + "step": 44, + "loss": 2.4026732444763184, + "grad_norm": 8.871479988098145 + }, + { + "step": 45, + "loss": 2.15500545501709, + "grad_norm": 8.206993103027344 + }, + { + "step": 46, + "loss": 1.3589471578598022, + "grad_norm": 8.473345756530762 + }, + { + "step": 47, + "loss": 1.2295477390289307, + "grad_norm": 24.53108787536621 + }, + { + "step": 48, + "loss": 1.878961443901062, + "grad_norm": 6.903346538543701 + }, + { + "step": 49, + "loss": 0.6936798691749573, + "grad_norm": 7.316105365753174 + }, + { + "step": 50, + "loss": 0.9757086038589478, + "grad_norm": 12.083908081054688 + } + ] +} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/test_invariant.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/test_invariant.py new file mode 100644 index 0000000000000000000000000000000000000000..210923e8ce35170eb0e791419677f2cadfa3d85a --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/invariant/test_invariant.py @@ -0,0 +1,299 @@ +# Copyright 2020-2026 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 platform +import subprocess +import sys +import tempfile +from dataclasses import asdict, dataclass +from pathlib import Path + +import accelerate +import pytest +import torch +import transformers + + +MODEL = "Qwen/Qwen2.5-0.5B-Instruct" +MODEL_REVISION = "7ae557604adf67be50417f59c2c2f167def9a775" + +SFT_DATASET = "trl-lib/Capybara" +DPO_DATASET = "trl-lib/ultrafeedback_binarized" + +REFERENCES_DIR = Path(__file__).parent / "references" + +NUM_STEPS = 50 +SEED = 42 +MAX_LENGTH = 512 + + +def _trl_commit() -> str: + """Return the current trl commit SHA (with `-dirty` suffix if the working tree has uncommitted changes). + + Assumes the suite is run from a `pip install -e .` checkout — the only intended setup. + """ + cwd = Path(__file__).parent + sha = subprocess.run( + ["git", "-C", str(cwd), "rev-parse", "HEAD"], capture_output=True, text=True, check=True + ).stdout.strip() + dirty = subprocess.run( + ["git", "-C", str(cwd), "status", "--porcelain"], capture_output=True, text=True, check=True + ).stdout.strip() + return f"{sha}-dirty" if dirty else sha + + +def env_snapshot() -> dict: + return { + "accelerate": accelerate.__version__, + "torch": torch.__version__, + "transformers": transformers.__version__, + "trl": _trl_commit(), + "python": platform.python_version(), + "gpu": torch.cuda.get_device_name(0) if torch.cuda.is_available() else "cpu", + } + + +@dataclass +class StepRecord: + step: int + loss: float + grad_norm: float + + +@dataclass +class Trajectory: + config: dict + env: dict + steps: list[StepRecord] + + +@dataclass +class CorrectnessConfig: + name: str + method: str # "sft" | "dpo" + args: dict[str, str] + num_processes: int = 1 + + def cli_args(self) -> list[str]: + out: list[str] = [] + for k, v in self.args.items(): + out.extend([f"--{k}", v]) + return out + + +def run(config: CorrectnessConfig) -> Trajectory: + """Invoke the trl CLI as a subprocess; parse its trainer_state.json into a Trajectory.""" + with tempfile.TemporaryDirectory() as tmpdir: + cmd = ["trl", config.method] + cmd += ["--num_processes", str(config.num_processes)] + cmd += ["--output_dir", tmpdir, *config.cli_args()] + env = {**os.environ, "CUDA_VISIBLE_DEVICES": ",".join(str(i) for i in range(config.num_processes))} + subprocess.run(cmd, check=True, env=env) + + state_paths = list(Path(tmpdir).glob("**/trainer_state.json")) + if not state_paths: + raise RuntimeError(f"trainer_state.json not produced in {tmpdir}") + state = json.loads(state_paths[0].read_text()) + + steps = [ + StepRecord( + step=int(log["step"]), + loss=float(log["loss"]), + grad_norm=float(log["grad_norm"]), + ) + for log in state["log_history"] + if "loss" in log # skip eval and final-summary entries + ] + + return Trajectory( + config={"name": config.name, "method": config.method, "args": config.args}, + env=env_snapshot(), + steps=steps, + ) + + +def save(trajectory: Trajectory, path: Path) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(asdict(trajectory), indent=2)) + + +def load(path: Path) -> Trajectory: + data = json.loads(path.read_text()) + return Trajectory( + config=data["config"], + env=data["env"], + steps=[StepRecord(**s) for s in data["steps"]], + ) + + +def compare_scalars(a: Trajectory, b: Trajectory, tol: dict[str, float], residual_tol: dict[str, float]) -> list[str]: + """Compare scalar series (loss, grad_norm). `tol` and `residual_tol` are per-field dicts keyed by `'loss'` and + `'grad_norm'`.""" + errors: list[str] = [] + if len(a.steps) != len(b.steps): + return [f"length mismatch: {len(a.steps)} vs {len(b.steps)}"] + + for field in ("loss", "grad_norm"): + sa = [getattr(s, field) for s in a.steps] + sb = [getattr(s, field) for s in b.steps] + diffs = [x - y for x, y in zip(sa, sb, strict=False)] + max_abs = max(abs(d) for d in diffs) + if max_abs > tol[field]: + i = max(range(len(diffs)), key=lambda k: abs(diffs[k])) + step = a.steps[i].step + errors.append( + f"{field}: max |Δ|={max_abs:.3e} at step {step} (a={sa[i]:.6e}, b={sb[i]:.6e}, tol={tol[field]:.1e})" + ) + + mean = sum(diffs) / len(diffs) + if abs(mean) > residual_tol[field]: + errors.append(f"{field}: systematic drift, mean Δ={mean:.3e} (tol={residual_tol[field]:.1e})") + + return errors + + +def _build( + name: str, method: str, dataset: str, attn: str = "eager", num_processes: int = 1, **overrides +) -> CorrectnessConfig: + args: dict[str, str] = { + "model_name_or_path": MODEL, + "model_revision": MODEL_REVISION, + "attn_implementation": attn, + "dataset_name": dataset, + "max_steps": str(NUM_STEPS), + "max_length": str(MAX_LENGTH), + "logging_steps": "1", + "report_to": "none", + "seed": str(SEED), + "data_seed": str(SEED), + "full_determinism": "True", + # Force pure fp32 training for maximal determinism and to avoid bfloat16-induced divergences. + "bf16": "False", + } + args.update({k: str(v) for k, v in overrides.items()}) + return CorrectnessConfig(name=name, method=method, args=args, num_processes=num_processes) + + +# Equivalence classes: each maps to a `members` list plus per-field `tol` (max |Δ|) and `residual_tol` (mean Δ) +# dicts. The first member is the canonical config — it owns the class's reference snapshot and is the only one +# re-recorded under `--update-references`. Every other member is asserted to match that snapshot. +# Tuning tip: run `python tests/invariant/test_invariant.py --report` to see actual Δs and set tolerances +# to ~1.5–2× the observed noise. +EQUIVALENCE_CLASSES: dict[str, dict] = { + "sft": { + "tol": {"loss": 1e-3, "grad_norm": 1e-1}, + "residual_tol": {"loss": 1e-5, "grad_norm": 1e-3}, + "members": [ + _build("sft_default", "sft", SFT_DATASET), + _build("sft_pdb1_gas8", "sft", SFT_DATASET, per_device_train_batch_size=1, gradient_accumulation_steps=8), + _build("sft_no_grad_ckpt", "sft", SFT_DATASET, gradient_checkpointing=False), + _build("sft_ddp2", "sft", SFT_DATASET, per_device_train_batch_size=4, num_processes=2), + ], + }, + "sft_fa2": { + # loss_type not pinned; this class exercises the current SFTConfig default ("chunked_nll"). + # Loss is much tighter than grad_norm under FA2+bf16 (grad_norm absorbs bf16 + FA varlen kernel noise). + # The grad_norm tol (5.0) is intentionally ~50× looser than the non-FA2 sft class (0.1): it is sized to the + # FA2 varlen kernel noise observed in practice, not a regression budget. Do not tighten it without re-running + # the class and confirming the new gap; see https://github.com/huggingface/trl/pull/5842#issuecomment-4539190615 + "tol": {"loss": 1.5e-2, "grad_norm": 5.0}, + "residual_tol": {"loss": 1e-3, "grad_norm": 2.5e-1}, + "members": [ + _build( + "sft_fa2", + "sft", + SFT_DATASET, + attn="kernels-community/flash-attn2", # to avoid cross-contamination between samples when padding_free=True + bf16=True, # required for FA2 kernels, which are bfloat16-only + max_length=None, # Required when padding_free=True + per_device_train_batch_size=2, + ), + _build( + "sft_fa2_padfree", + "sft", + SFT_DATASET, + attn="kernels-community/flash-attn2", # to avoid cross-contamination between samples when padding_free=True + bf16=True, # required for FA2 kernels, which are bfloat16-only + max_length=None, # Required when padding_free=True + per_device_train_batch_size=2, + padding_free=True, + ), + ], + }, + "dpo": { + "tol": {"loss": 1e-4, "grad_norm": 1e-2}, + "residual_tol": {"loss": 1e-5, "grad_norm": 1e-3}, + "members": [ + _build("dpo_default", "dpo", DPO_DATASET), + _build("dpo_pdb1_gas8", "dpo", DPO_DATASET, per_device_train_batch_size=1, gradient_accumulation_steps=8), + _build("dpo_no_grad_ckpt", "dpo", DPO_DATASET, gradient_checkpointing=False), + _build("dpo_ddp2", "dpo", DPO_DATASET, per_device_train_batch_size=4, num_processes=2), + ], + }, +} + + +_ALL = [(klass, c) for klass, ec in EQUIVALENCE_CLASSES.items() for c in ec["members"]] + + +@pytest.mark.invariant +@pytest.mark.parametrize("klass,config", _ALL, ids=[c.name for _, c in _ALL]) +def test_invariant(klass, config): + ref_path = REFERENCES_DIR / f"{klass}.json" + if not ref_path.exists(): + pytest.fail(f"no reference at {ref_path}; record it with `python {Path(__file__).name}`") + + if config.num_processes > 1 and torch.cuda.device_count() < config.num_processes: + pytest.skip(f"requires {config.num_processes} GPUs, got {torch.cuda.device_count()}") + + trajectory = run(config) + reference = load(ref_path) + ec = EQUIVALENCE_CLASSES[klass] + errors = compare_scalars(trajectory, reference, tol=ec["tol"], residual_tol=ec["residual_tol"]) + assert not errors, f"'{config.name}' diverges from class '{klass}' reference:\n " + "\n ".join(errors) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Record canonical reference trajectories for the invariant tests.") + parser.add_argument( + "klass", + nargs="*", + choices=list(EQUIVALENCE_CLASSES), + help="Equivalence class(es) to record. Default: all.", + ) + parser.add_argument( + "--allow-dirty", + action="store_true", + help="Allow recording from a dirty working tree (snapshot will pin an irreproducible state).", + ) + cli_args = parser.parse_args() + + if _trl_commit().endswith("-dirty") and not cli_args.allow_dirty: + sys.exit( + "Refusing to record from a dirty working tree: the snapshot would pin a state that can't be " + "reproduced from a commit SHA. Commit your changes first, or pass --allow-dirty to override." + ) + + classes = cli_args.klass or list(EQUIVALENCE_CLASSES) + for klass in classes: + canonical = EQUIVALENCE_CLASSES[klass]["members"][0] + print(f"recording '{klass}' from canonical config '{canonical.name}'") # noqa: T201 + trajectory = run(canonical) + ref_path = REFERENCES_DIR / f"{klass}.json" + save(trajectory, ref_path) + print(f" → {ref_path}") # noqa: T201 diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/tasksmith_behavior.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/tasksmith_behavior.py new file mode 100644 index 0000000000000000000000000000000000000000..493bd61c338556e5b4311e1bc13cbf951e854a5f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/tasksmith_behavior.py @@ -0,0 +1,202 @@ +import math +import pickle +import pytest + + +# --------------------------------------------------------------------------- +# Adjacent behavior: accuracy_reward already exists on the starting code. +# These tests pass before and after the PR. +# --------------------------------------------------------------------------- + +def test_accuracy_reward_correct_answer(): + from trl.rewards import accuracy_reward + completions = [[{"content": r"\boxed{\frac{1}{3}}"}]] + solution = [r"\frac{1}{3}"] + rewards = accuracy_reward(completions, solution) + assert rewards == [1.0] + + +def test_accuracy_reward_wrong_answer(): + from trl.rewards import accuracy_reward + completions = [[{"content": r"\boxed{\frac{1}{2}}"}]] + solution = [r"\frac{1}{3}"] + rewards = accuracy_reward(completions, solution) + assert rewards == [0.0] + + +# --------------------------------------------------------------------------- +# New behavior: get_cosine_scaled_reward (fails on starting code). +# Each test imports inside the function so collection never fails. +# --------------------------------------------------------------------------- + +def test_importable_from_trl_rewards(): + from trl.rewards import get_cosine_scaled_reward + fn = get_cosine_scaled_reward(max_len=100) + assert callable(fn) + + +def test_midpoint_values_default_bounds(): + """At progress=0.5 (cosine=0): correct->0.75, wrong->-0.75.""" + from trl.rewards import get_cosine_scaled_reward + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[1] * 50, [1] * 50] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards == [pytest.approx(0.75), pytest.approx(-0.75)] + + +def test_correct_shorter_rewarded_more(): + """Shorter correct completions receive a higher reward.""" + from trl.rewards import get_cosine_scaled_reward + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{3}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[1] * 25, [1] * 75] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards[0] > rewards[1] + assert rewards[0] == pytest.approx(0.92678, abs=1e-4) + assert rewards[1] == pytest.approx(0.57322, abs=1e-4) + + +def test_wrong_longer_penalized_less(): + """Longer wrong completions are penalized less (closer to zero).""" + from trl.rewards import get_cosine_scaled_reward + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{2}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[1] * 25, [1] * 75] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards[1] > rewards[0] + assert rewards[0] == pytest.approx(-0.92678, abs=1e-4) + assert rewards[1] == pytest.approx(-0.57322, abs=1e-4) + + +def test_correct_boundary_values(): + """Correct: empty (0 tokens) -> max_value_correct=1.0; full (max_len) -> min_value_correct=0.5.""" + from trl.rewards import get_cosine_scaled_reward + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{3}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[], [1] * 100] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards == [pytest.approx(1.0), pytest.approx(0.5)] + + +def test_wrong_boundary_values(): + """Wrong: empty (0 tokens) -> min_value_wrong=-1.0; full (max_len) -> max_value_wrong=-0.5.""" + from trl.rewards import get_cosine_scaled_reward + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{2}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[], [1] * 100] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards == [pytest.approx(-1.0), pytest.approx(-0.5)] + + +def test_length_exceeding_max_len_is_clamped(): + """Completions longer than max_len stay at the long-length bound value.""" + from trl.rewards import get_cosine_scaled_reward + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[1] * 200, [1] * 200] # 2x max_len + rewards = reward_fn(completions, solution, completion_ids) + # same as at exactly max_len + assert rewards == [pytest.approx(0.5), pytest.approx(-0.5)] + + +def test_unparsable_gold_yields_none(): + """An unparseable gold solution results in None reward for that example.""" + from trl.rewards import get_cosine_scaled_reward + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{42}"}]] + solution = ["forty two"] # plain text, not a math expression + completion_ids = [[1] * 50] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards == [None] + + +def test_custom_value_bounds(): + """Custom bounds are applied correctly in the formula.""" + from trl.rewards import get_cosine_scaled_reward + # At midpoint: 0.0 + 0.5*(2.0-0.0)*(1+0) = 1.0 + reward_fn = get_cosine_scaled_reward(max_len=100, min_value_correct=0.0, max_value_correct=2.0) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}]] + solution = [r"\frac{1}{3}"] + completion_ids = [[1] * 50] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards == [pytest.approx(1.0)] + + +def test_nondefault_configuration_and_pickle(): + """Budgets and all bounds govern fresh evaluations before and after pickling.""" + from trl.rewards import get_cosine_scaled_reward + + # Rows correspond to progress 0, 1/3, 1/2, 1, and 2 (clamped). + # Each row contains the independently expected correct and wrong rewards. + configurations = [ + ({}, [(1.0, -1.0), (0.875, -0.875), (0.75, -0.75), + (0.5, -0.5), (0.5, -0.5)]), + ({"min_value_wrong": -2.0, "max_value_wrong": -0.25, + "min_value_correct": 0.25, "max_value_correct": 1.25}, + [(1.25, -2.0), (1.0, -1.5625), (0.75, -1.125), + (0.25, -0.25), (0.25, -0.25)]), + ] + for budget in (60, 240): + for bounds, rows in configurations: + reward_fn = get_cosine_scaled_reward(max_len=budget, **bounds) + restored = pickle.loads(pickle.dumps(reward_fn)) + for fn in (reward_fn, restored): + assert fn.__name__ == "cosine_scaled_reward" + completions = [] + solutions = [] + token_ids = [] + for length in (0, budget // 3, budget // 2, budget, 2 * budget): + for answer in (r"\boxed{\frac{1}{3}}", r"\boxed{\frac{1}{2}}"): + completions.append([{"content": answer}]) + solutions.append(r"\frac{1}{3}") + token_ids.append([7] * length) + rewards = fn(completions, solutions, token_ids) + assert isinstance(rewards, list) + assert rewards == pytest.approx([value for row in rows for value in row]) + + +def test_mathematical_correctness_not_substring_matching(): + """Equivalent expressions count; mentioning the gold is not a correct final answer.""" + from trl.rewards import accuracy_reward, get_cosine_scaled_reward + + cases = [ + (r"\boxed{1+1}", "2", 1.0, 0.75), + (r"I considered 2, but my final answer is \boxed{3}.", "2", 0.0, -0.75), + (r"\boxed{\frac{6}{8}}", r"\frac{3}{4}", 1.0, 0.75), + (r"I considered 5, but my final answer is \boxed{6}.", "5", 0.0, -0.75), + ] + reward_fn = get_cosine_scaled_reward(max_len=80) + restored = pickle.loads(pickle.dumps(reward_fn)) + for fn in (reward_fn, restored): + completions = [[{"content": content}] for content, _, _, _ in cases] + solutions = [gold for _, gold, _, _ in cases] + # Validate fixture semantics against the repository's real math-verification API. + # Expected cosine rewards are independent of this submitted accuracy function. + assert accuracy_reward(completions, solutions) == [case[2] for case in cases] + rewards = fn( + completions=completions, + solution=solutions, + completion_ids=[[7] * 40 for _ in cases], + unused_trainer_metadata=None, + ) + assert isinstance(rewards, list) + assert rewards == pytest.approx([case[3] for case in cases]) + + +def test_reward_is_picklable(): + """The reward function survives pickle round-trip with correct behavior and __name__.""" + from trl.rewards import get_cosine_scaled_reward + reward_fn = get_cosine_scaled_reward(max_len=100) + unpickled = pickle.loads(pickle.dumps(reward_fn)) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}]] + solution = [r"\frac{1}{3}"] + completion_ids = [[1] * 50] + assert unpickled(completions, solution, completion_ids) == [pytest.approx(0.75)] + assert unpickled.__name__ == "cosine_scaled_reward" diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_activation_offloading.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_activation_offloading.py new file mode 100644 index 0000000000000000000000000000000000000000..5f2f6a03b4bb78911a64e08db2775094fd896edb --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_activation_offloading.py @@ -0,0 +1,237 @@ +# Copyright 2020-2026 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 torch +from torch import nn +from transformers import AutoModelForCausalLM +from transformers.testing_utils import torch_device +from transformers.utils import is_peft_available + +from trl.models.activation_offloading import NoOpManager, OffloadActivations + +from .testing_utils import TrlTestCase, require_peft, require_torch_accelerator + + +if is_peft_available(): + from peft import LoraConfig, get_peft_model + + +class TestActivationOffloading(TrlTestCase): + @require_torch_accelerator + @require_peft + def test_offloading_with_peft_models(self) -> None: + """Test that activation offloading works with PEFT models.""" + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id).to(torch_device) + peft_config = LoraConfig( + lora_alpha=16, + lora_dropout=0.1, + r=8, + bias="none", + task_type="CAUSAL_LM", + ) + + model = get_peft_model(model, peft_config) + inp = torch.randint(0, 100, (2, 10), device=torch_device) + + # First forward-backward pass without offloading + torch.manual_seed(42) + loss = model(inp, labels=inp).loss + loss.backward() + + # Store gradients - only from trainable parameters + grads_original = [] + for name, param in model.named_parameters(): + if param.requires_grad and param.grad is not None: + grads_original.append((name, param.grad.clone())) + + # Reset gradients + for p in model.parameters(): + if p.grad is not None: + p.grad = None + + # Second forward-backward pass with offloading + torch.manual_seed(42) + with OffloadActivations(): + loss_c = model(inp, labels=inp).loss + loss_c.backward() + + # Compare gradients - only trainable parameters + for name_orig, grad_orig in grads_original: + for name_param, param in model.named_parameters(): + if name_param == name_orig and param.requires_grad and param.grad is not None: + ( + torch.testing.assert_close(grad_orig, param.grad, rtol=1e-4, atol=1e-5), + (f"Gradient mismatch for {name_orig}"), + ) + + @require_torch_accelerator + def test_noop_manager_with_offloading(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id).to(torch_device) + inp = torch.randint(0, 100, (2, 10), device=torch_device) + + # Run with offloading but disable for specific section + with OffloadActivations(): + # First forward-backward with normal offloading + torch.manual_seed(42) + out1 = model(inp, labels=inp) + out1.loss.backward() + grads1 = [p.grad.clone() for p in model.parameters()] + + # Reset grads + for p in model.parameters(): + p.grad = None + + # Second forward-backward with NoOpManager + with NoOpManager(): + torch.manual_seed(42) + out2 = model(inp, labels=inp) + out2.loss.backward() + + grads2 = [p.grad.clone() for p in model.parameters()] + + # Gradients should match as NoOpManager should have prevented offloading + for g1, g2 in zip(grads1, grads2, strict=True): + torch.testing.assert_close(g1, g2, rtol=1e-4, atol=1e-5) + + @require_torch_accelerator + def test_min_offload_size(self): + """Test that tensors smaller than min_offload_size aren't offloaded""" + model = nn.Sequential( + nn.Linear(5, 5), # Small layer that shouldn't be offloaded + nn.Linear(5, 1000), # Large layer that should be offloaded + ).to(torch_device) + + inp = torch.randn(2, 5, device=torch_device) + + with OffloadActivations(min_offload_size=1000): + out = model(inp) + out.sum().backward() + + # The test passes if no errors occur, as we're mainly testing + # that the logic handles both offloaded and non-offloaded tensors + + @require_torch_accelerator + def test_real_hf_model(self): + """Test with an actual HuggingFace model""" + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id).to(torch_device) + + # Create small input + inp = torch.randint(0, 100, (2, 10), device=torch_device) + + # Baseline without offloading + torch.manual_seed(42) + out1 = model(inp, labels=inp).loss + out1.backward() + grads1 = [p.grad.clone() for p in model.parameters()] + + # Reset grads + for p in model.parameters(): + p.grad = None + + # With offloading + with OffloadActivations(): + torch.manual_seed(42) + out2 = model(inp, labels=inp).loss + out2.backward() + + grads2 = [p.grad.clone() for p in model.parameters()] + + # Check outputs and gradients match + torch.testing.assert_close(out1, out2) + for g1, g2 in zip(grads1, grads2, strict=True): + torch.testing.assert_close(g1, g2) + + @require_torch_accelerator + def test_tensor_deduplication(self): + """Test that deduplication works correctly for tensors sharing storage""" + + class ModelWithViews(nn.Module): + def __init__(self): + super().__init__() + self.linear = nn.Linear(100, 100) + + def forward(self, x): + out = self.linear(x) + view1 = out.view(-1) + view2 = out.transpose(0, 1) + return view1.sum() + view2.sum() + + model = ModelWithViews().to(torch_device) + offload_ctx = OffloadActivations(min_offload_size=1) + offload_ctx.update_model_params(model) + + x = torch.randn(10, 100, device=torch_device, requires_grad=True) + with offload_ctx: + loss = model(x) + + total_tensor_ids = offload_ctx.tensor_id + assert total_tensor_ids > 0, "Should have created tensor IDs" + + # modified=True means offloaded to CPU, modified=False means kept on GPU (deduplicated) + deduplicated_count = sum(1 for _, modified, _, _, _ in offload_ctx.tracker.values() if not modified) + offloaded_count = sum(1 for _, modified, _, _, _ in offload_ctx.tracker.values() if modified) + + assert offloaded_count > 0, "Should have offloaded at least one tensor" + assert deduplicated_count > 0, "Should have deduplicated at least one tensor (view)" + + unique_storages_offloaded = len(offload_ctx.storage_to_tensor_id) + assert unique_storages_offloaded < total_tensor_ids, ( + f"Deduplication should result in fewer storages ({unique_storages_offloaded}) " + f"than total tensors ({total_tensor_ids})" + ) + + loss.backward() + + @require_torch_accelerator + def test_stale_tracker_state_is_cleared_between_forwards(self): + """Test that tensors from unused graph branches don't accumulate across steps.""" + + class ModelWithUnusedBranch(nn.Module): + def __init__(self): + super().__init__() + self.used = nn.Linear(8, 8) + self.unused = nn.Linear(8, 8) + + def forward(self, x): + return self.used(x).sum(), self.unused(x).sum() + + model = ModelWithUnusedBranch().to(torch_device) + offload_ctx = OffloadActivations(use_pin_memory=False, use_streams=False, min_offload_size=1) + offload_ctx.update_model_params(model) + inp = torch.randn(4, 8, device=torch_device) + + tracker_counts = [] + for _ in range(3): + model.zero_grad(set_to_none=True) + with offload_ctx: + loss, _ = model(inp) + loss.backward() + tracker_counts.append(len(offload_ctx.tracker)) + + assert tracker_counts == [tracker_counts[0]] * len(tracker_counts) + + @require_torch_accelerator + def test_parameter_filtering(self): + """Test that model parameters are filtered during offloading""" + model = nn.Sequential(nn.Linear(10, 20), nn.Linear(20, 10)).to(torch_device) + offload_ctx = OffloadActivations() + offload_ctx.update_model_params(model) + + assert len(offload_ctx.param_storages) > 0, "Should have tracked parameter storages" + + param_ptrs = {p.data.untyped_storage().data_ptr() for p in model.parameters()} + assert offload_ctx.param_storages == param_ptrs, "Tracked storages should match parameter storages" diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_callbacks.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_callbacks.py new file mode 100644 index 0000000000000000000000000000000000000000..ef2aa71d81644f11b5963974d3f5f849334a93fd --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_callbacks.py @@ -0,0 +1,238 @@ +# Copyright 2020-2026 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 +from unittest.mock import call, patch + +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig, Trainer, TrainingArguments + +from trl import BEMACallback, LogCompletionsCallback + +from .testing_utils import TrlTestCase, require_comet, require_wandb + + +class TestLogCompletionsCallback(TrlTestCase): + def setup_method(self): + self.model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + self.tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + self.tokenizer.pad_token = self.tokenizer.eos_token + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only") + dataset["train"] = dataset["train"].select(range(8)) + + def tokenize_function(examples): + out = self.tokenizer(examples["prompt"], padding="max_length", max_length=16, truncation=True) + out["labels"] = out["input_ids"].copy() + return out + + self.dataset = dataset.map(tokenize_function, batched=True) + + self.generation_config = GenerationConfig(max_length=32) + + @require_wandb + def test_basic_wandb(self): + import wandb + + training_args = TrainingArguments( + output_dir=self.tmp_dir, + eval_strategy="steps", + eval_steps=2, # evaluate every 2 steps + per_device_train_batch_size=2, # 8 samples in total so 4 batches of 2 per epoch + per_device_eval_batch_size=2, + report_to="wandb", + ) + trainer = Trainer( + model=self.model, + args=training_args, + train_dataset=self.dataset["train"], + eval_dataset=self.dataset["test"], + processing_class=self.tokenizer, + ) + completions_callback = LogCompletionsCallback(trainer, self.generation_config, num_prompts=2) + trainer.add_callback(completions_callback) + trainer.train() + + # Get the current run + completions_path = wandb.run.summary.completions["path"] + json_path = os.path.join(wandb.run.dir, completions_path) + with open(json_path) as f: + completions = json.load(f) + + # Check that the columns are correct + assert "step" in completions["columns"] + assert "prompt" in completions["columns"] + assert "completion" in completions["columns"] + + # Check that the prompt is in the log + assert self.dataset["test"][0]["prompt"] in completions["data"][0] + + @require_comet + def test_basic_comet(self): + import comet_ml + + training_args = TrainingArguments( + output_dir=self.tmp_dir, + eval_strategy="steps", + eval_steps=2, # evaluate every 2 steps + per_device_train_batch_size=2, # 8 samples in total so 4 batches of 2 per epoch + per_device_eval_batch_size=2, + report_to="comet_ml", + ) + trainer = Trainer( + model=self.model, + args=training_args, + train_dataset=self.dataset["train"], + eval_dataset=self.dataset["test"], + processing_class=self.tokenizer, + ) + completions_callback = LogCompletionsCallback(trainer, self.generation_config, num_prompts=2) + trainer.add_callback(completions_callback) + trainer.train() + + # close experiment to make sure all pending data are flushed + experiment = comet_ml.get_running_experiment() + assert experiment is not None + experiment.end() + + # get experiment assets and check that all required tables was logged + steps = len(self.dataset["train"]) + len(self.dataset["test"]) + tables_logged = int(steps / 2) + 1 # +1 to include zero step + + api_experiment = comet_ml.APIExperiment(previous_experiment=experiment.id) + tables = api_experiment.get_asset_list("dataframe") + assert tables is not None + assert len(tables) == tables_logged + assert all(table["fileName"] == "completions.csv" for table in tables) + + +class TestBEMACallback(TrlTestCase): + def setup_method(self): + self.model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + self.tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + self.tokenizer.pad_token = self.tokenizer.eos_token + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling") + + def tokenize_function(examples, tokenizer): + out = tokenizer(examples["text"], padding="max_length", max_length=17) + out["labels"] = out["input_ids"].copy() + return out + + self.dataset = dataset.map( + tokenize_function, fn_kwargs={"tokenizer": self.tokenizer}, remove_columns=["text"], batched=True + ) + + def test_model_saved(self): + """Test that BEMACallback saves the BEMA model.""" + training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none") + bema_callback = BEMACallback(update_freq=2) + trainer = Trainer( + model=self.model, + args=training_args, + train_dataset=self.dataset["train"], + processing_class=self.tokenizer, + callbacks=[bema_callback], + ) + trainer.train() + + # Check that the BEMA model was saved and can be loaded + bema_path = os.path.join(self.tmp_dir, "bema") + assert os.path.isdir(bema_path), "BEMA directory was not created" + AutoModelForCausalLM.from_pretrained(bema_path) + + def test_update_frequency_0(self): + """Test that BEMA callback respects the update frequency.""" + training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none") + bema_callback = BEMACallback(update_freq=2) + + with patch.object(bema_callback, "_update_bema_weights") as mock_update: + trainer = Trainer( + model=self.model, + args=training_args, + train_dataset=self.dataset["train"], + processing_class=self.tokenizer, + callbacks=[bema_callback], + ) + + trainer.train() + + # Total 9 steps (17 samples, batch size 8, 3 epochs). + # BEMA starts after step 0 and updates every 2 steps → updates at 2, 4, 5, 8 + assert mock_update.call_args_list == [call(2), call(4), call(6), call(8)] + + def test_update_frequency_1(self): + """Test that BEMA callback respects the update frequency.""" + training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none") + bema_callback = BEMACallback(update_freq=3) + + with patch.object(bema_callback, "_update_bema_weights") as mock_update: + trainer = Trainer( + model=self.model, + args=training_args, + train_dataset=self.dataset["train"], + processing_class=self.tokenizer, + callbacks=[bema_callback], + ) + + trainer.train() + + # Total 9 steps (17 samples, batch size 8, 3 epochs). + # BEMA starts after step 0 and updates every 3 steps → updates at 3, 6, 9 + assert mock_update.call_args_list == [call(3), call(6), call(9)] + + def test_update_frequency_2(self): + """Test that BEMA callback respects the update frequency.""" + training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none") + bema_callback = BEMACallback(update_freq=2, update_after=3) + + with patch.object(bema_callback, "_update_bema_weights") as mock_update: + trainer = Trainer( + model=self.model, + args=training_args, + train_dataset=self.dataset["train"], + processing_class=self.tokenizer, + callbacks=[bema_callback], + ) + + trainer.train() + + # Total 9 steps (17 samples, batch size 8, 3 epochs). + # BEMA starts after step 3 and updates every 2 steps → updates at 5, 7, 9 + assert mock_update.call_args_list == [call(5), call(7), call(9)] + + def test_no_bema(self): + """Test that BEMACallback works without BEMA updates.""" + training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none") + bema_callback = BEMACallback(update_freq=2, bias_power=0.0) + trainer = Trainer( + model=self.model, + args=training_args, + train_dataset=self.dataset["train"], + processing_class=self.tokenizer, + callbacks=[bema_callback], + ) + trainer.train() + + def test_no_ema(self): + """Test that BEMACallback works without EMA updates.""" + training_args = TrainingArguments(output_dir=self.tmp_dir, report_to="none") + bema_callback = BEMACallback(update_freq=2, ema_power=0.0) + trainer = Trainer( + model=self.model, + args=training_args, + train_dataset=self.dataset["train"], + processing_class=self.tokenizer, + callbacks=[bema_callback], + ) + trainer.train() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_chat_template_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_chat_template_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f7ead60fc3875b460c8c56134dea928f61df067d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_chat_template_utils.py @@ -0,0 +1,1258 @@ +# Copyright 2020-2026 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 copy +import textwrap + +import pytest +import transformers +from packaging.version import Version +from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoProcessor, AutoTokenizer + +from trl import clone_chat_template +from trl.chat_template_utils import ( + add_response_schema, + get_training_chat_template, + is_chat_template_prefix_preserving, + is_chat_template_stop_token_trained, + parse_response, + supports_tool_calling, +) +from trl.data_utils import prepare_multimodal_messages + +from .testing_utils import TrlTestCase, require_jmespath, require_vision + + +class TestCloneChatTemplate(TrlTestCase): + def test_clone(self): + # This tokenizer doesn't have a chat_template by default + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM") + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM") + # This one has a chat_template by default + source = "trl-internal-testing/tiny-Qwen3ForCausalLM" + _, modified_tokenizer, _ = clone_chat_template(model, tokenizer, source) + + # Check if special tokens are correctly set + assert modified_tokenizer.eos_token == "<|im_end|>" + + def test_clone_with_resize(self): + # This tokenizer doesn't have a chat_template by default + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM") + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM") + # This one has a chat_template by default + source = "trl-internal-testing/tiny-Qwen3ForCausalLM" + modified_model, modified_tokenizer, _ = clone_chat_template( + model, tokenizer, source, resize_to_multiple_of=123 + ) + + # Check that the input embeddings have been resized to a multiple of 123 + assert (modified_model.vocab_size % 123) == 0 + # Check that the input embeddings size matches the tokenizer vocabulary size + assert model.vocab_size == len(modified_tokenizer.vocab) + + def test_clone_with_resize_and_extra_tokens_already_in_vocab(self): + # This tokenizer doesn't have a chat_template by default + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM") + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM") + # This one has a chat_template by default + source = "trl-internal-testing/tiny-Qwen3ForCausalLM" + # This will add , , ... to the tokenizer + modified_model, modified_tokenizer, _ = clone_chat_template( + model, tokenizer, source, resize_to_multiple_of=123 + ) + # Try if we can resize a tokenizer that already has extra these extra tokens + modified_model, modified_tokenizer, _ = clone_chat_template( + modified_model, modified_tokenizer, source, resize_to_multiple_of=124 + ) + + # Check that the input embeddings have been resized to a multiple of 123 + assert (modified_model.vocab_size % 124) == 0 + # Check that the input embeddings size matches the tokenizer vocabulary size + assert model.vocab_size == len(modified_tokenizer.vocab) + + def test_apply_new_chat_template(self): + # This tokenizer doesn't have a chat_template by default + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM") + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-BloomForCausalLM") + # This one has a chat_template by default + source = "trl-internal-testing/tiny-Qwen3ForCausalLM" + _, modified_tokenizer, _ = clone_chat_template(model, tokenizer, source) + messages = [ + {"role": "system", "content": "You are helpful"}, + {"role": "user", "content": "Hello"}, + {"role": "assistant", "content": "Hi, how can I help you?"}, + ] + prompt = modified_tokenizer.apply_chat_template(messages, tokenize=False) + + assert ( + prompt + == "<|im_start|>system\nYou are helpful<|im_end|>\n<|im_start|>user\nHello<|im_end|>\n<|im_start|>assistant\n\n\n\n\nHi, how can I help you?<|im_end|>\n" + ) + + def test_clone_with_sequence_classification_model(self): + # This tokenizer doesn't have a chat_template by default + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptNeoXForSequenceClassification") + model = AutoModelForSequenceClassification.from_pretrained( + "trl-internal-testing/tiny-GptNeoXForSequenceClassification" + ) + # This one has a chat_template by default + source = "trl-internal-testing/tiny-Qwen3ForCausalLM" + _, modified_tokenizer, _ = clone_chat_template(model, tokenizer, source) + + # Check if special tokens are correctly set + assert modified_tokenizer.eos_token == "<|im_end|>" + + +@pytest.mark.xfail( + condition=Version(transformers.__version__) < Version("5.0.0"), + reason="Response parsing is not supported in transformers versions below 5.0.0", + strict=True, +) +@require_jmespath +class TestAddResponseSchema: + @pytest.mark.parametrize( + "tokenizer_name", + [ + pytest.param("trl-internal-testing/tiny-Glm4MoeForCausalLM", id="glm4moe"), + pytest.param( + "trl-internal-testing/tiny-GptOssForCausalLM", + id="gptoss", + marks=pytest.mark.xfail( + Version(transformers.__version__) < Version("5.5.0"), + reason="Upstream bug in response parsing (see #5753; fixed in transformers#45166)", + strict=True, + ), + ), + pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.1", id="llama3.1"), + pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.2", id="llama3.2"), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-nano", + id="nemotron_3_nano", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-super", + id="nemotron_3_super", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-ultra", + id="nemotron_3_ultra", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", id="qwen2.5"), + pytest.param("trl-internal-testing/tiny-Qwen3MoeForCausalLM", id="qwen3"), + pytest.param("trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507", id="qwen3_instruct_2507"), + ], + ) + def test_add_response_schema(self, tokenizer_name): + tokenizer = AutoTokenizer.from_pretrained(tokenizer_name) + tokenizer = add_response_schema(tokenizer) + messages = [ + {"role": "user", "content": "What is 3*4?"}, + { + "role": "assistant", + "tool_calls": [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}], + }, + ] + prefix = tokenizer.apply_chat_template(messages[:1], tokenize=False, add_generation_prompt=True) + text = tokenizer.apply_chat_template(messages, tokenize=False) + response = text[len(prefix) :] + # Here, we just test that the parsing doesn't raise an error. + # The correctness of the parsing is tested in TestParseResponse + tokenizer.parse_response(response) + + @pytest.mark.parametrize( + "processor_name", + [ + pytest.param("trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", id="qwen3_vl"), + pytest.param("trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", id="qwen35-nothink"), + pytest.param("trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-Think", id="qwen35-think"), + pytest.param("trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", id="qwen36"), + ], + ) + def test_add_response_schema_vlm(self, processor_name): + # For VLM processors, `add_response_schema` must set the schema on the inner tokenizer, since + # `parse_response` is a tokenizer method that reads `self.response_schema` from the tokenizer instance. + processor = AutoProcessor.from_pretrained(processor_name) + processor = add_response_schema(processor) + assert processor.tokenizer.response_schema is not None + messages = [ + {"role": "user", "content": [{"type": "text", "text": "What is 3*4?"}]}, + { + "role": "assistant", + # "content" is required here because VLM processors crash on tokenize=True without it + # (KeyError in processing_utils.py). See huggingface/transformers#45290. + "content": [{"type": "text", "text": ""}], + "tool_calls": [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}], + }, + ] + prefix = processor.apply_chat_template(messages[:1], tokenize=False, add_generation_prompt=True) + text = processor.apply_chat_template(messages, tokenize=False) + response = text[len(prefix) :] + # Here, we just test that the parsing doesn't raise an error. + # The correctness of the parsing is tested in TestParseResponse + processor.tokenizer.parse_response(response) + + +class TestSupportsToolCalling: + @pytest.mark.parametrize( + "model_id", + [ + pytest.param("trl-internal-testing/tiny-DeepseekV3ForCausalLM", id="deepseekv3"), + pytest.param("trl-internal-testing/tiny-DeepseekV3ForCausalLM-0528", id="deepseekv3-0528"), + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + id="gemma4", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Glm4MoeForCausalLM", + id="glm4moe", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="GLM4 tokenizer requires transformers>=5.0.0", + ), + ), + pytest.param("trl-internal-testing/tiny-GptOssForCausalLM", id="gptoss"), + pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.1", id="llama3.1"), + pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.2", id="llama3.2"), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-nano", + id="nemotron_3_nano", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-super", + id="nemotron_3_super", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-ultra", + id="nemotron_3_ultra", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", id="qwen2.5"), + pytest.param("trl-internal-testing/tiny-Qwen3ForCausalLM", id="qwen3"), + pytest.param("trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507", id="qwen3_instruct_2507"), + pytest.param("trl-internal-testing/tiny-Qwen3MoeForCausalLM", id="qwen3moe"), + pytest.param( + "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", + id="qwen3_vl", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Qwen3-VL was introduced in transformers-4.57.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", + id="qwen35-nothink", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="Qwen3.5 tokenizer requires transformers>=5.0.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-Think", + id="qwen35-think", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="Qwen3.5 tokenizer requires transformers>=5.0.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", + id="qwen36", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="Qwen3.5 tokenizer requires transformers>=5.0.0", + ), + ), + ], + ) + def test_supports_tool_calling(self, model_id): + tokenizer = AutoTokenizer.from_pretrained(model_id) + assert supports_tool_calling(tokenizer) is True + + @pytest.mark.parametrize( + "model_id", + [ + # No chat template + pytest.param("trl-internal-testing/tiny-BartModel", id="bart"), + pytest.param("trl-internal-testing/tiny-BloomForCausalLM", id="bloom"), + pytest.param("trl-internal-testing/tiny-GPT2LMHeadModel", id="gpt2"), + pytest.param("trl-internal-testing/tiny-GPTNeoXForCausalLM", id="gptneox"), + pytest.param("trl-internal-testing/tiny-GptNeoXForSequenceClassification", id="gptneox-seq"), + pytest.param("trl-internal-testing/tiny-OPTForCausalLM", id="opt"), + pytest.param("trl-internal-testing/tiny-T5ForConditionalGeneration", id="t5"), + # TemplateError: rejects tool role sequence + pytest.param("trl-internal-testing/tiny-CohereForCausalLM", id="cohere"), + pytest.param("trl-internal-testing/tiny-FalconMambaForCausalLM", id="falconmamba"), + pytest.param("trl-internal-testing/tiny-GemmaForCausalLM", id="gemma"), + pytest.param("trl-internal-testing/tiny-Gemma2ForCausalLM", id="gemma2"), + pytest.param("trl-internal-testing/tiny-Gemma3ForConditionalGeneration", id="gemma3"), + pytest.param("trl-internal-testing/tiny-Idefics2ForConditionalGeneration", id="idefics2"), + pytest.param("trl-internal-testing/tiny-Idefics3ForConditionalGeneration", id="idefics3"), + pytest.param("trl-internal-testing/tiny-LlavaNextForConditionalGeneration", id="llava_next"), + pytest.param("trl-internal-testing/tiny-MistralForCausalLM-0.1", id="mistral0.1"), + pytest.param("trl-internal-testing/tiny-MistralForCausalLM-0.2", id="mistral0.2"), + pytest.param("trl-internal-testing/tiny-SmolVLMForConditionalGeneration", id="smolvlm"), + # Silently drops both tool_calls and tool messages + pytest.param("trl-internal-testing/tiny-Cohere2ForCausalLM", id="cohere2"), + pytest.param("trl-internal-testing/tiny-LlavaForConditionalGeneration", id="llava"), + # Olmo3 uses a bespoke function-calling schema (a `functions`/`function_calls` string on the + # message plus an `environment` role) instead of the standard `tools`/`tool_calls`/`tool` + # interface, so a standard tool-calling conversation is silently dropped. + pytest.param( + "trl-internal-testing/tiny-Olmo3ForCausalLM", + id="olmo3", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Olmo 3 was introduced in transformers>=4.57.0", + ), + ), + pytest.param("trl-internal-testing/tiny-Phi3ForCausalLM-3", id="phi3"), + pytest.param("trl-internal-testing/tiny-Phi3ForCausalLM-3.5", id="phi3.5"), + # Renders tool message content as plain text but drops assistant tool_calls + pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3", id="llama3"), + pytest.param("trl-internal-testing/tiny-Qwen2VLForConditionalGeneration", id="qwen2_vl"), + pytest.param("trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", id="qwen2.5_vl"), + ], + ) + def test_does_not_support_tool_calling(self, model_id): + tokenizer = AutoTokenizer.from_pretrained(model_id) + assert supports_tool_calling(tokenizer) is False + + +class TestIsChatTemplatePrefixPreserving: + def test_prefix_preserving_template(self): + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3MoeForCausalLM") + # docstyle-ignore + tokenizer.chat_template = textwrap.dedent(r""" + {%- for message in messages %} + + {%- if message.role == 'user' %} + {{- '<|im_start|>user\n' + message.content + '<|im_end|>\n' }} + {%- elif message.role == 'assistant' %} + {{- '<|im_start|>assistant\n' + message.content }} + {%- if message.tool_calls %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '' + tool_call.name + '' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == 'tool' %} + {{- '<|im_start|>tool\n' + message.content + '<|im_end|>\n' }} + {%- endif %} + + {%- endfor %} + + {%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- endif %}""") + assert is_chat_template_prefix_preserving(tokenizer) is True + + def test_non_prefix_preserving_template(self): + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3MoeForCausalLM") + # The following template is quite typical of models like Qwen3 and GPT-OSS, where the thinking part (even + # empty) is only present for last assistant message, which makes it non-prefix-preserving: appending a tool + # message changes the earlier output. + # docstyle-ignore + tokenizer.chat_template = textwrap.dedent(r""" + {%- if messages[0].role == 'system' %} + {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }} + {%- endif %} + {%- set ns = namespace(last_query_index=messages|length - 1) %} + {%- for message in messages[::-1] %} + {%- set index = (messages|length - 1) - loop.index0 %} + {%- if message.role == "user" and message.content is string %} + {%- set ns.last_query_index = index %} + {%- break %} + {%- endif %} + {%- endfor %} + {%- for message in messages %} + {%- set content = message.content if message.content is string else '' %} + {%- if message.role == "user" or (message.role == "system" and not loop.first) %} + {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>\n' }} + {%- elif message.role == "assistant" %} + {%- set reasoning_content = '' %} + {%- if message.reasoning_content is string %} + {%- set reasoning_content = message.reasoning_content %} + {%- else %} + {%- if '' in content %} + {%- set reasoning_content = content.split('')[0].rstrip('\n').split('')[-1].lstrip('\n') %} + {%- set content = content.split('')[-1].lstrip('\n') %} + {%- endif %} + {%- endif %} + {%- if loop.index0 > ns.last_query_index %} + {%- if loop.last or (not loop.last and reasoning_content) %} + {{- '<|im_start|>' + message.role + '\n\n' + reasoning_content.strip('\n') + '\n\n\n' + content.lstrip('\n') }} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + content }} + {%- endif %} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + content }} + {%- endif %} + {%- if message.tool_calls %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '' + tool_call.name + '' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {{- '<|im_start|>tool\n' + content + '<|im_end|>\n' }} + {%- endif %} + {%- endfor %} + {%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- if enable_thinking is defined and enable_thinking is false %} + {{- '\n\n\n\n' }} + {%- endif %} + {%- endif %}""") + assert is_chat_template_prefix_preserving(tokenizer) is False + + @require_vision + def test_prefix_preserving_template_processor(self): + processor = AutoProcessor.from_pretrained("trl-internal-testing/tiny-Qwen3VLForConditionalGeneration") + # Simple prefix-preserving template that mirrors how Qwen-VL templates emit image tokens: a list-of-blocks + # content is iterated, and `{"type": "image"}` blocks are rendered as `<|vision_start|><|image_pad|><|vision_end|>`. + # docstyle-ignore + processor.chat_template = textwrap.dedent(r""" + {%- for message in messages %} + + {%- if message.role == 'user' %} + {{- '<|im_start|>user\n' }} + {%- if message.content is string %} + {{- message.content }} + {%- else %} + {%- for content in message.content %} + {%- if content.type == 'image' or 'image' in content %} + {{- '<|vision_start|><|image_pad|><|vision_end|>' }} + {%- elif 'text' in content %} + {{- content.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == 'assistant' %} + {{- '<|im_start|>assistant\n' }} + {%- if message.content is string %} + {{- message.content }} + {%- else %} + {%- for content in message.content %} + {%- if 'text' in content %} + {{- content.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {%- if message.tool_calls %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '' + tool_call.name + '' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == 'tool' %} + {{- '<|im_start|>tool\n' }} + {%- if message.content is string %} + {{- message.content }} + {%- else %} + {%- for content in message.content %} + {%- if 'text' in content %} + {{- content.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- endif %} + + {%- endfor %} + + {%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- endif %}""") + assert is_chat_template_prefix_preserving(processor) is True + + +class TestIsChatTemplateStopTokenTrained: + def test_stop_token_trained(self): + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3MoeForCausalLM") + # The assistant turn is closed by <|im_end|> inside the generation span, so the end-of-turn token is masked + # in and the model is trained to stop. + # docstyle-ignore + tokenizer.chat_template = textwrap.dedent(r""" + {%- for message in messages %} + {%- if message.role == 'user' %} + {{- '<|im_start|>user\n' + message.content + '<|im_end|>\n' }} + {%- elif message.role == 'assistant' %} + {{- '<|im_start|>assistant\n' }} + {%- generation %}{{- message.content + '<|im_end|>' }}{%- endgeneration %} + {{- '\n' }} + {%- endif %} + {%- endfor %} + {%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- endif %}""") + assert is_chat_template_stop_token_trained(tokenizer) is True + + def test_stop_token_not_trained(self): + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3MoeForCausalLM") + # GLM-style: the assistant's end-of-turn token is emitted as the prefix of the following message, so the + # generation span covers content only and the model is never trained to stop. + # docstyle-ignore + tokenizer.chat_template = textwrap.dedent(r""" + {%- for message in messages %} + {%- if message.role == 'user' %} + {{- '<|im_start|>user\n' + message.content + '<|im_end|>\n' }} + {%- elif message.role == 'assistant' %} + {{- '<|im_start|>assistant\n' }} + {%- generation %}{{- message.content }}{%- endgeneration %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endfor %} + {%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- endif %}""") + assert is_chat_template_stop_token_trained(tokenizer) is False + + def test_template_error_returns_false(self): + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3MoeForCausalLM") + tokenizer.chat_template = "{{ raise_exception('probe rejected') }}" + assert is_chat_template_stop_token_trained(tokenizer) is False + + +@pytest.mark.parametrize( + "tokenizer_name", + [ + pytest.param("trl-internal-testing/tiny-CohereForCausalLM", id="cohere"), + pytest.param("trl-internal-testing/tiny-Cohere2ForCausalLM", id="cohere2"), + pytest.param("trl-internal-testing/tiny-DeepseekV3ForCausalLM", id="deepseekv3"), + pytest.param("trl-internal-testing/tiny-GemmaForCausalLM", id="gemma"), + pytest.param("trl-internal-testing/tiny-Gemma2ForCausalLM", id="gemma2"), + pytest.param("trl-internal-testing/tiny-Gemma3ForConditionalGeneration", id="gemma3", marks=require_vision), + pytest.param( + "trl-internal-testing/tiny-Glm4MoeForCausalLM", + id="glm4moe", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="GLM4 tokenizer requires transformers>=5.0.0", + ), + ), + pytest.param("trl-internal-testing/tiny-GptOssForCausalLM", id="gptoss"), + pytest.param( + "trl-internal-testing/tiny-Idefics3ForConditionalGeneration", id="idefics3", marks=require_vision + ), + pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3", id="llama3"), + pytest.param("trl-internal-testing/tiny-LlavaForConditionalGeneration", id="llava", marks=require_vision), + pytest.param( + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", id="llava_next", marks=require_vision + ), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-nano", + id="nemotron_3_nano", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-super", + id="nemotron_3_super", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-ultra", + id="nemotron_3_ultra", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param("trl-internal-testing/tiny-Phi3ForCausalLM-3", id="phi3"), + pytest.param("trl-internal-testing/tiny-Phi3ForCausalLM-3.5", id="phi3.5"), + pytest.param("trl-internal-testing/tiny-Qwen2VLForConditionalGeneration", id="qwen2_vl", marks=require_vision), + pytest.param("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", id="qwen2.5"), + pytest.param( + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", id="qwen2.5_vl", marks=require_vision + ), + pytest.param("trl-internal-testing/tiny-Qwen3MoeForCausalLM", id="qwen3"), + pytest.param("trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507", id="qwen3_instruct_2507"), + pytest.param( + "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", + id="qwen3_vl", + marks=[ + require_vision, + pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Qwen3-VL was introduced in transformers-4.57.0", + ), + ], + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", + id="qwen35-nothink", + marks=[ + require_vision, + pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="Qwen3.5 tokenizer requires transformers>=5.0.0", + ), + ], + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-Think", + id="qwen35-think", + marks=[ + require_vision, + pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="Qwen3.5 tokenizer requires transformers>=5.0.0", + ), + ], + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", + id="qwen36", + marks=[ + require_vision, + pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="Qwen3.5 tokenizer requires transformers>=5.0.0", + ), + ], + ), + ], +) +class TestGetTrainingChatTemplate: + def _load(self, model_name): + if "ForCausalLM" in model_name: + self.is_vlm = False + processing_class = AutoTokenizer.from_pretrained(model_name) + elif "ForConditionalGeneration" in model_name: + self.is_vlm = True + processing_class = AutoProcessor.from_pretrained(model_name) + + return processing_class + + def test_new_chat_template_is_prefix_preserving(self, tokenizer_name): + tokenizer = self._load(tokenizer_name) + new_chat_template = get_training_chat_template(tokenizer) + if new_chat_template is not None: + tokenizer.chat_template = new_chat_template + # Prefix-preservation is only meaningful for templates that actually support tool messages — the check + # itself renders one. Skip the assertion for tool-less templates (e.g. Gemma). + if not supports_tool_calling(tokenizer): + pytest.skip("Template does not support tool calling; prefix-preservation check is not applicable.") + assert is_chat_template_prefix_preserving(tokenizer) is True + + def test_new_chat_template_trains_stop_token(self, tokenizer_name, request): + if tokenizer_name in ( + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + ): + reason = f"{tokenizer_name}: the processor returns an all-zero assistant tokens mask" + request.node.add_marker(pytest.mark.xfail(strict=False, reason=reason)) + tokenizer = self._load(tokenizer_name) + new_chat_template = get_training_chat_template(tokenizer) + assert is_chat_template_stop_token_trained(tokenizer, chat_template=new_chat_template) is True + + def test_behavior_unchanged_single_user_no_generation_prompt(self, tokenizer_name): + tokenizer = self._load(tokenizer_name) + messages = [{"role": "user", "content": "What color is the sky?"}] + if self.is_vlm: + messages = prepare_multimodal_messages(messages) + + before = tokenizer.apply_chat_template(messages, tokenize=False) + new_chat_template = get_training_chat_template(tokenizer) + after = tokenizer.apply_chat_template(messages, tokenize=False, chat_template=new_chat_template) + assert before == after + + def test_behavior_unchanged_single_user_with_generation_prompt(self, tokenizer_name): + tokenizer = self._load(tokenizer_name) + messages = [{"role": "user", "content": "What color is the sky?"}] + if self.is_vlm: + messages = prepare_multimodal_messages(messages) + + before = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False) + new_chat_template = get_training_chat_template(tokenizer) + after = tokenizer.apply_chat_template( + messages, + tokenize=False, + add_generation_prompt=True, + chat_template=new_chat_template, + ) + assert before == after + + def test_behavior_unchanged_single_user_and_final_assistant_plain_content(self, tokenizer_name): + tokenizer = self._load(tokenizer_name) + messages = [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ] + if self.is_vlm: + messages = prepare_multimodal_messages(messages) + + before = tokenizer.apply_chat_template(messages, tokenize=False) + new_chat_template = get_training_chat_template(tokenizer) + after = tokenizer.apply_chat_template(messages, tokenize=False, chat_template=new_chat_template) + if tokenizer_name == "trl-internal-testing/tiny-Glm4MoeForCausalLM": + # GLM's native template doesn't terminate an assistant turn with an end-of-turn token; the turn is ended + # by the following message's role marker. The training template appends that terminator to the final + # assistant turn so the stop token is trained — here the `<|user|>` that would open the next turn. + assert after == before + "<|user|>" + else: + assert before == after + + def test_behavior_unchanged_final_assistant_with_reasoning_content(self, tokenizer_name): + tokenizer = self._load(tokenizer_name) + messages = [ + {"role": "user", "content": "What color is the sky?"}, + { + "role": "assistant", + "content": "It is blue.", + "reasoning_content": "The sky appears blue due to Rayleigh scattering.", + }, + ] + if self.is_vlm: + messages = prepare_multimodal_messages(messages) + + before = tokenizer.apply_chat_template(messages, tokenize=False) + new_chat_template = get_training_chat_template(tokenizer) + after = tokenizer.apply_chat_template(messages, tokenize=False, chat_template=new_chat_template) + if tokenizer_name == "trl-internal-testing/tiny-Glm4MoeForCausalLM": + # GLM's native template doesn't terminate an assistant turn with an end-of-turn token; the turn is ended + # by the following message's role marker. The training template appends that terminator to the final + # assistant turn so the stop token is trained — here the `<|user|>` that would open the next turn. + assert after == before + "<|user|>" + else: + assert before == after + + def test_behavior_unchanged_final_assistant_with_existing_think_tags(self, tokenizer_name): + tokenizer = self._load(tokenizer_name) + messages = [ + {"role": "user", "content": "What color is the sky?"}, + { + "role": "assistant", + "content": "\nThe sky scatters shorter wavelengths.\n\n\nIt is blue.", + }, + ] + if self.is_vlm: + messages = prepare_multimodal_messages(messages) + + before = tokenizer.apply_chat_template(messages, tokenize=False) + new_chat_template = get_training_chat_template(tokenizer) + after = tokenizer.apply_chat_template(messages, tokenize=False, chat_template=new_chat_template) + if tokenizer_name == "trl-internal-testing/tiny-Glm4MoeForCausalLM": + # GLM's native template doesn't terminate an assistant turn with an end-of-turn token; the turn is ended + # by the following message's role marker. The training template appends that terminator to the final + # assistant turn so the stop token is trained — here the `<|user|>` that would open the next turn. + assert after == before + "<|user|>" + else: + assert before == after + + def test_behavior_unchanged_assistant_with_tool_calls(self, tokenizer_name): + tokenizer = self._load(tokenizer_name) + tool_calls = [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}] + messages = [ + {"role": "user", "content": "Multiply 3 by 4."}, + {"role": "assistant", "content": "I will call a tool.", "tool_calls": tool_calls}, + ] + if self.is_vlm: + messages = prepare_multimodal_messages(messages) + + messages_before = copy.deepcopy(messages) + if tokenizer_name == "trl-internal-testing/tiny-DeepseekV3ForCausalLM": + # Best-effort fallback for templates that reject dict args (e.g. DeepSeek-V3). This is a chat template + # bug (see transformers#45419), and the training chat template fixes it to avoid blocking users. + messages_before[1]["tool_calls"][0]["function"]["arguments"] = '{"a": 3, "b": 4}' + + before = tokenizer.apply_chat_template(messages_before, tokenize=False) + new_chat_template = get_training_chat_template(tokenizer) + after = tokenizer.apply_chat_template(messages, tokenize=False, chat_template=new_chat_template) + if tokenizer_name == "trl-internal-testing/tiny-Glm4MoeForCausalLM": + # GLM's native template doesn't terminate an assistant turn with an end-of-turn token; the turn is ended + # by the following message's role marker. The training template appends that terminator to the final + # assistant turn so the stop token is trained — here `<|observation|>`, which closes a tool call. + assert after == before + "<|observation|>" + else: + assert before == after + + def test_behavior_unchanged_with_tools_with_and_without_system_message(self, tokenizer_name): + tokenizer = self._load(tokenizer_name) + tools = [ + { + "type": "function", + "function": { + "name": "multiply", + "description": "Multiply two numbers.", + "parameters": { + "type": "object", + "properties": { + "a": {"type": "number"}, + "b": {"type": "number"}, + }, + "required": ["a", "b"], + }, + }, + } + ] + messages = [{"role": "user", "content": "Multiply 3 by 4."}] + if self.is_vlm: + messages = prepare_multimodal_messages(messages) + + before = tokenizer.apply_chat_template(messages, tokenize=False, tools=tools) + new_chat_template = get_training_chat_template(tokenizer) + after = tokenizer.apply_chat_template(messages, tokenize=False, tools=tools, chat_template=new_chat_template) + assert before == after + + def test_behavior_unchanged_with_tools_with_system_message(self, tokenizer_name): + tokenizer = self._load(tokenizer_name) + if not supports_tool_calling(tokenizer): + pytest.skip("Template does not support tool calling; skipping tool_calls test.") + tools = [ + { + "type": "function", + "function": { + "name": "multiply", + "description": "Multiply two numbers.", + "parameters": { + "type": "object", + "properties": {"a": {"type": "number"}, "b": {"type": "number"}}, + "required": ["a", "b"], + }, + }, + } + ] + messages = [ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "Multiply 3 by 4."}, + ] + if self.is_vlm: + messages = prepare_multimodal_messages(messages) + + before = tokenizer.apply_chat_template(messages, tokenize=False, tools=tools) + new_chat_template = get_training_chat_template(tokenizer) + after = tokenizer.apply_chat_template(messages, tokenize=False, tools=tools, chat_template=new_chat_template) + assert before == after + + def test_behavior_unchanged_generation_prompt_with_enable_thinking_false(self, tokenizer_name): + tokenizer = self._load(tokenizer_name) + messages = [{"role": "user", "content": "What color is the sky?"}] + if self.is_vlm: + messages = prepare_multimodal_messages(messages) + + before = tokenizer.apply_chat_template( + messages, tokenize=False, add_generation_prompt=True, enable_thinking=False + ) + new_chat_template = get_training_chat_template(tokenizer) + after = tokenizer.apply_chat_template( + messages, + tokenize=False, + add_generation_prompt=True, + enable_thinking=False, + chat_template=new_chat_template, + ) + assert before == after + + def test_assistant_masks(self, tokenizer_name, request): + if tokenizer_name == "trl-internal-testing/tiny-LlavaForConditionalGeneration": + request.node.add_marker( + pytest.mark.xfail( + reason="Llava's official chat template `{% generation %}` markers don't yield assistant masks " + "through the processor path. It is not a supported training template.", + strict=True, + ) + ) + tokenizer = self._load(tokenizer_name) + messages = [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ] + if self.is_vlm: + messages = prepare_multimodal_messages(messages) + + chat_template = get_training_chat_template(tokenizer) + result = tokenizer.apply_chat_template( + messages, chat_template=chat_template, return_assistant_tokens_mask=True, return_dict=True, tokenize=True + ) + masks = result["assistant_masks"] + if self.is_vlm: # VLM processors return batched output + masks = masks[0] + assert 1 in masks + # The first tokens (user turn) should not be masked + assert masks[0] == 0 + # The last tokens (assistant turn ending with <|im_end|>) should be masked + assert masks[-1] == 1 + + def test_assistant_masks_multi_turn(self, tokenizer_name, request): + if tokenizer_name == "trl-internal-testing/tiny-LlavaForConditionalGeneration": + request.node.add_marker( + pytest.mark.xfail( + reason="Llava's official chat template `{% generation %}` markers don't yield assistant masks " + "through the processor path. It is not a supported training template.", + strict=True, + ) + ) + tokenizer = self._load(tokenizer_name) + messages = [ + {"role": "user", "content": "Hi"}, + {"role": "assistant", "content": "Hello!"}, + {"role": "user", "content": "Bye"}, + {"role": "assistant", "content": "Goodbye!"}, + ] + if self.is_vlm: + messages = prepare_multimodal_messages(messages) + + chat_template = get_training_chat_template(tokenizer) + result = tokenizer.apply_chat_template( + messages, chat_template=chat_template, return_assistant_tokens_mask=True, return_dict=True, tokenize=True + ) + masks = result["assistant_masks"] + if self.is_vlm: # VLM processors return batched output + masks = masks[0] + # Should have two masked regions (two assistant turns): 0→1, 1→0, 0→1 + transitions = sum(1 for i in range(1, len(masks)) if masks[i] != masks[i - 1]) + assert transitions == 3 + + +@pytest.mark.parametrize( + "model_name", + [ + pytest.param("trl-internal-testing/tiny-Glm4MoeForCausalLM", id="glm4moe"), + pytest.param("trl-internal-testing/tiny-GptOssForCausalLM", id="gptoss"), + pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.1", id="llama3.1"), + pytest.param("trl-internal-testing/tiny-LlamaForCausalLM-3.2", id="llama3.2"), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-nano", + id="nemotron_3_nano", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-super", + id="nemotron_3_super", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-ultra", + id="nemotron_3_ultra", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", id="qwen2.5"), + pytest.param("trl-internal-testing/tiny-Qwen3MoeForCausalLM", id="qwen3"), + pytest.param("trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507", id="qwen3_instruct_2507"), + pytest.param("trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", id="qwen3_vl"), + pytest.param("trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", id="qwen35-nothink"), + pytest.param("trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-Think", id="qwen35-think"), + pytest.param("trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", id="qwen36"), + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + id="gemma4", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + ], +) +@pytest.mark.xfail( + condition=Version(transformers.__version__) < Version("5.0.0"), + reason="Response parsing is not supported in transformers versions below 5.0.0", + strict=True, +) +@require_jmespath +class TestParseResponse: + def _load(self, model_name): + if "ForCausalLM" in model_name: + self.is_vlm = False + processing_class = AutoTokenizer.from_pretrained(model_name) + response_schema = getattr(processing_class, "response_schema", None) + elif "ForConditionalGeneration" in model_name: + self.is_vlm = True + processing_class = AutoProcessor.from_pretrained(model_name) + response_schema = getattr(processing_class.tokenizer, "response_schema", None) + + if response_schema is None: + processing_class = add_response_schema(processing_class) + + return processing_class + + def test_parse_response(self, model_name): + if model_name in ("trl-internal-testing/tiny-GptOssForCausalLM",) and Version( + transformers.__version__ + ) < Version("5.5.0"): + pytest.skip("Upstream bug in response parsing (see #5753; fixed in transformers#45166)") + processing_class = self._load(model_name) + messages = [ + {"role": "user", "content": "What is 3*4?"}, + {"role": "assistant", "content": "12"}, + ] + expected = messages[-1] + messages = prepare_multimodal_messages(messages) if self.is_vlm else messages + prefix = processing_class.apply_chat_template( + messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True + ).input_ids + text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids + if self.is_vlm: # VLM processors return batched output + prefix = prefix[0] + text = text[0] + response = text[len(prefix) :] + tokenizer = processing_class.tokenizer if self.is_vlm else processing_class + parsed = parse_response(tokenizer, response) + assert parsed == expected + + def test_parse_response_with_reasoning_content(self, model_name): + if model_name in ( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + "trl-internal-testing/tiny-GptOssForCausalLM", + "trl-internal-testing/tiny-LlamaForCausalLM-3.1", + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + "trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507", + "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", + ): + pytest.skip("This tokenizer doesn't support inline reasoning_content.") + + processing_class = self._load(model_name) + messages = [ + {"role": "user", "content": "What is 3*4?"}, + {"role": "assistant", "reasoning_content": "Hmmm.", "content": "12"}, + ] + expected = messages[-1] + messages = prepare_multimodal_messages(messages) if self.is_vlm else messages + # enable_thinking=True is required here because the Qwen3.5 NoThink fixture disables thinking by default + # for the generation prompt. + prefix = processing_class.apply_chat_template( + messages[:1], add_generation_prompt=True, enable_thinking=True, tokenize=True, return_dict=True + ).input_ids + text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids + if self.is_vlm: # VLM processors return batched output + prefix = prefix[0] + text = text[0] + response = text[len(prefix) :] + tokenizer = processing_class.tokenizer if self.is_vlm else processing_class + parsed = parse_response(tokenizer, response) + assert parsed == expected + + def test_parse_response_tool_call(self, model_name): + if model_name in ( + "trl-internal-testing/tiny-GptOssForCausalLM", + "trl-internal-testing/tiny-LlamaForCausalLM-3.1", + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + ) and Version(transformers.__version__) < Version("5.5.0"): + pytest.skip("Upstream bug in response parsing (see #5753; fixed in transformers#45166)") + processing_class = self._load(model_name) + tool_calls = [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}] + messages = [ + {"role": "user", "content": "What is 3*4?"}, + { + "role": "assistant", + # "content" is required here because VLM processors crash on tokenize=True without it + # (KeyError in processing_utils.py). See huggingface/transformers#45290. + "content": "", + "tool_calls": tool_calls, + }, + ] + expected = messages[-1] + messages = prepare_multimodal_messages(messages) if self.is_vlm else messages + prefix = processing_class.apply_chat_template( + messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True + ).input_ids + text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids + if self.is_vlm: # VLM processors return batched output + prefix = prefix[0] + text = text[0] + response = text[len(prefix) :] + tokenizer = processing_class.tokenizer if self.is_vlm else processing_class + parsed = parse_response(tokenizer, response) + assert parsed == expected + + def test_parse_response_tool_call_with_content(self, model_name): + if model_name in ( + "trl-internal-testing/tiny-LlamaForCausalLM-3.1", + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + ): + pytest.skip("Llama 3.1 / 3.2 templates only allow a single tool call per assistant turn, with no content.") + if model_name in ("trl-internal-testing/tiny-GptOssForCausalLM",) and Version( + transformers.__version__ + ) < Version("5.5.0"): + pytest.skip("Upstream bug in response parsing (see #5753; fixed in transformers#45166)") + processing_class = self._load(model_name) + tool_calls = [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}] + messages = [ + {"role": "user", "content": "What is 3*4?"}, + {"role": "assistant", "content": "Let's call the tool.", "tool_calls": tool_calls}, + ] + expected = messages[-1] + messages = prepare_multimodal_messages(messages) if self.is_vlm else messages + prefix = processing_class.apply_chat_template( + messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True + ).input_ids + text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids + if self.is_vlm: # VLM processors return batched output + prefix = prefix[0] + text = text[0] + response = text[len(prefix) :] + tokenizer = processing_class.tokenizer if self.is_vlm else processing_class + parsed = parse_response(tokenizer, response) + assert parsed == expected + + def test_parse_response_tool_call_without_arguments(self, model_name): + if model_name in ("trl-internal-testing/tiny-GptOssForCausalLM",) and Version( + transformers.__version__ + ) < Version("5.5.0"): + pytest.skip("Upstream bug in response parsing (see #5753; fixed in transformers#45166)") + processing_class = self._load(model_name) + tool_calls = [{"type": "function", "function": {"name": "ping", "arguments": {}}}] + messages = [ + {"role": "user", "content": "Ping the service."}, + { + "role": "assistant", + # "content" is required here because VLM processors crash on tokenize=True without it + # (KeyError in processing_utils.py). See huggingface/transformers#45290. + "content": "", + "tool_calls": tool_calls, + }, + ] + expected = messages[-1] + messages = prepare_multimodal_messages(messages) if self.is_vlm else messages + prefix = processing_class.apply_chat_template( + messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True + ).input_ids + text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids + if self.is_vlm: # VLM processors return batched output + prefix = prefix[0] + text = text[0] + response = text[len(prefix) :] + tokenizer = processing_class.tokenizer if self.is_vlm else processing_class + parsed = parse_response(tokenizer, response) + assert parsed == expected + + def test_parse_response_multiple_tool_calls(self, model_name): + if model_name in ( + "trl-internal-testing/tiny-GptOssForCausalLM", + "trl-internal-testing/tiny-LlamaForCausalLM-3.1", + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + ): + pytest.skip("This template only renders one tool call per assistant message.") + processing_class = self._load(model_name) + tool_calls = [ + {"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}, + {"type": "function", "function": {"name": "addition", "arguments": {"a": 4, "b": 3}}}, + ] + messages = [ + {"role": "user", "content": "What is 3*4?"}, + { + "role": "assistant", + # "content" is required here because VLM processors crash on tokenize=True without it + # (KeyError in processing_utils.py). See huggingface/transformers#45290. + "content": "", + "tool_calls": tool_calls, + }, + ] + expected = messages[-1] + messages = prepare_multimodal_messages(messages) if self.is_vlm else messages + prefix = processing_class.apply_chat_template( + messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True + ).input_ids + text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids + if self.is_vlm: # VLM processors return batched output + prefix = prefix[0] + text = text[0] + response = text[len(prefix) :] + tokenizer = processing_class.tokenizer if self.is_vlm else processing_class + parsed = parse_response(tokenizer, response) + assert parsed == expected + + def test_parse_response_malformed_tool_call(self, model_name): + if model_name != "trl-internal-testing/tiny-Qwen3MoeForCausalLM": + pytest.skip("For simplicity, we only test the malformed tool call case on one tokenizer.") + processing_class = self._load(model_name) + text = '\n{"name": "multiply", "arguments": {"a": 3, "b": 4}\n<|im_end|>' + assistant_text = processing_class(text)["input_ids"] + parsed = parse_response(processing_class, assistant_text) + expected = { + "role": "assistant", + "content": '\n{"name": "multiply", "arguments": {"a": 3, "b": 4}\n', + } + + assert parsed == expected + + def test_parse_response_truncated(self, model_name): + processing_class = self._load(model_name) + # Here we use 2 tool calls as it seems to be a more common source of failure when truncated. + # Llama 3.1 / 3.2 templates only allow a single tool call per assistant turn, so fall back to one. + tool_calls = [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 3, "b": 4}}}] + if model_name not in ( + "trl-internal-testing/tiny-LlamaForCausalLM-3.1", + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + ): + tool_calls.append({"type": "function", "function": {"name": "addition", "arguments": {"a": 4, "b": 3}}}) + messages = [ + {"role": "user", "content": "What is 3*4?"}, + {"role": "assistant", "content": "", "tool_calls": tool_calls}, + ] + messages = prepare_multimodal_messages(messages) if self.is_vlm else messages + prefix = processing_class.apply_chat_template( + messages[:1], add_generation_prompt=True, tokenize=True, return_dict=True + ).input_ids + text = processing_class.apply_chat_template(messages, tokenize=True, return_dict=True).input_ids + if self.is_vlm: # VLM processors return batched output + prefix = prefix[0] + text = text[0] + response = text[len(prefix) :] + tokenizer = processing_class.tokenizer if self.is_vlm else processing_class + # Truncate the response mid-tool-call and just check that parsing doesn't crash. + for end in range(1, len(response)): + parse_response(tokenizer, response[:end]) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_cli.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_cli.py new file mode 100644 index 0000000000000000000000000000000000000000..30c75cddca413fb9ffcace4d238a07ffcf7031ed --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_cli.py @@ -0,0 +1,140 @@ +# Copyright 2020-2026 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from io import StringIO +from unittest.mock import patch + +import pytest +import yaml + +from .testing_utils import TrlTestCase + + +@pytest.mark.parametrize("command", ["dpo", "grpo", "kto", "reward", "rloo", "sft"]) +def test_help_no_type_error(command): + # Regression test for https://github.com/huggingface/trl/issues/5099: + # TrainingArguments help strings with unescaped "%" caused TypeError in argparse. + from trl.cli import main + + with pytest.raises(SystemExit) as exc_info: + with patch("sys.argv", ["trl", command, "--help"]), patch("sys.stdout", new_callable=StringIO): + main() + assert exc_info.value.code == 0 + + +class TestCLI(TrlTestCase): + def test_dpo(self): + from trl.cli import main + + command = f"trl dpo --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_preference --report_to none" + with patch("sys.argv", command.split(" ")): + main() + + def test_dpo_multiple_loss_types(self): + from trl.cli import main + + command = f"trl dpo --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_preference --report_to none --loss_type sigmoid bco_pair --loss_weights 1.0 0.5" + with patch("sys.argv", command.split(" ")): + main() + + @patch("sys.stdout", new_callable=StringIO) + def test_env(self, mock_stdout): + from trl.cli import main + + command = "trl env" + with patch("sys.argv", command.split(" ")): + main() + assert "TRL version: " in mock_stdout.getvalue().strip() + + def test_grpo(self): + from trl.cli import main + + command = f"trl grpo --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --reward_model_name_or_path trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_prompt_only --num_generations 4 --max_completion_length 32 --report_to none" + with patch("sys.argv", command.split(" ")): + main() + + def test_kto(self): + from trl.cli import main + + command = f"trl kto --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_unpaired_preference --report_to none" + with patch("sys.argv", command.split(" ")): + main() + + def test_reward(self): + from trl.cli import main + + command = f"trl reward --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_implicit_prompt_preference --report_to none" + with patch("sys.argv", command.split(" ")): + main() + + def test_rloo(self): + from trl.cli import main + + command = f"trl rloo --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --reward_model_name_or_path trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_prompt_only --num_generations 2 --max_completion_length 32 --report_to none" + with patch("sys.argv", command.split(" ")): + main() + + def test_sft(self): + from trl.cli import main + + command = f"trl sft --output_dir {self.tmp_dir} --model_name_or_path trl-internal-testing/tiny-Qwen2ForCausalLM-2.5 --dataset_name trl-internal-testing/zen --dataset_config standard_language_modeling --report_to none" + with patch("sys.argv", command.split(" ")): + main() + + def test_sft_config_file(self): + from trl.cli import main + + output_dir = os.path.join(self.tmp_dir, "output") + + # Create a temporary config file + config_path = os.path.join(self.tmp_dir, "config.yaml") + config_content = { + "model_name_or_path": "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + "dataset_name": "trl-internal-testing/zen", + "dataset_config": "standard_language_modeling", + "report_to": "none", + "output_dir": output_dir, + "lr_scheduler_type": "cosine_with_restarts", + } + with open(config_path, "w") as config_file: + yaml.dump(config_content, config_file) + + # Test the CLI with config file + command = f"trl sft --config {config_path}" + with patch("sys.argv", command.split(" ")): + main() + + # Verify that output directory was created + assert os.path.exists(output_dir) + + def test_vllm_serve_config_file(self): + """ + Test `trl vllm-serve --config config.yaml` must not raise "the following arguments are required: --model" when + the required field is satisfied by the config file rather than the command line. + """ + from trl.cli import main + + config_path = os.path.join(self.tmp_dir, "config.yaml") + with open(config_path, "w") as f: + yaml.dump({"model": "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"}, f) + + # Patch the actual function that `VllmServeCommand.run` imports as `vllm_serve_main` + with patch("trl.scripts.vllm_serve.main") as mock_serve: + with patch("sys.argv", ["trl", "vllm-serve", "--config", config_path]): + main() + + mock_serve.assert_called_once() + script_args = mock_serve.call_args.args[0] + assert script_args.model == "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_cli_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_cli_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..cabb8f38bd2234ca3e698e01e0664b83a51f0813 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_cli_utils.py @@ -0,0 +1,426 @@ +# Copyright 2020-2026 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 tempfile +from dataclasses import dataclass +from unittest.mock import mock_open, patch + +import pytest +from datasets import DatasetDict, load_dataset + +from trl import DatasetMixtureConfig, TrlParser, get_dataset +from trl.scripts.utils import DatasetConfig + +from .testing_utils import TrlTestCase + + +@dataclass +class MyDataclass: + arg1: int + arg2: str = "default" + + +@dataclass +class InvalidDataclass: + config: str # This should raise an error in the TrlParser + + +class TestTrlParser(TrlTestCase): + def test_init_without_config_field(self): + """Test initialization without 'config' field in the dataclasses.""" + parser = TrlParser(dataclass_types=[MyDataclass]) + assert isinstance(parser, TrlParser) + + def test_init_with_config_field(self): + """Test initialization with a 'config' field in the dataclass (should raise ValueError).""" + with pytest.raises(ValueError, match="has a field named 'config'"): + TrlParser(dataclass_types=[InvalidDataclass]) + + @patch("builtins.open", mock_open(read_data="env:\n VAR1: value1\n VAR2: value2\narg1: 2")) + @patch("yaml.safe_load") + @patch("os.environ", new_callable=dict) # Mock os.environ as a dictionary + def test_parse_args_and_config_with_valid_config(self, mock_environ, mock_yaml_load): + """Test parse_args_and_config method with valid arguments and config.""" + mock_yaml_load.return_value = {"env": {"VAR1": "value1", "VAR2": "value2"}, "arg1": 2} + + parser = TrlParser(dataclass_types=[MyDataclass]) + + args = ["--arg2", "value", "--config", "config.yaml"] # don't set arg1 to test default value + + # Simulate the config being loaded and environment variables being set + result_args = parser.parse_args_and_config(args) + + # Set the environment variables using the mock + mock_environ["VAR1"] = "value1" + mock_environ["VAR2"] = "value2" + + # Ensure that the environment variables were set correctly + assert mock_environ.get("VAR1") == "value1" + assert mock_environ.get("VAR2") == "value2" + + # Check the parsed arguments + assert len(result_args) == 1 + assert isinstance(result_args[0], MyDataclass) + assert result_args[0].arg1 == 2 + assert result_args[0].arg2 == "value" + + @patch("builtins.open", mock_open(read_data="arg1: 2")) + @patch("yaml.safe_load") + def test_parse_args_and_arg_override_config(self, mock_yaml_load): + """Test parse_args_and_config method and check that arguments override the config.""" + mock_yaml_load.return_value = {"arg1": 2} # this arg is meant to be overridden + + parser = TrlParser(dataclass_types=[MyDataclass]) + + args = ["--arg1", "3", "--config", "config.yaml"] # override arg1 default with 3 + + # Simulate the config being loaded and arguments being passed + result_args = parser.parse_args_and_config(args) + + # Check the parsed arguments + assert len(result_args) == 1 + assert isinstance(result_args[0], MyDataclass) + assert result_args[0].arg1 == 3 + + @patch("builtins.open", mock_open(read_data="env: not_a_dict")) + @patch("yaml.safe_load") + def test_parse_args_and_config_with_invalid_env(self, mock_yaml_load): + """Test parse_args_and_config method when the 'env' field is not a dictionary.""" + mock_yaml_load.return_value = {"env": "not_a_dict"} + + parser = TrlParser(dataclass_types=[MyDataclass]) + + args = ["--arg1", "2", "--arg2", "value", "--config", "config.yaml"] + + with pytest.raises(ValueError, match="`env` field should be a dict in the YAML file."): + parser.parse_args_and_config(args) + + def test_parse_args_and_config_without_config(self): + """Test parse_args_and_config without the `--config` argument.""" + parser = TrlParser(dataclass_types=[MyDataclass]) + + args = ["--arg1", "2", "--arg2", "value"] + + # Simulate no config, just parse args normally + result_args = parser.parse_args_and_config(args) + + # Check that the arguments are parsed as is + assert len(result_args) == 1 + assert isinstance(result_args[0], MyDataclass) + assert result_args[0].arg1 == 2 + assert result_args[0].arg2 == "value" + + def test_set_defaults_with_config(self): + """Test set_defaults_with_config updates the defaults.""" + parser = TrlParser(dataclass_types=[MyDataclass]) + + # Update defaults + parser.set_defaults_with_config(arg1=42) + + # Ensure the default value is updated + result_args = parser.parse_args_and_config([]) + assert len(result_args) == 1 + assert isinstance(result_args[0], MyDataclass) + assert result_args[0].arg1 == 42 + + def test_parse_args_and_config_with_remaining_strings(self): + parser = TrlParser(dataclass_types=[MyDataclass]) + + args = ["--arg1", "2", "--arg2", "value", "remaining"] + + # Simulate no config, just parse args normally + result_args = parser.parse_args_and_config(args, return_remaining_strings=True) + + # Check that the arguments are parsed as is + assert len(result_args) == 2 + assert isinstance(result_args[0], MyDataclass) + assert result_args[0].arg1 == 2 + assert result_args[0].arg2 == "value" + assert result_args[1] == ["remaining"] + + @patch("builtins.open", mock_open(read_data="remaining_string_in_config: abc")) + @patch("yaml.safe_load") + def test_parse_args_and_config_with_remaining_strings_in_config_and_args(self, mock_yaml_load): + mock_yaml_load.return_value = {"remaining_string_in_config": "abc"} + + parser = TrlParser(dataclass_types=[MyDataclass]) + + args = ["--arg1", "2", "--remaining_string_in_args", "def", "--config", "config.yaml"] + + # Simulate the config being loaded and arguments being passed + result_args = parser.parse_args_and_config(args, return_remaining_strings=True) + + # Check that the arguments are parsed as is + assert len(result_args) == 2 + assert isinstance(result_args[0], MyDataclass) + assert result_args[0].arg1 == 2 + assert result_args[1] == ["--remaining_string_in_config", "abc", "--remaining_string_in_args", "def"] + + @patch("builtins.open", mock_open(read_data="arg1: 2\narg2: config_value")) + @patch("yaml.safe_load") + def test_subparsers_with_config_defaults(self, mock_yaml_load): + """Test that config defaults are applied to all subparsers.""" + mock_yaml_load.return_value = {"arg1": 2, "arg2": "config_value"} + + # Create the main parser + parser = TrlParser() + + # Add subparsers + subparsers = parser.add_subparsers(dest="command", parser_class=TrlParser) + + # Create a subparser for a specific command + subparsers.add_parser("subcommand", dataclass_types=[MyDataclass]) + + # Parse with config file + args = ["subcommand", "--config", "config.yaml"] + result_args = parser.parse_args_and_config(args) + + # Check main parser arguments + assert len(result_args) == 1 + + # Check that config values were applied to the subparser + assert result_args[0].arg1 == 2 # Default from config + assert result_args[0].arg2 == "config_value" # Default from config + + @patch("builtins.open", mock_open(read_data="arg1: 2\narg2: config_value")) + @patch("yaml.safe_load") + def test_subparsers_with_config_defaults_and_arg_override(self, mock_yaml_load): + """Test that config defaults are applied to all subparsers.""" + mock_yaml_load.return_value = {"arg1": 2, "arg2": "config_value"} + + # Create the main parser + parser = TrlParser() + + # Add subparsers + subparsers = parser.add_subparsers(dest="command", parser_class=TrlParser) + + # Create a subparser for a specific command + subparsers.add_parser("subcommand", dataclass_types=[MyDataclass]) + + # Test with command line arguments overriding config + args = ["subcommand", "--arg1", "3", "--config", "config.yaml"] + result_args = parser.parse_args_and_config(args) + + # Command line arguments should override config + assert result_args[0].arg1 == 3 + assert result_args[0].arg2 == "config_value" # Still from config + + @patch("builtins.open", mock_open(read_data="arg1: 2\nthis_arg_does_not_exist: config_value")) + @patch("yaml.safe_load") + def test_subparsers_with_config_defaults_and_arg_override_wrong_name(self, mock_yaml_load): + """Test that config defaults are applied to all subparsers.""" + mock_yaml_load.return_value = {"arg1": 2, "this_arg_does_not_exist": "config_value"} + + # Create the main parser + parser = TrlParser() + + # Add subparsers + subparsers = parser.add_subparsers(dest="command", parser_class=TrlParser) + + # Create a subparser for a specific command + subparsers.add_parser("subcommand", dataclass_types=[MyDataclass]) + + # Test with command line arguments overriding config + args = ["subcommand", "--arg1", "3", "--config", "config.yaml"] + with pytest.raises(ValueError): + parser.parse_args_and_config(args) + + parser.parse_args_and_config(args, fail_with_unknown_args=False) + + @patch("builtins.open", mock_open(read_data="arg1: 2\narg2: config_value")) + @patch("yaml.safe_load") + def test_subparsers_multiple_with_config_defaults(self, mock_yaml_load): + """Test that config defaults are applied to all subparsers.""" + mock_yaml_load.return_value = {"arg1": 2, "arg2": "config_value"} + + # Create the main parser + parser = TrlParser() + + # Add subparsers + subparsers = parser.add_subparsers(dest="command", parser_class=TrlParser) + + # Create a subparser for a specific command + subparsers.add_parser("subcommand0", dataclass_types=[MyDataclass]) + subparsers.add_parser("subcommand1", dataclass_types=[MyDataclass]) + + for idx in range(2): + # Parse with config file + args = [f"subcommand{idx}", "--config", "config.yaml"] + result_args = parser.parse_args_and_config(args) + + # Check main parser arguments + assert len(result_args) == 1 + + # Check that config values were applied to the subparser + assert result_args[0].arg1 == 2 # Default from config + assert result_args[0].arg2 == "config_value" # Default from config + + +class TestGetDataset: + def test_single_dataset_with_config(self): + mixture_config = DatasetMixtureConfig( + datasets=[DatasetConfig(path="trl-internal-testing/zen", name="standard_language_modeling")] + ) + result = get_dataset(mixture_config) + expected = load_dataset("trl-internal-testing/zen", "standard_language_modeling") + assert expected["train"][:] == result["train"][:] + + def test_single_dataset_preference_config(self): + mixture_config = DatasetMixtureConfig( + datasets=[DatasetConfig(path="trl-internal-testing/zen", name="standard_preference")] + ) + result = get_dataset(mixture_config) + expected = load_dataset("trl-internal-testing/zen", "standard_preference") + assert expected["train"][:] == result["train"][:] + + def test_single_dataset_streaming(self): + mixture_config = DatasetMixtureConfig( + datasets=[DatasetConfig(path="trl-internal-testing/zen", name="standard_language_modeling")], + streaming=True, + ) + result = get_dataset(mixture_config) + expected = load_dataset("trl-internal-testing/zen", "standard_language_modeling") + assert expected["train"].to_list() == list(result["train"]) + + def test_dataset_mixture_basic(self): + dataset_config1 = DatasetConfig( + path="trl-internal-testing/zen", name="standard_prompt_completion", split="train", columns=["prompt"] + ) + dataset_config2 = DatasetConfig( + path="trl-internal-testing/zen", name="standard_preference", split="train", columns=["prompt"] + ) + mixture_config = DatasetMixtureConfig(datasets=[dataset_config1, dataset_config2]) + result = get_dataset(mixture_config) + assert isinstance(result, DatasetDict) + assert "train" in result + train_dataset = result["train"] + assert train_dataset.column_names == ["prompt"] + prompts = train_dataset["prompt"] + expected_first_half = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + assert prompts[: len(prompts) // 2] == expected_first_half["prompt"] + expected_second_half = load_dataset("trl-internal-testing/zen", "standard_prompt_completion", split="train") + assert prompts[len(prompts) // 2 :] == expected_second_half["prompt"] + + def test_dataset_mixture_with_weights(self): + dataset_config1 = DatasetConfig( + path="trl-internal-testing/zen", name="standard_prompt_completion", split="train[:50%]", columns=["prompt"] + ) + dataset_config2 = DatasetConfig( + path="trl-internal-testing/zen", name="standard_preference", split="train[:50%]", columns=["prompt"] + ) + mixture_config = DatasetMixtureConfig(datasets=[dataset_config1, dataset_config2]) + result = get_dataset(mixture_config) + assert isinstance(result, DatasetDict) + assert "train" in result + train_dataset = result["train"] + assert train_dataset.column_names == ["prompt"] + prompts = train_dataset["prompt"] + expected_first_half = load_dataset("trl-internal-testing/zen", "standard_preference", split="train[:50%]") + assert prompts[: len(prompts) // 2] == expected_first_half["prompt"] + expected_second_half = load_dataset( + "trl-internal-testing/zen", "standard_prompt_completion", split="train[:50%]" + ) + assert prompts[len(prompts) // 2 :] == expected_second_half["prompt"] + + def test_dataset_mixture_with_test_split(self): + mixture_config = DatasetMixtureConfig( + datasets=[DatasetConfig(path="trl-internal-testing/zen", name="standard_language_modeling")], + test_split_size=2, + ) + result = get_dataset(mixture_config) + assert isinstance(result, DatasetDict) + assert "train" in result + assert "test" in result + assert len(result["train"]) == 15 + assert len(result["test"]) == 2 + + def test_empty_dataset_mixture_raises_error(self): + mixture_config = DatasetMixtureConfig(datasets=[]) + + with pytest.raises(ValueError, match="No datasets were loaded"): + get_dataset(mixture_config) + + def test_mixture_multiple_different_configs(self): + dataset_config1 = DatasetConfig( + path="trl-internal-testing/zen", name="conversational_preference", split="train", columns=["prompt"] + ) + dataset_config2 = DatasetConfig( + path="trl-internal-testing/zen", name="conversational_prompt_only", split="test" + ) + mixture_config = DatasetMixtureConfig(datasets=[dataset_config1, dataset_config2]) + result = get_dataset(mixture_config) + assert isinstance(result, DatasetDict) + assert "train" in result + assert len(result["train"]) > 0 + + def test_trlparser_parses_yaml_config_correctly(self): + # Prepare YAML content exactly like your example + # docstyle-ignore + yaml_content = """ + datasets: + - path: trl-internal-testing/zen + name: standard_prompt_only + - path: trl-internal-testing/zen + name: standard_preference + columns: + - prompt + """ + + # Write YAML to a temporary file + with tempfile.NamedTemporaryFile("w+", suffix=".yaml") as tmpfile: + tmpfile.write(yaml_content) + tmpfile.flush() + parser = TrlParser((DatasetMixtureConfig,)) + args = parser.parse_args_and_config(args=["--config", tmpfile.name])[0] + + # Assert that we got DatasetMixtureConfig instance + assert isinstance(args, DatasetMixtureConfig) + + # Assert datasets list length + assert len(args.datasets) == 2 + + # Check first dataset + dataset_config1 = args.datasets[0] + assert isinstance(dataset_config1, DatasetConfig) + assert dataset_config1.path == "trl-internal-testing/zen" + assert dataset_config1.name == "standard_prompt_only" + assert dataset_config1.columns is None # No columns specified + + # Check second dataset + dataset_config2 = args.datasets[1] + assert isinstance(dataset_config2, DatasetConfig) + assert dataset_config2.path == "trl-internal-testing/zen" + assert dataset_config2.name == "standard_preference" + assert dataset_config2.columns == ["prompt"] # Columns specified + + def test_trlparser_parses_yaml_and_loads_dataset(self): + # Prepare YAML content exactly like your example + # docstyle-ignore + yaml_content = """ + datasets: + - path: trl-internal-testing/zen + name: standard_language_modeling + """ + + # Write YAML to a temporary file + with tempfile.NamedTemporaryFile("w+", suffix=".yaml") as tmpfile: + tmpfile.write(yaml_content) + tmpfile.flush() + parser = TrlParser((DatasetMixtureConfig,)) + args = parser.parse_args_and_config(args=["--config", tmpfile.name])[0] + + # Load the dataset using get_dataset + result = get_dataset(args) + expected = load_dataset("trl-internal-testing/zen", "standard_language_modeling") + assert expected["train"][:] == result["train"][:] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_data_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..341ff337583f0205edd621134a56c4d515056d48 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_data_utils.py @@ -0,0 +1,1335 @@ +# Copyright 2020-2026 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 copy +import textwrap +from time import strftime + +import pytest +import transformers +from datasets import Dataset, DatasetDict +from packaging.version import Version +from transformers import AutoProcessor, AutoTokenizer, is_vision_available + +from trl.data_utils import ( + apply_chat_template, + extract_prompt, + is_conversational, + is_conversational_from_value, + maybe_apply_chat_template, + maybe_convert_to_chatml, + maybe_extract_prompt, + maybe_unpair_preference_dataset, + pack_dataset, + prepare_multimodal_messages, + prepare_multimodal_messages_vllm, + unpair_preference_dataset, +) + +from .testing_utils import TrlTestCase, require_vision + + +if is_vision_available(): + from PIL import Image + + +@require_vision +class TestPrepareMultimodalMessages: + def test_basic_user_assistant_conversation(self): + """Test basic conversation with user and assistant messages.""" + messages = [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ] + image = Image.new("RGB", (10, 10), color="blue") + messages = prepare_multimodal_messages(messages, images=[image]) + + expected = [ + { + "role": "user", + "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}], + }, + { + "role": "assistant", + "content": [{"type": "text", "text": "It is blue."}], + }, + ] + + assert messages == expected + + def test_first_user_message_gets_image(self): + """Test that only the first user message gets an image.""" + messages = [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + {"role": "user", "content": "How about the grass?"}, + ] + + image = Image.new("RGB", (10, 10), color="blue") + messages = prepare_multimodal_messages(messages, images=[image]) + + expected = [ + { + "role": "user", + "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}], + }, + { + "role": "assistant", + "content": [{"type": "text", "text": "It is blue."}], + }, + { + "role": "user", + "content": [{"type": "text", "text": "How about the grass?"}], + }, + ] + + assert messages == expected + + def test_multiple_images(self): + """Test that multiple images are added to the first user message.""" + messages = [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ] + images = [Image.new("RGB", (10, 10), color=color) for color in ["red", "green", "blue"]] + messages = prepare_multimodal_messages(messages, images=images) + + expected = [ + { + "role": "user", + "content": [ + {"type": "image", "image": images[0]}, + {"type": "image", "image": images[1]}, + {"type": "image", "image": images[2]}, + {"type": "text", "text": "What color is the sky?"}, + ], + }, + { + "role": "assistant", + "content": [{"type": "text", "text": "It is blue."}], + }, + ] + + assert messages == expected + + def test_system_message_transformation(self): + """Test that system messages are properly transformed.""" + messages = [ + {"role": "system", "content": "You are a helpful assistant"}, + {"role": "user", "content": "What color is the sky?"}, + ] + + image = Image.new("RGB", (10, 10), color="blue") + messages = prepare_multimodal_messages(messages, images=[image]) + + expected = [ + { + "role": "system", + "content": [{"type": "text", "text": "You are a helpful assistant"}], + }, + { + "role": "user", + "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}], + }, + ] + + assert messages == expected + + def test_already_prepared_messages_unchanged(self): + """Test that messages with list content are not modified.""" + messages = [ + {"role": "system", "content": [{"type": "text", "text": "You are a helpful assistant"}]}, + {"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What color is the sky?"}]}, + {"role": "assistant", "content": [{"type": "text", "text": "It is blue."}]}, + ] + + image = Image.new("RGB", (10, 10), color="blue") + messages = prepare_multimodal_messages(messages, images=[image]) + + expected = [ + { + "role": "system", + "content": [{"type": "text", "text": "You are a helpful assistant"}], + }, + { + "role": "user", + "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}], + }, + { + "role": "assistant", + "content": [{"type": "text", "text": "It is blue."}], + }, + ] + + assert messages == expected + + def test_mixed_prepared_and_unprepared_messages(self): + """Test handling of mixed prepared and unprepared messages.""" + messages = [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": [{"type": "text", "text": "It is blue."}]}, + {"role": "user", "content": "What about the grass?"}, + ] + + image = Image.new("RGB", (10, 10), color="blue") + messages = prepare_multimodal_messages(messages, images=[image]) + + expected = [ + { + "role": "user", + "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}], + }, + { + "role": "assistant", + "content": [{"type": "text", "text": "It is blue."}], + }, + { + "role": "user", + "content": [{"type": "text", "text": "What about the grass?"}], + }, + ] + + assert messages == expected + + def test_message_with_tool_calling_turns(self): + """Test that both the assistant tool call and the tool role turns messages are properly transformed.""" + messages = [ + {"role": "user", "content": "What's the weather like in New York?"}, + { + "role": "assistant", + "tool_calls": [ + { + "type": "tool", + "function": {"name": "get_current_weather", "arguments": {"location": "New York"}}, + } + ], + }, + {"role": "tool", "name": "get_current_weather", "content": "22.0"}, + {"role": "assistant", "content": "The current weather in New York is 22.0 degrees Celsius."}, + ] + + messages = prepare_multimodal_messages(messages) + + expected = [ + { + "role": "user", + "content": [{"type": "text", "text": "What's the weather like in New York?"}], + }, + { + "role": "assistant", + "tool_calls": [ + { + "type": "tool", + "function": {"name": "get_current_weather", "arguments": {"location": "New York"}}, + } + ], + }, + {"role": "tool", "name": "get_current_weather", "content": [{"type": "text", "text": "22.0"}]}, + { + "role": "assistant", + "content": [{"type": "text", "text": "The current weather in New York is 22.0 degrees Celsius."}], + }, + ] + + assert messages == expected + + def test_prepared_image_blocks_without_new_images(self): + """Test that existing image payloads are preserved when no new images are provided.""" + image = Image.new("RGB", (10, 10), color="blue") + messages = [ + { + "role": "user", + "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}], + }, + {"role": "assistant", "content": "It is blue."}, + ] + + messages = prepare_multimodal_messages(messages) + + expected = [ + { + "role": "user", + "content": [{"type": "image", "image": image}, {"type": "text", "text": "What color is the sky?"}], + }, + {"role": "assistant", "content": [{"type": "text", "text": "It is blue."}]}, + ] + + assert messages == expected + + +@require_vision +class TestPrepareMultimodalMessagesVLLM: + def test_single_image_conversion(self): + messages = [ + { + "role": "user", + "content": [ + {"type": "image", "image": Image.new("RGB", (10, 10), color="blue")}, + {"type": "text", "text": "What color is the sky?"}, + ], + } + ] + + result = prepare_multimodal_messages_vllm(messages) + + # Original should remain unchanged (deepcopy test) + assert messages[0]["content"][0]["type"] == "image" + + # Converted version should have correct structure + assert result[0]["content"][0]["type"] == "image_pil" + assert "image_pil" in result[0]["content"][0] + assert "image" not in result[0]["content"][0] + assert isinstance(result[0]["content"][0]["image_pil"], Image.Image) + assert result[0]["content"][1]["type"] == "text" + + def test_mixed_content_conversion(self): + messages = [ + { + "role": "user", + "content": [ + {"type": "text", "text": "What color is the sky?"}, + {"type": "image", "image": Image.new("RGB", (10, 10), color="blue")}, + ], + } + ] + + result = prepare_multimodal_messages_vllm(messages) + + # The image part should be converted, text should be unchanged + assert result[0]["content"][0]["type"] == "text" + assert result[0]["content"][1]["type"] == "image_pil" + + def test_no_images(self): + messages = [{"role": "user", "content": [{"type": "text", "text": "What color is the sky?"}]}] + + result = prepare_multimodal_messages_vllm(messages) + + # Should be identical since there are no images + assert result == messages + # And a deepcopy — not the same object + assert result is not messages + assert result[0] is not messages[0] + + def test_multiple_messages(self): + messages = [ + { + "role": "user", + "content": [ + {"type": "text", "text": "What color is the sky?"}, + {"type": "image", "image": Image.new("RGB", (10, 10), color="blue")}, + ], + }, + { + "role": "assistant", + "content": [{"type": "text", "text": "It is blue."}], + }, + ] + + result = prepare_multimodal_messages_vllm(messages) + + assert result[0]["content"][1]["type"] == "image_pil" + assert result[1]["content"][0]["type"] == "text" + assert result[1]["content"][0]["text"] == "It is blue." + + def test_deepcopy_integrity(self): + messages = [ + { + "role": "user", + "content": [ + {"type": "text", "text": "What color is the sky?"}, + {"type": "image", "image": Image.new("RGB", (10, 10), color="blue")}, + ], + }, + ] + original = copy.deepcopy(messages) + + _ = prepare_multimodal_messages_vllm(messages) + + # Original should not be mutated + assert messages == original + + +class TestIsConversational(TrlTestCase): + # fmt: off + conversational_examples = [ + { # Language modeling + "messages": [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ], + }, + { # Prompt-only + "prompt": [{"role": "user", "content": "What color is the sky?"}], + }, + { # Prompt-completion + "prompt": [{"role": "user", "content": "What color is the sky?"}], + "completion": [{"role": "assistant", "content": "It is blue."}], + }, + { # Preference + "prompt": [{"role": "user", "content": "What color is the sky?"}], + "chosen": [{"role": "assistant", "content": "It is blue."}], + "rejected": [{"role": "assistant", "content": "It is green."}], + }, + { # Preference with implicit prompt + "chosen": [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ], + "rejected": [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is green."}, + ], + }, + { # Preference with tool calls + "prompt": [{"role": "user", "content": "What color is the sky?"}], + "chosen": [ + {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_color", "arguments": {"what": "sky"}}}]}, + {"role": "tool", "name": "get_color", "content": "blue"}, + {"role": "assistant", "content": "It is blue."}, + ], + "rejected": [ + {"role": "assistant", "tool_calls": [{"type": "function", "function": {"name": "get_color", "arguments": {"what": "tree"}}}]}, + {"role": "tool", "name": "get_color", "content": "green"}, + {"role": "assistant", "content": "It is green."}, + ], + "tools": [ + { + "type": "function", + "function": { + "description": "Gets the color.", + "name": "get_color", + "parameters": {"properties": {"what": {"description": "What to get the color of.", "type": "string"}}, "required": ["what"], "type": "object"}, + "return": {"description": "The color.", "type": "string"}, + }, + }, + ], + }, + { # Unpaired preference + "prompt": [{"role": "user", "content": "What color is the sky?"}], + "completion": [{"role": "assistant", "content": "It is blue."}], + "label": True, + }, + { # Language modeling with harmony + "messages": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."}, + ], + }, + { # Prompt-only with harmony + "prompt": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + ], + }, + { # Prompt-completion with harmony + "prompt": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + ], + "completion": [ + {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."}, + ], + }, + { # Preference with harmony + "prompt": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + ], + "chosen": [ + {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."}, + ], + "rejected": [ + {"role": "assistant", "thinking": "The user asks the color of the tree...", "content": "It is green."}, + ], + }, + { # Preference with implicit prompt and harmony + "chosen": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."}, + ], + "rejected": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "thinking": "The user asks the color of the tree...", "content": "It is green."}, + ], + }, + { # Unpaired preference with harmony + "prompt": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + ], + "completion": [ + {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."}, + ], + "label": True, + }, + ] + # fmt: on + + non_conversational_examples = [ + {"prompt": "The sky is", "completion": " blue."}, + {"text": "The sky is blue."}, + {"prompt": "The sky is"}, + {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}, + {"prompt": "The sky is", "completion": " blue.", "label": True}, + ] + + @pytest.mark.parametrize("example", conversational_examples) + def test_conversational(self, example): + assert is_conversational(example) + + @pytest.mark.parametrize("example", non_conversational_examples) + def test_non_conversational(self, example): + assert not is_conversational(example) + + +class TestIsConversationalFromValue(TrlTestCase): + def test_positive_1(self): + example = { + "conversations": [ + {"from": "user", "value": "What color is the sky?"}, + {"from": "assistant", "value": "It is blue."}, + ], + } + assert is_conversational_from_value(example) + + def test_negative_1(self): + example = { + "messages": [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ], + } + assert not is_conversational_from_value(example) + + def test_negative_2(self): + example = {"text": "The sky is blue."} + assert not is_conversational_from_value(example) + + +class TestApplyChatTemplate(TrlTestCase): + tokenizers = [ + "trl-internal-testing/tiny-CohereForCausalLM", + "trl-internal-testing/tiny-Cohere2ForCausalLM", + "trl-internal-testing/tiny-DeepseekV3ForCausalLM", + "trl-internal-testing/tiny-DeepseekV3ForCausalLM-0528", + "trl-internal-testing/tiny-FalconMambaForCausalLM", + "trl-internal-testing/tiny-Gemma2ForCausalLM", + "trl-internal-testing/tiny-GemmaForCausalLM", + "trl-internal-testing/tiny-GptOssForCausalLM", + pytest.param( + "trl-internal-testing/tiny-Glm4MoeForCausalLM", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="GLM4 tokenizer requires transformers>=5.0.0", + ), + ), + "trl-internal-testing/tiny-LlamaForCausalLM-3.1", + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-LlamaForCausalLM-3", + "trl-internal-testing/tiny-MistralForCausalLM-0.1", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-nano", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-super", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-ultra", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 tokenizer requires transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Olmo3ForCausalLM", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Olmo 3 requires transformers>=4.57.0", + ), + ), + "trl-internal-testing/tiny-Phi3ForCausalLM-3", + "trl-internal-testing/tiny-Phi3ForCausalLM-3.5", + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + "trl-internal-testing/tiny-Qwen3ForCausalLM", + "trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507", + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="Qwen3.5 tokenizer requires transformers>=5.0.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="Qwen3.5 tokenizer requires transformers>=5.0.0", + ), + ), + ] + + conversational_examples = [ + { # Language modeling + "messages": [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ], + }, + { # Prompt-only + "prompt": [{"role": "user", "content": "What color is the sky?"}], + }, + { # Prompt-completion + "prompt": [{"role": "user", "content": "What color is the sky?"}], + "completion": [{"role": "assistant", "content": "It is blue."}], + }, + { # Preference + "prompt": [{"role": "user", "content": "What color is the sky?"}], + "chosen": [{"role": "assistant", "content": "It is blue."}], + "rejected": [{"role": "assistant", "content": "It is green."}], + }, + { # Preference with implicit prompt + "chosen": [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ], + "rejected": [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is green."}, + ], + }, + { # Unpaired preference + "prompt": [{"role": "user", "content": "What color is the sky?"}], + "completion": [{"role": "assistant", "content": "It is blue."}], + "label": True, + }, + ] + + non_conversational_examples = [ + {"text": "The sky is blue."}, # Language modeling + {"prompt": "The sky is"}, # Prompt-only + {"prompt": "The sky is", "completion": " blue."}, # Prompt-completion + {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}, # Preference + {"chosen": "The sky is blue.", "rejected": "The sky is green."}, # Preference with implicit prompt + {"prompt": "The sky is", "completion": " blue.", "label": True}, # Unpaired preference + ] + + @pytest.mark.parametrize("example", conversational_examples) + @pytest.mark.parametrize("tokenizer_id", tokenizers) + def test_apply_chat_template(self, tokenizer_id, example): + tokenizer = AutoTokenizer.from_pretrained(tokenizer_id) + result = apply_chat_template(example, tokenizer) + + # Checking if the result is a dictionary + assert isinstance(result, dict) + + # The chat template should be applied to the following keys + for key in ["prompt", "chosen", "rejected", "completion"]: + if key in example: + assert key in result + assert isinstance(result[key], str) + + # Exception for messages, the key is "text" once the chat template is applied + if "messages" in example: + assert "text" in result + assert isinstance(result["text"], str) + + # The label should be kept + if "label" in example: + assert "label" in result + assert isinstance(result["label"], bool) + assert result["label"] == example["label"] + + # both conversational and non-conversational examples + @pytest.mark.parametrize("example", conversational_examples + non_conversational_examples) + @pytest.mark.parametrize("tokenizer_id", tokenizers) + def test_maybe_apply_chat_template(self, tokenizer_id, example): + tokenizer = AutoTokenizer.from_pretrained(tokenizer_id) + result = maybe_apply_chat_template(example, tokenizer) + + # Checking if the result is a dictionary + assert isinstance(result, dict) + + # The chat template should be applied to the following keys + for key in ["prompt", "chosen", "rejected", "completion"]: + if key in example: + assert key in result + assert isinstance(result[key], str) + + # Exception for messages, the key is "text" once the chat template is applied + if "messages" in example: + assert "text" in result + assert isinstance(result["text"], str) + + # The label should be kept + if "label" in example: + assert "label" in result + assert isinstance(result["label"], bool) + assert result["label"] == example["label"] + + def test_apply_chat_template_with_chat_template_kwargs(self): + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3ForCausalLM") + + example = { + "prompt": [{"role": "user", "content": "What color is the sky?"}], + # with this tokenizer, when you pass enable_thinking=False, it will add "\n\n\n\n" + "chat_template_kwargs": {"enable_thinking": False}, + } + result = apply_chat_template(example, tokenizer) + + # docstyle-ignore + expected = textwrap.dedent("""\ + <|im_start|>user + What color is the sky?<|im_end|> + <|im_start|>assistant + + + + + """) + + assert result["prompt"] == expected + + def test_apply_chat_template_with_tools(self): + tokenizer = AutoProcessor.from_pretrained("trl-internal-testing/tiny-LlamaForCausalLM-3.2") + + # Define dummy test tools + def get_current_temperature(location: str): + """ + Gets the temperature at a given location. + + Args: + location: The location to get the temperature for + """ + return 22.0 + + # Define test case + test_case = { + "prompt": [ + {"content": "What's the temperature in London?", "role": "user"}, + ] + } + # Test with tools + result_with_tools = apply_chat_template(test_case, tokenizer, tools=[get_current_temperature]) + + # Verify tools are included in the output + assert "get_current_temperature" in result_with_tools["prompt"] + + # Test without tools + result_without_tools = apply_chat_template(test_case, tokenizer, tools=None) + + # Verify tools are not included in the output + assert "get_current_temperature" not in result_without_tools["prompt"] + + +class TestApplyChatTemplateHarmony(TrlTestCase): + def test_language_modeling(self): + messages = { + "messages": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."}, + ], + } + output = apply_chat_template( + messages, + processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"), + reasoning_effort="low", + model_identity="You are HuggingGPT.", + ) + + # docstyle-ignore + expected = textwrap.dedent(f"""\ + <|start|>system<|message|>You are HuggingGPT. + Knowledge cutoff: 2024-06 + Current date: {strftime("%Y-%m-%d")} + + Reasoning: low + + # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions + + Respond in a friendly manner. + + <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant<|channel|>analysis<|message|>The user asks the color of the sky...<|end|><|start|>assistant<|channel|>final<|message|>It is blue.<|return|>""") + + assert output["text"] == expected + + def test_prompt_only(self): + messages = { + "prompt": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + ], + } + output = apply_chat_template( + messages, + processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"), + reasoning_effort="low", + model_identity="You are HuggingGPT.", + ) + + # docstyle-ignore + expected = textwrap.dedent(f"""\ + <|start|>system<|message|>You are HuggingGPT. + Knowledge cutoff: 2024-06 + Current date: {strftime("%Y-%m-%d")} + + Reasoning: low + + # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions + + Respond in a friendly manner. + + <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant""") + + assert output["prompt"] == expected + + def test_prompt_completion(self): + messages = { + "prompt": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + ], + "completion": [ + {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."}, + ], + } + output = apply_chat_template( + messages, + processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"), + reasoning_effort="low", + model_identity="You are HuggingGPT.", + ) + + # docstyle-ignore + expected_prompt = textwrap.dedent(f"""\ + <|start|>system<|message|>You are HuggingGPT. + Knowledge cutoff: 2024-06 + Current date: {strftime("%Y-%m-%d")} + + Reasoning: low + + # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions + + Respond in a friendly manner. + + <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant""") + expected_completion = "<|channel|>analysis<|message|>The user asks the color of the sky...<|end|><|start|>assistant<|channel|>final<|message|>It is blue.<|return|>" + + assert output["prompt"] == expected_prompt + assert output["completion"] == expected_completion + + def test_preference(self): + messages = { + "prompt": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + ], + "chosen": [ + {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."}, + ], + "rejected": [ + {"role": "assistant", "thinking": "The user asks the color of the tree...", "content": "It is green."}, + ], + } + output = apply_chat_template( + messages, + processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"), + reasoning_effort="low", + model_identity="You are HuggingGPT.", + ) + + # docstyle-ignore + expected_prompt = textwrap.dedent(f"""\ + <|start|>system<|message|>You are HuggingGPT. + Knowledge cutoff: 2024-06 + Current date: {strftime("%Y-%m-%d")} + + Reasoning: low + + # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions + + Respond in a friendly manner. + + <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant""") + expected_chosen = "<|channel|>analysis<|message|>The user asks the color of the sky...<|end|><|start|>assistant<|channel|>final<|message|>It is blue.<|return|>" + expected_rejected = "<|channel|>analysis<|message|>The user asks the color of the tree...<|end|><|start|>assistant<|channel|>final<|message|>It is green.<|return|>" + + assert output["prompt"] == expected_prompt + assert output["chosen"] == expected_chosen + assert output["rejected"] == expected_rejected + + def test_preference_with_implicit_prompt(self): + messages = { + "chosen": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."}, + ], + "rejected": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "thinking": "The user asks the color of the tree...", "content": "It is green."}, + ], + } + output = apply_chat_template( + messages, + processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"), + reasoning_effort="low", + model_identity="You are HuggingGPT.", + ) + + # docstyle-ignore + expected_chosen = textwrap.dedent(f"""\ + <|start|>system<|message|>You are HuggingGPT. + Knowledge cutoff: 2024-06 + Current date: {strftime("%Y-%m-%d")} + + Reasoning: low + + # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions + + Respond in a friendly manner. + + <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant<|channel|>analysis<|message|>The user asks the color of the sky...<|end|><|start|>assistant<|channel|>final<|message|>It is blue.<|return|>""") + + # docstyle-ignore + expected_rejected = textwrap.dedent(f"""\ + <|start|>system<|message|>You are HuggingGPT. + Knowledge cutoff: 2024-06 + Current date: {strftime("%Y-%m-%d")} + + Reasoning: low + + # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions + + Respond in a friendly manner. + + <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant<|channel|>analysis<|message|>The user asks the color of the tree...<|end|><|start|>assistant<|channel|>final<|message|>It is green.<|return|>""") + + assert output["chosen"] == expected_chosen + assert output["rejected"] == expected_rejected + + def test_unpaired_preference(self): + messages = { + "prompt": [ + {"role": "system", "content": "Respond in a friendly manner."}, + {"role": "user", "content": "What color is the sky?"}, + ], + "completion": [ + {"role": "assistant", "thinking": "The user asks the color of the sky...", "content": "It is blue."}, + ], + "label": True, + } + output = apply_chat_template( + messages, + processing_class=AutoTokenizer.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM"), + reasoning_effort="low", + model_identity="You are HuggingGPT.", + ) + + # docstyle-ignore + expected_prompt = textwrap.dedent(f"""\ + <|start|>system<|message|>You are HuggingGPT. + Knowledge cutoff: 2024-06 + Current date: {strftime("%Y-%m-%d")} + + Reasoning: low + + # Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions + + Respond in a friendly manner. + + <|end|><|start|>user<|message|>What color is the sky?<|end|><|start|>assistant""") + expected_completion = "<|channel|>analysis<|message|>The user asks the color of the sky...<|end|><|start|>assistant<|channel|>final<|message|>It is blue.<|return|>" + + assert output["prompt"] == expected_prompt + assert output["completion"] == expected_completion + assert output["label"] + + +class TestUnpairPreferenceDataset(TrlTestCase): + paired_dataset = Dataset.from_dict( + { + "prompt": ["The sky is", "The sun is"], + "chosen": [" blue.", " in the sky."], + "rejected": [" green.", " in the sea."], + } + ) + + unpaired_dataset = Dataset.from_dict( + { + "prompt": ["The sky is", "The sun is", "The sky is", "The sun is"], + "completion": [" blue.", " in the sky.", " green.", " in the sea."], + "label": [True, True, False, False], + } + ) + + def test_unpair_preference_dataset(self): + # Test that a paired dataset is correctly converted to unpaired + unpaired_dataset = unpair_preference_dataset(self.paired_dataset) + assert unpaired_dataset.to_dict() == self.unpaired_dataset.to_dict(), ( + "The paired dataset should be converted to unpaired." + ) + + def test_unpair_preference_dataset_extra_columns(self): + # Test that extra columns are dropped (not causing a length mismatch error) + paired_dataset = Dataset.from_dict( + { + "prompt": ["The sky is", "The sun is"], + "chosen": [" blue.", " in the sky."], + "rejected": [" green.", " in the sea."], + "extra": [1, 2], + } + ) + unpaired_dataset = unpair_preference_dataset(paired_dataset) + assert unpaired_dataset.to_dict() == self.unpaired_dataset.to_dict() + + def test_unpair_preference_dataset_iterable(self): + # Test that an IterableDataset with extra columns is correctly unpaired + paired_dataset = self.paired_dataset.to_iterable_dataset() + unpaired_dataset = unpair_preference_dataset(paired_dataset) + assert list(unpaired_dataset) == [ + dict(zip(self.unpaired_dataset.column_names, vals, strict=False)) + for vals in zip(*self.unpaired_dataset.to_dict().values(), strict=False) + ] + + def test_unpair_preference_dataset_iterable_extra_columns(self): + # Test that an IterableDataset with extra columns drops them without error + paired_iterable = Dataset.from_dict( + { + "prompt": ["The sky is", "The sun is"], + "chosen": [" blue.", " in the sky."], + "rejected": [" green.", " in the sea."], + "extra": [1, 2], + } + ).to_iterable_dataset() + unpaired_dataset = unpair_preference_dataset(paired_iterable) + assert list(unpaired_dataset) == [ + dict(zip(self.unpaired_dataset.column_names, vals, strict=False)) + for vals in zip(*self.unpaired_dataset.to_dict().values(), strict=False) + ] + + def test_unpair_preference_dataset_dict(self): + # Test that a paired dataset dict is correctly converted to unpaired + paired_dataset_dict = DatasetDict({"abc": self.paired_dataset}) + unpaired_dataset_dict = unpair_preference_dataset(paired_dataset_dict) + assert unpaired_dataset_dict["abc"].to_dict() == self.unpaired_dataset.to_dict(), ( + "The paired dataset should be converted to unpaired." + ) + + def test_maybe_unpair_preference_dataset(self): + # Test that a paired dataset is correctly converted to unpaired with maybe_unpair_preference_dataset + unpaired_dataset = maybe_unpair_preference_dataset(self.paired_dataset) + assert unpaired_dataset.to_dict() == self.unpaired_dataset.to_dict(), ( + "The paired dataset should be converted to unpaired." + ) + + def test_maybe_unpair_preference_dataset_dict(self): + # Test that a paired dataset dict is correctly converted to unpaired with maybe_unpair_preference_dataset + paired_dataset_dict = DatasetDict({"abc": self.paired_dataset}) + unpaired_dataset_dict = maybe_unpair_preference_dataset(paired_dataset_dict) + assert unpaired_dataset_dict["abc"].to_dict() == self.unpaired_dataset.to_dict(), ( + "The paired dataset should be converted to unpaired." + ) + + def test_maybe_unpair_preference_dataset_already_paired(self): + # Test that a paired dataset remains unchanged with maybe_unpair_preference_dataset + unpaired_dataset = maybe_unpair_preference_dataset(self.unpaired_dataset) + assert unpaired_dataset.to_dict() == self.unpaired_dataset.to_dict(), ( + "The unpaired dataset should remain unchanged." + ) + + def test_maybe_unpair_preference_dataset_dict_already_paired(self): + # Test that a paired dataset dict remains unchanged with maybe_unpair_preference_dataset + unpaired_dataset_dict = maybe_unpair_preference_dataset(DatasetDict({"abc": self.unpaired_dataset})) + assert unpaired_dataset_dict["abc"].to_dict() == self.unpaired_dataset.to_dict(), ( + "The unpaired dataset should remain unchanged." + ) + + +class TestExtractPrompt(TrlTestCase): + example_implicit_prompt_conversational = { + "chosen": [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ], + "rejected": [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is green."}, + ], + } + + example_explicit_prompt_conversational = { + "prompt": [ + {"role": "user", "content": "What color is the sky?"}, + ], + "chosen": [ + {"role": "assistant", "content": "It is blue."}, + ], + "rejected": [ + {"role": "assistant", "content": "It is green."}, + ], + } + + example_implicit_prompt_standard = { + "chosen": "The sky is blue.", + "rejected": "The sky is green.", + } + + example_explicit_prompt_standard = { + "prompt": "The sky is", + "chosen": " blue.", + "rejected": " green.", + } + + def test_extract_prompt_conversational(self): + # Test that the prompt is correctly extracted from the dataset + example_extracted_prompt = extract_prompt(self.example_implicit_prompt_conversational) + assert example_extracted_prompt == self.example_explicit_prompt_conversational, ( + "The prompt is not correctly extracted from the dataset." + ) + + def test_maybe_extract_prompt_conversational(self): + # Test that the prompt is correctly extracted from the dataset with maybe_extract_prompt + example_extracted_prompt = maybe_extract_prompt(self.example_implicit_prompt_conversational) + assert example_extracted_prompt == self.example_explicit_prompt_conversational, ( + "The prompt is not correctly extracted from the dataset." + ) + + def test_maybe_extract_prompt_conversational_already_explicit(self): + # Test that the prompt remains unchanged with maybe_extract_prompt + example_extracted_prompt = maybe_extract_prompt(self.example_explicit_prompt_conversational) + assert example_extracted_prompt == self.example_explicit_prompt_conversational, ( + "The prompt should remain unchanged." + ) + + def test_extract_prompt_standard(self): + # Test that the prompt is correctly extracted from the dataset + example_extracted_prompt = extract_prompt(self.example_implicit_prompt_standard) + assert example_extracted_prompt == self.example_explicit_prompt_standard, ( + "The prompt is not correctly extracted from the dataset." + ) + + def test_maybe_extract_prompt_standard(self): + # Test that the prompt is correctly extracted from the dataset with maybe_extract_prompt + example_extracted_prompt = maybe_extract_prompt(self.example_implicit_prompt_standard) + assert example_extracted_prompt == self.example_explicit_prompt_standard, ( + "The prompt is not correctly extracted from the dataset." + ) + + def test_maybe_extract_prompt_standard_already_explicit(self): + # Test that the prompt remains unchanged with maybe_extract_prompt + example_extracted_prompt = maybe_extract_prompt(self.example_explicit_prompt_standard) + assert example_extracted_prompt == self.example_explicit_prompt_standard, "The prompt should remain unchanged." + + +class TestPackDatasetWrapped(TrlTestCase): + def test_with_dataset(self): + examples = { + "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]], + "attention_mask": [[0, 1, 1], [0, 0, 1, 1], [1]], + } + dataset = Dataset.from_dict(examples) + dataset = dataset.with_format("numpy", dtype="float32") + format = dataset.format + seq_length = 3 + expected_output = { + "input_ids": [[1, 2, 3], [4, 5, 6], [7, 8]], + "attention_mask": [[0, 1, 1], [0, 0, 1], [1, 1]], + } + dataset = pack_dataset(dataset, seq_length, strategy="wrapped") + assert dataset.to_dict() == expected_output + assert format == dataset.format + + def test_with_iterable_dataset(self): + examples = { + "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]], + "attention_mask": [[0, 1, 1], [0, 0, 1, 1], [1]], + } + dataset = Dataset.from_dict(examples).to_iterable_dataset() + dataset = dataset.with_format("numpy") + formatting = dataset._formatting + seq_length = 3 + expected_output = { + "input_ids": [[1, 2, 3], [4, 5, 6], [7, 8]], + "attention_mask": [[0, 1, 1], [0, 0, 1], [1, 1]], + } + dataset = pack_dataset(dataset, seq_length, strategy="wrapped") + num_examples = len(examples[next(iter(examples))]) + assert next(iter(dataset.with_format(None).batch(batch_size=num_examples))) == expected_output + assert formatting == dataset._formatting + + +class TestPackDatasetBfd(TrlTestCase): + def test_with_dataset(self): + examples = { + "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]], + } + dataset = Dataset.from_dict(examples) + dataset = dataset.with_format("numpy", dtype="float32") + format = dataset.format + seq_length = 4 + expected_output = { + "input_ids": [[4, 5, 6, 7], [1, 2, 3, 8]], + "seq_lengths": [[4], [3, 1]], + } + dataset = pack_dataset(dataset, seq_length, strategy="bfd") + expected_format = dataset.format + assert dataset.to_dict() == expected_output + assert "seq_lengths" in expected_format["columns"] + expected_format["columns"].remove("seq_lengths") + assert format == dataset.format + + def test_with_iterable_dataset(self): + examples = { + "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]], + } + dataset = Dataset.from_dict(examples).to_iterable_dataset() + dataset = dataset.with_format("numpy") + formatting = dataset._formatting + seq_length = 4 + expected_output = { + "input_ids": [[4, 5, 6, 7], [1, 2, 3, 8]], + "seq_lengths": [[4], [3, 1]], + } + dataset = pack_dataset(dataset, seq_length, strategy="bfd") + num_examples = len(examples[next(iter(examples))]) + assert next(iter(dataset.with_format(None).batch(batch_size=num_examples))) == expected_output + assert formatting == dataset._formatting + + def test_with_overlong_0(self): + examples = { + "input_ids": [[1, 2, 3, 4, 5], [6, 7], [8, 9, 10, 11], [12]], + } + dataset = Dataset.from_dict(examples) + seq_length = 4 + expected_output = { + "input_ids": [[1, 2, 3, 4], [8, 9, 10, 11], [6, 7, 5, 12]], + "seq_lengths": [[4], [4], [2, 1, 1]], + } + dataset = pack_dataset(dataset, seq_length, strategy="bfd_split") + assert dataset.to_dict() == expected_output + + def test_with_overlong_two_coluns(self): + examples = { + "col1": [[1, -2, 3, -4, 5, -6], [7, -8, 9], [-10, 11, -12], [13, -14, 15, -16]], + "col2": [[-1, 2, -3, 4, -5, 6], [-7, 8, -9], [10, -11, 12], [-13, 14, -15, 16]], + } + dataset = Dataset.from_dict(examples) + seq_length = 4 + expected_output = { + "col1": [[1, -2, 3, -4], [13, -14, 15, -16], [7, -8, 9], [-10, 11, -12], [5, -6]], + "col2": [[-1, 2, -3, 4], [-13, 14, -15, 16], [-7, 8, -9], [10, -11, 12], [-5, 6]], + "seq_lengths": [[4], [4], [3], [3], [2]], + } + dataset = pack_dataset(dataset, seq_length, strategy="bfd_split") + assert dataset.to_dict() == expected_output + + def test_with_non_power_of_2(self): + examples = { + "input_ids": [[1, 2, 3, 4, 5], [6], [7, 8, 9, 10], [11, 12, 13]], + } + dataset = Dataset.from_dict(examples) + seq_length = 5 + expected_output = { + "input_ids": [[1, 2, 3, 4, 5], [7, 8, 9, 10, 6], [11, 12, 13]], + "seq_lengths": [[5], [4, 1], [3]], + } + dataset = pack_dataset(dataset, seq_length, strategy="bfd_split") + assert dataset.to_dict() == expected_output + + def test_default_no_split(self): + """Test default 'bfd' strategy for SFT datasets (truncates overflow).""" + examples = { + "input_ids": [[1, 2, 3, 4, 5], [6, 7], [8, 9, 10, 11], [12]], + } + dataset = Dataset.from_dict(examples) + seq_length = 4 + # With default 'bfd' strategy, overflow tokens are discarded + expected_output = { + "input_ids": [[1, 2, 3, 4], [8, 9, 10, 11], [6, 7, 12]], + "seq_lengths": [[4], [4], [2, 1]], + } + dataset = pack_dataset(dataset, seq_length, strategy="bfd") + assert dataset.to_dict() == expected_output + + def test_with_empty_sequences(self): + examples = { + "input_ids": [[1, 2], [], [3, 4, 5], [], [6]], + } + dataset = Dataset.from_dict(examples) + seq_length = 4 + expected_output = { + "input_ids": [[3, 4, 5, 6], [1, 2]], + "seq_lengths": [[3, 1], [2]], + } + dataset = pack_dataset(dataset, seq_length, strategy="bfd_split") + assert dataset.to_dict() == expected_output + + +class TestMaybeConvertToChatML(TrlTestCase): + def test_with_conversations_key(self): + # Particular case where the key is "conversations": we rename it to "messages" + example = { + "conversations": [ + {"from": "user", "value": "What color is the sky?"}, + {"from": "assistant", "value": "It is blue."}, + ] + } + expected_output = { + "messages": [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ] + } + assert maybe_convert_to_chatml(example) == expected_output + + def test_without_conversations_key(self): + # Same as before, but we don't rename the keys + example = { + "prompt": [{"from": "user", "value": "What color is the sky?"}], + "completion": [{"from": "assistant", "value": "It is blue."}], + } + expected_output = { + "prompt": [{"role": "user", "content": "What color is the sky?"}], + "completion": [{"role": "assistant", "content": "It is blue."}], + } + assert maybe_convert_to_chatml(example) == expected_output + + def test_not_conversional(self): + # When not needed, the example should remain unchanged + example = {"text": "The sky is blue."} + assert maybe_convert_to_chatml(example) == example + + def test_already_chatml(self): + # When the example is already in ChatML format, it should remain unchanged + example = { + "messages": [ + {"role": "user", "content": "What color is the sky?"}, + {"role": "assistant", "content": "It is blue."}, + ] + } + assert maybe_convert_to_chatml(example) == example diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_dpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_dpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..c522c780ef43a9aaf21ec5f17983dddc8f3e4130 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_dpo_trainer.py @@ -0,0 +1,1358 @@ +# Copyright 2020-2026 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 pytest +import torch +import transformers +from datasets import load_dataset +from packaging.version import Version +from packaging.version import parse as parse_version +from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig +from transformers.testing_utils import torch_device +from transformers.utils import is_peft_available + +from trl import DPOConfig, DPOTrainer +from trl.trainer.dpo_trainer import DataCollatorForPreference, DataCollatorForVisionPreference + +from .testing_utils import ( + TrlTestCase, + is_ampere_or_newer, + require_bitsandbytes, + require_kernels, + require_liger_kernel, + require_peft, + require_vision, +) + + +if is_peft_available(): + from peft import LoraConfig, get_peft_model + + +class TestDataCollatorForPreference(TrlTestCase): + def test_padding_and_masks(self): + collator = DataCollatorForPreference(pad_token_id=0) + examples = [ + {"prompt_ids": [1, 2, 3], "chosen_ids": [4, 5], "rejected_ids": [6]}, + {"prompt_ids": [7, 8], "chosen_ids": [9, 10], "rejected_ids": [11, 12, 13]}, + ] + result = collator(examples) + + expected_input_ids = torch.tensor( + [ + [1, 2, 3, 4, 5], # prompt + chosen (example 1) + [7, 8, 9, 10, 0], # prompt + chosen (example 2, padded) + [1, 2, 3, 6, 0], # prompt + rejected (example 1, padded) + [7, 8, 11, 12, 13], # prompt + rejected (example 2) + ] + ) + expected_attention_mask = torch.tensor( + [ + [1, 1, 1, 1, 1], + [1, 1, 1, 1, 0], + [1, 1, 1, 1, 0], + [1, 1, 1, 1, 1], + ] + ) + expected_completion_mask = torch.tensor( + [ + [0, 0, 0, 1, 1], # chosen completion (example 1) + [0, 0, 1, 1, 0], # chosen completion (example 2, padded) + [0, 0, 0, 1, 0], # rejected completion (example 1, padded) + [0, 0, 1, 1, 1], # rejected completion (example 2) + ] + ) + + assert set(result.keys()) == {"input_ids", "attention_mask", "completion_mask"} + torch.testing.assert_close(result["input_ids"], expected_input_ids) + torch.testing.assert_close(result["attention_mask"], expected_attention_mask) + torch.testing.assert_close(result["completion_mask"], expected_completion_mask) + + def test_optional_reference_logps(self): + collator = DataCollatorForPreference(pad_token_id=0) + examples = [ + { + "prompt_ids": [1, 2], + "chosen_ids": [3], + "rejected_ids": [4], + "ref_chosen_logps": 0.1, + "ref_rejected_logps": 0.2, + }, + { + "prompt_ids": [5], + "chosen_ids": [6, 7], + "rejected_ids": [8, 9], + "ref_chosen_logps": 0.3, + "ref_rejected_logps": 0.4, + }, + ] + result = collator(examples) + + expected_ref_chosen_logps = torch.tensor([0.1, 0.3]) + expected_ref_rejected_logps = torch.tensor([0.2, 0.4]) + + assert set(result.keys()) == { + "input_ids", + "attention_mask", + "completion_mask", + "ref_chosen_logps", + "ref_rejected_logps", + } + torch.testing.assert_close(result["ref_chosen_logps"], expected_ref_chosen_logps) + torch.testing.assert_close(result["ref_rejected_logps"], expected_ref_rejected_logps) + + def test_with_pad_to_multiple_of(self): + collator = DataCollatorForPreference(pad_token_id=0, pad_to_multiple_of=5) + examples = [ + {"prompt_ids": [1], "chosen_ids": [2], "rejected_ids": [3]}, + {"prompt_ids": [4, 5], "chosen_ids": [6, 7], "rejected_ids": [8, 9]}, + ] + result = collator(examples) + + expected_input_ids = torch.tensor( + [ + [1, 2, 0, 0, 0], # prompt + chosen (example 1, padded to multiple of 5) + [4, 5, 6, 7, 0], # prompt + chosen (example 2) + [1, 3, 0, 0, 0], # prompt + rejected (example 1, padded to multiple of 5) + [4, 5, 8, 9, 0], # prompt + rejected (example 2) + ] + ) + + assert set(result.keys()) == {"input_ids", "attention_mask", "completion_mask"} + torch.testing.assert_close(result["input_ids"], expected_input_ids) + + +class TestDataCollatorForVisionPreference(TrlTestCase): + @pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="mm_token_type_ids are returned by default since transformers-5.3.0 (see transformers#43972)", + ) + @require_vision + def test_mm_token_type_ids_shape(self): + # Regression test: when the processor returns mm_token_type_ids (e.g. Qwen2.5-VL after + # transformers#43972), the collator must concatenate it with zeros for the completion part + # so that its shape matches input_ids. Without the fix this raises an IndexError in the model. + from PIL import Image + from transformers import AutoProcessor + + processor = AutoProcessor.from_pretrained("trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration") + collator = DataCollatorForVisionPreference(processor) + image = Image.new("RGB", (16, 16)) + examples = [ + { + "images": [image], + "prompt": [{"role": "user", "content": "What is this?"}], + "chosen": [{"role": "assistant", "content": "A red square."}], + "rejected": [{"role": "assistant", "content": "A blue circle."}], + } + ] + output = collator(examples) + assert "mm_token_type_ids" in output + assert output["mm_token_type_ids"].shape == output["input_ids"].shape, ( + f"mm_token_type_ids shape {output['mm_token_type_ids'].shape} != " + f"input_ids shape {output['input_ids'].shape}" + ) + + +class TestDPOTrainer(TrlTestCase): + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Cohere2ForCausalLM", + pytest.param( + "trl-internal-testing/tiny-Glm4MoeForCausalLM", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="GLM4 tokenizer requires transformers>=5.0.0", + ), + ), + "trl-internal-testing/tiny-GptOssForCausalLM", + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + "trl-internal-testing/tiny-Qwen3MoeForCausalLM", + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-nano", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.7.0"), + reason="Nemotron 3 gradient checkpointing requires transformers>=5.7.0 (see transformers#45625)", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Olmo3ForCausalLM", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Olmo 3 requires transformers>=4.57.0", + ), + ), + ], + ) + def test_train(self, model_id): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + trainer = DPOTrainer(model=model_id, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize("precompute_ref_log_probs", [False, True]) + def test_evaluate_with_raw_dataset(self, precompute_ref_log_probs): + # `evaluate` should accept the same (unprocessed) dataset types as the trainer, e.g. a held-out test set + # passed directly to `evaluate`. With `precompute_ref_log_probs=True`, the reference log-probs must also be + # precomputed for the freshly-passed dataset. See https://github.com/huggingface/trl/issues/6115. + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, precompute_ref_log_probs=precompute_ref_log_probs, report_to="none" + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + metrics = trainer.evaluate(eval_dataset=dataset) + assert metrics["eval_loss"] is not None + + def test_trust_remote_code(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + + with pytest.raises(ValueError, match="custom code"): + DPOTrainer( + model=model_id, + args=DPOConfig(output_dir=self.tmp_dir, report_to="none"), + train_dataset=dataset, + ) + + trainer = DPOTrainer( + model=model_id, + args=DPOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + train_dataset=dataset, + ) + assert type(trainer.model).__name__ == "RemoteForCausalLM" + + @pytest.mark.parametrize( + "config_name", + [ + "standard_preference", + "conversational_preference", + "standard_implicit_prompt_preference", + "conversational_implicit_prompt_preference", + ], + ) + def test_train_dataset_format(self, config_name): + dataset = load_dataset("trl-internal-testing/zen", config_name, split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + # Special case for harmony + def test_train_gpt_oss(self): + dataset = load_dataset("trl-internal-testing/harmony", "preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-GptOssForCausalLM", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_model(self): + model = AutoModelForCausalLM.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + dtype="float32", + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + trainer = DPOTrainer(model=model, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "loss_type", + [ + "sigmoid", + "hinge", + "ipo", + "exo_pair", + "nca_pair", + "robust", + "bco_pair", + "sppo_hard", + "aot", + "aot_unpaired", + "apo_zero", + "apo_down", + "discopop", + "sft", + "sigmoid_norm", + ], + ) + def test_train_loss_types(self, loss_type): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + loss_type=loss_type, + label_smoothing=1e-3 if loss_type == "exo_pair" else 0.0, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + eval_strategy="steps", + eval_steps=3, + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_multi_loss_types(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + loss_type=["sigmoid", "bco_pair", "sft"], # this specific combination is used in MPO + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_wpo(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + use_weighting=True, + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_ld(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ld_alpha=0.5, + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "f_divergence_type", + ["reverse_kl", "forward_kl", "js_divergence", "alpha_divergence"], + ) + def test_train_with_f_divergence(self, f_divergence_type): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + f_divergence_type=f_divergence_type, + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_explicit_ref_model(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + # When specifying a ref model, it's usually because we want it to be a different checkpoint, but for testing + # purposes we will just just use the same checkpoint + ref_model = AutoModelForCausalLM.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32" + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + ref_model=ref_model, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + new_ref_param = trainer.ref_model.get_parameter(n) + torch.testing.assert_close(param, new_ref_param, msg=f"Reference model parameter {n} has changed.") + + def test_train_with_sync_ref_model(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + sync_ref_model=True, + ref_model_sync_steps=2, # reduce sync steps to ensure a sync happens + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + assert trainer.ref_model is not None + previous_ref_params = {n: param.clone() for n, param in trainer.ref_model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + new_ref_param = trainer.ref_model.get_parameter(n) + assert not torch.equal(previous_ref_params[n], new_ref_param), f"Ref Parameter {n} has not changed." + + def test_train_model_dtype(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + model_init_kwargs={"dtype": torch.float16}, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + # For some reasonn model.layers.0.input_layernorm.weight doesn't change in GitHub Actions but does + # locally. We ignore this parameter for now + if "layernorm" in n: + continue + new_param = trainer.model.get_parameter(n) + # Check the torch dtype + assert new_param.dtype == torch.float16 + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_dense_with_peft_config_lora(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=1.0, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + + trainer = DPOTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_moe_with_peft_config(self): + model_id = "trl-internal-testing/tiny-GptOssForCausalLM" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + + trainer = DPOTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(target_parameters=["mlp.experts.down_proj", "mlp.experts.gate_up_proj"]), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_peft_model(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + lora_config = LoraConfig() + model = get_peft_model(model, lora_config) + + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=1.0, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + trainer = DPOTrainer(model=model, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n and "ref" not in n: # and the peft params to be different (except base and ref) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_moe_peft_model(self): + # Regression test for https://github.com/huggingface/trl/issues/5222. PEFT only supports one adapter per model + # when the LoRA config uses `target_parameters` (see peft#3340), so no "ref" adapter can be created and the + # reference log probs are computed with adapters disabled instead. + model_id = "trl-internal-testing/tiny-GptOssForCausalLM" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + lora_config = LoraConfig(target_parameters=["mlp.experts.down_proj", "mlp.experts.gate_up_proj"]) + model = get_peft_model(model, lora_config) + + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + trainer = DPOTrainer(model=model, args=training_args, train_dataset=dataset) + + assert "ref" not in trainer.model.peft_config + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + # In practice, this test is the same as `test_train_dense_with_peft_config_lora`, since gradient checkpointing is + # enabled by default in `DPOTrainer`. We keep it as a regression guard: if the default ever changes, we still + # explicitly test PEFT + gradient checkpointing, which has caused issues in the past. + @require_peft + def test_train_with_peft_config_and_gradient_checkpointing(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + gradient_checkpointing=True, + report_to="none", + ) + + trainer = DPOTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_liger_kernel + def test_train_with_liger(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + use_liger_kernel=True, + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_liger_kernel + @require_peft + def test_init_fails_with_peft_and_liger(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + use_liger_kernel=True, + report_to="none", + ) + + with pytest.raises(NotImplementedError, match="Liger DPO loss is not implemented for PEFT models."): + DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + def test_train_with_iterable_dataset(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train", streaming=True) + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + max_steps=3, + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_kernels + @pytest.mark.skipif( + not is_ampere_or_newer() and torch_device != "xpu", + reason="Flash Attention 2 requires Ampere or newer GPU, or XPU", + ) + def test_train_padding_free(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + padding_free=True, + model_init_kwargs={"attn_implementation": "kernels-community/flash-attn2"}, + bf16=True, # flash_attention_2 only supports bf16 and fp16 + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_chat_template_kwargs(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + # The following template is a simplified version of the Qwen chat template, where an additional argument + # `role_capital` is used to control the capitalization of roles. + tokenizer.chat_template = '{%- if messages[0]["role"] == "system" -%} {{ "<|im_start|>" + ("SYSTEM" if role_capital else "system") + "\\n" + messages[0]["content"] + "<|im_end|>\\n" }}{%- else -%} {{ "<|im_start|>" + ("SYSTEM" if role_capital else "system") + "\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n" }}{%- endif -%}{%- for message in messages -%} {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) -%} {{ "<|im_start|>" + (message.role.upper() if role_capital else message.role) + "\\n" + message.content + "<|im_end|>\\n" }} {%- elif message.role == "assistant" -%} {{ "<|im_start|>" + ("ASSISTANT" if role_capital else "assistant") }} {%- if message.content -%} {{ "\\n" + message.content }} {%- endif -%} {{ "<|im_end|>\\n" }} {%- elif message.role == "tool" -%} {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") -%} {{ "<|im_start|>" + ("USER" if role_capital else "user") }} {%- endif -%} {{ "\\n\\n" + message.content + "\\n" }} {%- if loop.last or (messages[loop.index0 + 1].role != "tool") -%} {{ "<|im_end|>\\n" }} {%- endif -%} {%- endif -%}{%- endfor -%}{%- if add_generation_prompt -%} {{ "<|im_start|>" + ("ASSISTANT" if role_capital else "assistant") + "\\n" }}{%- endif -%}' + + dataset = dataset.add_column( + "chat_template_kwargs", [{"role_capital": bool(i % 2)} for i in range(len(dataset))] + ) + assert "chat_template_kwargs" in dataset.features + + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + processing_class=tokenizer, + ) + + assert trainer.processing_class.chat_template == tokenizer.chat_template + + for i in range(2): + role = "SYSTEM" if i else "system" + system_prompt = ( + f"<|im_start|>{role}\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>" + ) + system_prompt_ids = trainer.processing_class(system_prompt)["input_ids"] + assert trainer.train_dataset[i]["prompt_ids"][: len(system_prompt_ids)] == system_prompt_ids + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_toolcall_data(self): + dataset = load_dataset("trl-internal-testing/toolcall", "preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # toolcall sequences are longer than standard data, reduce batch size to avoid OOM + max_length=512, # toolcall sequences are longer than standard data, limit length to avoid OOM + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_eval(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference") + + training_args = DPOConfig(output_dir=self.tmp_dir, eval_strategy="steps", eval_steps=3, report_to="none") + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + trainer.train() + + assert trainer.state.log_history[0]["eval_loss"] is not None + + def test_train_with_multiple_eval_dataset(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference") + + training_args = DPOConfig(output_dir=self.tmp_dir, eval_strategy="steps", eval_steps=3, report_to="none") + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset={"data1": dataset["test"], "data2": dataset["test"]}, + ) + trainer.train() + + assert trainer.state.log_history[-3]["eval_data1_loss"] is not None + assert trainer.state.log_history[-2]["eval_data2_loss"] is not None + + def test_train_with_compute_metrics(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference") + + def dummy_compute_metrics(eval_pred): + return {"my_metric": 0.123} + + training_args = DPOConfig( + output_dir=self.tmp_dir, + eval_strategy="steps", + eval_steps=3, + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + compute_metrics=dummy_compute_metrics, + ) + + trainer.train() + + assert trainer.state.log_history[-2]["eval_my_metric"] == 0.123 + + # In practice, this test is the same as `test_train`, since gradient checkpointing is enabled by default in + # `DPOTrainer`. We keep it as a regression guard: if the default ever changes, we still explicitly test gradient + # checkpointing, which has caused issues in the past. + def test_train_with_gradient_checkpointing(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + gradient_checkpointing=True, + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_tag_added(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + train_dataset=dataset, + ) + + for tag in ["dpo", "trl"]: + assert tag in trainer.model.model_tags + + @require_peft + def test_tag_added_peft(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + for tag in ["dpo", "trl"]: + assert tag in trainer.model.model_tags + + @require_peft + @require_bitsandbytes + def test_peft_with_quantization(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + + quantization_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_type="nf4", + bnb_4bit_compute_dtype=torch.float16, + ) + model = AutoModelForCausalLM.from_pretrained( + model_id, + dtype="float32", + quantization_config=quantization_config, + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train") + + # Initialize the trainer with the already configured PeftModel + training_args = DPOConfig(output_dir=self.tmp_dir, learning_rate=0.1, report_to="none") + trainer = DPOTrainer(model=model, args=training_args, train_dataset=dataset, peft_config=LoraConfig()) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + assert trainer.state.log_history[-1]["mean_token_accuracy"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + # In bitsandbytes, bias parameters are automatically cast to the input dtype during the forward pass if + # their dtype doesn’t match. This causes the module to change unexpectedly during the first forward pass of + # the training. To handle this, we cast these specific bias parameters to float32 before comparison. + # https://github.com/bitsandbytes-foundation/bitsandbytes/blob/45553f7392e524eacf400b132cfe01261f6477be/bitsandbytes/nn/modules.py#L518 + # We still need to investigate why the compute dtype ends up being different than for these parameters. + if n in [ + "base_model.model.model.layers.1.self_attn.k_proj.bias", + "base_model.model.model.layers.1.self_attn.q_proj.base_layer.bias", + "base_model.model.model.layers.1.self_attn.v_proj.base_layer.bias", + ]: + param = param.float() + + if "lora" not in n: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "lora" in n: # We expect the peft params to be different + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + else: + raise ValueError(f"Unexpected parameter {n} in model: {trainer.model}") + + +@require_vision +class TestDPOTrainerVLM(TrlTestCase): + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + # "trl-internal-testing/tiny-Idefics2ForConditionalGeneration", high memory peak, skipped for now + # "trl-internal-testing/tiny-Idefics3ForConditionalGeneration", high memory peak, skipped for now + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2VLForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + # "trl-internal-testing/tiny-SmolVLMForConditionalGeneration", seems not to support bf16 properly + pytest.param( + "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", + marks=[ + pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Qwen3-VL series were introduced in transformers-4.57.0", + ), + ], + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + ], + ) + def test_train_vlm(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + report_to="none", + ) + trainer = DPOTrainer(model=model_id, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + # LLaVA & LLaVA-Next: vision_feature_layer=-2 leaves the last encoder layer (layers.1) and + # post_layernorm (pooler-only path) without gradient by design. Assert they stay frozen — if they + # ever start training, the feature-selection plumbing has likely regressed. + if model_id in ( + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + ) and ("encoder.layers.1" in n or "post_layernorm" in n): + assert torch.equal(param, new_param), f"Param {n} expected frozen by LLaVA design, but changed" + else: + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + @pytest.mark.xfail( + parse_version(transformers.__version__) < parse_version("4.57.0"), + reason="Mixing text-only and image+text examples is only supported in transformers >= 4.57.0", + strict=False, + ) + def test_train_vlm_multi_image(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-multi-image", "conversational_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + per_device_train_batch_size=1, # VLM training is memory intensive, reduce batch size to avoid OOM + report_to="none", + ) + trainer = DPOTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + @pytest.mark.parametrize( + "dataset_config", + ["conversational_preference", "standard_preference"], + ) + def test_train_vlm_text_only_data(self, model_id, dataset_config): + dataset = load_dataset("trl-internal-testing/zen", dataset_config, split="train") + + training_args = DPOConfig(output_dir=self.tmp_dir, report_to="none") + trainer = DPOTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n.startswith("model.visual"): + torch.testing.assert_close(param, new_param, rtol=1e-12, atol=1e-12, msg=f"Param {n} is updated") + else: + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + def test_train_vlm_with_max_length(self): + # Regression test for #5283: mm_token_type_ids must be truncated alongside input_ids when max_length is set, + # otherwise a shape mismatch crashes the model forward pass. + # max_length=37 truncates 1 completion token (total_len=38) while keeping all image tokens (prompt_len=34) safe. + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train") + training_args = DPOConfig( + output_dir=self.tmp_dir, + max_length=37, # total_len=38, prompt_len=34 — truncates completion, not image tokens + per_device_train_batch_size=2, + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + args=training_args, + train_dataset=dataset, + ) + trainer.train() + assert trainer.state.log_history[-1]["train_loss"] is not None + + def test_train_vlm_keep_end_raises(self): + # Regression test for #5285: keep_end with a VLM must raise at init time, not silently corrupt training. + # Image tokens live at the start of the sequence (in the prompt); keep_end would drop them. + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train") + with pytest.warns(FutureWarning, match="keep_end.*deprecated"): + training_args = DPOConfig( + output_dir=self.tmp_dir, + max_length=32, + truncation_mode="keep_end", + report_to="none", + ) + with pytest.raises(ValueError, match="truncation_mode='keep_end' is not supported for vision-language models"): + DPOTrainer( + model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + args=training_args, + train_dataset=dataset, + ) + + def test_vision_dataset_with_text_model_raises(self): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train") + training_args = DPOConfig(output_dir=self.tmp_dir, report_to="none") + with pytest.raises(ValueError, match="vision-related.*vision-language model"): + DPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + def test_precompute_ref_log_probs_raises_for_vision(self): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train") + training_args = DPOConfig(output_dir=self.tmp_dir, report_to="none", precompute_ref_log_probs=True) + with pytest.raises(ValueError, match="precompute_ref_log_probs.*not supported for vision datasets"): + DPOTrainer( + model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + args=training_args, + train_dataset=dataset, + ) + + @require_liger_kernel + def test_train_vlm_liger(self): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train") + training_args = DPOConfig( + output_dir=self.tmp_dir, + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + use_liger_kernel=True, + report_to="none", + ) + trainer = DPOTrainer( + model="trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + +@pytest.mark.slow +class TestDPOTrainerSlow(TrlTestCase): + # Gemma 3n uses a timm encoder, making it difficult to create a smaller variant for testing. + # To ensure coverage, we run tests on the full model but mark them as slow to exclude from default runs. + @pytest.mark.skip(reason="Model google/gemma-3n-E2B-it is gated and requires HF token") + @require_vision + def test_train_vlm_gemma_3n(self): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_preference", split="train") + + training_args = DPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + per_device_train_batch_size=1, # VLM training is memory intensive, reduce batch size to avoid OOM + model_init_kwargs={"dtype": "bfloat16"}, + report_to="none", + ) + trainer = DPOTrainer(model="google/gemma-3n-E2B-it", args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if "model.audio_tower" in n or "model.embed_audio" in n: + # The audio embedding parameters are not updated because this dataset contains no audio data + continue + assert not torch.equal(param, new_param), f"Param {n} is not updated" diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_grpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_grpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..d7a0b9960da5ba15e3b6c990f9cd433ab94ae6e2 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_grpo_trainer.py @@ -0,0 +1,3546 @@ +# Copyright 2020-2026 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 gc +import os +import warnings +from collections.abc import Callable +from types import SimpleNamespace +from unittest.mock import MagicMock, patch + +import numpy as np +import pytest +import torch +import transformers +from accelerate.utils.memory import release_memory +from datasets import Dataset, Image, load_dataset +from packaging.version import Version +from transformers import ( + AutoModelForCausalLM, + AutoModelForImageTextToText, + AutoModelForSequenceClassification, + AutoProcessor, + AutoTokenizer, + BitsAndBytesConfig, +) +from transformers.testing_utils import backend_empty_cache, torch_device +from transformers.utils import is_peft_available + +from trl import GRPOConfig, GRPOTrainer +from trl.import_utils import is_liger_kernel_available +from trl.trainer.utils import get_kbit_device_map + +from .testing_utils import ( + TrlTestCase, + is_ampere_or_newer, + require_bitsandbytes, + require_jmespath, + require_kernels, + require_liger_kernel, + require_peft, + require_torch_accelerator, + require_vision, + require_vllm, +) + + +if is_peft_available(): + from peft import LoraConfig, PeftModel, get_peft_model + + +def multiply_tool(a: int, b: int) -> int: + """ + Multiplies two integers. + + Args: + a: The first integer. + b: The second integer. + + Returns: + The product of the two integers. + """ + return a * b + + +async def async_multiply_tool(a: int, b: int) -> int: + """ + Asynchronously multiplies two integers. + + Args: + a: The first integer. + b: The second integer. + + Returns: + The product of the two integers. + """ + return a * b + + +class TestGetHighEntropyMask(TrlTestCase): + def get_high_entropy_mask(self, entropies, mask, threshold): + """Helper method to test the get_high_entropy_mask functionality.""" + # Create a mock trainer with minimal setup + from unittest.mock import Mock + + # Create a mock accelerator + mock_accelerator = Mock() + mock_accelerator.num_processes = 1 # Single process for testing + + # Create a minimal trainer instance just to access the method + trainer = Mock(spec=GRPOTrainer) + trainer.accelerator = mock_accelerator + trainer.accelerator.gather = lambda x: x + trainer.accelerator.pad_across_processes = lambda x, dim, pad_index: x + + # Call the actual method from GRPOTrainer + return GRPOTrainer.get_high_entropy_mask(trainer, entropies, mask, threshold) + + def test_compute_entropy_mask_0(self): + # We have a total of 12 tokens out of which 10 are non-pad. + # for a top_entropy_quantile of 0.8, we expect the top 20% i.e 2 non-pad tokens corresponding to + # the highest entropy to be unmasked. + # In our example these will be the tokens corresponding to the entropies 0.9 and 1.0 since 1.1 and 1.2 are pad + # tokens they are excluded from the entropy threshold calculation. + entropies = torch.tensor([[0.1, 0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1.0, 1.1, 1.2]]) + mask = torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 0, 0]]) + entropy_mask = self.get_high_entropy_mask(entropies, mask, threshold=0.8) + expected_mask = torch.tensor([[0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0]], dtype=torch.bool) + torch.testing.assert_close(entropy_mask, expected_mask) + + def test_compute_entropy_mask_1(self): + # Another example with a different set of entropies and a different mask. + entropies = torch.tensor([[0.1, 0.2, 0.3, 1.4, 0.5, 0.14], [0.5, 0.6, 0.7, 0.8, 0.9, 1.0]]) + mask = torch.tensor([[1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 0, 0]]) + entropy_mask = self.get_high_entropy_mask(entropies, mask, threshold=0.8) + expected_mask = torch.tensor([[0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0]], dtype=torch.bool) + torch.testing.assert_close(entropy_mask, expected_mask) + + def test_compute_entropy_mask_lower_threshold(self): + # For a threshold of 0.5 we expect the top half of the non-pad tokens to be unmasked. + entropies = torch.tensor([[0.1, 0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1.0, 1.1, 1.2]]) + mask = torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 0, 0]]) + entropy_mask = self.get_high_entropy_mask(entropies, mask, threshold=0.5) + expected_mask = torch.tensor([[0, 0, 0, 0, 0, 1], [1, 1, 1, 1, 0, 0]], dtype=torch.bool) + torch.testing.assert_close(entropy_mask, expected_mask) + + def test_compute_entropy_threshold_0(self): + # If the threshold is 0.0 then we expect the mask to be all ones for non-pad tokens. + entropies = torch.tensor([[0.1, 0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1.0, 1.1, 1.2]]) + mask = torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 0, 0]]) + entropy_mask = self.get_high_entropy_mask(entropies, mask, threshold=0.0) + expected_mask = torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 0, 0]], dtype=torch.bool) + torch.testing.assert_close(entropy_mask, expected_mask) + + def test_compute_entropy_threshold_1(self): + # If the threshold is 1.0 then we expect the mask to be all zeros BUT ONE VALUE. + entropies = torch.tensor([[0.1, 0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1.0, 1.1, 1.2]]) + mask = torch.tensor([[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 0, 0]]) + entropy_mask = self.get_high_entropy_mask(entropies, mask, threshold=1.0) + expected_mask = torch.tensor([[0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0]], dtype=torch.bool) + torch.testing.assert_close(entropy_mask, expected_mask) + + def test_compute_entropy_all_masked(self): + # If there are no non-pad tokens we expect the mask to be all zeros. + entropies = torch.tensor([[0.1, 0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1.0, 1.1, 1.2]]) + mask = torch.tensor([[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]) + entropy_mask = self.get_high_entropy_mask(entropies, mask, threshold=0.5) + expected_mask = torch.tensor([[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], dtype=torch.bool) + torch.testing.assert_close(entropy_mask, expected_mask) + + +class TestGRPORolloutDispatch: + def _make_trainer(self): + trainer = object.__new__(GRPOTrainer) + trainer.accelerator = SimpleNamespace( + device=torch.device("cpu"), + is_main_process=True, + gather=lambda t: t, + ) + trainer.args = SimpleNamespace(report_to=[]) + trainer.model = SimpleNamespace(training=True) + trainer.state = SimpleNamespace(global_step=2, num_input_tokens_seen=0) + trainer._last_loaded_step = 1 + trainer.use_vllm = False + trainer.use_transformers_continuous_batching = False + trainer.vllm_generation = SimpleNamespace(sync_weights=MagicMock()) + trainer.processing_class = SimpleNamespace( + batch_decode=MagicMock(return_value=["decoded"]), + ) + trainer._tokenizer = SimpleNamespace(eos_token_id=2, pad_token_id=0) + trainer.tools = None + trainer._metrics = { + "train": { + "num_tokens": [], + **{ + k: [] + for k in [ + "completions/mean_length", + "completions/min_length", + "completions/max_length", + "completions/clipped_ratio", + "completions/mean_terminated_length", + "completions/min_terminated_length", + "completions/max_terminated_length", + ] + }, + } + } + return trainer + + def test_generate_prefers_rollout_func(self): + trainer = self._make_trainer() + trainer.rollout_func = MagicMock( + return_value={ + "prompt_ids": [[1]], + "completion_ids": [[2]], + "logprobs": [[-0.1]], + "env_mask": [[1]], + } + ) + + result = trainer._generate(["prompt"]) + + assert result[0] == [[1]] # prompt_ids + assert result[1] == [[2]] # completion_ids + assert result[2] == [[1]] # tool_mask (from env_mask) + trainer.rollout_func.assert_called_once_with(["prompt"], trainer) + + def test_generate_rollout_func_syncs_vllm_weights_when_needed(self): + trainer = self._make_trainer() + trainer.use_vllm = True + trainer.rollout_func = MagicMock( + return_value={"prompt_ids": [[1]], "completion_ids": [[2]], "logprobs": [[0.0]]} + ) + + trainer._generate(["prompt"]) + + trainer.vllm_generation.sync_weights.assert_called_once() + assert trainer._last_loaded_step == trainer.state.global_step + trainer.rollout_func.assert_called_once_with(["prompt"], trainer) + + def test_generate_rollout_func_raises_when_required_keys_are_missing(self): + trainer = self._make_trainer() + trainer.rollout_func = MagicMock(return_value={"prompt_ids": [[1]], "completion_ids": [[2]]}) + + with pytest.raises(ValueError, match="rollout_func must return keys"): + trainer._generate(["prompt"]) + + +@pytest.mark.skipif( + Version(transformers.__version__) < Version("5.8.0"), + reason="transformers continuous batching requires transformers>=5.8.0", +) +class TestTransformersContinuousBatchingContract: + """Contract tests for the transformers CB API that GRPOTrainer depends on.""" + + def test_generation_output_has_logprobs_field(self): + from transformers.generation.continuous_batching.requests import GenerationOutput + + output = GenerationOutput(request_id="req_0") + assert output.logprobs == [], "GenerationOutput.logprobs must default to an empty list" + + def test_generation_output_logprobs_accepts_floats(self): + from transformers.generation.continuous_batching.requests import GenerationOutput + + output = GenerationOutput(request_id="req_0", generated_tokens=[1, 2, 3], logprobs=[-0.1, -0.5, -0.3]) + assert output.logprobs == [-0.1, -0.5, -0.3] + + def test_continuous_batching_config_has_return_logprobs(self): + from transformers.generation import ContinuousBatchingConfig + + cfg = ContinuousBatchingConfig(return_logprobs=True) + assert cfg.return_logprobs is True + + def test_generate_batch_accepts_continuous_batching_config(self): + import inspect + + from transformers.generation.continuous_batching.continuous_api import ContinuousMixin + + sig = inspect.signature(ContinuousMixin.generate_batch) + assert "continuous_batching_config" in sig.parameters, ( + "generate_batch() must accept a continuous_batching_config parameter" + ) + + +class TestGRPOTrainer(TrlTestCase): + def test_init_minimal(self): + # Test that GRPOTrainer can be instantiated with only model, reward_model and train_dataset + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + train_dataset=dataset, + ) + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Cohere2ForCausalLM", + pytest.param( + "trl-internal-testing/tiny-Glm4MoeForCausalLM", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="GLM4 tokenizer requires transformers>=5.0.0", + ), + ), + "trl-internal-testing/tiny-GptOssForCausalLM", + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + "trl-internal-testing/tiny-Qwen3MoeForCausalLM", + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-nano", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.7.0"), + reason="Nemotron 3 gradient checkpointing requires transformers>=5.7.0 (see transformers#45625)", + ), + ), + ], + ) + def test_train(self, model_id): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model=model_id, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # MoE models log the load-balancing auxiliary loss (on by default) + if trainer.aux_loss_enabled: + assert trainer.state.log_history[-1]["aux_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"]) + def test_train_dataset_format(self, config_name): + dataset = load_dataset("trl-internal-testing/zen", config_name, split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_trust_remote_code(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + + def reward_func(completions, **kwargs): + return [0.0] * len(completions) + + with pytest.raises(ValueError, match="custom code"): + GRPOTrainer( + model=model_id, + args=GRPOConfig(output_dir=self.tmp_dir, report_to="none"), + reward_funcs=reward_func, + train_dataset=dataset, + ) + + trainer = GRPOTrainer( + model=model_id, + args=GRPOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + reward_funcs=reward_func, + train_dataset=dataset, + ) + assert type(trainer.model).__name__ == "RemoteForCausalLM" + + @pytest.mark.parametrize("use_liger_kernel", [False, pytest.param(True, marks=require_liger_kernel)]) + @pytest.mark.parametrize("loss_type", ["bnpo", "dr_grpo", "dapo", "cispo", "sapo", "luspo", "vespo"]) + def test_train_loss_types(self, loss_type, use_liger_kernel): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + importance_sampling_level="sequence" if loss_type == "luspo" else "token", + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=32, # reduce the completion length to reduce memory usage + gradient_accumulation_steps=2, # set to 2 to test than DAPO can operate with accumulated batch + loss_type=loss_type, + use_liger_kernel=use_liger_kernel, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_eval(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + per_device_eval_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + eval_strategy="steps", + eval_steps=2, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + trainer.train() + + def test_train_with_num_generations_eval(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + per_device_eval_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + num_generations_eval=1, + eval_strategy="steps", + eval_steps=2, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + trainer.train() + + # Regression test for eval_on_start with loss_type="grpo" (one of the loss types that depends on + # current_gradient_accumulation_steps): evaluation runs before the first training step, when that value is still + # unset. Previously this caused the initial eval to crash. + def test_train_eval_on_start(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only") + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + per_device_eval_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + loss_type="grpo", + eval_strategy="steps", + eval_steps=2, + eval_on_start=True, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + trainer.train() + + def test_train_multiple_iterations(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + num_iterations=2, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_peft_config(self): + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_liger_kernel_with_peft_lm_head_raises(self): + # The Liger fused GRPO loss reads `lm_head.weight` directly, so a LoRA adapter on `lm_head` is silently + # ignored and never trained. The trainer must fail fast instead of training a silently-frozen head (#4612). + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + training_args = GRPOConfig(output_dir=self.tmp_dir, use_liger_kernel=True, report_to="none") + with pytest.raises(ValueError, match="lm_head"): + GRPOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(target_modules=["q_proj", "v_proj", "lm_head"]), + ) + + @require_peft + def test_liger_kernel_with_peft_non_lm_head_target_allowed(self): + # The lm_head guard must only fire when the adapter actually wraps lm_head. An adapter that targets other + # modules (here q_proj/v_proj) leaves lm_head as a plain Linear, so Liger reads the real (frozen) head weight + # and there is nothing to silently drop. Guards against an over-broad regression. + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + training_args = GRPOConfig(output_dir=self.tmp_dir, use_liger_kernel=True, report_to="none") + kwargs = { + "model": model, + "reward_funcs": "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + "args": training_args, + "train_dataset": dataset, + "peft_config": LoraConfig(target_modules=["q_proj", "v_proj"]), + } + if is_liger_kernel_available(): + GRPOTrainer(**kwargs) # must construct without raising + else: + # Liger isn't installed on this lane: the guard runs before the Liger-availability check, so the only + # acceptable failure is the missing-dependency ImportError, never the lm_head ValueError. + with pytest.raises(ImportError): + GRPOTrainer(**kwargs) + + @require_peft + def test_liger_kernel_with_peft_modules_to_save_lm_head_allowed(self): + # `modules_to_save=["lm_head"]` makes the head a fully trained copy (ModulesToSaveWrapper, not a tuner layer), + # so `lm_head.weight` resolves to the trained weight and Liger trains it correctly. This is the documented + # workaround in the guard's error message, so it must stay unblocked. + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + training_args = GRPOConfig(output_dir=self.tmp_dir, use_liger_kernel=True, report_to="none") + kwargs = { + "model": model, + "reward_funcs": "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + "args": training_args, + "train_dataset": dataset, + "peft_config": LoraConfig(target_modules=["q_proj", "v_proj"], modules_to_save=["lm_head"]), + } + if is_liger_kernel_available(): + GRPOTrainer(**kwargs) # must construct without raising + else: + with pytest.raises(ImportError): + GRPOTrainer(**kwargs) + + @require_peft + def test_train_peft_model(self): + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + lora_config = LoraConfig() + model = get_peft_model(model, lora_config) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n and "ref" not in n: # and the peft params to be different (except base and ref) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_moe_peft_model(self): + # Regression test for https://github.com/huggingface/trl/issues/5222. PEFT only supports one adapter per model + # when the LoRA config uses `target_parameters` (see peft#3340), so no "ref" adapter can be created and the + # reference log probs are computed with adapters disabled instead. + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM", dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + lora_config = LoraConfig(target_parameters=["mlp.experts.down_proj", "mlp.experts.gate_up_proj"]) + model = get_peft_model(model, lora_config) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + beta=0.1, # set beta to a non-zero value so that the trainer needs a reference model + report_to="none", + ) + trainer = GRPOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + assert "ref" not in trainer.model.peft_config + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + # In practice, this test is the same as `test_train_peft_config`, since gradient checkpointing is enabled by + # default in `GRPOTrainer`. We keep it as a regression guard: if the default ever changes, we still explicitly test + # PEFT + gradient checkpointing, which has caused issues in the past. + @require_peft + def test_train_peft_with_gradient_checkpointing(self): + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + gradient_checkpointing=True, # enable gradient checkpointing + report_to="none", + ) + trainer = GRPOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_different_reward_model(self): + # Use a reward model different from the model: different chat template, tokenization, etc. + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train") + reward_model_id = "trl-internal-testing/tiny-LlamaForSequenceClassification-3.2" + reward_model = AutoModelForSequenceClassification.from_pretrained(reward_model_id) + reward_tokenizer = AutoTokenizer.from_pretrained(reward_model_id) + # By default, the trainer uses the eos token as the padding token. However, for Llama models, the eos token + # appears in the chat template. Using it as a pad token disrupts the reward calculation, as the calculation + # considers the score of the last token before the first pad token. To ensure correct reward calculations, + # we use a separate pad token instead. + reward_tokenizer.pad_token = "<|finetune_right_pad_id|>" + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_model, + args=training_args, + train_dataset=dataset, + reward_processing_classes=reward_tokenizer, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_reward_func_standard(self): + # Test if trainer can handle reward function with standard format + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_reward_func_conversational(self): + # Test if trainer can handle reward function with conversational format + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that gives higher scores to longer completion content.""" + completion_contents = [completion[0]["content"] for completion in completions] + return [float(len(content)) for content in completion_contents] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_multiple_reward_funcs(self): + # Test that GRPOTrainer can be instantiated with multiple reward functions + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func1(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + def reward_func2(completions, **kwargs): + """Reward function that rewards completions with more unique letters.""" + return [float(len(set(completion))) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[reward_func1, reward_func2], + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_sync_and_async_reward_funcs(self): + # Test that GRPOTrainer can be instantiated with multiple reward functions one of which is async + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def sync_reward_func1(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + def sync_reward_func2(completions, **kwargs): + return [1 for _ in completions] + + async def async_reward_func(completions, **kwargs): + """Async Reward function that rewards completions with more unique letters.""" + return [float(len(set(completion))) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[sync_reward_func1, sync_reward_func2, async_reward_func], + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_multiple_reward_funcs_with_None_output(self): + """Test that a valid math reward function is processed correctly while the code reward function returns None.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def applicable_reward_func(completions, **kwargs): + """A reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + def non_applicable_reward_func(completions, **kwargs): + """A reward function that returns None for all inputs, as it is not applicable to this sample.""" + return [None] * len(completions) + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[ + applicable_reward_func, + non_applicable_reward_func, + ], # One applicable, one non applicable + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = { + n: param.clone() for n, param in trainer.model.named_parameters() if param.requires_grad + } + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_multiple_reward_funcs_with_weights(self): + """Test that GRPOTrainer can handle multiple reward functions with weights.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func1(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + def reward_func2(completions, **kwargs): + """Reward function that rewards completions with more unique letters.""" + return [float(len(set(completion))) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + reward_weights=[0.7, 0.3], # weight of reward_func1 and reward_func2 respectively + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[reward_func1, reward_func2], + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + # Check that training logs contain both reward metrics + assert trainer.state.log_history[-1]["train_loss"] is not None + assert "rewards/reward_func1/mean" in trainer.state.log_history[-1] + assert "rewards/reward_func1/std" in trainer.state.log_history[-1] + assert "rewards/reward_func2/mean" in trainer.state.log_history[-1] + assert "rewards/reward_func2/std" in trainer.state.log_history[-1] + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize("multi_objective_aggregation", ["sum_then_normalize", "normalize_then_sum"]) + def test_reward_metric_reflects_reward_weights(self, multi_objective_aggregation): + """Test that the logged 'reward' metric uses reward_weights, not an unweighted sum.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def constant_reward_1(completions, **kwargs): + return [1.0] * len(completions) + + def constant_reward_0(completions, **kwargs): + return [0.0] * len(completions) + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + reward_weights=[0.7, 0.3], + multi_objective_aggregation=multi_objective_aggregation, + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[constant_reward_1, constant_reward_0], + args=training_args, + train_dataset=dataset, + ) + + trainer.train() + + log = trainer.state.log_history[-1] + # With reward_weights=[0.7, 0.3] and rewards [1.0, 0.0]: + # weighted reward = 0.7*1.0 + 0.3*0.0 = 0.7 + # unweighted reward = 1.0 + 0.0 = 1.0 + assert abs(log["reward"] - 0.7) < 1e-5, ( + f"Expected logged reward to be ~0.7 (weighted), got {log['reward']}. " + "The reward metric should reflect reward_weights." + ) + + def test_train_multiple_mixed_reward_funcs(self): + # Test if the trainer can handle a mix of reward functions and reward models + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[reward_func, "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5"], + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_reward_func_additional_column(self): + # Test if trainer can handle reward function that rely on additional columns in the dataset + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + # Add a column to the dataset (dummy example, the column could be anything) + some_values = list(range(len(dataset))) + dataset = dataset.add_column("some_values", some_values) + + def reward_func(completions, some_values, **kwargs): + """Reward function that rewards completions with lengths closer to the values in some_values.""" + return [ + float(abs(len(completion) - value)) for completion, value in zip(completions, some_values, strict=True) + ] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_sync_ref_model(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + beta=0.1, # ensure ref model is created so sync can update it + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + sync_ref_model=True, + ref_model_sync_steps=2, # reduce sync steps to ensure a sync happens + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + assert trainer.ref_model is not None + previous_ref_params = {n: param.clone() for n, param in trainer.ref_model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + new_ref_param = trainer.ref_model.get_parameter(n) + assert not torch.equal(previous_ref_params[n], new_ref_param), f"Ref Parameter {n} has not changed." + + def test_train_beta_non_zero(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + training_args = GRPOConfig( + output_dir=self.tmp_dir, + beta=0.1, # set beta to non-zero value to test the case where the reference model is used + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_pad_to_multiple_of(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + pad_to_multiple_of=8, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_get_off_policy_mask(self): + """ + Test the logic of off-policy masking: + - Keep if Advantage >= 0 + - Keep if KL <= threshold + - Drop if Advantage < 0 AND KL > threshold + """ + mask = torch.ones((3, 4)) # B=3 sequences, T=4 tokens + + advantages = torch.tensor([1.0, -1.0, -1.0]).unsqueeze(-1) + sampling_per_token_logps = torch.zeros((3, 4)) + per_token_logps = torch.zeros((3, 4)) + + per_token_logps[0, :] = -2.0 # Pos adv + High KL (0−(−2)=2) -> Keep + per_token_logps[1, :] = -0.5 # Neg adv + Low KL (0.5) -> Keep + per_token_logps[2, :] = -2.0 # Neg adv + High KL (2.0) -> Drop + + off_policy_threshold = 1.0 + + expected_mask = torch.tensor([[1.0], [1.0], [0.0]]) + + off_policy_mask = GRPOTrainer.get_off_policy_mask( + advantages, per_token_logps, sampling_per_token_logps, mask, off_policy_threshold + ) + + torch.testing.assert_close(off_policy_mask, expected_mask) + + def test_get_off_policy_mask_padding(self): + """Test that padding is correctly ignored in KL calculation.""" + mask = torch.tensor([[1.0, 1.0, 0.0, 0.0]]) # 2 valid tokens + advantages = torch.tensor([[-1.0]]) # Negative advantage + + sampling_per_token_logps = torch.zeros((1, 4)) + per_token_logps = torch.zeros((1, 4)) + + # Valid tokens have High KL (2.0) + per_token_logps[0, 0] = -2.0 + per_token_logps[0, 1] = -2.0 + + # Padding tokens have abnormal values (should be ignored) + per_token_logps[0, 2] = -10_000.0 + per_token_logps[0, 3] = 10_000.0 + + off_policy_threshold = 1.0 + + # Avg KL on valid tokens = (2+2)/2 = 2.0 > 1.0 -> Drop + expected_mask = torch.tensor([[0.0]]) + + off_policy_mask = GRPOTrainer.get_off_policy_mask( + advantages, per_token_logps, sampling_per_token_logps, mask, off_policy_threshold + ) + + torch.testing.assert_close(off_policy_mask, expected_mask) + + # Now test with Low KL on valid tokens + per_token_logps[0, 0] = -0.5 + per_token_logps[0, 1] = -0.5 + # Avg KL = 0.5 <= 1.0 -> Keep + expected_mask_keep = torch.tensor([[1.0]]) + + off_policy_mask_keep = GRPOTrainer.get_off_policy_mask( + advantages, per_token_logps, sampling_per_token_logps, mask, off_policy_threshold + ) + + torch.testing.assert_close(off_policy_mask_keep, expected_mask_keep) + + def test_train_with_off_policy_mask(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + off_policy_mask_threshold=0.5, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_liger_kernel + @pytest.mark.xfail(reason="Off-Policy Masking isn't compatible with Liger yet.") + def test_train_with_off_policy_mask_with_liger(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + off_policy_mask_threshold=0.5, + use_liger_kernel=True, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_liger_kernel + def test_compute_liger_loss_passes_vllm_is_ratio(self): + """Test that importance_sampling_ratio from inputs is passed to liger_grpo_loss as vllm_is_ratio.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + use_liger_kernel=True, + report_to="none", + logging_strategy="no", + ) + + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + # Mock _generate_and_score_completions to inject importance_sampling_ratio + original_gen = trainer._generate_and_score_completions + + def gen_with_is_ratio(*args, **kwargs): + result = original_gen(*args, **kwargs) + B, T = result["completion_ids"].shape + result["importance_sampling_ratio"] = torch.full((B, T), 0.5, device=result["completion_ids"].device) + return result + + with ( + patch.object(trainer, "_generate_and_score_completions", side_effect=gen_with_is_ratio), + patch.object(trainer.liger_grpo_loss, "forward", wraps=trainer.liger_grpo_loss.forward) as mock_forward, + ): + trainer.train() + + # Verify vllm_is_ratio was passed in every call to liger_grpo_loss + assert mock_forward.call_count > 0, "liger_grpo_loss.forward was never called" + for call in mock_forward.call_args_list: + vllm_is_ratio = call.kwargs.get("vllm_is_ratio") + assert vllm_is_ratio is not None, ( + "vllm_is_ratio should not be None when importance_sampling_ratio is present" + ) + assert (vllm_is_ratio == 0.5).all(), ( + "vllm_is_ratio values should match the injected importance_sampling_ratio" + ) + + release_memory(trainer.model, trainer) + + @pytest.mark.parametrize("use_liger_kernel", [False, pytest.param(True, marks=require_liger_kernel)]) + def test_train_with_bias_correction_kl(self, use_liger_kernel): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + training_args = GRPOConfig( + output_dir=self.tmp_dir, + beta=0.1, # set beta to non-zero value to test the case where the reference model is used + use_bias_correction_kl=True, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + use_liger_kernel=use_liger_kernel, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_name", + ["trl-internal-testing/tiny-Qwen3ForCausalLM", "trl-internal-testing/tiny-Gemma2ForCausalLM"], + # Gemma2 has the input word embeddings and lm_head tied, Qwen3 does not + ) + def test_train_with_cast_lm_head_to_fp32(self, model_name): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + cast_lm_head_to_fp32=True, + ) + trainer = GRPOTrainer( + model=model_name, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + assert trainer.model.lm_head.weight.dtype == torch.float32 + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_entropy_filter(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + top_entropy_quantile=0.2, + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + @require_vllm + @pytest.mark.skip(reason="We should add a mock for the vLLM server.") + def test_train_vllm_and_peft(self): + """Test that training works with vLLM for generation.""" + model = AutoModelForCausalLM.from_pretrained( + "Qwen/Qwen2.5-0.5B-Instruct", dtype="float32" + ) # tiny model is too small for vLLM + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + use_vllm=True, + ) + lora_config = LoraConfig( + target_modules="all-linear", + # test with non-default modules as it adds extra keys in state_dict that we need to handle + modules_to_save=["embed_tokens", "lm_head"], + ) + trainer = GRPOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + peft_config=lora_config, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n and "original_module" not in n: + # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_vllm + @pytest.mark.skip(reason="We should add a mock for the vLLM server.") + def test_train_vllm_structured_outputs(self): + """Test that training works with vLLM for generation with structured outputs.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + use_vllm=True, + vllm_structured_outputs_regex=r"\n.*\n\n\n.*\n", + ) + trainer = GRPOTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", # tiny model is too small for vLLM + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_vllm + @pytest.mark.skip(reason="We should add a mock for the vLLM server.") + @pytest.mark.parametrize( + "vllm_importance_sampling_clip_min, vllm_importance_sampling_clip_max", + [ + (None, 3.0), # only max (current default) + (0.5, None), # only min + (0.5, 5.0), # both (IcePop) + ], + ) + def test_train_vllm_importance_sampling_correction( + self, vllm_importance_sampling_clip_min, vllm_importance_sampling_clip_max + ): + """Test that training works with vLLM for generation with importance sampling correction.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + use_vllm=True, + vllm_importance_sampling_correction=True, + vllm_importance_sampling_clip_min=vllm_importance_sampling_clip_min, + vllm_importance_sampling_clip_max=vllm_importance_sampling_clip_max, + ) + trainer = GRPOTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", # tiny model is too small for vLLM + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_additional_generation_kwargs(self): + """Test that training works with additional generation kwargs.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + top_p=0.9, + top_k=10, + min_p=0.01, + repetition_penalty=1.1, + ) + + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_vllm + @pytest.mark.skip(reason="We should add a mock for the vLLM server.") + def test_train_vllm_with_additional_generation_kwargs(self): + """Test that training works with vLLM and additional generation kwargs.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + use_vllm=True, + top_p=0.9, + top_k=10, + min_p=0.01, + repetition_penalty=1.1, + ) + + trainer = GRPOTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", # tiny model is too small for vLLM + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_normalize_then_sum_aggregation(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func1(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + def reward_func2(completions, **kwargs): + """Reward function that rewards completions with more unique letters.""" + return [float(len(set(completion))) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + multi_objective_aggregation="normalize_then_sum", + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[reward_func1, reward_func2], + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize("scale_rewards", [False, "group", "batch", True, "none"]) + def test_train_scale_rewards(self, scale_rewards): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + scale_rewards=scale_rewards, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @patch("transformers.generation.utils.GenerationMixin.generate") + def test_train_with_mask_truncated_completions(self, mock_generate): + """Test that training works with mask_truncated_completions=True parameter.""" + + # We mock the generate method because the model's random weights make it extremely unlikely to produce a + # sequence containing the EOS token within the allowed max_completion_length. As a result, all tokens are + # masked in the loss, the model doesn't update, and the final check (which verifies the update) fails. + def fake_generate(input_ids, **kwargs): + # pad_token_id = 151643; eos_token_id = 151645 + completion_ids = torch.tensor( + [ + [1, 2, 3, 4, 5, 6, 7, 8], # this one is truncated + [9, 10, 11, 151645, 151643, 151643, 151643, 151643], # this one contains eos + [12, 13, 14, 15, 16, 17, 18, 151645], # particular case, eos is generated just within the limit + ], + device=input_ids.device, + ) + return torch.cat([input_ids, completion_ids], dim=1) + + mock_generate.side_effect = fake_generate + + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + mask_truncated_completions=True, # Enable masking of truncated completions + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_mask_truncated_completions_all_masked(self): + """ + Test that when all generated completions are truncated (i.e., none contain an EOS token), and + mask_truncated_completions=True, the model receives no effective learning signal and therefore does not update + its parameters. + + Here, we don't mock the generate method, be we rely on the fact that the model the probability of generating + the EOS token is extremely low, so all generated completions are truncated. + """ + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + mask_truncated_completions=True, # Enable masking of truncated completions + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert torch.equal(param, new_param), f"Parameter {n} has changed." + + def test_warning_raised_all_rewards_none(self, caplog): + """Test that a proper warning is raised when all rewards are None.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def always_none_reward_func(completions, **kwargs): + """Reward function that always returns None.""" + return [None] * len(completions) + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=always_none_reward_func, + args=training_args, + train_dataset=dataset, + ) + + with caplog.at_level("WARNING", logger="trl.trainer.grpo_trainer"): + trainer.train() + + expected_warning = "All reward functions returned None for the following kwargs:" + assert expected_warning in caplog.text + + def test_train_num_generations_larger_than_batch_size(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + num_generations=6, # the number of generations is larger than the batch size, but + gradient_accumulation_steps=2, # gradient accumulation should allow that + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize("use_liger_kernel", [False, pytest.param(True, marks=require_liger_kernel)]) + def test_train_delta_clipping(self, use_liger_kernel): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + delta=2.0, # set delta to a non-None value + use_liger_kernel=use_liger_kernel, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_multiple_dataloader_workers(self): + # Pytest/CI often starts background threads before tests run. With Python 3.12, using the default "fork" start + # method in a multi-threaded process emits a DeprecationWarning and may deadlock. + # + # We force "spawn" here to make multiprocessing safe under pytest when DataLoader workers are enabled. This is + # test-environment–specific and not required by the training logic itself. + # + # This means the test does not cover "fork". However, "spawn" is stricter (requires full picklability and clean + # state) and avoids fork-after-threads issues that pytest cannot reliably test anyway. Fork-specific behavior, + # if needed, should be tested in a clean process outside pytest. + torch.multiprocessing.set_start_method("spawn", force=True) + + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + dataloader_num_workers=2, # use multiple dataloader workers + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_generation_kwargs(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + # Pass gen kwargs + generation_kwargs={"do_sample": True, "top_k": 50, "num_beams": 2, "length_penalty": -0.1}, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_reward_func_accessing_trainer_state(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func(completions, **kwargs): + trainer_state = kwargs.get("trainer_state") + assert trainer_state is not None + # transformers.TrainerState instance should have a `global_step` property. + assert hasattr(trainer_state, "global_step") + return [float(len(set(completion))) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + trainer.train() + + def test_train_reward_func_with_log_extra(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func(completions, **kwargs): + log_extra = kwargs.get("log_extra") + assert log_extra is not None + log_extra("test_column", [completion[:5] for completion in completions]) + return [float(len(completion)) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + log_completions=True, + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + trainer.train() + assert "test_column" in trainer._logs["extra"] + + def test_train_reward_func_with_log_metric(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func(completions, **kwargs): + log_metric = kwargs.get("log_metric") + assert log_metric is not None + log_metric("custom_accuracy", 0.75) + return [float(len(completion)) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + trainer.train() + # log_metric appends to _metrics, which gets averaged and merged into log_history + logged_keys = {k for entry in trainer.state.log_history for k in entry} + assert "custom_accuracy" in logged_keys + + def test_prepare_input_called_with_correct_data(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + max_completion_length=8, # reduce the completion length to reduce memory usage + gradient_accumulation_steps=3, # can be anything in this test + # steps_per_generation*per_device_train_batch_size=24 is divisible by num_generations=4 + steps_per_generation=4, + num_generations=4, + per_device_train_batch_size=6, # reduce the batch size to reduce memory usage + num_iterations=2, + shuffle_dataset=False, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + # steps_per_generation=4, per_device_train_batch_size=6 and num_generations=4, so we expect a + # generation batch of 24 samples (steps_per_generation * per_device_train_batch_size), containing 6 + # different prompts (steps_per_generation * per_device_train_batch_size // num_generations), each repeated + # 4 times (num_generations). + expected_first_generation_batch = ( + [{"prompt": "Beautiful is better than"}] * 4 + + [{"prompt": "Explicit is"}] * 4 + + [{"prompt": "Simple is better"}] * 4 + + [{"prompt": "Complex"}] * 4 + + [{"prompt": "Flat is better than"}] * 4 + + [{"prompt": "Sparse is better"}] * 4 + ) + expected_second_generation_batch = ( + [{"prompt": "Readability"}] * 4 + + [{"prompt": "Special cases aren't special"}] * 4 + + [{"prompt": "Although practicality beats"}] * 4 + + [{"prompt": "Errors should never"}] * 4 + + [{"prompt": "Unless explicitly"}] * 4 + + [{"prompt": "In the face of ambiguity, refuse"}] * 4 + ) + + with patch.object(GRPOTrainer, "training_step", wraps=trainer.training_step) as mock_prepare: + trainer.train() + # 3 epochs * 2 iterations * 2 generation batches to cover the dataset * 4 steps_per_generation + assert mock_prepare.call_count == 48 + for i in range(0, 8): # Generation batch repeated 8 times (steps_per_generation*num_iterations) + assert mock_prepare.call_args_list[i].args[1] == expected_first_generation_batch + for i in range(8, 16): + assert mock_prepare.call_args_list[i].args[1] == expected_second_generation_batch + + def test_train_sequence_importance_sampling(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + num_iterations=2, # the importance sampling weights won't be 0 in this case + importance_sampling_level="sequence", + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_chat_template_kwargs(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + chat_template_kwargs={"enable_thinking": False}, + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen3ForCausalLM", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.xfail( + condition=Version(transformers.__version__) < Version("5.0.0"), + reason="Tool parsing is not supported in transformers versions below 5.0.0", + strict=True, + ) + @require_jmespath + @pytest.mark.parametrize("tools", [[multiply_tool], [async_multiply_tool]]) + def test_train_with_tools(self, tools: list[Callable]): + # In this test, we define a simple tool that multiplies two integers. Regardless of the input prompt, + # the model will generate 3 completions, 2 of which will be valid tool calls. Among the 2 tool calls, one will + # succeed and the other will fail (because of a wrong argument name). + + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=128, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen3MoeForCausalLM", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + tools=tools, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + tool_name = tools[0].__name__ + + def fake_generate(input_ids, **kwargs): + if input_ids.shape[0] == 3: # first call + # fmt: off + if tool_name == "multiply_tool": + completion_ids = torch.tensor( + [ + # '\n{"name": "multiply_tool", "arguments": {"a": 3, "b": 4}}\n<|im_end|>' + [151657, 198, 4913, 606, 788, 330, 64648, 22785, 497, 330, 16370, 788, 5212, 64, 788, 220, 18, 11, 330, 65, 788, 220, 19, 11248, 151658, 151645], + # an invalid tool call with wrong argument name + # '\n{"name": "multiply_tool", "arguments": {"a": 3, "c": 4}}\n<|im_end|>' + [151657, 198, 4913, 606, 788, 330, 64648, 22785, 497, 330, 16370, 788, 5212, 64, 788, 220, 18, 11, 330, 66, 788, 220, 19, 11248, 151658, 151645], + # "I don't know any tool<|im_end|>" + [40, 1513, 944, 1414, 894, 5392, 151645, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643], + ], + device=input_ids.device, + ) + elif tool_name == "async_multiply_tool": + completion_ids = torch.tensor( + [ + # '\n{"name": "async_multiply_tool", "arguments": {"a": 3, "b": 4}}\n<|im_end|>' + [151657, 198, 4913, 606, 788, 330, 7692, 93054, 22785, 497, 330, 16370, 788, 5212, 64, 788, 220, 18, 11, 330, 65, 788, 220, 19, 11248, 151658, 151645], + # an invalid tool call with wrong argument name + # '\n{"name": "async_multiply_tool", "arguments": {"a": 3, "c": 4}}\n<|im_end|>' + [151657, 198, 4913, 606, 788, 330, 7692, 93054, 22785, 497, 330, 16370, 788, 5212, 64, 788, 220, 18, 11, 330, 66, 788, 220, 19, 11248, 151658, 151645], + # "I don't know any tool<|im_end|>" + [40, 1513, 944, 1414, 894, 5392, 151645, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643], + ], + device=input_ids.device, + ) + # fmt: on + else: # second call will only have two inputs in the batch, because two examples have a tool call. + completion_ids = torch.tensor( + [ + # 'Done!<|im_end|>' + [17453, 0, 151645], + # 'Done!<|im_end|>' + [17453, 0, 151645], + ], + device=input_ids.device, + ) + return torch.cat([input_ids, completion_ids], dim=-1) + + with patch.object(trainer.model, "generate", side_effect=fake_generate): + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + assert trainer.state.log_history[-1]["tools/call_frequency"] is not None + assert trainer.state.log_history[-1]["tools/call_frequency"] == pytest.approx(2 / 3) + assert trainer.state.log_history[-1]["tools/failure_frequency"] is not None + assert trainer.state.log_history[-1]["tools/failure_frequency"] == pytest.approx(1 / 2) + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.xfail( + condition=Version(transformers.__version__) < Version("5.2.0"), + reason="Environment factory support is not available in transformers versions below 5.2.0", + strict=True, + ) + @require_jmespath + @patch.dict(os.environ, {"TRL_EXPERIMENTAL_SILENCE": "1"}) + def test_train_with_environment_factory(self): + # In this test, we define a simple tool that increments an internal counter. Regardless of the input prompt, + # the model will generate 3 completions, 2 of which will be valid tool calls. Among the 2 tool calls, one will + # succeed and the other will fail (because of a wrong tool name). + + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train") + + class DummyEnvironment: + def reset(self, **kwargs): + self._counter = 0 + + def increment(self, step: int) -> int: + """ + Increment the internal counter. + + Args: + step: Value to add to the counter. + + Returns: + The updated counter value. + """ + self._counter += step + return self._counter + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + report_to="none", + ) + + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen3MoeForCausalLM", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + environment_factory=DummyEnvironment, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + def fake_generate(input_ids, **kwargs): + if input_ids.shape[0] == 3: # first call + # fmt: off + completion_ids = torch.tensor( + [ + # '\n{"name": "increment", "arguments": {"step": 1}}\n<|im_end|>' + [151657, 198, 4913, 606, 788, 330, 35744, 497, 330, 16370, 788, 5212, 9520, 788, 220, 16, 11248, 151658, 151645, 151643], + # an invalid tool call with wrong tool name + # '\n{"name": "decrement", "arguments": {"step": 2}}\n<|im_end|>' + [151657, 198, 4913, 606, 788, 330, 450, 13477, 497, 330, 16370, 788, 5212, 9520, 788, 220, 17, 11248, 151658, 151645], + # "I won't increment<|im_end|>" + [40, 2765, 944, 16252, 151645, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643, 151643], + ], + device=input_ids.device, + ) + # fmt: on + else: # second call will only have two inputs in the batch, because two examples have a tool call. + completion_ids = torch.tensor( + [ + # 'Done!<|im_end|>' + [17453, 0, 151645], + # 'Done!<|im_end|>' + [17453, 0, 151645], + ], + device=input_ids.device, + ) + return torch.cat([input_ids, completion_ids], dim=-1) + + with patch.object(trainer.model, "generate", side_effect=fake_generate): + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + assert trainer.state.log_history[-1]["tools/call_frequency"] is not None + assert trainer.state.log_history[-1]["tools/call_frequency"] == pytest.approx(2 / 3) + assert trainer.state.log_history[-1]["tools/failure_frequency"] is not None + assert trainer.state.log_history[-1]["tools/failure_frequency"] == pytest.approx(1 / 2) + + # Check the states of the environment + assert trainer.environments[0]._counter == 1 # should have been incremented once + assert trainer.environments[1]._counter == 0 # shouldn't have been incremented because the tool call failed + assert trainer.environments[2]._counter == 0 # shouldn't have been incremented because no tool call was made + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.xfail( + condition=Version(transformers.__version__) < Version("5.0.0"), + reason="Tool parsing is not supported in transformers versions below 5.0.0", + strict=True, + ) + @require_jmespath + def test_train_with_malformed_tool_calls(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=128, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen3MoeForCausalLM", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + tools=[multiply_tool], + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + def fake_generate(input_ids, **kwargs): + # If input_ids.shape[0] < 3, it means that it's a second call, which should not happen here + assert input_ids.shape[0] == 3 + # fmt: off + completion_ids = torch.tensor( + [ + # '\n{"arguments": {"a": 3, "b": 4}}\n<|im_end|>' + [151657, 198, 4913, 16370, 788, 5212, 64, 788, 220, 18, 11, 330, 65, 788, 220, 19, 11248, 151658, 151645, 151643, 151643, 151643, 151643, 151643], + # '\n{"arguments": {"a": 3, "b": 4}}\n<|im_end|>' + [27, 14172, 6659, 397, 4913, 16370, 788, 5212, 64, 788, 220, 18, 11, 330, 65, 788, 220, 19, 11248, 522, 14172, 6659, 29, 151645], + # '\n{"arguments": {a: 3, b: 4}}\n<|im_end|>' + [151657, 198, 4913, 16370, 788, 314, 64, 25, 220, 18, 11, 293, 25, 220, 19, 11248, 151658, 151645, 151643, 151643, 151643, 151643, 151643, 151643], + ], + device=input_ids.device, + ) + # fmt: on + return torch.cat([input_ids, completion_ids], dim=-1) + + with patch.object(trainer.model, "generate", side_effect=fake_generate): + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_mismatched_reward_processing_classes_length(self): + """Test that mismatched length between reward_funcs and reward_processing_classes raises error.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + # Use two reward models + reward_models = [ + "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + "trl-internal-testing/tiny-Qwen3ForSequenceClassification", + ] + + # Create a single processing class (tokenizer) + single_processing_class = AutoTokenizer.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5" + ) + + training_args = GRPOConfig(output_dir=self.tmp_dir, report_to="none") + + with pytest.raises(ValueError, match="must match"): + GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_models, + reward_processing_classes=single_processing_class, # only one, but need two + args=training_args, + train_dataset=dataset, + ) + + def test_correct_reward_processing_classes_list(self): + """Test that correct list of reward_processing_classes works properly.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + # Use two reward models + reward_models = [ + "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + "trl-internal-testing/tiny-Qwen3ForSequenceClassification", + ] + + # Create processing classes + processing_class1 = AutoTokenizer.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5" + ) + processing_class2 = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3ForSequenceClassification") + + training_args = GRPOConfig(output_dir=self.tmp_dir, report_to="none") + + # Correct list length should work + correct_processing_classes = [processing_class1, processing_class2] + + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_models, + reward_processing_classes=correct_processing_classes, + args=training_args, + train_dataset=dataset, + ) + + assert len(trainer.reward_processing_classes) == len(reward_models) + + def test_single_reward_model_with_single_processing_class(self): + """Test that single reward model with single processing class works.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + # Use single reward model + reward_model = "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5" + + # Create a single processing class (tokenizer) + single_processing_class = AutoTokenizer.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5" + ) + + training_args = GRPOConfig(output_dir=self.tmp_dir, report_to="none") + + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_model, + reward_processing_classes=single_processing_class, # single object for single reward model + args=training_args, + train_dataset=dataset, + ) + + assert len(trainer.reward_processing_classes) == 1 + assert trainer.reward_processing_classes[0] == single_processing_class + + +@require_vision +class TestGRPOTrainerVLM(TrlTestCase): + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2VLForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + # "trl-internal-testing/tiny-SmolVLMForConditionalGeneration", seems not to support bf16 properly + ], + ) + def test_train_vlm(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model=model_id, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + # LLaVA & LLaVA-Next: vision_feature_layer=-2 leaves the last encoder layer (layers.1) and + # post_layernorm (pooler-only path) without gradient by design. Assert they stay frozen — if they + # ever start training, the feature-selection plumbing has likely regressed. + if model_id in ( + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + ) and ("encoder.layers.1" in n or "post_layernorm" in n): + assert torch.equal(param, new_param), f"Param {n} expected frozen by LLaVA design, but changed" + else: + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_vlm_with_pad_to_multiple_of(self): + # Models like Gemma3 use other forward keyword arguments like token_type_ids that also need to be padded when + # using pad_to_multiple_of, so we test that the trainer correctly pads all the necessary inputs in this case. + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + pad_to_multiple_of=7, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + def test_train_vlm_beta_non_zero(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + beta=0.1, # set beta to non-zero value to test the case where the reference model is used + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model=model_id, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + @require_peft + def test_train_vlm_peft(self, model_id): + model = AutoModelForImageTextToText.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model=model, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(target_modules=["q_proj", "v_proj"]), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + def test_train_vlm_and_importance_sampling(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + steps_per_generation=2, # increase the steps per generation to trigger IS + report_to="none", + ) + trainer = GRPOTrainer( + model=model_id, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_id", + [ + pytest.param( + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + marks=pytest.mark.xfail( + (Version("5.2.0") < Version(transformers.__version__)) + and not is_liger_kernel_available(min_version="0.8.0"), + reason="Upstream issue tracked at https://github.com/linkedin/Liger-Kernel/issues/1117", + ), + ), + ], + ) + @require_liger_kernel + def test_train_vlm_and_liger(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + use_liger_kernel=True, # enable Liger kernel + report_to="none", + ) + trainer = GRPOTrainer( + model=model_id, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + "trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + ], + ) + @require_vllm + @pytest.mark.skip(reason="We should add a mock for the vLLM server.") + def test_train_vlm_and_vllm(self, model_id) -> None: + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + use_vllm=True, + vllm_mode="server", + ) + trainer = GRPOTrainer( + model=model_id, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + def test_train_vlm_multi_image(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-multi-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = GRPOTrainer( + model=model_id, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.xfail( + condition=Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + strict=True, + ) + @require_jmespath + def test_train_with_tools_multimodal_response(self): + # Test that tools returning images (multimodal responses) work correctly with a VLM. + # The tool returns a list of content blocks including an image. + from PIL import Image as PILImage + + def screenshot_tool() -> list: + """ + Takes a screenshot and returns it. + + Returns: + A list of content blocks with the screenshot image. + """ + img = PILImage.new("RGB", (64, 64), color="red") + return [{"type": "image", "image": img}, {"type": "text", "text": "Here is the screenshot"}] + + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=512, + report_to="none", + ) + trainer = GRPOTrainer( + model="trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + tools=[screenshot_tool], + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + def fake_generate(input_ids, **kwargs): + if input_ids.shape[0] == 2: # first call: num_generations=2 completions for 1 prompt + # fmt: off + completion_ids = torch.tensor( + [ + # '\n\n\n<|im_end|>' + [248058, 198, 27, 1628, 13744, 30091, 22076, 29, 198, 510, 1628, 29, 198, 248059, 248046], + # "I don't know any tool<|im_end|>" + padding + [40, 1459, 914, 1366, 866, 5224, 248046, 248044, 248044, 248044, 248044, 248044, 248044, 248044, 248044], + ], + device=input_ids.device, + ) + # fmt: on + else: # second call: 1 tool call succeeded + completion_ids = torch.tensor( + [ + # 'Done!<|im_end|>' + [16936, 0, 248046], + ], + device=input_ids.device, + ) + return torch.cat([input_ids, completion_ids], dim=-1) + + with patch.object(trainer.model, "generate", side_effect=fake_generate): + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + # With num_generations=2: 1 out of 2 completions is a tool call (1/2), and it succeeds (0 failures). + assert trainer.state.log_history[-1]["tools/call_frequency"] == pytest.approx(1 / 2) + assert trainer.state.log_history[-1]["tools/failure_frequency"] == pytest.approx(0.0) + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + +@pytest.mark.slow +@require_torch_accelerator +class TestGRPOTrainerSlow(TrlTestCase): + def setup_method(self): + self.train_dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + self.eval_dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="test") + self.max_length = 128 + + def teardown_method(self): + gc.collect() + backend_empty_cache(torch_device) + gc.collect() + + @pytest.mark.parametrize( + "model_name", + [ + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + ], + ) + @require_liger_kernel + def test_train_with_liger_grpo_kernel(self, model_name): + training_args = GRPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, + num_generations=3, + use_liger_kernel=True, + max_completion_length=self.max_length, + report_to="none", + logging_strategy="no", + ) + + model = AutoModelForCausalLM.from_pretrained(model_name, dtype="float32") + tokenizer = AutoTokenizer.from_pretrained(model_name) + tokenizer.pad_token = tokenizer.eos_token if tokenizer.pad_token is None else tokenizer.pad_token + + trainer = GRPOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=self.train_dataset, + eval_dataset=self.eval_dataset, + processing_class=tokenizer, + ) + from liger_kernel.chunked_loss import LigerFusedLinearGRPOLoss + + assert isinstance(trainer.liger_grpo_loss, LigerFusedLinearGRPOLoss) + + previous_trainable_params = {n: param.clone() for n, param in model.named_parameters()} + + trainer.train() + + for n, param in previous_trainable_params.items(): + new_param = model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + release_memory(model, trainer) + + @pytest.mark.parametrize( + "model_name", + [ + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + ], + ) + @require_liger_kernel + @require_peft + def test_train_with_liger_grpo_kernel_and_peft(self, model_name): + from peft import LoraConfig, TaskType + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, + num_generations=3, + use_liger_kernel=True, + max_completion_length=self.max_length, + report_to="none", + logging_strategy="no", + ) + + model = AutoModelForCausalLM.from_pretrained(model_name, dtype="float32") + tokenizer = AutoTokenizer.from_pretrained(model_name) + tokenizer.pad_token = tokenizer.eos_token if tokenizer.pad_token is None else tokenizer.pad_token + + # Configure PEFT with LoRA + peft_config = LoraConfig( + task_type=TaskType.CAUSAL_LM, + inference_mode=False, + r=8, + lora_alpha=32, + lora_dropout=0.1, + target_modules=["q_proj", "v_proj"], + ) + + trainer = GRPOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=self.train_dataset, + eval_dataset=self.eval_dataset, + processing_class=tokenizer, + peft_config=peft_config, + ) + from liger_kernel.chunked_loss import LigerFusedLinearGRPOLoss + + assert isinstance(trainer.liger_grpo_loss, LigerFusedLinearGRPOLoss) + + # Verify PEFT adapter is properly initialized + from peft import PeftModel + + assert isinstance(trainer.model, PeftModel), "Model should be wrapped with PEFT" + + # Store adapter weights before training + previous_trainable_params = { + n: param.clone() for n, param in trainer.model.named_parameters() if param.requires_grad + } + assert len(previous_trainable_params) > 0, "No trainable parameters found in PEFT model" + + trainer.train() + + # Verify adapter weights have changed after training + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + release_memory(model, trainer) + + @require_liger_kernel + def test_liger_grpo_kernel_importance_sampling(self): + model_name = "trl-internal-testing/tiny-LlamaForCausalLM-3.2" + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, + num_generations=3, + use_liger_kernel=True, + max_completion_length=self.max_length, + importance_sampling_level="sequence", + report_to="none", + logging_strategy="no", + ) + + model = AutoModelForCausalLM.from_pretrained(model_name, dtype="float32") + tokenizer = AutoTokenizer.from_pretrained(model_name) + tokenizer.pad_token = tokenizer.eos_token if tokenizer.pad_token is None else tokenizer.pad_token + + trainer = GRPOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=self.train_dataset, + eval_dataset=self.eval_dataset, + processing_class=tokenizer, + ) + from liger_kernel.chunked_loss import LigerFusedLinearGRPOLoss + + assert isinstance(trainer.liger_grpo_loss, LigerFusedLinearGRPOLoss) + + previous_trainable_params = {n: param.clone() for n, param in model.named_parameters()} + + trainer.train() + + for n, param in previous_trainable_params.items(): + new_param = model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + release_memory(model, trainer) + + @pytest.mark.parametrize( + "model_name", + [ + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + ], + ) + def test_train_with_transformers_continuous_batching(self, model_name): + """Test that training works with transformers continuous batching (requires GPU).""" + if not Version(transformers.__version__) >= Version("5.8.0"): + pytest.skip("transformers continuous batching requires transformers>=5.8.0.") + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + use_transformers_continuous_batching=True, + report_to="none", + logging_strategy="no", + ) + + model = AutoModelForCausalLM.from_pretrained(model_name, dtype="float32") + + trainer = GRPOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=self.train_dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + release_memory(model, trainer) + + @pytest.mark.parametrize( + "model_name", + [ + "HuggingFaceTB/SmolVLM-Instruct", # Only test the smaller model to avoid OOM + ], + ) + @pytest.mark.skipif( + not is_ampere_or_newer() and torch_device != "xpu", + reason="Flash Attention 2 requires Ampere or newer GPU, or XPU", + ) + @require_kernels + @require_bitsandbytes + @require_peft + def test_vlm_training(self, model_name): + """ + Test VLM training with aggressive memory optimization. + + This test uses multiple memory reduction techniques: + - 4-bit quantization with double quantization + - LoRA with very low rank (r=4) + - Minimal batch size (1) with gradient accumulation + - Small images (64x64 instead of 224x224) + - Short sequences (max_completion_length=8) + - Only 4 training samples + - Only 1 training step + - Gradient checkpointing and bfloat16 + """ + + # Create processor once outside the data generator + processor = AutoProcessor.from_pretrained(model_name, use_fast=True, padding_side="left") + prompt = [{"role": "user", "content": "What is in the image?"}] + + dataset = Dataset.from_list( + [ + { + "prompt": prompt, + "image": np.random.uniform(low=0.0, high=255.0, size=(64, 64, 3)).astype(np.uint8), + } + for _ in range(4) + ], + ).cast_column("image", Image()) + # reduce memory requirements as much as possible + quantization_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype="bfloat16", + bnb_4bit_quant_type="nf4", + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_storage="bfloat16", + ) + model = AutoModelForImageTextToText.from_pretrained( + model_name, + attn_implementation="kernels-community/flash-attn2", + dtype="bfloat16", + device_map=get_kbit_device_map(), + quantization_config=quantization_config, + ) + + def reward_func(prompts, completions, **kwargs): + # Use hash-based reward to ensure different completions get different rewards, + # avoiding zero-std advantages which would result in zero loss and no parameter updates. + return [float(hash(c[0]["content"]) % 100) for c in completions] + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=1, # Minimal batch size + gradient_accumulation_steps=2, # Maintain effective batch size + num_generations=2, + max_completion_length=8, # Much shorter completions + bf16=True, # Use bfloat16 precision + max_steps=1, # Only do 1 training step to save time and memory + report_to="none", + logging_strategy="no", + ) + lora_config = LoraConfig( + task_type="CAUSAL_LM", + r=4, # Much lower rank for minimal memory + lora_alpha=8, # Reduced alpha proportionally + lora_dropout=0.1, + target_modules=["q_proj", "v_proj"], # Minimal target modules + # For VLM models, we typically want to freeze the vision encoder + # and only adapt the language model parameters + modules_to_save=None, + ) + + try: + trainer = GRPOTrainer( + model=model, + processing_class=processor, + reward_funcs=[reward_func], + args=training_args, + train_dataset=dataset, + peft_config=lora_config, + ) + + assert isinstance(trainer.model, PeftModel) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that LoRA parameters have changed + # For VLM models, we're more permissive about which parameters can change + lora_params_changed = False + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if "lora" in n.lower(): # LoRA parameters should change + if not torch.equal(param, new_param): + lora_params_changed = True + + # At least some LoRA parameters should have changed during training + assert lora_params_changed, "No LoRA parameters were updated during training." + + except torch.OutOfMemoryError as e: + pytest.skip(f"Skipping VLM training test due to insufficient GPU memory: {e}") + except Exception as e: + # Check for other memory-related errors + if any(keyword in str(e).lower() for keyword in ["memory", "cuda", "out of memory", "insufficient"]): + pytest.skip(f"Skipping VLM training test due to hardware constraints: {e}") + else: + raise + + release_memory(model, trainer) + + @require_vllm + @require_bitsandbytes + @require_peft + def test_vlm_processor_vllm_colocate_mode(self): + """ + Test that VLM processors work with vLLM in colocate mode. + + This test uses multiple memory optimization techniques to ensure it runs on limited hardware: + - LoRA (Low-Rank Adaptation) with minimal rank (r=4) + - 4-bit quantization with BitsAndBytesConfig + - Gradient checkpointing + - bfloat16 precision + - Minimal batch sizes and sequence lengths + - Very low GPU memory utilization (5%) + """ + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + config = GRPOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, # Minimal batch size + gradient_accumulation_steps=2, # Make effective batch size 2, divisible by num_generations + num_generations=2, + max_completion_length=4, # Very short completions to reduce memory + use_vllm=True, # Enable vLLM + vllm_mode="colocate", # Use colocate mode to avoid server dependency + vllm_gpu_memory_utilization=0.05, # Use minimal GPU memory (5%) + bf16=True, # Use bfloat16 to reduce memory + report_to="none", + logging_strategy="no", + ) + + # Create a VLM processor + processor = AutoProcessor.from_pretrained("HuggingFaceTB/SmolVLM-Instruct", use_fast=True, padding_side="left") + + # Verify processor has both required attributes for VLM detection + assert hasattr(processor, "tokenizer") + assert hasattr(processor, "image_processor") + + def dummy_reward_func(completions, **kwargs): + return [1.0] * len(completions) + + # Use LoRA configuration for memory efficiency + lora_config = LoraConfig( + r=4, # Very low rank for minimal memory + lora_alpha=8, + target_modules=["q_proj", "v_proj"], # Minimal target modules + lora_dropout=0.1, + bias="none", + task_type="CAUSAL_LM", + ) + + # Use 4-bit quantization for further memory reduction + quantization_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=torch.bfloat16, + bnb_4bit_quant_type="nf4", + bnb_4bit_use_double_quant=True, + ) + + original_env = {} + required_env_vars = { + "RANK": "0", + "LOCAL_RANK": "0", + "WORLD_SIZE": "1", + "LOCAL_WORLD_SIZE": "1", + "MASTER_ADDR": "localhost", + "MASTER_PORT": "12355", + } + + for key, value in required_env_vars.items(): + original_env[key] = os.environ.get(key) + os.environ[key] = value + + try: + # Test VLM processor with vLLM colocate mode + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + try: + # Load model with quantization for memory efficiency + model = AutoModelForCausalLM.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + quantization_config=quantization_config, + dtype=torch.bfloat16, + ) + + trainer = GRPOTrainer( + model=model, + reward_funcs=dummy_reward_func, + args=config, + train_dataset=dataset, + processing_class=processor, # VLM processor + peft_config=lora_config, # Use LoRA for memory efficiency + ) + + # Should detect VLM processor correctly and allow vLLM + assert trainer.use_vllm, "vLLM should be enabled for VLM processors in colocate mode" + assert trainer.vllm_mode == "colocate", "Should use colocate mode" + + # Check if signature columns were set properly + if trainer._signature_columns is not None: + # Should include 'image' in signature columns for VLM processors + assert "image" in trainer._signature_columns, ( + "Should include 'image' in signature columns for VLM" + ) + + # Should not emit any warnings about VLM incompatibility + incompatibility_warnings = [ + str(w_item.message) + for w_item in w + if "does not support VLMs" in str(w_item.message) + or "not compatible" in str(w_item.message).lower() + ] + assert len(incompatibility_warnings) == 0, ( + f"Should not emit VLM incompatibility warnings, but got: {incompatibility_warnings}" + ) + + # Test passes if we get this far without exceptions + + except Exception as e: + # If vLLM fails to initialize due to hardware constraints or other issues, that's expected + if any( + keyword in str(e).lower() + for keyword in [ + "outofmemoryerror", + "cuda", + "memory", + "insufficient", + "no such device", + "free memory", + "gpu memory utilization", + "decrease gpu memory", + ] + ): + pytest.skip(f"Skipping vLLM colocate test due to hardware constraints: {e}") + elif "KeyError" in str(e) and "RANK" in str(e): + pytest.skip(f"Skipping vLLM colocate test due to environment setup issues: {e}") + elif "ValueError" in str(e) and "memory" in str(e).lower(): + pytest.skip(f"Skipping vLLM colocate test due to memory constraints: {e}") + else: + raise + finally: + # Restore original environment variables + for key, original_value in original_env.items(): + if original_value is None: + os.environ.pop(key, None) + else: + os.environ[key] = original_value + + release_memory(model, trainer) + + @require_vllm + def test_train_vllm(self): + """Test that training works with vLLM for generation.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = GRPOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + logging_strategy="no", + use_vllm=True, + ) + + try: + trainer = GRPOTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", # tiny models are too small for vLLM + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + except Exception as e: + # If vLLM fails to initialize due to hardware constraints or other issues, that's expected + if any( + keyword in str(e).lower() + for keyword in [ + "outofmemoryerror", + "cuda", + "memory", + "insufficient", + "no such device", + "free memory", + "gpu memory utilization", + "decrease gpu memory", + ] + ): + pytest.skip(f"Skipping vLLM training test due to hardware constraints: {e}") + elif "KeyError" in str(e) and "RANK" in str(e): + pytest.skip(f"Skipping vLLM training test due to environment setup issues: {e}") + elif "ValueError" in str(e) and "memory" in str(e).lower(): + pytest.skip(f"Skipping vLLM training test due to memory constraints: {e}") + else: + raise + + release_memory(trainer.model, trainer) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_model_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_model_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..7e3fde991ddcf4469b3efccb78bb412e1da1e8a6 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_model_utils.py @@ -0,0 +1,34 @@ +# Copyright 2020-2026 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. + +from transformers import AutoModelForCausalLM + +from trl.models.utils import disable_gradient_checkpointing + + +class TestDisableGradientCheckpointing: + def test_when_disabled(self): + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + assert model.is_gradient_checkpointing is False + with disable_gradient_checkpointing(model): + assert model.is_gradient_checkpointing is False + assert model.is_gradient_checkpointing is False + + def test_when_enabled(self): + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + model.gradient_checkpointing_enable() + assert model.is_gradient_checkpointing is True + with disable_gradient_checkpointing(model): + assert model.is_gradient_checkpointing is False + assert model.is_gradient_checkpointing is True diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_reward_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_reward_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..422e9f5aab7714441a9b587c7e77b722b399739b --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_reward_trainer.py @@ -0,0 +1,868 @@ +# Copyright 2020-2026 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 pathlib + +import pytest +import torch +from datasets import load_dataset +from transformers import AutoModelForSequenceClassification, AutoTokenizer +from transformers.utils import is_peft_available + +from trl import RewardConfig, RewardTrainer +from trl.trainer.reward_trainer import DataCollatorForPreference + +from .testing_utils import TrlTestCase, require_peft + + +if is_peft_available(): + from peft import LoraConfig, get_peft_model + + +class TestDataCollatorForPreference(TrlTestCase): + def test_basic_padding(self): + """Test basic padding functionality without completion masks.""" + collator = DataCollatorForPreference(pad_token_id=0) + examples = [ + {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5]}, + {"chosen_ids": [6, 7], "rejected_ids": [8]}, + ] + + result = collator(examples) + + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [6, 7, 0], [4, 5, 0], [8, 0, 0]])) + torch.testing.assert_close( + result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0], [1, 1, 0], [1, 0, 0]]) + ) + + def test_pad_to_multiple_of(self): + """Test padding to multiple of specified value.""" + collator = DataCollatorForPreference(pad_token_id=0, pad_to_multiple_of=4) + examples = [ + {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5]}, + {"chosen_ids": [6, 7], "rejected_ids": [8]}, + ] + + result = collator(examples) + + torch.testing.assert_close( + result["input_ids"], torch.tensor([[1, 2, 3, 0], [6, 7, 0, 0], [4, 5, 0, 0], [8, 0, 0, 0]]) + ) + torch.testing.assert_close( + result["attention_mask"], torch.tensor([[1, 1, 1, 0], [1, 1, 0, 0], [1, 1, 0, 0], [1, 0, 0, 0]]) + ) + + def test_single_example(self): + """Test collator with a single example.""" + collator = DataCollatorForPreference(pad_token_id=0) + examples = [{"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5]}] + + result = collator(examples) + + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [4, 5, 0]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0]])) + + def test_different_pad_token_id(self): + """Test with different pad token ID.""" + collator = DataCollatorForPreference(pad_token_id=999) + examples = [ + {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5]}, + {"chosen_ids": [6, 7], "rejected_ids": [8]}, + ] + + result = collator(examples) + + torch.testing.assert_close( + result["input_ids"], torch.tensor([[1, 2, 3], [6, 7, 999], [4, 5, 999], [8, 999, 999]]) + ) + torch.testing.assert_close( + result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0], [1, 1, 0], [1, 0, 0]]) + ) + + def test_collate_with_margin(self): + collator = DataCollatorForPreference(pad_token_id=0) + examples = [ + {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5], "margin": 0.1}, + {"chosen_ids": [6, 7], "rejected_ids": [8], "margin": 0.2}, + ] + + result = collator(examples) + + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [6, 7, 0], [4, 5, 0], [8, 0, 0]])) + torch.testing.assert_close( + result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0], [1, 1, 0], [1, 0, 0]]) + ) + torch.testing.assert_close(result["margin"], torch.tensor([0.1, 0.2])) + + +class TestRewardTrainer(TrlTestCase): + def test_raises_error_when_model_num_labels_not_one(self): + """Test that RewardTrainer raises ValueError when model doesn't have num_labels=1.""" + model = AutoModelForSequenceClassification.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + dtype="float32", + # num_labels=2, # Defaults to 2 num_labels for causal models + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + with pytest.raises(ValueError, match=r"reward models require `num_labels=1`"): + RewardTrainer(model=model, args=training_args, train_dataset=dataset) + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + "trl-internal-testing/tiny-Qwen3MoeForCausalLM", + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + ], + ) + def test_train(self, model_id): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + trainer = RewardTrainer(model=model_id, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_evaluate_with_raw_dataset(self): + # `evaluate` should accept the same (unprocessed) dataset types as the trainer, e.g. a held-out test set + # passed directly to `evaluate`. See https://github.com/huggingface/trl/issues/6115. + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + metrics = trainer.evaluate(eval_dataset=dataset) + assert metrics["eval_loss"] is not None + + def test_trust_remote_code(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + + with pytest.raises(ValueError, match="custom code"): + RewardTrainer( + model=model_id, + args=RewardConfig(output_dir=self.tmp_dir, report_to="none"), + train_dataset=dataset, + ) + + trainer = RewardTrainer( + model=model_id, + args=RewardConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + train_dataset=dataset, + ) + assert type(trainer.model).__name__ == "RemoteForSequenceClassification" + + @pytest.mark.parametrize( + "config_name", + [ + "standard_preference", + "conversational_preference", + "standard_implicit_prompt_preference", + "conversational_implicit_prompt_preference", + ], + ) + def test_train_dataset_types(self, config_name): + dataset = load_dataset("trl-internal-testing/zen", config_name, split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_model(self): + model = AutoModelForSequenceClassification.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + num_labels=1, # required for reward models + dtype="float32", + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + trainer = RewardTrainer(model=model, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_from_sequence_classification_model(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_model_dtype(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig( + output_dir=self.tmp_dir, + model_init_kwargs={"dtype": torch.float16}, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + # For some reasonn model.layers.0.input_layernorm.weight doesn't change in GitHub Actions but does + # locally. We ignore this parameter for now + if "layernorm" in n: + continue + new_param = trainer.model.get_parameter(n) + # Check the torch dtype + assert new_param.dtype == torch.float16 + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_dense_with_peft_config(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForSequenceClassification.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + + trainer = RewardTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_moe_with_peft_config(self): + model_id = "trl-internal-testing/tiny-Qwen3MoeForCausalLM" + model = AutoModelForSequenceClassification.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + + trainer = RewardTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(target_modules=["gate_proj", "up_proj", "down_proj", "score"]), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_peft_model(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForSequenceClassification.from_pretrained( + model_id, + num_labels=1, # required for reward models + dtype="float32", + ) + + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + lora_config = LoraConfig() + model = get_peft_model(model, lora_config) + + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + trainer = RewardTrainer(model=model, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + # In practice, this test is the same as `test_train_dense_with_peft_config`, since gradient checkpointing is + # enabled by default in `RewardTrainer`. We keep it as a regression guard: if the default ever changes, we still + # explicitly test PEFT + gradient checkpointing, which has caused issues in the past. + @require_peft + def test_train_with_peft_config_and_gradient_checkpointing(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForSequenceClassification.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, gradient_checkpointing=True, report_to="none") + + trainer = RewardTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize("use_reentrant", [True, False]) + @require_peft + def test_train_with_peft_config_and_gradient_checkpointing_reentrant(self, use_reentrant): + model_id = "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5" + model = AutoModelForSequenceClassification.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig( + output_dir=self.tmp_dir, + gradient_checkpointing=True, + gradient_checkpointing_kwargs={"use_reentrant": use_reentrant}, + report_to="none", + ) + + trainer = RewardTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "chosen_column,rejected_column,expect_deprecation_warning", + [ + ("chosen_ids", "rejected_ids", False), + ("chosen_input_ids", "rejected_input_ids", True), + ], + ) + def test_train_with_pretokenized_data(self, chosen_column, rejected_column, expect_deprecation_warning): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + tokenizer = AutoTokenizer.from_pretrained(model_id) + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + def tokenize_example(example): + return { + chosen_column: tokenizer(example["chosen"]).input_ids, + rejected_column: tokenizer(example["rejected"]).input_ids, + } + + # Apply tokenization + tokenized_dataset = dataset.map(tokenize_example, remove_columns=["chosen", "rejected"]) + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + if expect_deprecation_warning: + with pytest.warns(FutureWarning, match=r"will not be supported in v1"): + trainer = RewardTrainer(model=model_id, args=training_args, train_dataset=tokenized_dataset) + else: + trainer = RewardTrainer(model=model_id, args=training_args, train_dataset=tokenized_dataset) + + assert "chosen_ids" in trainer.train_dataset.column_names + assert "rejected_ids" in trainer.train_dataset.column_names + assert "chosen_input_ids" not in trainer.train_dataset.column_names + assert "rejected_input_ids" not in trainer.train_dataset.column_names + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_iterable_dataset(self): + dataset = load_dataset( + "trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train", streaming=True + ) + + training_args = RewardConfig(output_dir=self.tmp_dir, max_steps=3, report_to="none") + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_chat_template_kwargs(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + # The following template is a simplified version of the Qwen chat template, where an additional argument + # `role_capital` is used to control the capitalization of roles. + tokenizer.chat_template = '{%- if messages[0]["role"] == "system" -%} {{ "<|im_start|>" + ("SYSTEM" if role_capital else "system") + "\\n" + messages[0]["content"] + "<|im_end|>\\n" }}{%- else -%} {{ "<|im_start|>" + ("SYSTEM" if role_capital else "system") + "\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n" }}{%- endif -%}{%- for message in messages -%} {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) -%} {{ "<|im_start|>" + (message.role.upper() if role_capital else message.role) + "\\n" + message.content + "<|im_end|>\\n" }} {%- elif message.role == "assistant" -%} {{ "<|im_start|>" + ("ASSISTANT" if role_capital else "assistant") }} {%- if message.content -%} {{ "\\n" + message.content }} {%- endif -%} {{ "<|im_end|>\\n" }} {%- elif message.role == "tool" -%} {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") -%} {{ "<|im_start|>" + ("USER" if role_capital else "user") }} {%- endif -%} {{ "\\n\\n" + message.content + "\\n" }} {%- if loop.last or (messages[loop.index0 + 1].role != "tool") -%} {{ "<|im_end|>\\n" }} {%- endif -%} {%- endif -%}{%- endfor -%}{%- if add_generation_prompt -%} {{ "<|im_start|>" + ("ASSISTANT" if role_capital else "assistant") + "\\n" }}{%- endif -%}' + + dataset = dataset.add_column( + "chat_template_kwargs", [{"role_capital": bool(i % 2)} for i in range(len(dataset))] + ) + assert "chat_template_kwargs" in dataset.features + + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + processing_class=tokenizer, + ) + + assert trainer.processing_class.chat_template == tokenizer.chat_template + + for i in range(2): + role = "SYSTEM" if i else "system" + system_prompt = ( + f"<|im_start|>{role}\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>" + ) + system_prompt_ids = trainer.processing_class(system_prompt)["input_ids"] + assert trainer.train_dataset[i]["chosen_ids"][: len(system_prompt_ids)] == system_prompt_ids + assert trainer.train_dataset[i]["rejected_ids"][: len(system_prompt_ids)] == system_prompt_ids + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_set_chat_template_from_model(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, chat_template_path="Qwen/Qwen3-4B", report_to="none") + # trl-internal-testing/tiny-GPTNeoXForCausalLM doesn't have a chat template set by default + trainer = RewardTrainer( + model="trl-internal-testing/tiny-GPTNeoXForCausalLM", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + # RewardTrainer uses a mean-free loss that cancels uniform shifts in output scores. Since GPT-NeoX models + # include a final LayerNorm, its bias consistently receives zero gradient and remains unchanged, so we skip + # this parameter. + if n == "gpt_neox.final_layer_norm.bias": + continue + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_set_chat_template_from_path(self, lazy_shared_datadir): + dataset = load_dataset("trl-internal-testing/zen", "conversational_preference", split="train") + + training_args = RewardConfig( + output_dir=self.tmp_dir, + chat_template_path=str(lazy_shared_datadir / "template.jinja"), + report_to="none", + ) + # trl-internal-testing/tiny-GPTNeoXForCausalLM doesn't have a chat template set by default + trainer = RewardTrainer( + model="trl-internal-testing/tiny-GPTNeoXForCausalLM", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + # RewardTrainer uses a mean-free loss that cancels uniform shifts in output scores. Since GPT-NeoX models + # include a final LayerNorm, its bias consistently receives zero gradient and remains unchanged, so we skip + # this parameter. + if n == "gpt_neox.final_layer_norm.bias": + continue + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + # Check that the template saved in the output directory is the same as the one used for training + template_path = pathlib.Path(self.tmp_dir) / "checkpoint-9" / "chat_template.jinja" + assert template_path.exists(), f"Chat template not found at {template_path}" + + with open(template_path) as f: + template_content = f.read() + with open(training_args.chat_template_path) as f: + original_template_content = f.read() + assert template_content == original_template_content, "Chat template content does not match the original" + + def test_train_toolcall_data(self): + dataset = load_dataset("trl-internal-testing/toolcall", "preference", split="train") + + training_args = RewardConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, # toolcall sequences are longer than standard data, reduce batch size to avoid OOM + max_length=512, # toolcall sequences are longer than standard data, limit length to avoid OOM + report_to="none", + ) + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_toolcall_data_as_json(self): + # Tabular backends (Arrow/Parquet) can insert `None` for missing keys in nested structures. + # If `tools` is stored as a list of dicts and examples use different dict schemas, nulls may + # be introduced and break tool processing. This test ensures we also support `tools` provided + # as a list of dicts. + dataset = load_dataset("trl-internal-testing/toolcall", "preference", split="train") + + def convert_to_json(example): + return {"tools": json.loads(example["tools"])} + + dataset = dataset.map(convert_to_json) + + training_args = RewardConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, # toolcall sequences are longer than standard data, reduce batch size to avoid OOM + max_length=512, # toolcall sequences are longer than standard data, limit length to avoid OOM + report_to="none", + ) + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_eval(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference") + + training_args = RewardConfig(output_dir=self.tmp_dir, eval_strategy="steps", eval_steps=3, report_to="none") + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + trainer.train() + + assert trainer.state.log_history[0]["eval_loss"] is not None + + def test_train_with_multiple_eval_dataset(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference") + + training_args = RewardConfig(output_dir=self.tmp_dir, eval_strategy="steps", eval_steps=3, report_to="none") + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset={"data1": dataset["test"], "data2": dataset["test"]}, + ) + trainer.train() + + assert trainer.state.log_history[-3]["eval_data1_loss"] is not None + assert trainer.state.log_history[-2]["eval_data2_loss"] is not None + + def test_train_with_compute_metrics(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference") + + def dummy_compute_metrics(eval_pred): + return {"my_metric": 0.123} + + training_args = RewardConfig( + output_dir=self.tmp_dir, + eval_strategy="steps", + eval_steps=3, + report_to="none", + ) + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + compute_metrics=dummy_compute_metrics, + ) + + trainer.train() + + assert trainer.state.log_history[-2]["eval_my_metric"] == 0.123 + + # In practice, this test is the same as `test_train`, since gradient checkpointing is enabled by default in + # `RewardTrainer`. We keep it as a regression guard: if the default ever changes, we still explicitly test gradient + # checkpointing, which has caused issues in the past. + def test_train_with_gradient_checkpointing(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, gradient_checkpointing=True, report_to="none") + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize("use_reentrant", [True, False]) + def test_train_with_gradient_checkpointing_reentrant(self, use_reentrant): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig( + output_dir=self.tmp_dir, + gradient_checkpointing=True, + gradient_checkpointing_kwargs={"use_reentrant": use_reentrant}, + report_to="none", + ) + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_tag_added(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + train_dataset=dataset, + ) + + for tag in ["reward-trainer", "trl"]: + assert tag in trainer.model.model_tags + + @require_peft + def test_tag_added_peft(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + for tag in ["reward-trainer", "trl"]: + assert tag in trainer.model.model_tags + + def test_train_with_margin(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + def add_margin(example): + # dummy margin based on the length of the chosen summary + return {"margin": len(example["chosen"])} + + dataset = dataset.map(add_margin) + + training_args = RewardConfig(output_dir=self.tmp_dir, report_to="none") + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_center_rewards_coefficient(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = RewardConfig(output_dir=self.tmp_dir, center_rewards_coefficient=0.01, report_to="none") + trainer = RewardTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rewards.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rewards.py new file mode 100644 index 0000000000000000000000000000000000000000..f5fd582f68ded8bc5bed8a369a9287ca7eb29d92 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rewards.py @@ -0,0 +1,399 @@ +# Copyright 2020-2026 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 pickle +import threading + +import pytest + +from trl.rewards import ( + accuracy_reward, + get_cosine_scaled_reward, + get_repetition_penalty_reward, + get_soft_overlong_punishment, + reasoning_accuracy_reward, + think_format_reward, +) + +from .testing_utils import TrlTestCase, require_math_latex + + +class TestThinkFormatReward(TrlTestCase): + def test_valid_format(self): + completions = [ + "This is my reasoning.This is my answer.", # Simple, one-line reasoning + "\nThis is my reasoning.\n\nThis is my answer.", # Multiline reasoning + "\nThis is\nmy reasoning.\n\nThis is my answer.", # Multiline reasoning + "\nThis is my reasoning.\nThis is my answer.", # Reasoning including other tags + "\nThis is my answer.", # Empty reasoning + ] + completions = [[{"content": completion}] for completion in completions] + expected_rewards = [1.0, 1.0, 1.0, 1.0, 1.0] # All should be valid + rewards = think_format_reward(completions) + assert rewards == expected_rewards + + def test_invalid_format(self): + completions = [ + "\nThis is my reasoning.\nThis is my answer.", # No closing + "This is my reasoning.\nThis is my answer.", # No closing + "This is my reasoning. This is my answer.", # No tags + "This is my reasoning.\nThis is my answer.", # No tags + "This is my reasoning.\nThis is my answer.", # No opening + "This is my reasoning.This is my answer.", # No opening + "Thisis my reasoning.\nThis is my answer.", # tag in the middle + "This ismy reasoning.This is my answer.", # Nested tags + "This is\nmy\nreasoning.\nThis is my answer.", # Multiline + ] + completions = [[{"content": completion}] for completion in completions] + expected_rewards = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] # All should be invalid + rewards = think_format_reward(completions) + assert rewards == expected_rewards + + def test_mixed_format(self): + completions = [ + "This is my reasoning.This is my answer.", # Valid + "\nThis is my reasoning.\n\nThis is my answer.", # Valid + "This is my reasoning.\nThis is my answer.", # Invalid + "This is my reasoning. This is my answer.", # Invalid + ] + completions = [[{"content": completion}] for completion in completions] + expected_rewards = [1.0, 1.0, 0.0, 0.0] + rewards = think_format_reward(completions) + assert rewards == expected_rewards + + +class TestSoftOverlongPunishmentReward: + def test_soft_overlong_punishment_short_completion(self): + """Test soft overlong punishment reward function with a short completion.""" + # length 50, with max=100 and soft cache=20, reward should be 0. + reward_fn = get_soft_overlong_punishment(max_completion_len=100, soft_punish_cache=20) + completion_ids = [[1] * 50] # 50 <= 80 + rewards = reward_fn(completion_ids=completion_ids) + assert rewards == [0] + + def test_soft_overlong_punishment_long_completion(self): + """Test soft overlong punishment reward function with a longer than max completion.""" + # 110 > 100, reward should be -1. + reward_fn = get_soft_overlong_punishment(max_completion_len=100, soft_punish_cache=20) + completion_ids = [[1] * 110] + rewards = reward_fn(completion_ids) + assert rewards == [-1] + + def test_soft_overlong_punishment_intermediate_completion(self): + """Test soft overlong punishment reward function for intermediate length completion.""" + reward_fn = get_soft_overlong_punishment(max_completion_len=100, soft_punish_cache=20) + completion_ids = [[1] * 90] # 90 is between 80 and 100 + rewards = reward_fn(completion_ids) + assert round(abs(rewards[0] - -0.5), 4) == 0 + + +class TestRepetitionPenaltyReward: + def test_no_repetition_yields_zero(self): + """A completion with only unique n-grams gets no penalty.""" + reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0) + completion_ids = [[1, 2, 3, 4]] + assert reward_fn(completion_ids) == [0.0] + + def test_full_repetition_approaches_max_penalty(self): + """A fully repetitive completion approaches max_penalty.""" + reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0) + # [5, 5, 5, 5, 5] -> 4 bigrams, 1 unique -> scaling = 1 - 1/4 = 0.75 + completion_ids = [[5, 5, 5, 5, 5]] + assert reward_fn(completion_ids) == [pytest.approx(-0.75)] + + def test_partial_repetition(self): + reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0) + # [1, 2, 1, 2, 1, 2] -> 5 bigrams, 2 unique -> scaling = 1 - 2/5 = 0.6 + completion_ids = [[1, 2, 1, 2, 1, 2]] + assert reward_fn(completion_ids) == [pytest.approx(-0.6)] + + def test_completion_shorter_than_ngram_size_yields_zero(self): + reward_fn = get_repetition_penalty_reward(ngram_size=3, max_penalty=-1.0) + completion_ids = [[1, 2]] # 2 tokens < ngram_size + assert reward_fn(completion_ids) == [0.0] + + def test_completion_exactly_ngram_size_yields_zero(self): + reward_fn = get_repetition_penalty_reward(ngram_size=3, max_penalty=-1.0) + completion_ids = [[1, 2, 3]] # a single, unique n-gram + assert reward_fn(completion_ids) == [0.0] + + def test_empty_completion_yields_zero(self): + reward_fn = get_repetition_penalty_reward(ngram_size=3, max_penalty=-1.0) + completion_ids = [[]] + assert reward_fn(completion_ids) == [0.0] + + def test_max_penalty_scales_reward(self): + reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-0.5) + # scaling 0.75 * max_penalty -0.5 = -0.375 + completion_ids = [[5, 5, 5, 5, 5]] + assert reward_fn(completion_ids) == [pytest.approx(-0.375)] + + def test_ngram_size_changes_reward(self): + completion_ids = [[1, 2, 3, 1, 2, 3]] + # bigrams: 5 total, 3 unique -> 1 - 3/5 = 0.4 + reward_bigram = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0) + assert reward_bigram(completion_ids) == [pytest.approx(-0.4)] + # trigrams: 4 total, 3 unique -> 1 - 3/4 = 0.25 + reward_trigram = get_repetition_penalty_reward(ngram_size=3, max_penalty=-1.0) + assert reward_trigram(completion_ids) == [pytest.approx(-0.25)] + + def test_batch_of_completions(self): + reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0) + completion_ids = [ + [1, 2, 3, 4], # no repetition + [5, 5, 5, 5, 5], # full repetition + [9], # shorter than ngram_size + ] + assert reward_fn(completion_ids) == [pytest.approx(0.0), pytest.approx(-0.75), pytest.approx(0.0)] + + def test_positive_max_penalty_raises(self): + with pytest.raises(ValueError): + get_repetition_penalty_reward(ngram_size=2, max_penalty=0.5) + + def test_extra_kwargs_are_ignored(self): + """Trainers pass prompts/completions/etc. as kwargs; the reward must accept and ignore them.""" + reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0) + completion_ids = [[5, 5, 5, 5, 5]] + rewards = reward_fn(completion_ids, prompts=["x"], completions=[[{"content": "5 5 5 5 5"}]]) + assert rewards == [pytest.approx(-0.75)] + + def test_reward_is_picklable(self): + """The reward must survive pickling for the async GRPO rollout worker.""" + reward_fn = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0) + unpickled = pickle.loads(pickle.dumps(reward_fn)) + completion_ids = [[5, 5, 5, 5, 5]] + assert unpickled(completion_ids) == [pytest.approx(-0.75)] + assert unpickled.__name__ == "repetition_penalty_reward" + + +class TestAccuracyReward: + @require_math_latex + def test_accuracy_reward_correct_answer(self): + """Test accuracy_reward with a correct answer.""" + completion = [[{"content": r"\boxed{\frac{63}{400}}"}], [{"content": r"\boxed{\frac{63}{400}}"}]] + solution = [r"\frac{63}{400}", "63/400"] + rewards = accuracy_reward(completion, solution) + assert rewards[0] == 1.0 + assert rewards[1] == 1.0 + + @require_math_latex + def test_accuracy_reward_wrong_answer(self): + """Test accuracy_reward with an incorrect answer.""" + completion = [[{"content": r"\boxed{\frac{64}{400}}"}]] + solution = [r"\frac{63}{400}"] + rewards = accuracy_reward(completion, solution) + assert rewards[0] == 0.0 + + @require_math_latex + def test_accuracy_reward_wrong_answer_no_latex(self): + """Test accuracy_reward with an incorrect answer and gold solution with no latex.""" + completion = [[{"content": r"\boxed{3}"}]] + solution = ["6"] + rewards = accuracy_reward(completion, solution) + assert rewards[0] == 0.0 + + @require_math_latex + def test_accuracy_reward_unparsable_gold(self): + """Test accuracy_reward with an unparsable gold solution.""" + completion = [ + [{"content": "Answer is forty two."}], + [{"content": r"Some other content. \boxed{43}."}], + ] + solution = [ + "Answer is forty two.", + "Answer is forty three.", + ] + rewards = accuracy_reward(completion, solution) + assert rewards[0] is None + assert rewards[1] is None + + @require_math_latex + def test_accuracy_reward_in_worker_thread(self): + """Test that accuracy_reward works when called from a non-main thread.""" + completions = [[{"content": r"\boxed{\frac{1}{3}}"}]] + solutions = [r"\frac{1}{3}"] + results = [] + exceptions = [] + + def target(): + try: + results.extend(accuracy_reward(completions, solutions)) + except Exception as e: + exceptions.append(e) + + t = threading.Thread(target=target) + t.start() + t.join() + + assert not exceptions, f"accuracy_reward raised in worker thread: {exceptions[0]}" + assert results == [1.0] + + +class TestReasoningAccuracyReward: + @require_math_latex + def test_correct_answer_yields_unit_reward(self): + completions = [ + [{"content": r" Reasoning content \boxed{\frac{63}{400}}"}], + [{"content": r"Reasoning content \boxed{\frac{63}{400}}"}], + ] + solutions = [r"\frac{63}{400}", r"\frac{63}{400}"] + rewards = reasoning_accuracy_reward(completions, solutions) + assert rewards[0] == 1.0 + assert rewards[1] == 1.0 + + @require_math_latex + def test_correct_answer_with_custom_tags_yields_unit_reward(self): + completions = [ + [{"content": r" Reasoning content \boxed{\frac{63}{400}}"}], + ] + solutions = [ + r"\frac{63}{400}", + ] + rewards = reasoning_accuracy_reward(completions, solutions, reasoning_delimiters=[""]) + assert rewards[0] == 1.0 + + @require_math_latex + def test_incorrect_answer_yields_zero_reward(self): + completion = [[{"content": r" Reasoning content \boxed{\frac{64}{400}}"}]] + solution = [r"\frac{63}{400}"] + rewards = reasoning_accuracy_reward(completion, solution) + assert rewards[0] == 0.0 + + @require_math_latex + def test_correct_answer_in_reasoning_yields_zero_reward(self): + completions = [ + [{"content": r" My answer is \boxed{42} Some other text."}], + [{"content": r" The answer is \boxed{42} Here's a wrong answer: \boxed{43}."}], + ] + solutions = [r"\boxed{42}", r"\boxed{42}"] + rewards = reasoning_accuracy_reward(completions, solutions) + assert rewards[0] == 0.0 + assert rewards[1] == 0.0 + + @require_math_latex + def test_incomplete_reasoning_yields_zero_reward(self): + completions = [ + [{"content": r" Incomplete reasoning without closing tag"}], + [{"content": r"Correct answer \frac{63}{400} but completely missing reasoning content"}], + ] + solutions = [r"\frac{63}{400}", r"\frac{63}{400}"] + rewards = reasoning_accuracy_reward(completions, solutions) + assert rewards[0] == 0.0 + assert rewards[1] == 0.0 + + @require_math_latex + def test_unparsable_gold_solution_yields_none_reward(self): + completions = [ + [{"content": r" Reasoning content \boxed{42}"}], + ] + solutions = [ + "forty two", + ] + rewards = reasoning_accuracy_reward(completions, solutions) + assert rewards[0] is None + + +class TestCosineScaledReward: + @require_math_latex + def test_correct_shorter_rewarded_more(self): + """For correct completions, a shorter one gets a higher reward.""" + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{3}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[1] * 25, [1] * 75] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards[0] > rewards[1] + assert rewards == [pytest.approx(0.92678, abs=1e-4), pytest.approx(0.57322, abs=1e-4)] + + @require_math_latex + def test_wrong_longer_penalized_less(self): + """For wrong completions, a longer one is penalized less (closer to zero).""" + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{2}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[1] * 25, [1] * 75] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards[1] > rewards[0] + assert rewards == [pytest.approx(-0.92678, abs=1e-4), pytest.approx(-0.57322, abs=1e-4)] + + @require_math_latex + def test_midpoint_values(self): + """At half of max_len (cosine = 0), correct -> 0.75 and wrong -> -0.75 with default bounds.""" + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[1] * 50, [1] * 50] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards == [pytest.approx(0.75), pytest.approx(-0.75)] + + @require_math_latex + def test_correct_boundary_values(self): + """Correct: shortest -> max_value_correct (1.0), longest -> min_value_correct (0.5).""" + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{3}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[], [1] * 100] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards == [pytest.approx(1.0), pytest.approx(0.5)] + + @require_math_latex + def test_wrong_boundary_values(self): + """Wrong: shortest -> min_value_wrong (-1.0), longest -> max_value_wrong (-0.5).""" + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{2}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[], [1] * 100] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards == [pytest.approx(-1.0), pytest.approx(-0.5)] + + @require_math_latex + def test_length_exceeding_max_len_is_clamped(self): + """Completions longer than max_len stay at the long-length bound (no climb back up past max_len).""" + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]] + solution = [r"\frac{1}{3}", r"\frac{1}{3}"] + completion_ids = [[1] * 200, [1] * 200] # both 2x max_len + rewards = reward_fn(completions, solution, completion_ids) + # correct -> min_value_correct (0.5), wrong -> max_value_wrong (-0.5); same as at exactly max_len + assert rewards == [pytest.approx(0.5), pytest.approx(-0.5)] + + @require_math_latex + def test_unparsable_gold_yields_none(self): + """An unparseable gold solution is skipped, as in accuracy_reward.""" + reward_fn = get_cosine_scaled_reward(max_len=100) + completions = [[{"content": r"\boxed{42}"}]] + solution = ["forty two"] + completion_ids = [[1] * 50] + rewards = reward_fn(completions, solution, completion_ids) + assert rewards == [None] + + @require_math_latex + def test_custom_value_bounds(self): + reward_fn = get_cosine_scaled_reward(max_len=100, min_value_correct=0.0, max_value_correct=2.0) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}]] + solution = [r"\frac{1}{3}"] + completion_ids = [[1] * 50] # progress 0.5, cosine 0 -> 0.0 + 0.5 * (2.0 - 0.0) * 1 = 1.0 + rewards = reward_fn(completions, solution, completion_ids) + assert rewards == [pytest.approx(1.0)] + + @require_math_latex + def test_reward_is_picklable(self): + """The reward must survive pickling for the async GRPO rollout worker.""" + reward_fn = get_cosine_scaled_reward(max_len=100) + unpickled = pickle.loads(pickle.dumps(reward_fn)) + completions = [[{"content": r"\boxed{\frac{1}{3}}"}]] + solution = [r"\frac{1}{3}"] + completion_ids = [[1] * 50] + assert unpickled(completions, solution, completion_ids) == [pytest.approx(0.75)] + assert unpickled.__name__ == "cosine_scaled_reward" diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rich_progress_callback.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rich_progress_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..9c6a256b8a9805730b96a3d69d11a82a851e3266 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rich_progress_callback.py @@ -0,0 +1,64 @@ +# Copyright 2020-2026 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 torch +import torch.nn as nn +from datasets import Dataset +from transformers import Trainer, TrainingArguments + +from trl.trainer.callbacks import RichProgressCallback + +from .testing_utils import TrlTestCase, require_rich + + +class DummyModel(nn.Module): + def __init__(self): + super().__init__() + self.a = nn.Parameter(torch.tensor(1.0)) + + def forward(self, x): + return self.a * x + + +@require_rich +class TestRichProgressCallback(TrlTestCase): + def setup_method(self): + self.dummy_model = DummyModel() + self.dummy_train_dataset = Dataset.from_list([{"x": 1.0, "y": 2.0}] * 5) + self.dummy_val_dataset = Dataset.from_list([{"x": 1.0, "y": 2.0}] * 101) + + def test_rich_progress_callback_logging(self): + training_args = TrainingArguments( + output_dir=self.tmp_dir, + per_device_eval_batch_size=2, + per_device_train_batch_size=2, + num_train_epochs=4, + eval_strategy="steps", + eval_steps=1, + logging_strategy="steps", + logging_steps=1, + save_strategy="no", + report_to="none", + disable_tqdm=True, + ) + callbacks = [RichProgressCallback()] + trainer = Trainer( + model=self.dummy_model, + train_dataset=self.dummy_train_dataset, + eval_dataset=self.dummy_val_dataset, + args=training_args, + callbacks=callbacks, + ) + + trainer.train() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rloo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rloo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..4c60be9928894c2003467ee1286b1931d6dc0669 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_rloo_trainer.py @@ -0,0 +1,1836 @@ +# Copyright 2020-2026 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. + +from unittest.mock import patch + +import pytest +import torch +import transformers +from datasets import load_dataset +from packaging.version import Version +from transformers import ( + AutoModelForCausalLM, + AutoModelForImageTextToText, + AutoModelForSequenceClassification, + AutoTokenizer, +) +from transformers.utils import is_peft_available + +from trl import RLOOConfig, RLOOTrainer + +from .testing_utils import TrlTestCase, require_peft, require_vision, require_vllm + + +if is_peft_available(): + from peft import LoraConfig, get_peft_model + + +class TestRLOOTrainer(TrlTestCase): + def test_init_minimal(self): + # Test that RLOOTrainer can be instantiated with only model, reward_model and train_dataset + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + train_dataset=dataset, + ) + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Cohere2ForCausalLM", + pytest.param( + "trl-internal-testing/tiny-Glm4MoeForCausalLM", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="GLM4 tokenizer requires transformers>=5.0.0", + ), + ), + "trl-internal-testing/tiny-GptOssForCausalLM", + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + "trl-internal-testing/tiny-Qwen3MoeForCausalLM", + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-nano", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.7.0"), + reason="Nemotron 3 gradient checkpointing requires transformers>=5.7.0 (see transformers#45625)", + ), + ), + ], + ) + def test_train(self, model_id): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model=model_id, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # MoE models log the load-balancing auxiliary loss (on by default) + if trainer.aux_loss_enabled: + assert trainer.state.log_history[-1]["aux_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize("config_name", ["standard_prompt_only", "conversational_prompt_only"]) + def test_train_dataset_format(self, config_name): + dataset = load_dataset("trl-internal-testing/zen", config_name, split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_trust_remote_code(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + + def reward_func(completions, **kwargs): + return [0.0] * len(completions) + + with pytest.raises(ValueError, match="custom code"): + RLOOTrainer( + model=model_id, + args=RLOOConfig(output_dir=self.tmp_dir, report_to="none"), + reward_funcs=reward_func, + train_dataset=dataset, + ) + + trainer = RLOOTrainer( + model=model_id, + args=RLOOConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + reward_funcs=reward_func, + train_dataset=dataset, + ) + assert type(trainer.model).__name__ == "RemoteForCausalLM" + + def test_train_with_eval(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + per_device_eval_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + eval_strategy="steps", + eval_steps=2, + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + trainer.train() + + def test_train_with_num_generations_eval(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + per_device_eval_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + num_generations_eval=1, + eval_strategy="steps", + eval_steps=2, + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + trainer.train() + + def test_train_multiple_iterations(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + num_iterations=2, + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_peft_config(self): + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_peft_model(self): + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + lora_config = LoraConfig() + model = get_peft_model(model, lora_config) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n and "ref" not in n: # and the peft params to be different (except base and ref) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_moe_peft_model(self): + # Regression test for https://github.com/huggingface/trl/issues/5222. PEFT only supports one adapter per model + # when the LoRA config uses `target_parameters` (see peft#3340), so no "ref" adapter can be created and the + # reference log probs are computed with adapters disabled instead. + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-GptOssForCausalLM", dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + lora_config = LoraConfig(target_parameters=["mlp.experts.down_proj", "mlp.experts.gate_up_proj"]) + model = get_peft_model(model, lora_config) + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + assert "ref" not in trainer.model.peft_config + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + # In practice, this test is the same as `test_train_peft_config`, since gradient checkpointing is enabled by + # default in `RLOOTrainer`. We keep it as a regression guard: if the default ever changes, we still explicitly test + # PEFT + gradient checkpointing, which has caused issues in the past. + @require_peft + def test_train_peft_with_gradient_checkpointing(self): + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + gradient_checkpointing=True, # enable gradient checkpointing + report_to="none", + ) + trainer = RLOOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_different_reward_model(self): + # Use a reward model different from the model: different chat template, tokenization, etc. + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train") + reward_model_id = "trl-internal-testing/tiny-LlamaForSequenceClassification-3.2" + reward_model = AutoModelForSequenceClassification.from_pretrained(reward_model_id) + reward_tokenizer = AutoTokenizer.from_pretrained(reward_model_id) + # By default, the trainer uses the eos token as the padding token. However, for Llama models, the eos token + # appears in the chat template. Using it as a pad token disrupts the reward calculation, as the calculation + # considers the score of the last token before the first pad token. To ensure correct reward calculations, + # we use a separate pad token instead. + reward_tokenizer.pad_token = "<|finetune_right_pad_id|>" + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_model, + args=training_args, + train_dataset=dataset, + reward_processing_classes=reward_tokenizer, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_reward_func_standard(self): + # Test if trainer can handle reward function with standard format + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_reward_func_conversational(self): + # Test if trainer can handle reward function with conversational format + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that gives higher scores to longer completion content.""" + completion_contents = [completion[0]["content"] for completion in completions] + return [float(len(content)) for content in completion_contents] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_multiple_reward_funcs(self): + # Test that RLOOTrainer can be instantiated with multiple reward functions + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func1(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + def reward_func2(completions, **kwargs): + """Reward function that rewards completions with more unique letters.""" + return [float(len(set(completion))) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[reward_func1, reward_func2], + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_sync_and_async_reward_funcs(self): + # Test that RLOOTrainer can be instantiated with multiple reward functions one of which is async + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def sync_reward_func1(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + def sync_reward_func2(completions, **kwargs): + return [1 for _ in completions] + + async def async_reward_func(completions, **kwargs): + """Async Reward function that rewards completions with more unique letters.""" + return [float(len(set(completion))) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[sync_reward_func1, sync_reward_func2, async_reward_func], + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_multiple_reward_funcs_with_None_output(self): + """Test that a valid math reward function is processed correctly while the code reward function returns None.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def applicable_reward_func(completions, **kwargs): + """A reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + def non_applicable_reward_func(completions, **kwargs): + """A reward function that returns None for all inputs, as it is not applicable to this sample.""" + return [None] * len(completions) + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[ + applicable_reward_func, + non_applicable_reward_func, + ], # One applicable, one non applicable + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = { + n: param.clone() for n, param in trainer.model.named_parameters() if param.requires_grad + } + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_multiple_reward_funcs_with_weights(self): + """Test that RLOOTrainer can handle multiple reward functions with weights.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func1(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + def reward_func2(completions, **kwargs): + """Reward function that rewards completions with more unique letters.""" + return [float(len(set(completion))) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + reward_weights=[0.7, 0.3], # weight of reward_func1 and reward_func2 respectively + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[reward_func1, reward_func2], + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + # Check that training logs contain both reward metrics + assert trainer.state.log_history[-1]["train_loss"] is not None + assert "rewards/reward_func1/mean" in trainer.state.log_history[-1] + assert "rewards/reward_func1/std" in trainer.state.log_history[-1] + assert "rewards/reward_func2/mean" in trainer.state.log_history[-1] + assert "rewards/reward_func2/std" in trainer.state.log_history[-1] + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_reward_metric_reflects_reward_weights(self): + """Test that the logged 'reward' metric uses reward_weights, not an unweighted sum.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def constant_reward_1(completions, **kwargs): + return [1.0] * len(completions) + + def constant_reward_0(completions, **kwargs): + return [0.0] * len(completions) + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + reward_weights=[0.7, 0.3], + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[constant_reward_1, constant_reward_0], + args=training_args, + train_dataset=dataset, + ) + + trainer.train() + + log = trainer.state.log_history[-1] + # With reward_weights=[0.7, 0.3] and rewards [1.0, 0.0]: + # weighted reward = 0.7*1.0 + 0.3*0.0 = 0.7 + # unweighted reward = 1.0 + 0.0 = 1.0 + assert abs(log["reward"] - 0.7) < 1e-5, ( + f"Expected logged reward to be ~0.7 (weighted), got {log['reward']}. " + "The reward metric should reflect reward_weights." + ) + + def test_train_multiple_mixed_reward_funcs(self): + # Test if the trainer can handle a mix of reward functions and reward models + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion)) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=[reward_func, "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5"], + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_reward_func_additional_column(self): + # Test if trainer can handle reward function that rely on additional columns in the dataset + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + # Add a column to the dataset (dummy example, the column could be anything) + some_values = list(range(len(dataset))) + dataset = dataset.add_column("some_values", some_values) + + def reward_func(completions, some_values, **kwargs): + """Reward function that rewards completions with lengths closer to the values in some_values.""" + return [ + float(abs(len(completion) - value)) for completion, value in zip(completions, some_values, strict=True) + ] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_sync_ref_model(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + beta=0.1, # ensure ref model is created so sync can update it + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + sync_ref_model=True, + ref_model_sync_steps=2, # reduce sync steps to ensure a sync happens + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + assert trainer.ref_model is not None + previous_ref_params = {n: param.clone() for n, param in trainer.ref_model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + new_ref_param = trainer.ref_model.get_parameter(n) + assert not torch.equal(previous_ref_params[n], new_ref_param), f"Ref Parameter {n} has not changed." + + def test_train_beta_zero(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + training_args = RLOOConfig( + output_dir=self.tmp_dir, + beta=0.0, # set beta to zero value to test the case where the reference model is not used + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_pad_to_multiple_of(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + pad_to_multiple_of=8, + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + @require_vllm + @pytest.mark.skip(reason="We should add a mock for the vLLM server.") + def test_train_vllm_and_peft(self): + """Test that training works with vLLM for generation.""" + model = AutoModelForCausalLM.from_pretrained( + "Qwen/Qwen2.5-0.5B-Instruct", dtype="float32" + ) # tiny model is too small for vLLM + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + use_vllm=True, + ) + lora_config = LoraConfig( + target_modules="all-linear", + # test with non-default modules as it adds extra keys in state_dict that we need to handle + modules_to_save=["embed_tokens", "lm_head"], + ) + trainer = RLOOTrainer( + model=model, + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + peft_config=lora_config, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n and "original_module" not in n: + # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_vllm + @pytest.mark.skip(reason="We should add a mock for the vLLM server.") + def test_train_vllm_structured_outputs(self): + """Test that training works with vLLM for generation with structured outputs.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + use_vllm=True, + vllm_structured_outputs_regex=r"\n.*\n\n\n.*\n", + ) + trainer = RLOOTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", # tiny model is too small for vLLM + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_additional_generation_kwargs(self): + """Test that training works with additional generation kwargs.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + top_p=0.9, + top_k=10, + min_p=0.01, + repetition_penalty=1.1, + ) + + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_vllm + @pytest.mark.skip(reason="We should add a mock for the vLLM server.") + def test_train_vllm_with_additional_generation_kwargs(self): + """Test that training works with vLLM and additional generation kwargs.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + use_vllm=True, + top_p=0.9, + top_k=10, + min_p=0.01, + repetition_penalty=1.1, + ) + + trainer = RLOOTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", # tiny model is too small for vLLM + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_normalized_advantages(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + normalize_advantages=True, + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_clipped_rewards(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + reward_clip_range=(-1, 1), + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @patch("transformers.generation.utils.GenerationMixin.generate") + def test_train_with_mask_truncated_completions(self, mock_generate): + """Test that training works with mask_truncated_completions=True parameter.""" + + # We mock the generate method because the model's random weights make it extremely unlikely to produce a + # sequence containing the EOS token within the allowed max_completion_length. As a result, all tokens are + # masked in the loss, the model doesn't update, and the final check (which verifies the update) fails. + def fake_generate(input_ids, **kwargs): + # pad_token_id = 151643; eos_token_id = 151645 + completion_ids = torch.tensor( + [ + [1, 2, 3, 4, 5, 6, 7, 8], # this one is truncated + [9, 10, 11, 151645, 151643, 151643, 151643, 151643], # this one contains eos + [12, 13, 14, 15, 16, 17, 18, 151645], # particular case, eos is generated just within the limit + ], + device=input_ids.device, + ) + return torch.cat([input_ids, completion_ids], dim=1) + + mock_generate.side_effect = fake_generate + + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + mask_truncated_completions=True, # Enable masking of truncated completions + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_mask_truncated_completions_all_masked(self): + """ + Test that when all generated completions are truncated (i.e., none contain an EOS token), and + mask_truncated_completions=True, the model receives no effective learning signal and therefore does not update + its parameters. + + Here, we don't mock the generate method, be we rely on the fact that the model the probability of generating + the EOS token is extremely low, so all generated completions are truncated. + """ + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + mask_truncated_completions=True, # Enable masking of truncated completions + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert torch.equal(param, new_param), f"Parameter {n} has changed." + + def test_warning_raised_all_rewards_none(self, caplog): + """Test that a proper warning is raised when all rewards are None.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def always_none_reward_func(completions, **kwargs): + """Reward function that always returns None.""" + return [None] * len(completions) + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=always_none_reward_func, + args=training_args, + train_dataset=dataset, + ) + + with caplog.at_level("WARNING", logger="trl.trainer.rloo_trainer"): + trainer.train() + + expected_warning = "All reward functions returned None for the following kwargs:" + assert expected_warning in caplog.text + + def test_train_num_generations_larger_than_batch_size(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + num_generations=6, # the number of generations is larger than the batch size, but + gradient_accumulation_steps=2, # gradient accumulation should allow that + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_multiple_dataloader_workers(self): + # Pytest/CI often starts background threads before tests run. With Python 3.12, using the default "fork" start + # method in a multi-threaded process emits a DeprecationWarning and may deadlock. + # + # We force "spawn" here to make multiprocessing safe under pytest when DataLoader workers are enabled. This is + # test-environment–specific and not required by the training logic itself. + # + # This means the test does not cover "fork". However, "spawn" is stricter (requires full picklability and clean + # state) and avoids fork-after-threads issues that pytest cannot reliably test anyway. Fork-specific behavior, + # if needed, should be tested in a clean process outside pytest. + torch.multiprocessing.set_start_method("spawn", force=True) + + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + dataloader_num_workers=2, # use multiple dataloader workers + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_generation_kwargs(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + # Pass gen kwargs + generation_kwargs={"do_sample": True, "top_k": 50, "num_beams": 2, "length_penalty": -0.1}, + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_reward_func_accessing_trainer_state(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func(completions, **kwargs): + trainer_state = kwargs.get("trainer_state") + assert trainer_state is not None + # transformers.TrainerState instance should have a `global_step` property. + assert hasattr(trainer_state, "global_step") + return [float(len(set(completion))) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + trainer.train() + + def test_train_reward_func_with_log_extra(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func(completions, **kwargs): + log_extra = kwargs.get("log_extra") + assert log_extra is not None + log_extra("test_column", [completion[:5] for completion in completions]) + return [float(len(completion)) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + log_completions=True, + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + trainer.train() + assert "test_column" in trainer._logs["extra"] + + def test_train_reward_func_with_log_metric(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + def reward_func(completions, **kwargs): + log_metric = kwargs.get("log_metric") + assert log_metric is not None + log_metric("custom_accuracy", 0.75) + return [float(len(completion)) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + trainer.train() + # log_metric appends to _metrics, which gets averaged and merged into log_history + logged_keys = {k for entry in trainer.state.log_history for k in entry} + assert "custom_accuracy" in logged_keys + + def test_prepare_input_called_with_correct_data(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + max_completion_length=8, # reduce the completion length to reduce memory usage + gradient_accumulation_steps=3, # can be anything in this test + # steps_per_generation*per_device_train_batch_size=24 is divisible by num_generations=4 + steps_per_generation=4, + num_generations=4, + per_device_train_batch_size=6, # reduce the batch size to reduce memory usage + num_iterations=2, + shuffle_dataset=False, + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + # steps_per_generation=4, per_device_train_batch_size=6 and num_generations=4, so we expect a + # generation batch of 24 samples (steps_per_generation * per_device_train_batch_size), containing 6 + # different prompts (steps_per_generation * per_device_train_batch_size // num_generations), each repeated + # 4 times (num_generations). + expected_first_generation_batch = ( + [{"prompt": "Beautiful is better than"}] * 4 + + [{"prompt": "Explicit is"}] * 4 + + [{"prompt": "Simple is better"}] * 4 + + [{"prompt": "Complex"}] * 4 + + [{"prompt": "Flat is better than"}] * 4 + + [{"prompt": "Sparse is better"}] * 4 + ) + expected_second_generation_batch = ( + [{"prompt": "Readability"}] * 4 + + [{"prompt": "Special cases aren't special"}] * 4 + + [{"prompt": "Although practicality beats"}] * 4 + + [{"prompt": "Errors should never"}] * 4 + + [{"prompt": "Unless explicitly"}] * 4 + + [{"prompt": "In the face of ambiguity, refuse"}] * 4 + ) + + with patch.object(RLOOTrainer, "training_step", wraps=trainer.training_step) as mock_prepare: + trainer.train() + # 3 epochs * 2 iterations * 2 generation batches to cover the dataset * 4 steps_per_generation + assert mock_prepare.call_count == 48 + for i in range(0, 8): # Generation batch repeated 8 times (steps_per_generation*num_iterations) + assert mock_prepare.call_args_list[i].args[1] == expected_first_generation_batch + for i in range(8, 16): + assert mock_prepare.call_args_list[i].args[1] == expected_second_generation_batch + + def test_train_with_chat_template_kwargs(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_only", split="train") + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=3, # reduce the batch size to reduce memory usage + num_generations=3, # reduce the number of generations to reduce memory usage + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + chat_template_kwargs={"enable_thinking": False}, + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen3ForCausalLM", + reward_funcs="trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_mismatched_reward_processing_classes_length(self): + """Test that mismatched length between reward_funcs and reward_processing_classes raises error.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + # Use two reward models + reward_models = [ + "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + "trl-internal-testing/tiny-Qwen3ForSequenceClassification", + ] + + # Create a single processing class (tokenizer) + single_processing_class = AutoTokenizer.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5" + ) + + training_args = RLOOConfig(output_dir=self.tmp_dir, report_to="none") + + with pytest.raises(ValueError, match="must match"): + RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_models, + reward_processing_classes=single_processing_class, # only one, but need two + args=training_args, + train_dataset=dataset, + ) + + def test_correct_reward_processing_classes_list(self): + """Test that correct list of reward_processing_classes works properly.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + # Use two reward models + reward_models = [ + "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5", + "trl-internal-testing/tiny-Qwen3ForSequenceClassification", + ] + + # Create processing classes + processing_class1 = AutoTokenizer.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5" + ) + processing_class2 = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen3ForSequenceClassification") + + training_args = RLOOConfig(output_dir=self.tmp_dir, report_to="none") + + # Correct list length should work + correct_processing_classes = [processing_class1, processing_class2] + + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_models, + reward_processing_classes=correct_processing_classes, + args=training_args, + train_dataset=dataset, + ) + + assert len(trainer.reward_processing_classes) == len(reward_models) + + def test_single_reward_model_with_single_processing_class(self): + """Test that single reward model with single processing class works.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_only", split="train") + + # Use single reward model + reward_model = "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5" + + # Create a single processing class (tokenizer) + single_processing_class = AutoTokenizer.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForSequenceClassification-2.5" + ) + + training_args = RLOOConfig(output_dir=self.tmp_dir, report_to="none") + + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + reward_funcs=reward_model, + reward_processing_classes=single_processing_class, # single object for single reward model + args=training_args, + train_dataset=dataset, + ) + + assert len(trainer.reward_processing_classes) == 1 + assert trainer.reward_processing_classes[0] == single_processing_class + + +@require_vision +class TestRLOOTrainerVLM(TrlTestCase): + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2VLForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + # "trl-internal-testing/tiny-SmolVLMForConditionalGeneration", seems not to support bf16 properly + ], + ) + def test_train_vlm(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model=model_id, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + # LLaVA & LLaVA-Next: vision_feature_layer=-2 leaves the last encoder layer (layers.1) and + # post_layernorm (pooler-only path) without gradient by design. Assert they stay frozen — if they + # ever start training, the feature-selection plumbing has likely regressed. + if model_id in ( + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + ) and ("encoder.layers.1" in n or "post_layernorm" in n): + assert torch.equal(param, new_param), f"Param {n} expected frozen by LLaVA design, but changed" + else: + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_vlm_with_pad_to_multiple_of(self): + # Models like Gemma3 use other forward keyword arguments like token_type_ids that also need to be padded when + # using pad_to_multiple_of, so we test that the trainer correctly pads all the necessary inputs in this case. + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + pad_to_multiple_of=7, + report_to="none", + ) + trainer = RLOOTrainer( + model="trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + def test_train_vlm_beta_non_zero(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + beta=0.1, # set beta to non-zero value to test the case where the reference model is used + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model=model_id, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + @require_peft + def test_train_vlm_peft(self, model_id): + model = AutoModelForImageTextToText.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model=model, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(target_modules=["q_proj", "v_proj"]), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + "trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + ], + ) + @require_vllm + @pytest.mark.skip(reason="We should add a mock for the vLLM server.") + def test_train_vlm_and_vllm(self, model_id) -> None: + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + use_vllm=True, + vllm_mode="server", + ) + trainer = RLOOTrainer( + model=model_id, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + def test_train_vlm_multi_image(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-multi-image", "conversational_prompt_only", split="train") + + def reward_func(completions, **kwargs): + """Reward function that rewards longer completions.""" + return [float(len(completion[0]["content"])) for completion in completions] + + training_args = RLOOConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + per_device_train_batch_size=2, # VLM training is memory intensive, reduce batch size to avoid OOM + num_generations=2, # VLM training is memory intensive, reduce num_generations to avoid OOM + # note: num_generations=2 is only suitable for CI testing; production training should use more generations + max_completion_length=8, # reduce the completion length to reduce memory usage + report_to="none", + ) + trainer = RLOOTrainer( + model=model_id, + reward_funcs=reward_func, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_sft_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_sft_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..bb9b24182ef4a2c56e40fce69cbcae30d0216d5d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_sft_trainer.py @@ -0,0 +1,2865 @@ +# Copyright 2020-2026 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 copy +import gc +import json +import pathlib +from unittest.mock import MagicMock, patch + +import pytest +import torch +import torch.nn.functional as F +import transformers +from accelerate.utils.memory import release_memory +from datasets import Dataset, load_dataset +from packaging.version import Version +from packaging.version import parse as parse_version +from transformers import ( + AutoModelForCausalLM, + AutoModelForImageTextToText, + AutoTokenizer, + BitsAndBytesConfig, + TrainingArguments, +) +from transformers.testing_utils import backend_empty_cache, torch_device +from transformers.utils import is_peft_available + +from trl import SFTConfig, SFTTrainer +from trl.trainer.sft_trainer import ( + DataCollatorForLanguageModeling, + _chunked_cross_entropy_loss, + _patch_chunked_ce_lm_head, + dft_loss, +) + +from .testing_utils import ( + TrlTestCase, + ignore_warnings, + is_ampere_or_newer, + require_bitsandbytes, + require_kernels, + require_liger_kernel, + require_peft, + require_torch_accelerator, + require_torch_multi_accelerator, + require_vision, +) + + +if is_peft_available(): + import peft + from peft import ( + LoraConfig, + PeftModel, + PrefixTuningConfig, + PromptEncoderConfig, + PromptTuningConfig, + TaskType, + get_peft_model, + ) + + +class TestDFTLoss(TrlTestCase): + def test_dft_loss(self): + batch_size = 2 + seq_len = 3 + vocab_size = 2 + # All tokens have the same probability + logits = torch.fill(torch.empty(batch_size, seq_len, vocab_size), torch.rand(1).item()) + outputs = MagicMock() + outputs.logits = logits + labels = torch.tensor([[1, 0, 0], [0, 1, -100]]) + ce_loss = torch.nn.functional.cross_entropy( + logits.view(-1, vocab_size), labels.view(-1), ignore_index=-100, reduction="mean" + ) + # We need to account for the logits shift operation so we don't consider the first tokens + # in each row of the batch + num_items_in_batch = 3 + # Dft loss + predicted_dft_loss = dft_loss(outputs, labels, num_items_in_batch) + # If we have just two tokens in our vocab and all logits are the same, + # dft scales the ce_loss per token by 0.5. So the dft_loss should be ce_loss/2 + torch.testing.assert_close(ce_loss / 2.0, predicted_dft_loss, atol=1e-4, rtol=1e-4) + + +class TestDataCollatorForLanguageModeling(TrlTestCase): + def test_basic_padding(self): + """Test basic padding functionality without completion masks.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0) + examples = [{"input_ids": [1, 2, 3]}, {"input_ids": [4, 5]}] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [4, 5, 0]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0]])) + torch.testing.assert_close(result["labels"], torch.tensor([[1, 2, 3], [4, 5, -100]])) + + def test_completion_mask(self): + """Test completion mask functionality.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0) + examples = [ + {"input_ids": [1, 2, 3], "completion_mask": [0, 1, 1]}, + {"input_ids": [4, 5], "completion_mask": [0, 1]}, + ] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [4, 5, 0]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0]])) + torch.testing.assert_close(result["labels"], torch.tensor([[-100, 2, 3], [-100, 5, -100]])) + + def test_completion_only_loss_disabled(self): + """Test behavior when completion_only_loss is disabled.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, completion_only_loss=False) + examples = [ + {"input_ids": [1, 2, 3], "completion_mask": [0, 1, 1]}, + {"input_ids": [4, 5], "completion_mask": [0, 1]}, + ] + + result = collator(examples) + + # Labels should not be masked when completion_only_loss=False + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [4, 5, 0]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0]])) + torch.testing.assert_close(result["labels"], torch.tensor([[1, 2, 3], [4, 5, -100]])) + + def test_padding_free_mode(self): + """Test padding-free mode where sequences are concatenated.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, padding_free=True) + examples = [{"input_ids": [1, 2, 3]}, {"input_ids": [4, 5]}] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "position_ids", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3, 4, 5]])) + torch.testing.assert_close(result["position_ids"], torch.tensor([[0, 1, 2, 0, 1]])) + torch.testing.assert_close(result["labels"], torch.tensor([[-100, 2, 3, -100, 5]])) + + def test_padding_free_with_completion_mask(self): + """Test padding-free mode with completion masks.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, padding_free=True) + examples = [ + {"input_ids": [1, 2, 3], "completion_mask": [0, 0, 1]}, + {"input_ids": [4, 5], "completion_mask": [1, 1]}, + ] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "position_ids", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3, 4, 5]])) + torch.testing.assert_close(result["position_ids"], torch.tensor([[0, 1, 2, 0, 1]])) + torch.testing.assert_close(result["labels"], torch.tensor([[-100, -100, 3, -100, 5]])) + + def test_packing(self): + """Test that when using packing with position_ids, attention_mask is dropped with fa2.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, padding_free=True) + + # Simulate packed sequences with position_ids that restart (typical of BFD packing) + examples = [ + {"input_ids": [1, 2, 3, 4, 5, 6], "seq_lengths": [3, 3]}, + {"input_ids": [7, 8, 9, 10, 11], "seq_lengths": [4, 1]}, + ] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "position_ids", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]])) + torch.testing.assert_close(result["position_ids"], torch.tensor([[0, 1, 2, 0, 1, 2, 0, 1, 2, 3, 0]])) + torch.testing.assert_close(result["labels"], torch.tensor([[-100, 2, 3, -100, 5, 6, -100, 8, 9, 10, -100]])) + + def test_pad_to_multiple_of(self): + """Test padding to multiple of specified value.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, pad_to_multiple_of=4) + examples = [{"input_ids": [1, 2, 3]}, {"input_ids": [4, 5]}] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3, 0], [4, 5, 0, 0]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1, 0], [1, 1, 0, 0]])) + torch.testing.assert_close(result["labels"], torch.tensor([[1, 2, 3, -100], [4, 5, -100, -100]])) + + def test_pad_to_multiple_of_and_padding_free(self): + """Test padding to multiple of specified value.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, padding_free=True, pad_to_multiple_of=4) + examples = [{"input_ids": [1, 2, 3]}, {"input_ids": [4, 5]}] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "position_ids", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3, 4, 5, 0, 0, 0]])) + torch.testing.assert_close(result["position_ids"], torch.tensor([[0, 1, 2, 0, 1, 0, 0, 0]])) + torch.testing.assert_close(result["labels"], torch.tensor([[-100, 2, 3, -100, 5, -100, -100, -100]])) + + def test_custom_position_ids_but_no_padding_free(self): + """Test that custom position_ids are ignored if padding_free is False.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0) + examples = [{"input_ids": [1, 2, 3], "seq_lengths": [1, 2]}, {"input_ids": [4, 5], "seq_lengths": [2]}] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [4, 5, 0]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0]])) + torch.testing.assert_close(result["labels"], torch.tensor([[1, 2, 3], [4, 5, -100]])) + + def test_single_example(self): + """Test collator with a single example.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0) + examples = [{"input_ids": [1, 2, 3, 4]}] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3, 4]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1, 1]])) + torch.testing.assert_close(result["labels"], torch.tensor([[1, 2, 3, 4]])) + + def test_different_pad_token_id(self): + """Test with different pad token ID.""" + collator = DataCollatorForLanguageModeling(pad_token_id=999) + examples = [{"input_ids": [1, 2, 3]}, {"input_ids": [4, 5]}] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [4, 5, 999]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0]])) + torch.testing.assert_close(result["labels"], torch.tensor([[1, 2, 3], [4, 5, -100]])) + + def test_assistant_masks(self): + """Test handling of assistant masks in examples.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0) + examples = [ + {"input_ids": [1, 2, 3], "assistant_masks": [0, 1, 1]}, + {"input_ids": [4, 5], "assistant_masks": [0, 1]}, + ] + + result = collator(examples) + + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [4, 5, 0]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0]])) + torch.testing.assert_close(result["labels"], torch.tensor([[-100, 2, 3], [-100, 5, -100]])) + + def test_max_length_keep_start(self): + """Test that sequences longer than max_length are truncated from the start.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, max_length=3) + examples = [{"input_ids": [1, 2, 3, 4, 5]}, {"input_ids": [6, 7, 8]}] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [6, 7, 8]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 1]])) + torch.testing.assert_close(result["labels"], torch.tensor([[1, 2, 3], [6, 7, 8]])) + + def test_max_length_keep_end(self): + """Test that sequences longer than max_length are truncated from the end (keeping last tokens).""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, max_length=3, truncation_mode="keep_end") + examples = [{"input_ids": [1, 2, 3, 4, 5]}, {"input_ids": [6, 7, 8]}] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[3, 4, 5], [6, 7, 8]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 1]])) + torch.testing.assert_close(result["labels"], torch.tensor([[3, 4, 5], [6, 7, 8]])) + + def test_max_length_no_truncation_needed(self): + """Test that max_length larger than sequences does not alter the output.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, max_length=10) + examples = [{"input_ids": [1, 2, 3]}, {"input_ids": [4, 5]}] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [4, 5, 0]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 0]])) + torch.testing.assert_close(result["labels"], torch.tensor([[1, 2, 3], [4, 5, -100]])) + + def test_max_length_with_completion_mask(self): + """Test that truncation is applied correctly when completion masks are present.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, max_length=3) + examples = [ + {"input_ids": [1, 2, 3, 4, 5], "completion_mask": [0, 0, 1, 1, 1]}, + {"input_ids": [6, 7, 8], "completion_mask": [0, 1, 1]}, + ] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[1, 2, 3], [6, 7, 8]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 1]])) + torch.testing.assert_close(result["labels"], torch.tensor([[-100, -100, 3], [-100, 7, 8]])) + + def test_max_length_keep_end_with_completion_mask(self): + """Test keep_end truncation with completion masks preserves the final tokens.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, max_length=3, truncation_mode="keep_end") + examples = [ + {"input_ids": [1, 2, 3, 4, 5], "completion_mask": [0, 0, 1, 1, 1]}, + {"input_ids": [6, 7, 8], "completion_mask": [0, 1, 1]}, + ] + + result = collator(examples) + + assert set(result.keys()) == {"input_ids", "attention_mask", "labels"} + torch.testing.assert_close(result["input_ids"], torch.tensor([[3, 4, 5], [6, 7, 8]])) + torch.testing.assert_close(result["attention_mask"], torch.tensor([[1, 1, 1], [1, 1, 1]])) + torch.testing.assert_close(result["labels"], torch.tensor([[3, 4, 5], [-100, 7, 8]])) + + def test_max_length_invalid_truncation_mode(self): + """Test that an invalid truncation_mode raises ValueError.""" + collator = DataCollatorForLanguageModeling(pad_token_id=0, max_length=3, truncation_mode="invalid") + examples = [{"input_ids": [1, 2, 3, 4, 5]}] + + with pytest.raises(ValueError, match="Unsupported truncation mode"): + collator(examples) + + def test_single_example_single_doc(self): + batch_seq_lengths = [[5]] + result = DataCollatorForLanguageModeling.get_position_ids_from_packed_seq_lengths(batch_seq_lengths) + assert len(result) == 1 + assert torch.equal(result[0], torch.arange(5)) + + def test_single_example_multiple_docs(self): + batch_seq_lengths = [[3, 2]] + result = DataCollatorForLanguageModeling.get_position_ids_from_packed_seq_lengths(batch_seq_lengths) + assert len(result) == 1 + # First sequence: 0, 1, 2; second sequence: 0, 1 + assert torch.equal(result[0], torch.tensor([0, 1, 2, 0, 1])) + + def test_multiple_examples(self): + batch_seq_lengths = [[2, 2], [3]] + result = DataCollatorForLanguageModeling.get_position_ids_from_packed_seq_lengths(batch_seq_lengths) + assert len(result) == 2 + assert torch.equal(result[0], torch.tensor([0, 1, 0, 1])) + assert torch.equal(result[1], torch.arange(3)) + + +class TestSFTTrainer(TrlTestCase): + def test_init_with_training_arguments(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + args = TrainingArguments(output_dir=self.tmp_dir, report_to="none") + SFTTrainer(model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=args, train_dataset=dataset) + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Cohere2ForCausalLM", + pytest.param( + "trl-internal-testing/tiny-Glm4MoeForCausalLM", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="GLM4 tokenizer requires transformers>=5.0.0", + ), + ), + "trl-internal-testing/tiny-GptOssForCausalLM", + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + "trl-internal-testing/tiny-Qwen3MoeForCausalLM", + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-nano", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.7.0"), + reason="Nemotron 3 gradient checkpointing requires transformers>=5.7.0 (see transformers#45625)", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Olmo3ForCausalLM", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Olmo 3 requires transformers>=4.57.0", + ), + ), + ], + ) + def test_train(self, model_id): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer(model=model_id, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # MoE models log the load-balancing auxiliary loss (on by default) + if trainer.aux_loss_enabled: + assert trainer.state.log_history[-1]["aux_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "config_name", + [ + "standard_language_modeling", + "conversational_language_modeling", + "standard_prompt_completion", + "conversational_prompt_completion", + ], + ) + def test_train_dataset_format(self, config_name): + dataset = load_dataset("trl-internal-testing/zen", config_name, split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_trust_remote_code(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + model_id = "trl-internal-testing/tiny-RemoteForCausalLM" + + with pytest.raises(ValueError, match="custom code"): + SFTTrainer( + model=model_id, + args=SFTConfig(output_dir=self.tmp_dir, report_to="none"), + train_dataset=dataset, + ) + + trainer = SFTTrainer( + model=model_id, + args=SFTConfig(output_dir=self.tmp_dir, report_to="none", trust_remote_code=True), + train_dataset=dataset, + ) + assert type(trainer.model).__name__ == "RemoteForCausalLM" + + # Special case for harmony + def test_train_gpt_oss(self): + dataset = load_dataset("trl-internal-testing/harmony", "language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-GptOssForCausalLM", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_model(self): + model = AutoModelForCausalLM.from_pretrained( + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + dtype="float32", + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer(model=model, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_dft_loss(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + loss_type="dft", + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + eval_strategy="steps", + eval_steps=3, + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_nll_loss(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, loss_type="nll", report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_nll_loss_peft(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, loss_type="nll", report_to="none") + trainer = SFTTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2VLForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", + marks=[ + pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Qwen3-VL series were introduced in transformers-4.57.0", + ), + ], + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + ], + ) + @require_vision + def test_train_nll_loss_vlm(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_language_modeling", split="train") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + loss_type="nll", + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + report_to="none", + ) + trainer = SFTTrainer(model=model_id, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + # LLaVA & LLaVA-Next: vision_feature_layer=-2 leaves the last encoder layer (layers.1) and + # post_layernorm (pooler-only path) without gradient by design. Assert they stay frozen — if they + # ever start training, the feature-selection plumbing has likely regressed. + if model_id in ( + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + ) and ("encoder.layers.1" in n or "post_layernorm" in n): + assert torch.equal(param, new_param), f"Param {n} expected frozen by LLaVA design, but changed" + else: + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + def test_train_with_formatting_func(self): + # Dummy formatting function + def formatting_prompts_func(example): + chosen, rejected = example["chosen"], example["rejected"] + return f"### Chosen: {chosen}\n### Rejected: {rejected}" + + dataset = load_dataset("trl-internal-testing/zen", "standard_implicit_prompt_preference", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + formatting_func=formatting_prompts_func, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_model_dtype(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + model_init_kwargs={"dtype": torch.float16}, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + report_to="none", + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + # For some reasonn model.layers.0.input_layernorm.weight doesn't change in GitHub Actions but does + # locally. We ignore this parameter for now + if "layernorm" in n: + continue + new_param = trainer.model.get_parameter(n) + # Check the torch dtype + assert new_param.dtype == torch.float16 + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_dense_with_peft_config_lora(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + + trainer = SFTTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize( + "peft_type", + [ + "prompt_tuning", + "prefix_tuning", + "prompt_encoder", + ], + ) + @require_peft + def test_train_with_peft_config_prompt_tuning(self, peft_type): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + # Initialize the trainer, p-tuning doesn't support gradient checkpointing + training_args = SFTConfig(bf16=False, output_dir=self.tmp_dir, report_to="none", gradient_checkpointing=False) + if peft_type == "prompt_tuning": + peft_config = PromptTuningConfig( + task_type=TaskType.CAUSAL_LM, + num_virtual_tokens=4, + tokenizer_name_or_path="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + ) + elif peft_type == "prefix_tuning": + if parse_version(peft.__version__) <= Version("0.17.1"): + pytest.xfail( + "Prefix tuning with device_map='auto' is broken in peft 0.17.1 and below. See " + "https://github.com/huggingface/peft/issues/2821" + ) + peft_config = PrefixTuningConfig( + task_type=TaskType.CAUSAL_LM, + num_virtual_tokens=4, + ) + elif peft_type == "prompt_encoder": + peft_config = PromptEncoderConfig( + task_type=TaskType.CAUSAL_LM, + num_virtual_tokens=4, + encoder_hidden_size=model.config.hidden_size, # This will be overwritten below + ) + trainer = SFTTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=peft_config, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + else: # We expect the peft params to be different + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_moe_with_peft_config(self): + model_id = "trl-internal-testing/tiny-GptOssForCausalLM" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + + trainer = SFTTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(target_parameters=["mlp.experts.down_proj", "mlp.experts.gate_up_proj"]), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_peft + def test_train_peft_model(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + lora_config = LoraConfig() + model = get_peft_model(model, lora_config) + + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer(model=model, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + # In practice, this test is the same as `test_train_dense_with_peft_config_lora`, since gradient checkpointing is + # enabled by default in `SFTTrainer`. We keep it as a regression guard: if the default ever changes, we still + # explicitly test PEFT + gradient checkpointing, which has caused issues in the past. + @require_peft + def test_train_with_peft_config_and_gradient_checkpointing(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, gradient_checkpointing=True, report_to="none") + + trainer = SFTTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize("use_reentrant", [True, False]) + @require_peft + def test_train_with_peft_config_and_gradient_checkpointing_reentrant(self, use_reentrant): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + model = AutoModelForCausalLM.from_pretrained(model_id, dtype="float32") + base_param_names = [f"base_model.model.{n}" for n, _ in model.named_parameters()] + + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + gradient_checkpointing=True, + gradient_checkpointing_kwargs={"use_reentrant": use_reentrant}, + report_to="none", + ) + + trainer = SFTTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n in base_param_names: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "base_layer" not in n: # We expect the peft params to be different (except for the base layer) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_liger_kernel + def test_train_with_liger(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, use_liger_kernel=True, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_torch_accelerator + @require_liger_kernel + def test_compute_loss_skip_logits_on_eval_without_metrics_with_liger(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train[:1]") + + # Init with `use_liger_kernel=False` to skip Liger model wrapping, then flip the flag after to exercise the + # Liger branch of `compute_loss`. `loss_type="nll"` so the chunked path isn't patched in (incompatible with + # Liger), keeping `model.forward` unmodified. + training_args = SFTConfig( + output_dir=self.tmp_dir, + use_liger_kernel=False, + loss_type="nll", + report_to="none", + max_length=8, + bf16=False, + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + compute_metrics=None, + ) + trainer.args.use_liger_kernel = True + trainer.model.eval() + + captured = {} + + def mock_super_compute_loss(model, inputs, return_outputs=False, num_items_in_batch=None): + captured["skip_logits"] = inputs.get("skip_logits") + dummy_loss = torch.tensor(1.0, requires_grad=True) + dummy_outputs = MagicMock() + dummy_outputs.token_accuracy = None + dummy_outputs.logits = torch.randn(1, 5, trainer.model.config.vocab_size) + return (dummy_loss, dummy_outputs) + + inputs = { + "input_ids": torch.tensor([[1, 2, 3, 4, 5]]), + "labels": torch.tensor([[1, 2, 3, 4, 5]]), + "attention_mask": torch.tensor([[1, 1, 1, 1, 1]]), + } + + with patch("transformers.Trainer.compute_loss", side_effect=mock_super_compute_loss): + trainer.compute_loss(trainer.model, inputs) + + assert captured["skip_logits"] is True + + @require_torch_accelerator + @require_liger_kernel + def test_predict_does_not_skip_logits_with_liger(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train[:1]") + + # Same pattern as `test_compute_loss_skip_logits_on_eval_without_metrics_with_liger`: init without Liger then + # flip the flag, and force `loss_type="nll"` to keep `model.forward` unpatched. + training_args = SFTConfig( + output_dir=self.tmp_dir, + use_liger_kernel=False, + loss_type="nll", + report_to="none", + max_length=8, + bf16=False, + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + compute_metrics=None, + ) + trainer.args.use_liger_kernel = True + trainer.model.eval() + + captured = {} + + def mock_super_compute_loss(model, inputs, return_outputs=False, num_items_in_batch=None): + captured["skip_logits"] = inputs.get("skip_logits") + dummy_loss = torch.tensor(1.0, requires_grad=True) + dummy_outputs = (dummy_loss, torch.randn(1, 5, trainer.model.config.vocab_size)) + return (dummy_loss, dummy_outputs) + + with patch("transformers.Trainer.compute_loss", side_effect=mock_super_compute_loss): + trainer.predict(trainer.train_dataset) + + assert captured["skip_logits"] is False + + def test_train_with_non_chatml_conversational_data(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train") + + # Rename role/content to from/value to ensure SFT works with non-chatML conversational data + def rename_fields(example: list[dict]): + return {"conversations": [{"from": m["role"], "value": m["content"]} for m in example["messages"]]} + + dataset = dataset.map(rename_fields, remove_columns="messages") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_pretokenized_data(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + tokenizer = AutoTokenizer.from_pretrained(model_id) + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + def tokenize_example(example): + return tokenizer(example["text"]) + + # Apply tokenization + tokenized_dataset = dataset.map(tokenize_example, remove_columns=["text"]) + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer(model=model_id, args=training_args, train_dataset=tokenized_dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_skip_prepare_dataset_passes_truncation_to_text_collator(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train[:2]") + with pytest.warns(FutureWarning, match="keep_end.*deprecated"): + training_args = SFTConfig( + output_dir=self.tmp_dir, + max_length=16, + truncation_mode="keep_end", + dataset_kwargs={"skip_prepare_dataset": True}, + report_to="none", + ) + + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + assert isinstance(trainer.data_collator, DataCollatorForLanguageModeling) + assert trainer.data_collator.max_length == 16 + assert trainer.data_collator.truncation_mode == "keep_end" + + def test_dataset_with_transform_requires_skip_prepare_dataset(self): + dataset = Dataset.from_dict({"text": ["hello world"]}) + + def add_suffix(batch): + batch["text"] = [text + " " for text in batch["text"]] + return batch + + dataset = dataset.with_transform(add_suffix) + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + + with pytest.raises( + ValueError, + match=r"Dataset\.with_transform\(\).*skip_prepare_dataset.*trainer-ready", + ): + SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + def test_padding_free_without_packing_and_max_length_raises(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train[:2]") + training_args = SFTConfig( + output_dir=self.tmp_dir, + max_length=16, + padding_free=True, + report_to="none", + ) + + with pytest.raises(ValueError, match="`max_length` is not enforced"): + SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + def test_train_with_iterable_dataset(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train", streaming=True) + + training_args = SFTConfig(output_dir=self.tmp_dir, max_steps=3, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @require_kernels + @pytest.mark.skipif( + not is_ampere_or_newer() and torch_device != "xpu", + reason="Flash Attention 2 requires Ampere or newer GPU, or XPU", + ) + def test_train_padding_free(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + padding_free=True, + max_length=None, # padding-free without packing doesn't enforce max_length + model_init_kwargs={"attn_implementation": "kernels-community/flash-attn2"}, + bf16=True, # flash_attention_2 only supports bf16 and fp16 + report_to="none", + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize("packing_strategy", ["bfd", "wrapped"]) + @ignore_warnings(message="You are using packing, but the attention implementation is not.*", category=UserWarning) + @ignore_warnings(message="Padding-free training is enabled, but the attention.*", category=UserWarning) + def test_train_packing(self, packing_strategy): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig( + output_dir=self.tmp_dir, packing=True, packing_strategy=packing_strategy, max_length=10, report_to="none" + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @ignore_warnings(message="You are using packing, but the attention implementation is not.*", category=UserWarning) + @ignore_warnings(message="Padding-free training is enabled, but the attention.*", category=UserWarning) + def test_eval_packing(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + packing=True, + max_length=64, + report_to="none", + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + # Check the number of sequences in train and eval datasets + num_train_seqs = sum(len(x) for x in trainer.train_dataset["seq_lengths"]) + num_eval_seqs = sum(len(x) for x in trainer.eval_dataset["seq_lengths"]) + assert num_train_seqs == 17 # we should still have 17 seqs + assert num_eval_seqs == 2 # we should still have 2 seqs + + # Check that all sequences are shorter than the max length + assert all(sum(x) <= 64 for x in trainer.train_dataset["seq_lengths"]) + assert all(sum(x) <= 64 for x in trainer.eval_dataset["seq_lengths"]) + + # Check the number of sequences in train and eval datasets + assert len(trainer.train_dataset["input_ids"]) == 3 # w/ this dataset, we end up with 46 seqs + assert len(trainer.eval_dataset["input_ids"]) == 1 # w/ this dataset, we end up with 6 seqs + + @ignore_warnings(message="You are using packing, but the attention implementation is not.*", category=UserWarning) + @ignore_warnings(message="Padding-free training is enabled, but the attention.*", category=UserWarning) + def test_only_train_packing(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + packing=True, + eval_packing=False, + max_length=64, + report_to="none", + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + # Check the number of sequences in train dataset + num_train_seqs = sum(len(x) for x in trainer.train_dataset["seq_lengths"]) + assert num_train_seqs == 17 # we should still have 17 seqs + + # We expect eval dataset not having "seq_lengths" as eval_packing is False + assert "seq_lengths" not in trainer.eval_dataset + + # Check that all sequences are shorter than the max length + assert all(sum(x) <= 64 for x in trainer.train_dataset["seq_lengths"]) + + # Check the number of sequences in train and eval datasets + assert len(trainer.train_dataset["input_ids"]) == 3 # w/ this dataset, we end up with 46 seqs + assert len(trainer.eval_dataset["input_ids"]) == 2 # w/ this dataset, we end up with 6 seqs + + def test_train_with_chat_template_kwargs(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + + tokenizer = AutoTokenizer.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5") + # The following template is a simplified version of the Qwen chat template, where an additional argument + # `role_capital` is used to control the capitalization of roles. + tokenizer.chat_template = '{%- if messages[0]["role"] == "system" -%} {{ "<|im_start|>" + ("SYSTEM" if role_capital else "system") + "\\n" + messages[0]["content"] + "<|im_end|>\\n" }}{%- else -%} {{ "<|im_start|>" + ("SYSTEM" if role_capital else "system") + "\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n" }}{%- endif -%}{%- for message in messages -%} {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) -%} {{ "<|im_start|>" + (message.role.upper() if role_capital else message.role) + "\\n" + message.content + "<|im_end|>\\n" }} {%- elif message.role == "assistant" -%} {{ "<|im_start|>" + ("ASSISTANT" if role_capital else "assistant") }} {%- if message.content -%} {{ "\\n" + message.content }} {%- endif -%} {{ "<|im_end|>\\n" }} {%- elif message.role == "tool" -%} {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") -%} {{ "<|im_start|>" + ("USER" if role_capital else "user") }} {%- endif -%} {{ "\\n\\n" + message.content + "\\n" }} {%- if loop.last or (messages[loop.index0 + 1].role != "tool") -%} {{ "<|im_end|>\\n" }} {%- endif -%} {%- endif -%}{%- endfor -%}{%- if add_generation_prompt -%} {{ "<|im_start|>" + ("ASSISTANT" if role_capital else "assistant") + "\\n" }}{%- endif -%}' + + dataset = dataset.add_column( + "chat_template_kwargs", [{"role_capital": bool(i % 2)} for i in range(len(dataset))] + ) + assert "chat_template_kwargs" in dataset.features + + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + processing_class=tokenizer, + ) + + assert trainer.processing_class.chat_template == tokenizer.chat_template + + for i in range(2): + role = "SYSTEM" if i else "system" + system_prompt = ( + f"<|im_start|>{role}\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>" + ) + system_prompt_ids = trainer.processing_class(system_prompt)["input_ids"] + assert trainer.train_dataset[i]["input_ids"][: len(system_prompt_ids)] == system_prompt_ids + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_assistant_only(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, assistant_only_loss=True, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen3ForCausalLM", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_completion_only(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_completion", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, completion_only_loss=True, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen3ForCausalLM", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_completion_only_harmony(self): + dataset = load_dataset("trl-internal-testing/harmony", "prompt_completion", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, completion_only_loss=True, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-GptOssForCausalLM", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_assistant_only_and_completion_only(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_prompt_completion", split="train") + + # To test this case, we need to add user messages in the completion (they'll be masked in the loss) + def add_to_completion(example): + example["completion"].append(example["prompt"][0]) + example["completion"].append(example["completion"][0]) + return example + + dataset = dataset.map(add_to_completion) + + training_args = SFTConfig( + output_dir=self.tmp_dir, assistant_only_loss=True, completion_only_loss=True, report_to="none" + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen3ForCausalLM", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_assistant_only_iterable_dataset(self): + dataset = load_dataset( + "trl-internal-testing/zen", "conversational_language_modeling", split="train", streaming=True + ) + + training_args = SFTConfig(output_dir=self.tmp_dir, assistant_only_loss=True, max_steps=3, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen3ForCausalLM", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_set_chat_template_from_model(self): + dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, chat_template_path="Qwen/Qwen3-4B", report_to="none") + # trl-internal-testing/tiny-GPTNeoXForCausalLM doesn't have a chat template set by default + trainer = SFTTrainer( + model="trl-internal-testing/tiny-GPTNeoXForCausalLM", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_set_chat_template_from_path(self, lazy_shared_datadir): + dataset = load_dataset("trl-internal-testing/zen", "conversational_language_modeling", split="train") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + chat_template_path=str(lazy_shared_datadir / "template.jinja"), + report_to="none", + ) + # trl-internal-testing/tiny-GPTNeoXForCausalLM doesn't have a chat template set by default + trainer = SFTTrainer( + model="trl-internal-testing/tiny-GPTNeoXForCausalLM", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + # Check that the template saved in the output directory is the same as the one used for training + template_path = pathlib.Path(self.tmp_dir) / "checkpoint-9" / "chat_template.jinja" + assert template_path.exists(), f"Chat template not found at {template_path}" + + with open(template_path) as f: + template_content = f.read() + with open(training_args.chat_template_path) as f: + original_template_content = f.read() + assert template_content == original_template_content, "Chat template content does not match the original" + + def test_train_toolcall_data(self): + dataset = load_dataset("trl-internal-testing/toolcall", "language_modeling", split="train") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, # toolcall sequences are longer than standard data, reduce batch size to avoid OOM + max_length=512, # toolcall sequences are longer than standard data, limit length to avoid OOM + report_to="none", + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_toolcall_data_as_json(self): + # Tabular backends (Arrow/Parquet) can insert `None` for missing keys in nested structures. + # If `tools` is stored as a list of dicts and examples use different dict schemas, nulls may + # be introduced and break tool processing. This test ensures we also support `tools` provided + # as a list of dicts. + dataset = load_dataset("trl-internal-testing/toolcall", "language_modeling", split="train") + + def convert_to_json(example): + return {"tools": json.loads(example["tools"])} + + dataset = dataset.map(convert_to_json) + + training_args = SFTConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=2, # toolcall sequences are longer than standard data, reduce batch size to avoid OOM + max_length=512, # toolcall sequences are longer than standard data, limit length to avoid OOM + report_to="none", + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_train_with_eval(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling") + + training_args = SFTConfig(output_dir=self.tmp_dir, eval_strategy="steps", eval_steps=3, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + trainer.train() + + assert trainer.state.log_history[0]["eval_loss"] is not None + + def test_evaluate_with_raw_dataset(self): + # `evaluate` should accept the same (unprocessed) dataset types as the trainer, e.g. a held-out test set + # passed directly to `evaluate`. See https://github.com/huggingface/trl/issues/6115. + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_completion") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + ) + + metrics = trainer.evaluate(eval_dataset=dataset["test"]) + assert metrics["eval_loss"] is not None + + def test_evaluate_with_raw_dataset_dict(self): + # Same as above, but passing a dict of raw datasets to `evaluate`. + dataset = load_dataset("trl-internal-testing/zen", "standard_prompt_completion") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + ) + + metrics = trainer.evaluate(eval_dataset={"data1": dataset["test"], "data2": dataset["test"]}) + assert metrics["eval_data1_loss"] is not None + assert metrics["eval_data2_loss"] is not None + + def test_train_with_metric_for_best_model(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + eval_strategy="steps", + eval_steps=3, + # It's important to use a key that SFTTrainer adds itself (not one from the base Trainer), since the bug is + # that trainer-specific metrics don't reach the dict returned by `evaluate()`. + metric_for_best_model="eval_mean_token_accuracy", + report_to="none", + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + ) + + trainer.train() + + def test_train_with_multiple_eval_dataset(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling") + + training_args = SFTConfig(output_dir=self.tmp_dir, eval_strategy="steps", eval_steps=3, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset={"data1": dataset["test"], "data2": dataset["test"]}, + ) + trainer.train() + + assert trainer.state.log_history[-3]["eval_data1_loss"] is not None + assert trainer.state.log_history[-2]["eval_data2_loss"] is not None + + def test_train_with_compute_metrics(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling") + + def dummy_compute_metrics(eval_pred): + return {"my_metric": 0.123} + + training_args = SFTConfig( + output_dir=self.tmp_dir, + eval_strategy="steps", + eval_steps=3, + report_to="none", + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset["train"], + eval_dataset=dataset["test"], + compute_metrics=dummy_compute_metrics, + ) + + trainer.train() + + assert trainer.state.log_history[-2]["eval_my_metric"] == 0.123 + + # In practice, this test is the same as `test_train`, since gradient checkpointing is enabled by default in + # `SFTTrainer`. We keep it as a regression guard: if the default ever changes, we still explicitly test gradient + # checkpointing, which has caused issues in the past. + def test_train_with_gradient_checkpointing(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, gradient_checkpointing=True, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + @pytest.mark.parametrize("use_reentrant", [True, False]) + def test_train_with_gradient_checkpointing_reentrant(self, use_reentrant): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + gradient_checkpointing=True, + gradient_checkpointing_kwargs={"use_reentrant": use_reentrant}, + report_to="none", + ) + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", args=training_args, train_dataset=dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + def test_tag_added(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + train_dataset=dataset, + ) + + for tag in ["sft", "trl"]: + assert tag in trainer.model.model_tags + + @require_peft + def test_tag_added_peft(self): + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + train_dataset=dataset, + peft_config=LoraConfig(), + ) + + for tag in ["sft", "trl"]: + assert tag in trainer.model.model_tags + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + # "trl-internal-testing/tiny-Idefics2ForConditionalGeneration", high memory peak, skipped for now + # "trl-internal-testing/tiny-Idefics3ForConditionalGeneration", high memory peak, skipped for now + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2VLForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + # "trl-internal-testing/tiny-SmolVLMForConditionalGeneration", seems not to support bf16 properly + pytest.param( + "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", + marks=[ + pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Qwen3-VL series were introduced in transformers-4.57.0", + ), + ], + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + ], + ) + @require_vision + def test_train_vlm(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_language_modeling", split="train") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, # VLM training is memory intensive, reduce batch size to avoid OOM + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + report_to="none", + ) + trainer = SFTTrainer(model=model_id, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + # LLaVA & LLaVA-Next: vision_feature_layer=-2 leaves the last encoder layer (layers.1) and + # post_layernorm (pooler-only path) without gradient by design. Assert they stay frozen — if they + # ever start training, the feature-selection plumbing has likely regressed. + if model_id in ( + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + ) and ("encoder.layers.1" in n or "post_layernorm" in n): + assert torch.equal(param, new_param), f"Param {n} expected frozen by LLaVA design, but changed" + else: + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + @pytest.mark.xfail( + parse_version(transformers.__version__) < parse_version("4.57.0"), + reason="Mixing text-only and image+text examples is only supported in transformers >= 4.57.0", + strict=False, + ) + @require_vision + def test_train_vlm_multi_image(self, model_id): + dataset = load_dataset( + "trl-internal-testing/zen-multi-image", "conversational_prompt_completion", split="train" + ) + + training_args = SFTConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, # VLM training is memory intensive, reduce batch size to avoid OOM + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + report_to="none", + ) + trainer = SFTTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + # Special case for Gemma, as it uses token_type_ids, and we need to ensure they are properly in the collator: + "trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + ], + ) + @require_vision + def test_train_vlm_prompt_completion(self, model_id): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_prompt_completion", split="train") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + per_device_train_batch_size=1, # VLM training is memory intensive, reduce batch size to avoid OOM + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + report_to="none", + ) + trainer = SFTTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + # Gemma 3n uses a timm encoder, making it difficult to create a smaller variant for testing. + # To ensure coverage, we run tests on the full model but mark them as slow to exclude from default runs. + @pytest.mark.slow + @require_vision + @pytest.mark.skip(reason="Model google/gemma-3n-E2B-it is gated and requires HF token") + def test_train_vlm_gemma_3n(self): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_language_modeling", split="train") + + training_args = SFTConfig( + output_dir=self.tmp_dir, + learning_rate=0.1, # use higher lr because gradients are tiny and default lr can stall updates + max_length=None, # for VLMs, truncating can remove image tokens, leading to errors + per_device_train_batch_size=1, # VLM training is memory intensive, reduce batch size to avoid OOM + model_init_kwargs={"dtype": "bfloat16"}, + report_to="none", + ) + trainer = SFTTrainer(model="google/gemma-3n-E2B-it", args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if "model.audio_tower" in n or "model.embed_audio" in n: + # The audio embedding parameters are not updated because this dataset contains no audio data + continue + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + ], + ) + @pytest.mark.parametrize( + "dataset_config", + [ + "conversational_language_modeling", + "conversational_prompt_completion", + "standard_language_modeling", # Regression test for #5334 + "standard_prompt_completion", + ], + ) + @require_vision + def test_train_vlm_text_only_data(self, model_id, dataset_config): + dataset = load_dataset("trl-internal-testing/zen", dataset_config, split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer( + model=model_id, + args=training_args, + train_dataset=dataset, + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if n.startswith("model.visual"): + torch.testing.assert_close(param, new_param, rtol=1e-12, atol=1e-12, msg=f"Param {n} is updated") + else: + assert not torch.equal(param, new_param), f"Param {n} is not updated" + + @require_vision + def test_vision_dataset_with_text_model_raises(self): + dataset = load_dataset("trl-internal-testing/zen-image", "conversational_language_modeling", split="train") + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + with pytest.raises(ValueError, match="vision-related.*vision-language model"): + SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + ) + + @require_peft + def test_prompt_tuning(self): + """Test that SFT works with Prompt Tuning.""" + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer( + model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + args=training_args, + train_dataset=dataset, + peft_config=PromptEncoderConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=8), + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + assert trainer.state.log_history[-1]["mean_token_accuracy"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if "base_model" in n: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "prompt_encoder" in n: # We expect the peft params to be different + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + else: + raise ValueError(f"Unexpected parameter {n} in model: {trainer.model}") + + @require_peft + @require_bitsandbytes + def test_peft_with_quantization(self): + model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5" + + quantization_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_type="nf4", + bnb_4bit_compute_dtype=torch.float16, + ) + model = AutoModelForCausalLM.from_pretrained( + model_id, + dtype="float32", + quantization_config=quantization_config, + ) + + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + # Initialize the trainer with the already configured PeftModel + training_args = SFTConfig(output_dir=self.tmp_dir, learning_rate=0.1, report_to="none") + trainer = SFTTrainer(model=model, args=training_args, train_dataset=dataset, peft_config=LoraConfig()) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + assert trainer.state.log_history[-1]["mean_token_accuracy"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + # In bitsandbytes, bias parameters are automatically cast to the input dtype during the forward pass if + # their dtype doesn’t match. This causes the module to change unexpectedly during the first forward pass of + # the training. To handle this, we cast these specific bias parameters to float32 before comparison. + # https://github.com/bitsandbytes-foundation/bitsandbytes/blob/45553f7392e524eacf400b132cfe01261f6477be/bitsandbytes/nn/modules.py#L518 + # We still need to investigate why the compute dtype ends up being different than for these parameters. + if n in [ + "base_model.model.model.layers.1.self_attn.k_proj.bias", + "base_model.model.model.layers.1.self_attn.q_proj.base_layer.bias", + "base_model.model.model.layers.1.self_attn.v_proj.base_layer.bias", + ]: + param = param.float() + + if "lora" not in n: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "lora" in n: # We expect the peft params to be different + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + else: + raise ValueError(f"Unexpected parameter {n} in model: {trainer.model}") + + @require_peft + def test_prompt_tuning_peft_model(self): + """Test that SFT works with Prompt Tuning and a pre-converted PeftModel""" + model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", dtype="float32") + model = get_peft_model(model, PromptEncoderConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=8)) + + dataset = load_dataset("trl-internal-testing/zen", "standard_language_modeling", split="train") + + training_args = SFTConfig(output_dir=self.tmp_dir, report_to="none") + trainer = SFTTrainer(model=model, args=training_args, train_dataset=dataset) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + assert trainer.state.log_history[-1]["mean_token_accuracy"] is not None + + # Check that the peft params have changed and the base model params have not changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + if "base_model" in n: # We expect the base model params to be the same + torch.testing.assert_close(param, new_param, msg=f"Parameter {n} has changed.") + elif "prompt_encoder" in n: # We expect the peft params to be different + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + else: + raise ValueError(f"Unexpected parameter {n} in model: {trainer.model}") + + +@pytest.mark.slow +@require_torch_accelerator +@require_peft +class TestSFTTrainerSlow(TrlTestCase): + def setup_method(self): + self.train_dataset = load_dataset("stanfordnlp/imdb", split="train[:10%]") + self.eval_dataset = load_dataset("stanfordnlp/imdb", split="test[:10%]") + self.max_length = 128 + self.peft_config = LoraConfig( + lora_alpha=16, + lora_dropout=0.1, + r=8, + bias="none", + task_type="CAUSAL_LM", + ) + + def teardown_method(self): + gc.collect() + backend_empty_cache(torch_device) + gc.collect() + + @pytest.mark.parametrize("packing", [True, False]) + @pytest.mark.parametrize( + "model_name", + [ + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + ], + ) + def test_sft_trainer_transformers_mp(self, model_name, packing): + """ + Simply tests if passing a transformers model to `SFTTrainer` loads and runs the trainer as expected in mixed + precision. + """ + training_args = SFTConfig( + output_dir=self.tmp_dir, + logging_strategy="no", + report_to="none", + per_device_train_batch_size=2, + max_steps=10, + fp16=True, # this is sufficient to enable amp + packing=packing, + max_length=self.max_length, + ) + + model = AutoModelForCausalLM.from_pretrained(model_name, dtype="float32") + tokenizer = AutoTokenizer.from_pretrained(model_name) + + trainer = SFTTrainer( + model, + args=training_args, + processing_class=tokenizer, + train_dataset=self.train_dataset, + eval_dataset=self.eval_dataset, + ) + + trainer.train() + + release_memory(model, trainer) + + @pytest.mark.parametrize("device_map", [{"": 0}, "auto"]) + @pytest.mark.parametrize( + "gradient_checkpointing_kwargs", [None, {"use_reentrant": False}, {"use_reentrant": True}] + ) + @pytest.mark.parametrize("packing", [True, False]) + @pytest.mark.parametrize( + "model_name", + [ + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + ], + ) + @require_torch_multi_accelerator + def test_sft_trainer_transformers_mp_gc_device_map( + self, model_name, packing, gradient_checkpointing_kwargs, device_map + ): + """ + Simply tests if passing a transformers model to `SFTTrainer` loads and runs the trainer as expected in mixed + precision + different scenarios of gradient_checkpointing (single, multi-gpu, etc). + """ + training_args = SFTConfig( + output_dir=self.tmp_dir, + logging_strategy="no", + report_to="none", + per_device_train_batch_size=2, + max_steps=10, + packing=packing, + max_length=self.max_length, + fp16=True, # this is sufficient to enable amp + gradient_checkpointing=True, # default, here for clarity + gradient_checkpointing_kwargs=gradient_checkpointing_kwargs, + ) + + model = AutoModelForCausalLM.from_pretrained(model_name, dtype="float32", device_map=device_map) + tokenizer = AutoTokenizer.from_pretrained(model_name) + + trainer = SFTTrainer( + model, + args=training_args, + processing_class=tokenizer, + train_dataset=self.train_dataset, + eval_dataset=self.eval_dataset, + ) + + trainer.train() + + release_memory(model, trainer) + + @pytest.mark.parametrize( + "gradient_checkpointing_kwargs", [None, {"use_reentrant": False}, {"use_reentrant": True}] + ) + @pytest.mark.parametrize("packing", [True, False]) + @pytest.mark.parametrize( + "model_name", + [ + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + ], + ) + @require_peft + @require_bitsandbytes + def test_sft_trainer_transformers_mp_gc_peft_qlora(self, model_name, packing, gradient_checkpointing_kwargs): + """ + Simply tests if passing a transformers model + PEFT + bnb to `SFTTrainer` loads and runs the trainer as + expected in mixed precision + different scenarios of gradient_checkpointing. + """ + training_args = SFTConfig( + output_dir=self.tmp_dir, + logging_strategy="no", + report_to="none", + per_device_train_batch_size=2, + max_steps=10, + packing=packing, + max_length=self.max_length, + gradient_checkpointing=True, # default, here for clarity + gradient_checkpointing_kwargs=gradient_checkpointing_kwargs, + ) + + quantization_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16) + + model = AutoModelForCausalLM.from_pretrained( + model_name, dtype="float32", quantization_config=quantization_config + ) + tokenizer = AutoTokenizer.from_pretrained(model_name) + + trainer = SFTTrainer( + model, + args=training_args, + processing_class=tokenizer, + train_dataset=self.train_dataset, + eval_dataset=self.eval_dataset, + peft_config=self.peft_config, + ) + + assert isinstance(trainer.model, PeftModel) + + trainer.train() + + release_memory(model, trainer) + + @pytest.mark.parametrize("packing", [True, False]) + @pytest.mark.parametrize( + "model_name", + [ + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + ], + ) + @require_peft + @require_bitsandbytes + def test_sft_trainer_with_chat_format_qlora(self, model_name, packing): + """ + Simply tests if using setup_chat_format with a transformers model + peft + bnb config to `SFTTrainer` loads and + runs the trainer as expected. + """ + train_dataset = load_dataset("trl-internal-testing/dolly-chatml-sft", split="train") + + training_args = SFTConfig( + packing=packing, + max_length=self.max_length, + output_dir=self.tmp_dir, + logging_strategy="no", + report_to="none", + per_device_train_batch_size=2, + max_steps=10, + ) + + quantization_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16) + + model = AutoModelForCausalLM.from_pretrained( + model_name, dtype="float32", quantization_config=quantization_config + ) + tokenizer = AutoTokenizer.from_pretrained(model_name) + + trainer = SFTTrainer( + model, + args=training_args, + processing_class=tokenizer, + train_dataset=train_dataset, + peft_config=self.peft_config, + ) + + assert isinstance(trainer.model, PeftModel) + + trainer.train() + + release_memory(model, trainer) + + @pytest.mark.parametrize("packing", [True, False]) + @pytest.mark.parametrize( + "model_name", + [ + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + ], + ) + @require_liger_kernel + def test_sft_trainer_with_liger(self, model_name, packing): + """ + Tests if passing use_liger=True to SFTConfig loads and runs the trainer with AutoLigerKernelForCausalLM as + expected. + """ + import importlib + + def cleanup_liger_patches(trainer): + """Clean up liger_kernel patches by reloading the model's specific module""" + try: + # Get the specific module that was used by the trainer's model + module_path = trainer.model.__module__ + reload_module = importlib.import_module(module_path) + importlib.reload(reload_module) + except Exception: + pass # Continue if reload fails + + training_args = SFTConfig( + output_dir=self.tmp_dir, + logging_strategy="no", + report_to="none", + per_device_train_batch_size=2, + max_steps=2, + packing=packing, + max_length=self.max_length, + use_liger_kernel=True, + ) + + trainer = SFTTrainer( + model_name, + args=training_args, + train_dataset=self.train_dataset, + eval_dataset=self.eval_dataset, + ) + + # Ensure cleanup of liger patches after the test + try: + trainer.train() + release_memory(trainer.model, trainer) + finally: + cleanup_liger_patches(trainer) + + @pytest.mark.parametrize("packing", [True, False]) + @pytest.mark.parametrize( + "model_name", + [ + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + ], + ) + @require_torch_accelerator + def test_train_offloading(self, model_name, packing): + """Test that activation offloading works with SFTTrainer.""" + training_args = SFTConfig( + output_dir=self.tmp_dir, + activation_offloading=True, + report_to="none", + per_device_train_batch_size=2, + max_steps=2, + packing=packing, + max_length=self.max_length, + ) + trainer = SFTTrainer( + model=model_name, args=training_args, train_dataset=self.train_dataset, eval_dataset=self.eval_dataset + ) + + previous_trainable_params = {n: param.clone() for n, param in trainer.model.named_parameters()} + + trainer.train() + + assert trainer.state.log_history[-1]["train_loss"] is not None + + # Check that the params have changed + for n, param in previous_trainable_params.items(): + new_param = trainer.model.get_parameter(n) + assert not torch.equal(param, new_param), f"Parameter {n} has not changed." + + release_memory(trainer.model, trainer) + + +_CHUNKED_CE_MODEL_IDS = [ + "trl-internal-testing/tiny-CohereForCausalLM", + pytest.param( + "trl-internal-testing/tiny-DeepseekV3ForCausalLM", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="DeepseekV3 SDPA attention is broken in transformers < 5.0.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-DeepseekV3ForCausalLM-0528", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="DeepseekV3 SDPA attention is broken in transformers < 5.0.0", + ), + ), + "trl-internal-testing/tiny-Gemma2ForCausalLM", + "trl-internal-testing/tiny-GemmaForCausalLM", + "trl-internal-testing/tiny-Glm4MoeForCausalLM", + "trl-internal-testing/tiny-GptOssForCausalLM", + "trl-internal-testing/tiny-LlamaForCausalLM-3.1", + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-LlamaForCausalLM-3", + "trl-internal-testing/tiny-MistralForCausalLM-0.1", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-nano", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 was introduced in transformers>=5.3.0", + ), + ), + "trl-internal-testing/tiny-Phi3ForCausalLM", + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + "trl-internal-testing/tiny-Qwen3ForCausalLM", + "trl-internal-testing/tiny-Qwen3MoeForCausalLM", +] + + +_CHUNKED_CE_VLM_MODEL_IDS = [ + "trl-internal-testing/tiny-Gemma3ForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Gemma4ForConditionalGeneration", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.5.0"), + reason="Gemma4 models were introduced in transformers-5.5.0", + ), + ), + "trl-internal-testing/tiny-LlavaForConditionalGeneration", + "trl-internal-testing/tiny-LlavaNextForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2VLForConditionalGeneration", + "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration", + pytest.param( + "trl-internal-testing/tiny-Qwen3VLForConditionalGeneration", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Qwen3-VL series were introduced in transformers-4.57.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5ForConditionalGeneration-NoThink", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), +] + + +class TestChunkedCrossEntropyLoss: + B, S, H, V = 2, 8, 4, 16 + CHUNK_SIZE = 3 # deliberately small to force multiple chunks and a partial final chunk + + def _inputs(self, seed=0, ignore_positions=None, requires_grad=False): + torch.manual_seed(seed) + hidden = torch.randn(self.B, self.S, self.H, dtype=torch.float32, requires_grad=requires_grad) + weight = torch.randn(self.V, self.H, dtype=torch.float32, requires_grad=requires_grad) + labels = torch.randint(0, self.V, (self.B, self.S)) + if ignore_positions is not None: + labels[:, ignore_positions] = -100 + return hidden, weight, labels + + @staticmethod + def _reference(hidden, weight, labels, num_items_in_batch=None): + shift_h = hidden[..., :-1, :].reshape(-1, hidden.size(-1)) + shift_l = labels[..., 1:].reshape(-1) + logits = shift_h.float() @ weight.float().t() + if num_items_in_batch is None: + loss = F.cross_entropy(logits, shift_l, ignore_index=-100, reduction="mean") + else: + loss = F.cross_entropy(logits, shift_l, ignore_index=-100, reduction="sum") + loss = loss / num_items_in_batch + valid = shift_l != -100 + if valid.any(): + log_p = F.log_softmax(logits, dim=-1) + preds = logits.argmax(dim=-1) + accuracy = (preds[valid] == shift_l[valid]).float().mean() + entropy = -(log_p.exp() * log_p).sum(dim=-1)[valid].mean() + else: + accuracy = torch.zeros((), dtype=torch.float32) + entropy = torch.zeros((), dtype=torch.float32) + return loss, accuracy, entropy + + def test_forward_matches_cross_entropy(self): + """With no ignored tokens, chunked loss equals standard mean cross-entropy.""" + hidden, weight, labels = self._inputs() + expected_n_valid = (labels[..., 1:] != -100).sum() + loss_c, correct_c, ent_sum_c, n_valid_c = _chunked_cross_entropy_loss(hidden, weight, self.CHUNK_SIZE, labels) + loss_r, acc_r, ent_r = self._reference(hidden, weight, labels) + torch.testing.assert_close(loss_c, loss_r, atol=1e-5, rtol=1e-5) + torch.testing.assert_close(correct_c / n_valid_c, acc_r, atol=1e-5, rtol=1e-5) + torch.testing.assert_close(ent_sum_c / n_valid_c, ent_r, atol=1e-5, rtol=1e-5) + assert n_valid_c.item() == expected_n_valid.item() + + def test_forward_ignore_index(self): + """Ignored labels are excluded from loss, accuracy and entropy (matches F.cross_entropy).""" + hidden, weight, labels = self._inputs(ignore_positions=slice(0, 3)) + expected_n_valid = (labels[..., 1:] != -100).sum() + loss_c, correct_c, ent_sum_c, n_valid_c = _chunked_cross_entropy_loss(hidden, weight, self.CHUNK_SIZE, labels) + loss_r, acc_r, ent_r = self._reference(hidden, weight, labels) + torch.testing.assert_close(loss_c, loss_r, atol=1e-5, rtol=1e-5) + torch.testing.assert_close(correct_c / n_valid_c, acc_r, atol=1e-5, rtol=1e-5) + torch.testing.assert_close(ent_sum_c / n_valid_c, ent_r, atol=1e-5, rtol=1e-5) + assert n_valid_c.item() == expected_n_valid.item() + + def test_num_items_in_batch_reduction(self): + """When num_items_in_batch is provided, loss is sum / num_items_in_batch.""" + hidden, weight, labels = self._inputs(ignore_positions=slice(0, 3)) + num_items = 5 # arbitrary global denominator, != local valid count + loss_c, *_ = _chunked_cross_entropy_loss(hidden, weight, self.CHUNK_SIZE, labels, num_items_in_batch=num_items) + loss_r, *_ = self._reference(hidden, weight, labels, num_items_in_batch=num_items) + torch.testing.assert_close(loss_c, loss_r, atol=1e-5, rtol=1e-5) + + def test_num_items_in_batch_tensor(self): + """A tensor `num_items_in_batch` is accepted and produces the same result as the int form.""" + hidden, weight, labels = self._inputs() + num_items_tensor = torch.tensor(7, dtype=torch.float32) + loss_t, *_ = _chunked_cross_entropy_loss( + hidden, weight, self.CHUNK_SIZE, labels, num_items_in_batch=num_items_tensor + ) + loss_i, *_ = _chunked_cross_entropy_loss(hidden, weight, self.CHUNK_SIZE, labels, num_items_in_batch=7) + torch.testing.assert_close(loss_t, loss_i, atol=1e-6, rtol=1e-6) + + def test_backward_matches_reference(self): + """Gradients on hidden_states and lm_head weight match the standard CE path.""" + hidden_c, weight_c, labels = self._inputs(ignore_positions=slice(0, 3), requires_grad=True) + hidden_r = hidden_c.detach().clone().requires_grad_(True) + weight_r = weight_c.detach().clone().requires_grad_(True) + + loss_c, *_ = _chunked_cross_entropy_loss(hidden_c, weight_c, self.CHUNK_SIZE, labels) + loss_c.backward() + + loss_r, *_ = self._reference(hidden_r, weight_r, labels) + loss_r.backward() + + torch.testing.assert_close(hidden_c.grad, hidden_r.grad, atol=1e-5, rtol=1e-5) + torch.testing.assert_close(weight_c.grad, weight_r.grad, atol=1e-5, rtol=1e-5) + + def test_all_ignored_returns_zero(self): + """If every label is ignored, loss/correct/entropy_sum are all zero and backward still works. + + Every trainable parameter of the chunked path (hidden_states, lm_head_weight, and lm_head_bias when present) + must receive a gradient — otherwise DDP / FSDP synchronization hangs or errors at the all-reduce step. + """ + hidden, weight, labels = self._inputs(requires_grad=True) + bias = torch.zeros(self.V, dtype=torch.float32, requires_grad=True) + labels[:] = -100 + loss, correct, ent_sum, n_valid = _chunked_cross_entropy_loss( + hidden, weight, self.CHUNK_SIZE, labels, lm_head_bias=bias + ) + assert loss.item() == 0.0 + assert correct.item() == 0.0 + assert ent_sum.item() == 0.0 + assert n_valid.item() == 0 + assert not torch.isnan(loss) + # Backward must succeed even when n_valid == 0 (can happen with completion-only loss + # + truncation where a whole micro-batch is masked). + loss.backward() + assert hidden.grad is not None and hidden.grad.abs().sum().item() == 0.0 + assert weight.grad is not None and weight.grad.abs().sum().item() == 0.0 + assert bias.grad is not None and bias.grad.abs().sum().item() == 0.0 + + def test_shift_labels_matches_labels(self): + """`shift_labels` path (CP/SP) must match the default `labels` path after external shifting.""" + hidden, weight, labels = self._inputs(ignore_positions=slice(0, 3)) + loss_l, correct_l, ent_l, n_valid_l = _chunked_cross_entropy_loss(hidden, weight, self.CHUNK_SIZE, labels) + # Mimic what transformers does under CP/SP: pad labels with -100, then shift. + shift_labels = F.pad(labels, (0, 1), value=-100)[..., 1:].contiguous() + loss_s, correct_s, ent_s, n_valid_s = _chunked_cross_entropy_loss( + hidden, weight, self.CHUNK_SIZE, shift_labels=shift_labels + ) + torch.testing.assert_close(loss_s, loss_l, atol=1e-6, rtol=1e-6) + torch.testing.assert_close(correct_s, correct_l, atol=1e-6, rtol=1e-6) + torch.testing.assert_close(ent_s, ent_l, atol=1e-6, rtol=1e-6) + assert n_valid_s.item() == n_valid_l.item() + + def test_requires_labels_or_shift_labels(self): + """Must provide at least one of `labels` or `shift_labels`.""" + hidden, weight, _ = self._inputs() + with pytest.raises(ValueError, match="At least one"): + _chunked_cross_entropy_loss(hidden, weight, self.CHUNK_SIZE) + + def test_shift_labels_wins_when_both_provided(self): + """When both `labels` and `shift_labels` are provided (Ulysses / CP / SP path), `shift_labels` wins.""" + hidden, weight, labels = self._inputs(ignore_positions=slice(0, 3)) + shift_labels = F.pad(labels, (0, 1), value=-100)[..., 1:].contiguous() + # Chunked result with both passed in must match the shift_labels-only path. + loss_both, *_ = _chunked_cross_entropy_loss( + hidden, weight, self.CHUNK_SIZE, labels=labels, shift_labels=shift_labels + ) + loss_shift, *_ = _chunked_cross_entropy_loss(hidden, weight, self.CHUNK_SIZE, shift_labels=shift_labels) + torch.testing.assert_close(loss_both, loss_shift, atol=1e-6, rtol=1e-6) + + def test_lm_head_bias(self): + """When `lm_head_bias` is provided, chunked loss matches `F.linear(h, w, b)` followed by CE.""" + hidden, weight, labels = self._inputs(ignore_positions=slice(0, 3)) + torch.manual_seed(1) + bias = torch.randn(self.V, dtype=torch.float32) + + loss_c, *_ = _chunked_cross_entropy_loss(hidden, weight, self.CHUNK_SIZE, labels, lm_head_bias=bias) + + # Reference: full F.linear with bias, then CE over non-ignored shifted positions. + logits_ref = F.linear(hidden[..., :-1, :], weight, bias).reshape(-1, self.V) + labels_ref = labels[..., 1:].reshape(-1) + valid = labels_ref != -100 + loss_r = F.cross_entropy(logits_ref[valid], labels_ref[valid], reduction="mean") + torch.testing.assert_close(loss_c, loss_r, atol=1e-5, rtol=1e-5) + + +@require_torch_accelerator +class TestPatchChunkedCELMHead: + """Patched `forward` must be numerically equivalent to the standard HF causal-LM loss path.""" + + CHUNK_SIZE = 5 # small, to exercise the chunk loop + + def _setup(self, model_id): + ref_model = AutoModelForCausalLM.from_pretrained(model_id, dtype=torch.float32, device_map=torch_device) + chunked_model = copy.deepcopy(ref_model) + _patch_chunked_ce_lm_head(chunked_model, chunk_size=self.CHUNK_SIZE) + + B, S = 2, 16 + input_ids = torch.randint(0, ref_model.config.vocab_size, (B, S), device=torch_device) + labels = input_ids.clone() + labels[:, :4] = -100 # prompt-like mask + num_items = int((labels[..., 1:] != -100).sum()) + return ref_model, chunked_model, input_ids, labels, num_items + + def _setup_vlm(self, model_id): + ref_model = AutoModelForImageTextToText.from_pretrained(model_id, dtype=torch.float32, device_map=torch_device) + chunked_model = copy.deepcopy(ref_model) + _patch_chunked_ce_lm_head(chunked_model, chunk_size=self.CHUNK_SIZE, is_vlm=True) + + B, S = 2, 16 + vocab_size = ref_model.config.text_config.vocab_size + input_ids = torch.randint(0, vocab_size, (B, S), device=torch_device) + labels = input_ids.clone() + labels[:, :4] = -100 + num_items = int((labels[..., 1:] != -100).sum()) + return ref_model, chunked_model, input_ids, labels, num_items + + @pytest.mark.parametrize("model_id", _CHUNKED_CE_MODEL_IDS) + def test_forward_matches_reference(self, model_id): + ref_model, chunked_model, input_ids, labels, num_items = self._setup(model_id) + + with torch.no_grad(): + ref_out = ref_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + out = chunked_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + + torch.testing.assert_close(out.loss, ref_out.loss, atol=1e-5, rtol=1e-5) + assert out.logits is None + assert out.num_correct_tokens is not None and out.num_correct_tokens.item() >= 0 + assert out.entropy_sum is not None and out.entropy_sum.item() >= 0.0 + + @pytest.mark.parametrize( + "model_id", + [ + "trl-internal-testing/tiny-Qwen3MoeForCausalLM", + "trl-internal-testing/tiny-GptOssForCausalLM", + ], + ) + def test_forward_matches_reference_with_aux_loss(self, model_id): + """MoE models with `output_router_logits=True` add `router_aux_loss_coef * load_balancing_loss` + to the main loss. The chunked path must match the reference loss and expose `aux_loss`.""" + ref_model = AutoModelForCausalLM.from_pretrained( + model_id, dtype=torch.float32, output_router_logits=True, device_map=torch_device + ) + chunked_model = copy.deepcopy(ref_model) + _patch_chunked_ce_lm_head(chunked_model, chunk_size=self.CHUNK_SIZE) + + B, S = 2, 16 + input_ids = torch.randint(0, ref_model.config.vocab_size, (B, S), device=torch_device) + labels = input_ids.clone() + labels[:, :4] = -100 + num_items = int((labels[..., 1:] != -100).sum()) + + with torch.no_grad(): + ref_out = ref_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + out = chunked_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + + torch.testing.assert_close(out.loss, ref_out.loss, atol=1e-5, rtol=1e-5) + torch.testing.assert_close(out.aux_loss, ref_out.aux_loss, atol=1e-5, rtol=1e-5) + + @pytest.mark.parametrize("model_id", _CHUNKED_CE_MODEL_IDS) + def test_backward_matches_reference(self, model_id): + ref_model, chunked_model, input_ids, labels, num_items = self._setup(model_id) + + ref_out = ref_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + ref_out.loss.backward() + + out = chunked_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + out.loss.backward() + + # lm_head gradient + torch.testing.assert_close( + chunked_model.lm_head.weight.grad, ref_model.lm_head.weight.grad, atol=1e-5, rtol=1e-5 + ) + # Base decoder gradients + for name, ref_param in ref_model.model.named_parameters(): + chunked_grad = chunked_model.model.get_parameter(name).grad + ref_grad = ref_param.grad + assert (chunked_grad is None) == (ref_grad is None), f"grad presence mismatch on model.{name}" + if ref_grad is not None: + torch.testing.assert_close( + chunked_grad, ref_grad, atol=1e-5, rtol=1e-5, msg=f"gradient mismatch on model.{name}" + ) + + @pytest.mark.parametrize("model_id", _CHUNKED_CE_VLM_MODEL_IDS) + def test_forward_matches_reference_vlm(self, model_id): + ref_model, chunked_model, input_ids, labels, num_items = self._setup_vlm(model_id) + + with torch.no_grad(): + ref_out = ref_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + out = chunked_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + + torch.testing.assert_close(out.loss, ref_out.loss, atol=1e-5, rtol=1e-5) + assert out.logits is None + assert out.num_correct_tokens is not None and out.num_correct_tokens.item() >= 0 + assert out.entropy_sum is not None and out.entropy_sum.item() >= 0.0 + + @pytest.mark.parametrize( + "model_id", + [ + pytest.param( + "trl-internal-testing/tiny-Qwen3_5MoeForConditionalGeneration-3.6", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.2.0"), + reason="Qwen3.5 models were introduced in transformers-5.2.0", + ), + ), + ], + ) + def test_forward_matches_reference_vlm_with_aux_loss(self, model_id): + ref_model = AutoModelForImageTextToText.from_pretrained(model_id, dtype=torch.float32, device_map=torch_device) + chunked_model = copy.deepcopy(ref_model) + _patch_chunked_ce_lm_head(chunked_model, chunk_size=self.CHUNK_SIZE, is_vlm=True) + + # VLM MoE wrappers only read `output_router_logits` from forward kwargs (their `text_config` explicitly + # removes the attribute), so we have to pass it at call time on both paths. + B, S = 2, 16 + input_ids = torch.randint(0, ref_model.config.text_config.vocab_size, (B, S), device=torch_device) + labels = input_ids.clone() + labels[:, :4] = -100 + num_items = int((labels[..., 1:] != -100).sum()) + + with torch.no_grad(): + ref_out = ref_model( + input_ids=input_ids, labels=labels, num_items_in_batch=num_items, output_router_logits=True + ) + out = chunked_model( + input_ids=input_ids, labels=labels, num_items_in_batch=num_items, output_router_logits=True + ) + + torch.testing.assert_close(out.loss, ref_out.loss, atol=1e-5, rtol=1e-5) + torch.testing.assert_close(out.aux_loss, ref_out.aux_loss, atol=1e-5, rtol=1e-5) + + @pytest.mark.parametrize("model_id", _CHUNKED_CE_VLM_MODEL_IDS) + def test_backward_matches_reference_vlm(self, model_id): + ref_model, chunked_model, input_ids, labels, num_items = self._setup_vlm(model_id) + + ref_out = ref_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + ref_out.loss.backward() + + out = chunked_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + out.loss.backward() + + # lm_head gradient + torch.testing.assert_close( + chunked_model.lm_head.weight.grad, ref_model.lm_head.weight.grad, atol=1e-5, rtol=1e-5 + ) + # Multimodal-wrapper gradients (covers both vision tower and inner text decoder). + for name, ref_param in ref_model.model.named_parameters(): + chunked_grad = chunked_model.model.get_parameter(name).grad + ref_grad = ref_param.grad + assert (chunked_grad is None) == (ref_grad is None), f"grad presence mismatch on model.{name}" + if ref_grad is not None: + torch.testing.assert_close( + chunked_grad, ref_grad, atol=1e-5, rtol=1e-5, msg=f"gradient mismatch on model.{name}" + ) + + def test_forward_without_labels_uses_original_path(self): + """With labels=None the patched forward returns real logits (for generation / eval).""" + _, chunked_model, input_ids, _, _ = self._setup("trl-internal-testing/tiny-LlamaForCausalLM-3.2") + with torch.no_grad(): + out = chunked_model(input_ids=input_ids) + assert out.logits is not None + assert out.logits.shape[-1] == chunked_model.config.vocab_size + + def test_forward_without_labels_matches_reference(self): + """labels=None logits must match the unpatched model, including per-model post-processing + (`final_logit_softcapping`, `logit_scale`, ...). This is what makes `.generate()` safe to call on a patched + model.""" + ref_model, chunked_model, input_ids, *_ = self._setup("trl-internal-testing/tiny-CohereForCausalLM") + with torch.no_grad(): + ref_out = ref_model(input_ids=input_ids) + out = chunked_model(input_ids=input_ids) + torch.testing.assert_close(out.logits, ref_out.logits, atol=1e-5, rtol=1e-5) + + @require_peft + @pytest.mark.filterwarnings("ignore:Model has `tie_word_embeddings=True`") + @pytest.mark.parametrize( + "peft_config_factory", + [ + pytest.param(lambda: LoraConfig(r=4, target_modules=["q_proj", "v_proj"]), id="lora"), + pytest.param( + lambda: LoraConfig(r=4, target_modules=["q_proj", "v_proj"], modules_to_save=["lm_head"]), + id="lora+modules_to_save", + ), + pytest.param( + lambda: PromptTuningConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=4), id="prompt_tuning" + ), + pytest.param( + lambda: PromptEncoderConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=4), id="prompt_encoder" + ), + pytest.param( + lambda: PrefixTuningConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=4), id="prefix_tuning" + ), + ], + ) + def test_forward_matches_reference_with_peft(self, peft_config_factory): + """Patching the inner causal LM (`peft_model.get_base_model()`) must produce a forward whose loss matches + the unpatched PEFT reference for both LoRA-style (adapters live in the module tree) and prompt-learning + (`PeftModel.forward` injects virtual tokens, then delegates into the patched inner forward).""" + base = AutoModelForCausalLM.from_pretrained( + "trl-internal-testing/tiny-Qwen3ForCausalLM", dtype=torch.float32, device_map=torch_device + ) + ref_model = get_peft_model(copy.deepcopy(base), peft_config_factory()) + chunked_model = copy.deepcopy(ref_model) + _patch_chunked_ce_lm_head(chunked_model.get_base_model(), chunk_size=self.CHUNK_SIZE) + + B, S = 2, 16 + input_ids = torch.randint(0, base.config.vocab_size, (B, S), device=torch_device) + labels = input_ids.clone() + labels[:, :4] = -100 + num_items = int((labels[..., 1:] != -100).sum()) + + ref_out = ref_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + out = chunked_model(input_ids=input_ids, labels=labels, num_items_in_batch=num_items) + torch.testing.assert_close(out.loss, ref_out.loss, atol=1e-5, rtol=1e-5) + + ref_out.loss.backward() + out.loss.backward() + chunked_params = dict(chunked_model.named_parameters()) + for name, ref_param in ref_model.named_parameters(): + if not ref_param.requires_grad or ref_param.grad is None: + continue + torch.testing.assert_close( + chunked_params[name].grad, + ref_param.grad, + atol=1e-5, + rtol=1e-5, + msg=f"gradient mismatch on {name}", + ) + + @require_peft + @pytest.mark.filterwarnings("ignore:Model has `tie_word_embeddings=True`") + def test_num_valid_tokens_with_prompt_learning_peft(self): + """For prompt-learning PEFT (PromptTuning, P-Tuning), `PeftModel.forward` prepends `-100`-padded virtual + tokens before delegating into the patched inner forward. The patched output's `num_valid_tokens` must reflect + the padded labels — when original `label[0] != -100`, it counts as a valid target paired with the last virtual + token's hidden state, so it must be included in the metric denominator to keep accuracy ≤ 1.""" + base = AutoModelForCausalLM.from_pretrained( + "trl-internal-testing/tiny-Qwen3ForCausalLM", dtype=torch.float32, device_map=torch_device + ) + peft_config = PromptTuningConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=4) + chunked_model = get_peft_model(base, peft_config) + _patch_chunked_ce_lm_head(chunked_model.get_base_model(), chunk_size=self.CHUNK_SIZE) + + B, S = 2, 16 + input_ids = torch.randint(0, base.config.vocab_size, (B, S), device=torch_device) + labels = input_ids.clone() # all positions valid, including label[0] + + out = chunked_model(input_ids=input_ids, labels=labels) + + # `labels[..., 1:]` (un-padded, what compute_loss used to compute) excludes original `label[0]`, + # but the patched forward sees padded labels and counts `label[0]` as a valid target. + unpadded = int((labels[..., 1:] != -100).sum()) + # One extra valid target per sequence (original `label[0]`). + assert out.num_valid_tokens.item() == unpadded + B + # Accuracy denominator from the patched output keeps numerator/denominator aligned, so accuracy ≤ 1. + assert out.num_correct_tokens.item() <= out.num_valid_tokens.item() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_skills.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_skills.py new file mode 100644 index 0000000000000000000000000000000000000000..bcbec3971a25ef1ca44e9999c54b68125525ff12 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_skills.py @@ -0,0 +1,578 @@ +# Copyright 2020-2026 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. + +from pathlib import Path + +import pytest + +from trl.skills import install_skill, list_agent_names, list_skills, resolve_target_path, uninstall_skill +from trl.skills.skills import _get_trl_skills_dir + + +class TestGetTrlSkillsDir: + """Tests for _get_trl_skills_dir function.""" + + def test_returns_path_object(self): + """Test that returns a Path object.""" + skills_dir = _get_trl_skills_dir() + assert isinstance(skills_dir, Path) + + def test_directory_exists(self): + """Test that the returned directory exists.""" + skills_dir = _get_trl_skills_dir() + assert skills_dir.exists(), f"Skills directory does not exist: {skills_dir}" + + def test_is_directory(self): + """Test that the returned path is a directory.""" + skills_dir = _get_trl_skills_dir() + assert skills_dir.is_dir(), f"Skills path is not a directory: {skills_dir}" + + def test_contains_skills_module(self): + """Test that the path ends with 'skills' (the module name).""" + skills_dir = _get_trl_skills_dir() + assert skills_dir.name == "skills" + + +class TestListSkills: + """Tests for list_skills function.""" + + def test_returns_list(self): + """Test that list_skills returns a list.""" + skills = list_skills() + assert isinstance(skills, list) + + def test_contains_trl_training(self): + """Test that list_skills includes the trl-training skill.""" + skills = list_skills() + assert "trl-training" in skills + + def test_skills_are_sorted(self): + """Test that skills are returned in sorted order.""" + skills = list_skills() + assert skills == sorted(skills) + + def test_with_custom_directory(self, tmp_path): + """Test list_skills with a custom directory.""" + # Create fake skills + (tmp_path / "skill1").mkdir() + (tmp_path / "skill1" / "SKILL.md").write_text("# Skill 1") + (tmp_path / "skill2").mkdir() + (tmp_path / "skill2" / "SKILL.md").write_text("# Skill 2") + (tmp_path / "not-a-skill").mkdir() # No SKILL.md + + skills = list_skills(tmp_path) + assert skills == ["skill1", "skill2"] + + def test_empty_directory(self, tmp_path): + """Test list_skills with an empty directory.""" + skills = list_skills(tmp_path) + assert skills == [] + + def test_nonexistent_directory(self, tmp_path): + """Test list_skills with a non-existent directory.""" + nonexistent = tmp_path / "nonexistent" + skills = list_skills(nonexistent) + assert skills == [] + + def test_ignores_files(self, tmp_path): + """Test that list_skills ignores files, only returns directories.""" + (tmp_path / "skill1").mkdir() + (tmp_path / "skill1" / "SKILL.md").write_text("# Skill 1") + (tmp_path / "not-a-skill.txt").write_text("Not a skill") + + skills = list_skills(tmp_path) + assert skills == ["skill1"] + + def test_requires_skill_md(self, tmp_path): + """Test that directories without SKILL.md are ignored.""" + (tmp_path / "has-skill-md").mkdir() + (tmp_path / "has-skill-md" / "SKILL.md").write_text("# Valid") + (tmp_path / "no-skill-md").mkdir() + (tmp_path / "no-skill-md" / "readme.md").write_text("# Invalid") + + skills = list_skills(tmp_path) + assert skills == ["has-skill-md"] + + +class TestInstallSkill: + """Tests for install_skill function.""" + + def test_basic_installation(self, tmp_path): + """Test basic skill installation.""" + target_dir = tmp_path / "target" + + result = install_skill("trl-training", target_dir) + + assert result is True + assert (target_dir / "trl-training").exists() + assert (target_dir / "trl-training" / "SKILL.md").exists() + + def test_creates_target_directory(self, tmp_path): + """Test that install_skill creates the target directory if it doesn't exist.""" + target_dir = tmp_path / "nested" / "target" + + install_skill("trl-training", target_dir) + + assert target_dir.exists() + assert (target_dir / "trl-training").exists() + + def test_skill_not_found(self, tmp_path): + """Test that install_skill raises FileNotFoundError for non-existent skill.""" + target_dir = tmp_path / "target" + + with pytest.raises(FileNotFoundError, match="Skill 'nonexistent' not found"): + install_skill("nonexistent", target_dir) + + def test_skill_already_exists_without_force(self, tmp_path): + """Test that install_skill raises FileExistsError if skill exists and force=False.""" + target_dir = tmp_path / "target" + + # Install once + install_skill("trl-training", target_dir) + + # Try to install again without force + with pytest.raises(FileExistsError, match="already installed"): + install_skill("trl-training", target_dir, force=False) + + def test_force_overwrites_existing(self, tmp_path): + """Test that install_skill with force=True overwrites existing skill.""" + target_dir = tmp_path / "target" + + # Install once + install_skill("trl-training", target_dir) + + # Modify the installed skill + marker_file = target_dir / "trl-training" / "marker.txt" + marker_file.write_text("This should be removed") + + # Install again with force + result = install_skill("trl-training", target_dir, force=True) + + assert result is True + assert (target_dir / "trl-training").exists() + assert not marker_file.exists() # Marker should be gone + + def test_force_overwrites_symlink(self, tmp_path): + """Test that install_skill with force=True can overwrite a symlink.""" + target_dir = tmp_path / "target" + target_dir.mkdir() + + # Create a symlink + symlink = target_dir / "trl-training" + symlink.symlink_to(_get_trl_skills_dir() / "trl-training") + + # Install with force should replace symlink with copy + result = install_skill("trl-training", target_dir, force=True) + + assert result is True + assert (target_dir / "trl-training").exists() + assert not (target_dir / "trl-training").is_symlink() + + def test_skill_not_directory(self, tmp_path): + """Test that install_skill raises ValueError if skill is not a directory.""" + source_dir = tmp_path / "source" + source_dir.mkdir() + target_dir = tmp_path / "target" + + # Create a file instead of directory + (source_dir / "fake-skill").write_text("not a directory") + + with pytest.raises(ValueError, match="is not a directory"): + install_skill("fake-skill", target_dir, source=source_dir) + + def test_preserves_directory_structure(self, tmp_path): + """Test that install_skill preserves the skill's directory structure.""" + source_dir = tmp_path / "source" + target_dir = tmp_path / "target" + + # Create a skill with subdirectories + skill_dir = source_dir / "test-skill" + skill_dir.mkdir(parents=True) + (skill_dir / "SKILL.md").write_text("# Test") + (skill_dir / "subdir").mkdir() + (skill_dir / "subdir" / "file.txt").write_text("content") + + install_skill("test-skill", target_dir, source=source_dir) + + assert (target_dir / "test-skill" / "SKILL.md").exists() + assert (target_dir / "test-skill" / "subdir" / "file.txt").exists() + assert (target_dir / "test-skill" / "subdir" / "file.txt").read_text() == "content" + + def test_install_to_same_directory_fails(self, tmp_path): + """Test that installing to the same directory as source is handled correctly.""" + source_dir = tmp_path / "skills" + source_dir.mkdir() + + # Create a skill + skill_dir = source_dir / "test-skill" + skill_dir.mkdir() + (skill_dir / "SKILL.md").write_text("# Test") + + # Try to install to same directory (should fail with exists error) + with pytest.raises(FileExistsError): + install_skill("test-skill", source_dir, source=source_dir, force=False) + + +class TestUninstallSkill: + """Tests for uninstall_skill function.""" + + def test_basic_uninstallation(self, tmp_path): + """Test basic skill uninstallation.""" + target_dir = tmp_path / "target" + + # Install first + install_skill("trl-training", target_dir) + assert (target_dir / "trl-training").exists() + + # Uninstall + result = uninstall_skill("trl-training", target_dir) + + assert result is True + assert not (target_dir / "trl-training").exists() + + def test_skill_not_installed(self, tmp_path): + """Test that uninstall_skill raises FileNotFoundError for non-existent skill.""" + target_dir = tmp_path / "target" + target_dir.mkdir() + + with pytest.raises(FileNotFoundError, match="not installed"): + uninstall_skill("nonexistent", target_dir) + + def test_uninstall_from_nonexistent_directory(self, tmp_path): + """Test uninstall_skill when target directory doesn't exist.""" + target_dir = tmp_path / "nonexistent" + + with pytest.raises(FileNotFoundError, match="not installed"): + uninstall_skill("trl-training", target_dir) + + def test_uninstall_removes_all_contents(self, tmp_path): + """Test that uninstall removes the entire skill directory.""" + source_dir = tmp_path / "source" + target_dir = tmp_path / "target" + + # Create a skill with multiple files + skill_dir = source_dir / "test-skill" + skill_dir.mkdir(parents=True) + (skill_dir / "SKILL.md").write_text("# Test") + (skill_dir / "file1.txt").write_text("content1") + (skill_dir / "subdir").mkdir() + (skill_dir / "subdir" / "file2.txt").write_text("content2") + + # Install and uninstall + install_skill("test-skill", target_dir, source=source_dir) + uninstall_skill("test-skill", target_dir) + + assert not (target_dir / "test-skill").exists() + # Target directory itself should still exist + assert target_dir.exists() + + def test_uninstall_doesnt_affect_other_skills(self, tmp_path): + """Test that uninstalling one skill doesn't affect others.""" + source_dir = tmp_path / "source" + target_dir = tmp_path / "target" + + # Create two skills + for skill_name in ["skill1", "skill2"]: + skill_dir = source_dir / skill_name + skill_dir.mkdir(parents=True) + (skill_dir / "SKILL.md").write_text(f"# {skill_name}") + + # Install both + install_skill("skill1", target_dir, source=source_dir) + install_skill("skill2", target_dir, source=source_dir) + + # Uninstall one + uninstall_skill("skill1", target_dir) + + # Check that only skill1 is removed + assert not (target_dir / "skill1").exists() + assert (target_dir / "skill2").exists() + + +class TestIntegration: + """Integration tests for skills functions.""" + + def test_full_workflow(self, tmp_path): + """Test complete install -> list -> uninstall workflow.""" + source_dir = tmp_path / "source" + target_dir = tmp_path / "target" + + # Create skills + for i in range(3): + skill_dir = source_dir / f"skill{i}" + skill_dir.mkdir(parents=True) + (skill_dir / "SKILL.md").write_text(f"# Skill {i}") + + # List available skills + available = list_skills(target=source_dir) + assert available == ["skill0", "skill1", "skill2"] + + # Install skills + for skill in available: + install_skill(skill, target_dir, source=source_dir) + + # List installed skills + installed_dirs = [d.name for d in target_dir.iterdir() if d.is_dir()] + assert sorted(installed_dirs) == ["skill0", "skill1", "skill2"] + + # Uninstall one skill + uninstall_skill("skill1", target_dir) + + # Verify + installed_dirs = [d.name for d in target_dir.iterdir() if d.is_dir()] + assert sorted(installed_dirs) == ["skill0", "skill2"] + + def test_install_uninstall_cycle(self, tmp_path): + """Test that we can install and uninstall the same skill multiple times.""" + source_dir = tmp_path / "source" + target_dir = tmp_path / "target" + + # Create skill + skill_dir = source_dir / "test-skill" + skill_dir.mkdir(parents=True) + (skill_dir / "SKILL.md").write_text("# Test") + + # Install -> Uninstall -> Install -> Uninstall + for _ in range(2): + install_skill("test-skill", target_dir, source=source_dir) + assert (target_dir / "test-skill").exists() + + uninstall_skill("test-skill", target_dir) + assert not (target_dir / "test-skill").exists() + + def test_force_reinstall_workflow(self, tmp_path): + """Test the workflow of using force to update an installed skill.""" + source_dir = tmp_path / "source" + target_dir = tmp_path / "target" + + # Create initial skill version + skill_dir = source_dir / "test-skill" + skill_dir.mkdir(parents=True) + (skill_dir / "SKILL.md").write_text("# Version 1") + + # Install + install_skill("test-skill", target_dir, source=source_dir) + assert (target_dir / "test-skill" / "SKILL.md").read_text() == "# Version 1" + + # Update source skill + (skill_dir / "SKILL.md").write_text("# Version 2") + + # Force reinstall + install_skill("test-skill", target_dir, source=source_dir, force=True) + assert (target_dir / "test-skill" / "SKILL.md").read_text() == "# Version 2" + + +class TestEdgeCases: + """Tests for edge cases and special scenarios.""" + + def test_skill_with_special_characters_in_name(self, tmp_path): + """Test handling skills with special characters in names.""" + source_dir = tmp_path / "source" + target_dir = tmp_path / "target" + + # Create skill with hyphens and underscores (common in skill names) + skill_name = "test-skill_v2" + skill_dir = source_dir / skill_name + skill_dir.mkdir(parents=True) + (skill_dir / "SKILL.md").write_text("# Test") + + # Should work fine + install_skill(skill_name, target_dir, source=source_dir) + assert (target_dir / skill_name).exists() + + uninstall_skill(skill_name, target_dir) + assert not (target_dir / skill_name).exists() + + def test_empty_skill_directory(self, tmp_path): + """Test installing a skill with only SKILL.md (no other files).""" + source_dir = tmp_path / "source" + target_dir = tmp_path / "target" + + skill_dir = source_dir / "minimal-skill" + skill_dir.mkdir(parents=True) + (skill_dir / "SKILL.md").write_text("# Minimal") + + install_skill("minimal-skill", target_dir, source=source_dir) + + assert (target_dir / "minimal-skill" / "SKILL.md").exists() + # Should only contain SKILL.md + files = list((target_dir / "minimal-skill").iterdir()) + assert len(files) == 1 + assert files[0].name == "SKILL.md" + + def test_skill_with_hidden_files(self, tmp_path): + """Test that hidden files are preserved during installation.""" + source_dir = tmp_path / "source" + target_dir = tmp_path / "target" + + skill_dir = source_dir / "test-skill" + skill_dir.mkdir(parents=True) + (skill_dir / "SKILL.md").write_text("# Test") + (skill_dir / ".hidden").write_text("hidden content") + + install_skill("test-skill", target_dir, source=source_dir) + + assert (target_dir / "test-skill" / ".hidden").exists() + assert (target_dir / "test-skill" / ".hidden").read_text() == "hidden content" + + def test_list_skills_with_symlinks(self, tmp_path): + """Test that list_skills handles symlinked skill directories.""" + source_dir = tmp_path / "source" + skills_dir = tmp_path / "skills" + skills_dir.mkdir() + + # Create a real skill + skill_dir = source_dir / "real-skill" + skill_dir.mkdir(parents=True) + (skill_dir / "SKILL.md").write_text("# Real") + + # Create symlink to it + (skills_dir / "linked-skill").symlink_to(skill_dir) + + # list_skills should include symlinked skills if they have SKILL.md + skills = list_skills(target=skills_dir) + assert "linked-skill" in skills + + +class TestListAgentNames: + """Tests for list_agent_names function.""" + + def test_returns_list(self): + """Test that list_agent_names returns a list.""" + agents = list_agent_names() + assert isinstance(agents, list) + + def test_contains_expected_agents(self): + """Test that list includes expected agent names.""" + agents = list_agent_names() + assert "agents" in agents + assert "claude" in agents + + +class TestResolveTargetPath: + """Tests for resolve_target_path function.""" + + def test_resolve_agent_name_project_scope(self): + """Test resolving agent name with project scope.""" + path = resolve_target_path("claude", "project") + assert path == Path("./.claude/skills").expanduser().resolve() + + def test_resolve_agent_name_global_scope(self): + """Test resolving agent name with global scope.""" + path = resolve_target_path("claude", "global") + assert path == Path("~/.claude/skills").expanduser().resolve() + + def test_resolve_custom_path_string(self): + """Test resolving custom path as string.""" + path = resolve_target_path("/custom/path", "project") + assert path == Path("/custom/path").resolve() + + def test_resolve_custom_path_object(self): + """Test resolving Path object.""" + custom = Path("/custom/path") + path = resolve_target_path(custom, "project") + assert path == Path("/custom/path").resolve() + + def test_resolve_path_with_tilde(self): + """Test that tilde expansion works.""" + path = resolve_target_path("~/my/skills", "project") + assert path == Path("~/my/skills").expanduser().resolve() + assert "~" not in str(path) + + def test_all_predefined_agents(self): + """Test that all predefined agents can be resolved.""" + for agent in list_agent_names(): + for scope in ["project", "global"]: + path = resolve_target_path(agent, scope) + assert isinstance(path, Path) + assert path.is_absolute() + + def test_invalid_scope_for_predefined_agent(self): + """Test invalid scope raises ValueError for predefined agents.""" + with pytest.raises(ValueError, match="Invalid scope"): + resolve_target_path("claude", "invalid") + + +class TestHighLevelAPI: + """Tests for the new high-level API (target/scope instead of Path).""" + + def test_list_skills_with_target_string(self, tmp_path): + """Test list_skills with target as string (custom path).""" + # Create skills in target + (tmp_path / "skill1").mkdir() + (tmp_path / "skill1" / "SKILL.md").write_text("# Skill 1") + + skills = list_skills(target=str(tmp_path), scope="project") + assert skills == ["skill1"] + + def test_list_skills_with_target_path(self, tmp_path): + """Test list_skills with target as Path object.""" + (tmp_path / "skill1").mkdir() + (tmp_path / "skill1" / "SKILL.md").write_text("# Skill 1") + + skills = list_skills(target=tmp_path, scope="project") + assert skills == ["skill1"] + + def test_list_skills_without_target(self): + """Test list_skills without target lists TRL's built-in skills.""" + skills = list_skills() + assert isinstance(skills, list) + assert "trl-training" in skills + + def test_install_skill_with_target_string(self, tmp_path): + """Test install_skill with target as string.""" + result = install_skill("trl-training", target=str(tmp_path), scope="project") + assert result is True + assert (tmp_path / "trl-training").exists() + + def test_install_skill_with_target_path(self, tmp_path): + """Test install_skill with target as Path object.""" + result = install_skill("trl-training", target=tmp_path, scope="project") + assert result is True + assert (tmp_path / "trl-training").exists() + + def test_install_skill_with_force(self, tmp_path): + """Test install_skill with force parameter.""" + install_skill("trl-training", target=tmp_path) + # Install again with force + result = install_skill("trl-training", target=tmp_path, force=True) + assert result is True + + def test_uninstall_skill_with_target_string(self, tmp_path): + """Test uninstall_skill with target as string.""" + install_skill("trl-training", target=tmp_path) + result = uninstall_skill("trl-training", target=str(tmp_path), scope="project") + assert result is True + assert not (tmp_path / "trl-training").exists() + + def test_uninstall_skill_with_target_path(self, tmp_path): + """Test uninstall_skill with target as Path object.""" + install_skill("trl-training", target=tmp_path) + result = uninstall_skill("trl-training", target=tmp_path, scope="project") + assert result is True + assert not (tmp_path / "trl-training").exists() + + def test_install_with_custom_source(self, tmp_path): + """Test install_skill with custom source parameter.""" + source_dir = tmp_path / "source" + target_dir = tmp_path / "target" + + # Create custom skill + skill_dir = source_dir / "custom-skill" + skill_dir.mkdir(parents=True) + (skill_dir / "SKILL.md").write_text("# Custom") + + result = install_skill("custom-skill", target=target_dir, source=source_dir) + assert result is True + assert (target_dir / "custom-skill").exists() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_skills_cli.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_skills_cli.py new file mode 100644 index 0000000000000000000000000000000000000000..e2afff3fe900ad62cb09b8b3da997a5662022110 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_skills_cli.py @@ -0,0 +1,288 @@ +# Copyright 2020-2026 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 argparse + +import pytest + +from trl.skills import install_skill +from trl.skills.cli import add_skills_subcommands, cmd_install, cmd_list, cmd_uninstall + + +class TestCLICommands: + """Tests for CLI command handlers.""" + + def test_cmd_list_without_target(self, capsys): + """Test cmd_list without target (lists TRL skills).""" + args = argparse.Namespace(target=None, scope="project") + + result = cmd_list(args) + + captured = capsys.readouterr() + assert result == 0 + assert "TRL (available for installation)" in captured.out + assert "trl-training" in captured.out + assert "Use 'trl skills install" in captured.out + + def test_cmd_list_with_target(self, tmp_path, capsys): + """Test cmd_list with target (lists installed skills).""" + # Install a skill + install_skill("trl-training", target=tmp_path) + + args = argparse.Namespace(target=str(tmp_path), scope="project") + result = cmd_list(args) + + captured = capsys.readouterr() + assert result == 0 + assert "trl-training" in captured.out + assert str(tmp_path) in captured.out + + def test_cmd_list_empty_target(self, tmp_path, capsys): + """Test cmd_list with empty target directory.""" + args = argparse.Namespace(target=str(tmp_path), scope="project") + + result = cmd_list(args) + + captured = capsys.readouterr() + assert result == 0 + assert "No skills installed" in captured.out + + def test_cmd_install_single_skill(self, tmp_path, capsys): + """Test cmd_install with single skill.""" + args = argparse.Namespace(skill="trl-training", all=False, target=str(tmp_path), scope="project", force=False) + + result = cmd_install(args) + + captured = capsys.readouterr() + assert result == 0 + assert "✓" in captured.out + assert "1/1 skills installed" in captured.out + assert (tmp_path / "trl-training").exists() + + def test_cmd_install_all_skills(self, tmp_path, capsys): + """Test cmd_install with --all flag.""" + args = argparse.Namespace(skill=None, all=True, target=str(tmp_path), scope="project", force=False) + + result = cmd_install(args) + + captured = capsys.readouterr() + assert result == 0 + assert "✓" in captured.out + assert "installed successfully" in captured.out + assert (tmp_path / "trl-training").exists() + + def test_cmd_install_no_skill_or_all(self, capsys): + """Test cmd_install without skill name or --all flag.""" + args = argparse.Namespace(skill=None, all=False, target="/tmp/test", scope="project", force=False) + + result = cmd_install(args) + + captured = capsys.readouterr() + assert result == 1 + assert "Error: Either provide a skill name or use --all" in captured.out + + def test_cmd_install_both_skill_and_all(self, capsys): + """Test cmd_install with both skill name and --all (error).""" + args = argparse.Namespace(skill="trl-training", all=True, target="/tmp/test", scope="project", force=False) + + result = cmd_install(args) + + captured = capsys.readouterr() + assert result == 1 + assert "Cannot specify both" in captured.out + + def test_cmd_install_nonexistent_skill(self, tmp_path, capsys): + """Test cmd_install with non-existent skill.""" + args = argparse.Namespace(skill="nonexistent", all=False, target=str(tmp_path), scope="project", force=False) + + result = cmd_install(args) + + captured = capsys.readouterr() + assert result == 1 + assert "✗" in captured.out + assert "0/1 skills installed" in captured.out + + def test_cmd_install_already_exists(self, tmp_path, capsys): + """Test cmd_install when skill already exists without force.""" + # Install once + install_skill("trl-training", target=tmp_path) + + args = argparse.Namespace(skill="trl-training", all=False, target=str(tmp_path), scope="project", force=False) + + result = cmd_install(args) + + captured = capsys.readouterr() + assert result == 1 + assert "✗" in captured.out + assert "Use --force to overwrite" in captured.out + + def test_cmd_install_with_force(self, tmp_path, capsys): + """Test cmd_install with --force to overwrite.""" + # Install once + install_skill("trl-training", target=tmp_path) + + args = argparse.Namespace(skill="trl-training", all=False, target=str(tmp_path), scope="project", force=True) + + result = cmd_install(args) + + captured = capsys.readouterr() + assert result == 0 + assert "✓" in captured.out + assert "1/1 skills installed" in captured.out + + def test_cmd_uninstall_success(self, tmp_path, capsys): + """Test cmd_uninstall with installed skill.""" + # Install first + install_skill("trl-training", target=tmp_path) + + args = argparse.Namespace(skill="trl-training", target=str(tmp_path), scope="project") + + result = cmd_uninstall(args) + + captured = capsys.readouterr() + assert result == 0 + assert "✓" in captured.out + assert "has been removed" in captured.out + assert not (tmp_path / "trl-training").exists() + + def test_cmd_uninstall_not_installed(self, tmp_path, capsys): + """Test cmd_uninstall when skill is not installed.""" + args = argparse.Namespace(skill="nonexistent", target=str(tmp_path), scope="project") + + result = cmd_uninstall(args) + + captured = capsys.readouterr() + assert result == 1 + assert "✗" in captured.out + assert "Error:" in captured.out + + def test_cmd_install_creates_target_directory(self, tmp_path, capsys): + """Test cmd_install creates target directory if it doesn't exist.""" + # Custom path that doesn't exist yet + target_path = tmp_path / "new_directory" + assert not target_path.exists() + + args = argparse.Namespace( + skill="trl-training", all=False, target=str(target_path), scope="project", force=False + ) + + result = cmd_install(args) + + captured = capsys.readouterr() + assert result == 0 + assert "✓" in captured.out + assert target_path.exists() + + def test_cmd_uninstall_invalid_target(self, capsys): + """Test cmd_uninstall with non-existent path.""" + args = argparse.Namespace(skill="trl-training", target="/nonexistent/invalid/path", scope="project") + + result = cmd_uninstall(args) + + captured = capsys.readouterr() + assert result == 1 + assert "✗" in captured.out + + +class TestCLIArgumentParsing: + """Tests for CLI argument parsing setup.""" + + def test_add_skills_subcommands_creates_parsers(self): + """Test that add_skills_subcommands creates the expected subparsers.""" + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command") + + add_skills_subcommands(subparsers) + + # Test that we can parse expected commands + args = parser.parse_args(["list"]) + assert args.command == "list" + assert hasattr(args, "func") + + args = parser.parse_args(["install", "trl-training", "--target", "claude"]) + assert args.command == "install" + assert args.skill == "trl-training" + assert args.target == "claude" + + args = parser.parse_args(["uninstall", "trl-training", "--target", "claude"]) + assert args.command == "uninstall" + assert args.skill == "trl-training" + + def test_list_command_optional_target(self): + """Test that list command has optional target.""" + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command") + add_skills_subcommands(subparsers) + + # Should work without target + args = parser.parse_args(["list"]) + assert args.target is None + + # Should work with target + args = parser.parse_args(["list", "--target", "claude"]) + assert args.target == "claude" + + def test_default_target_is_agents(self): + """Test that default target is 'agents'.""" + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command") + add_skills_subcommands(subparsers) + + args = parser.parse_args(["install", "trl-training"]) + assert args.target == "agents" + + def test_scope_choices(self): + """Test that scope parameter accepts valid choices.""" + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command") + add_skills_subcommands(subparsers) + + # Valid scopes + args = parser.parse_args(["install", "trl-training", "--target", "claude", "--scope", "project"]) + assert args.scope == "project" + + args = parser.parse_args(["install", "trl-training", "--target", "claude", "--scope", "global"]) + assert args.scope == "global" + + # Invalid scope should fail + with pytest.raises(SystemExit): + parser.parse_args(["install", "trl-training", "--target", "claude", "--scope", "invalid"]) + + def test_install_all_flag(self): + """Test install --all flag.""" + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command") + add_skills_subcommands(subparsers) + + args = parser.parse_args(["install", "--all", "--target", "claude"]) + assert args.all is True + assert args.skill is None + + def test_install_force_flag(self): + """Test install --force flag.""" + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command") + add_skills_subcommands(subparsers) + + args = parser.parse_args(["install", "trl-training", "--target", "claude", "--force"]) + assert args.force is True + + def test_default_scope_is_project(self): + """Test that default scope is 'project'.""" + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command") + add_skills_subcommands(subparsers) + + args = parser.parse_args(["install", "trl-training", "--target", "claude"]) + assert args.scope == "project" diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b4a48523611b32b696e6d234ff35da8c0650d5a1 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_utils.py @@ -0,0 +1,1380 @@ +# Copyright 2020-2026 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 copy +import textwrap +from io import StringIO +from unittest.mock import patch + +import pytest +import torch +import torch.nn as nn +import torch.nn.functional as F +import transformers +from packaging.version import Version +from transformers import AutoConfig, AutoModelForCausalLM +from transformers.testing_utils import torch_device +from transformers.utils import is_peft_available + +from trl import ModelConfig +from trl.trainer.utils import ( + RepeatSampler, + _ChunkedLogProbFunction, + adjusted_mfu, + compute_flops_per_token, + compute_mfu, + entropy_from_logits, + flush_left, + generate_model_card, + get_peft_config, + hash_module, + nanstd, + pad, + patch_chunked_lm_head, + print_prompt_completions_sample, + selective_log_softmax, + shuffle_sequence_dict, + split_pixel_values_by_grid, + split_tensor_dict, + unsplit_pixel_values_by_grid, + use_adapter, +) + +from .testing_utils import TrlTestCase, require_peft, require_rich, require_torch_accelerator + + +if is_peft_available(): + from peft import AutoPeftModelForCausalLM, LoraConfig + + +@require_peft +class TestUseAdapter(TrlTestCase): + def test_disables_on_none(self): + model = AutoPeftModelForCausalLM.from_pretrained( + "trl-internal-testing/tiny-PeftModel", adapter_name="my_adapter" + ) + input_ids = torch.tensor([[1, 2, 3], [4, 5, 6]]) + with model.disable_adapter(): + expected = model(input_ids).logits + + with use_adapter(model, None): + output = model(input_ids).logits + + assert torch.equal(output, expected) + + def test_restores_previous_adapter(self): + model = AutoPeftModelForCausalLM.from_pretrained( + "trl-internal-testing/tiny-PeftModel", adapter_name="my_adapter" + ) + input_ids = torch.tensor([[1, 2, 3], [4, 5, 6]]) + expected = model(input_ids).logits + with use_adapter(model, "my_adapter"): + pass + output = model(input_ids).logits + assert torch.equal(output, expected) + + with use_adapter(model, None): + pass + output = model(input_ids).logits + assert torch.equal(output, expected) + + def test_with_multiple_adapters(self): + model = AutoPeftModelForCausalLM.from_pretrained( + "trl-internal-testing/tiny-PeftModel", adapter_name="my_adapter_1" + ) + model.load_adapter("trl-internal-testing/tiny-PeftModel-2", "my_adapter_2") + input_ids = torch.tensor([[1, 2, 3], [4, 5, 6]]) + + model.set_adapter("my_adapter_1") # should be a no-op, but let's keep it for clarity + expected_1 = model(input_ids).logits + model.set_adapter("my_adapter_2") + expected_2 = model(input_ids).logits + + with use_adapter(model, "my_adapter_1"): + output_1 = model(input_ids).logits + + with use_adapter(model, "my_adapter_2"): + output_2 = model(input_ids).logits + + assert torch.equal(output_1, expected_1) + assert torch.equal(output_2, expected_2) + + +class TestPad(TrlTestCase): + def test_pad_1_dim_left(self): + x = torch.tensor([1, 2, 3]) + y = torch.tensor([4, 5]) + output = pad((x, y), padding_value=0, padding_side="left") + expected = torch.tensor([[1, 2, 3], [0, 4, 5]]) + assert torch.equal(output, expected) + + def test_pad_1_dim_right(self): + x = torch.tensor([1, 2, 3]) + y = torch.tensor([4, 5]) + output = pad((x, y), padding_value=0, padding_side="right") + expected = torch.tensor([[1, 2, 3], [4, 5, 0]]) + assert torch.equal(output, expected) + + def test_pad_2_dim_left(self): + x = torch.tensor([[1, 2], [3, 4]]) + y = torch.tensor([[5, 6]]) + output = pad((x, y), padding_value=0, padding_side="left") + expected = torch.tensor( + [ + [[1, 2], [3, 4]], + [[0, 0], [5, 6]], + ] + ) + assert torch.equal(output, expected) + + def test_pad_2_dim_right(self): + x = torch.tensor([[1, 2], [3, 4]]) + y = torch.tensor([[5, 6]]) + output = pad((x, y), padding_value=0, padding_side="right") + expected = torch.tensor( + [ + [[1, 2], [3, 4]], + [[5, 6], [0, 0]], + ] + ) + assert torch.equal(output, expected) + + def test_pad_2_dim_right_multidim(self): + x = torch.tensor([[1, 2], [3, 4]]) + y = torch.tensor([[5]]) + output = pad((x, y), padding_value=0, padding_side="right") + expected = torch.tensor( + [ + [[1, 2], [3, 4]], + [[5, 0], [0, 0]], + ] + ) + assert torch.equal(output, expected) + + def test_pad_to_multiple_of_1(self): + x = torch.tensor([1, 2, 3]) + y = torch.tensor([4, 5]) + # Max length is 3, pad to multiple of 4 + output = pad((x, y), padding_value=0, padding_side="right", pad_to_multiple_of=4) + expected = torch.tensor([[1, 2, 3, 0], [4, 5, 0, 0]]) + assert torch.equal(output, expected) + + def test_pad_to_multiple_of_2(self): + x = torch.tensor([1, 2, 3, 4, 5]) + y = torch.tensor([6, 7, 8]) + # Max length is 3, pad to multiple of 4 + output = pad((x, y), padding_value=0, padding_side="right", pad_to_multiple_of=4) + expected = torch.tensor([[1, 2, 3, 4, 5, 0, 0, 0], [6, 7, 8, 0, 0, 0, 0, 0]]) + assert torch.equal(output, expected) + + def test_pad_to_multiple_of_side_left(self): + x = torch.tensor([1, 2, 3, 4, 5]) + y = torch.tensor([6, 7, 8]) + # Max length is 3, pad to multiple of 4 + output = pad((x, y), padding_value=0, padding_side="left", pad_to_multiple_of=4) + expected = torch.tensor([[0, 0, 0, 1, 2, 3, 4, 5], [0, 0, 0, 0, 0, 6, 7, 8]]) + assert torch.equal(output, expected) + + def test_pad_to_multiple_of_no_extra_padding(self): + x = torch.tensor([1, 2, 3, 4]) + y = torch.tensor([5, 6, 7, 8]) + # Already multiple of 4 + output = pad((x, y), padding_value=0, padding_side="left", pad_to_multiple_of=4) + expected = torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]) + assert torch.equal(output, expected) + + +class TestHashModule(TrlTestCase): + def test_hash_module_deterministic_across_order(self): + class ModAB(torch.nn.Module): + def __init__(self, a: torch.Tensor, b: torch.Tensor): + super().__init__() + self.a = torch.nn.Parameter(a) + self.b = torch.nn.Parameter(b) + + class ModBA(torch.nn.Module): + def __init__(self, a: torch.Tensor, b: torch.Tensor): + super().__init__() + self.b = torch.nn.Parameter(b) + self.a = torch.nn.Parameter(a) + + a = torch.tensor([[1.0, 2.0]]) + b = torch.tensor([3.0]) + assert hash_module(ModAB(a, b)) == hash_module(ModBA(a, b)) + + def test_hash_module_changes_with_value(self): + class Mod(torch.nn.Module): + def __init__(self, value: float): + super().__init__() + self.weight = torch.nn.Parameter(torch.tensor([value, 2.0])) + + assert hash_module(Mod(1.0)) != hash_module(Mod(1.5)) + + def test_hash_module_includes_dtype(self): + class Mod(torch.nn.Module): + def __init__(self, dtype: torch.dtype): + super().__init__() + self.weight = torch.nn.Parameter(torch.tensor([1.0, 2.0], dtype=dtype)) + + assert hash_module(Mod(torch.float32)) != hash_module(Mod(torch.float16)) + + def test_hash_module_tiny_model_twice(self): + model_id = "trl-internal-testing/tiny-GptOssForCausalLM" + model_a = AutoModelForCausalLM.from_pretrained(model_id) + model_b = AutoModelForCausalLM.from_pretrained(model_id) + assert hash_module(model_a) == hash_module(model_b) + + def test_hash_module_tiny_model_change_layer(self): + model_id = "trl-internal-testing/tiny-GptOssForCausalLM" + model = AutoModelForCausalLM.from_pretrained(model_id) + h1 = hash_module(model) + with torch.no_grad(): + model.lm_head.weight.add_(0.01) + h2 = hash_module(model) + assert h1 != h2 + + +@require_peft +class TestGetPEFTConfig(TrlTestCase): + def test_create_peft_config_use_peft_false(self): + """Test that when use_peft is False, the function returns None.""" + model_args = ModelConfig(use_peft=False) + peft_config = get_peft_config(model_args) + assert peft_config is None + + def test_create_peft_config_use_peft_true(self): + """Test that when use_peft is True, the function returns a LoraConfig object.""" + # Provide non-default values to the model config for testing + peft_kwargs = { + "lora_r": 8, + "lora_alpha": 16, + "lora_dropout": 0.1, + "lora_task_type": "SEQ_CLS", + "use_rslora": True, + "lora_target_modules": ["up_proj", "down_proj"], + "lora_modules_to_save": ["up_proj"], + } + model_args = ModelConfig(use_peft=True, **peft_kwargs) + peft_config = get_peft_config(model_args) + assert isinstance(peft_config, LoraConfig) + for arg, value in peft_kwargs.items(): + # Test that lists of modules are converted to sets + if arg == "lora_target_modules": + value = set(value) + # Rename the argument to match the LoraConfig attribute name + if arg in ["lora_r", "lora_task_type", "lora_target_modules", "lora_modules_to_save"]: + arg = arg[len("lora_") :] if arg.startswith("lora_") else arg + + assert getattr(peft_config, arg) == value + + +class TestNanStd(TrlTestCase): + def test_nanstd_ignores_nans(self): + x = torch.tensor([1.0, 2.0, 3.0, float("nan")]) + result = nanstd(x) + torch.testing.assert_close(result, torch.tensor(1.0)) + + def test_nanstd_dim_and_keepdim(self): + x = torch.tensor([[1.0, float("nan")], [3.0, 5.0]]) + result = nanstd(x, dim=1, keepdim=True) + assert torch.isnan(result[0, 0]) + torch.testing.assert_close(result[1, 0], torch.tensor(1.4142135), rtol=1e-5, atol=1e-6) + + def test_nanstd_all_nan(self): + x = torch.tensor([float("nan"), float("nan")]) + result = nanstd(x) + assert torch.isnan(result) + + +class TestGenerateModelCard(TrlTestCase): + def test_full(self): + model_card = generate_model_card( + base_model="username/my_base_model", + model_name="my_model", + hub_model_id="username/my_hub_model", + dataset_name="username/my_dataset", + tags=["trl", "trainer-tag"], + wandb_url="https://wandb.ai/username/project_id/runs/abcd1234", + trackio_url="https://huggingface.co/spaces/username/space_id", + comet_url="https://www.comet.com/username/project_id/experiment_id", + trainer_name="My Trainer", + trainer_citation="@article{my_trainer, ...}", + paper_title="My Paper", + paper_id="1234.56789", + ) + card_text = str(model_card) + assert "[username/my_base_model](https://huggingface.co/username/my_base_model)" in card_text + assert "my_model" in card_text + assert 'pipeline("text-generation", model="username/my_hub_model", device="cuda")' in card_text + assert "datasets: username/my_dataset" in card_text + assert "](https://wandb.ai/username/project_id/runs/abcd1234)" in card_text + assert "](https://huggingface.co/spaces/username/space_id)" in card_text + assert "](https://www.comet.com/username/project_id/experiment_id" in card_text + assert "My Trainer" in card_text + assert "```bibtex\n@article{my_trainer, ...}\n```" in card_text + assert "[My Paper](https://huggingface.co/papers/1234.56789)" in card_text + + def test_val_none(self): + model_card = generate_model_card( + base_model=None, + model_name="my_model", + hub_model_id="username/my_hub_model", + dataset_name=None, + tags=[], + wandb_url=None, + trackio_url=None, + comet_url=None, + trainer_name="My Trainer", + trainer_citation=None, + paper_title=None, + paper_id=None, + ) + card_text = str(model_card) + assert "my_model" in card_text + assert 'pipeline("text-generation", model="username/my_hub_model", device="cuda")' in card_text + assert "My Trainer" in card_text + + +class TestFlushLeft(TrlTestCase): + def test_basic_case(self): + mask = torch.tensor([[0, 0, 1, 1, 1], [0, 1, 1, 0, 0]]) + tensor1 = torch.tensor([[0, 0, 2, 3, 4], [0, 5, 6, 0, 0]]) + tensor2 = torch.tensor([[0, 0, 7, 8, 9], [0, 10, 11, 0, 0]]) + new_mask, new_tensor1, new_tensor2 = flush_left(mask, tensor1, tensor2) + + expected_mask = torch.tensor([[1, 1, 1], [1, 1, 0]]) + expected_tensor1 = torch.tensor([[2, 3, 4], [5, 6, 0]]) + expected_tensor2 = torch.tensor([[7, 8, 9], [10, 11, 0]]) + + assert torch.equal(new_mask, expected_mask) + assert torch.equal(new_tensor1, expected_tensor1) + assert torch.equal(new_tensor2, expected_tensor2) + + def test_single_row(self): + mask = torch.tensor([[0, 0, 1, 1]]) + tensor1 = torch.tensor([[0, 0, 2, 3]]) + new_mask, new_tensor1 = flush_left(mask, tensor1) + + expected_mask = torch.tensor([[1, 1]]) + expected_tensor1 = torch.tensor([[2, 3]]) + + assert torch.equal(new_mask, expected_mask) + assert torch.equal(new_tensor1, expected_tensor1) + + def test_no_shift_needed(self): + mask = torch.tensor([[1, 1, 0, 0], [1, 0, 0, 0]]) + tensor1 = torch.tensor([[5, 6, 0, 0], [7, 0, 0, 0]]) + new_mask, new_tensor1 = flush_left(mask, tensor1) + + expected_mask = torch.tensor([[1, 1], [1, 0]]) + expected_tensor1 = torch.tensor([[5, 6], [7, 0]]) + + assert torch.equal(new_mask, expected_mask) + assert torch.equal(new_tensor1, expected_tensor1) + + def test_no_tensors(self): + mask = torch.tensor([[0, 0, 1, 1, 1], [0, 1, 1, 0, 0]]) + new_mask = flush_left(mask) + expected_mask = torch.tensor([[1, 1, 1], [1, 1, 0]]) + assert torch.equal(new_mask, expected_mask) + + +class TestRepeatRandomSampler(TrlTestCase): + def test_sampler(self): + dataset = ["a", "b", "c", "d", "e", "f", "g"] + sampler = RepeatSampler(dataset, mini_repeat_count=2) + # Should output something like [4, 4, 3, 3, 0, 0, 1, 1, 2, 2, 6, 6, 5, 5] + sampled = list(sampler) + # Check that the length is doubled + assert len(sampled) == 2 * len(dataset) + # Check that all indexes are present + assert set(sampled) == set(range(len(dataset))) + # Check that each element is repeated twice + assert all(sampled[i] == sampled[i + 1] for i in range(0, len(sampled), 2)) + + def test_sampler_no_shuffle(self): + dataset = ["a", "b", "c", "d", "e", "f", "g"] + sampler = RepeatSampler(dataset, mini_repeat_count=2, shuffle=False) + sampled = list(sampler) + expected = [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6] + assert sampled == expected + + def test_sampler_no_repeat(self): + dataset = ["a", "b", "c", "d", "e", "f", "g"] + sampler = RepeatSampler(dataset, mini_repeat_count=1) + # Should output something like [4, 3, 0, 1, 2, 6, 5] + sampled = list(sampler) + # Check that the length is the same + assert len(sampled) == len(dataset) + # Check that all indexes are present + assert set(sampled) == set(range(len(dataset))) + + def test_sampler_with_batch_size(self): + dataset = ["a", "b", "c", "d", "e", "f", "g", "h"] + sampler = RepeatSampler(dataset, mini_repeat_count=1, batch_size=2, repeat_count=2) + # Should output something like [4, 3, 4, 3, 0, 1, 0, 1, 2, 6, 2, 6, 5, 7, 5, 7] + sampled = list(sampler) + # Check that the length is doubled + assert len(sampled) == 2 * len(dataset) + # Check that all indexes are present + assert set(sampled) == set(range(len(dataset))) + # Check that each element is repeated as expected + assert all(sampled[i : i + 1] == sampled[i + 2 : i + 3] for i in range(0, len(sampled), 4)) + + def test_sampler_with_batch_size_and_drop(self): + dataset = ["a", "b", "c", "d", "e", "f", "g"] + sampler = RepeatSampler(dataset, mini_repeat_count=1, batch_size=2, repeat_count=2) + # Should output something like [4, 3, 4, 3, 0, 1, 0, 1, 2, 6, 2, 6] + sampled = list(sampler) + # Check that the length is doubled + assert len(sampled) == 2 * ( + len(dataset) - 1 + ) # one element is dropped, because it's not enough to form a batch + assert len(sampler) == len(sampled) # the length should be the same as the sampled length + # Check that the sampled indexes are a subset of the dataset indexes + assert set(sampled).issubset(set(range(len(dataset)))) + # Check that each element is repeated as expected + assert all(sampled[i : i + 1] == sampled[i + 2 : i + 3] for i in range(0, len(sampled), 4)) + + def test_sampler_with_mini_repeat_count_and_batch_size_1(self): + dataset = ["a", "b", "c", "d", "e", "f", "g"] + sampler = RepeatSampler(dataset, mini_repeat_count=2, batch_size=3, repeat_count=2) + # Should output something like [4, 4, 3, 3, 0, 0, 4, 4, 3, 3, 0, 0, + # 1, 1, 2, 2, 6, 6, 1, 1, 2, 2, 6, 6] + sampled = list(sampler) + # Check that the length is quadrupled + assert len(sampled) == 4 * (len(dataset) - 1) # 1 element is dropped, because it's not enough to form a batch + assert len(sampler) == len(sampled) # the length should be the same as the sampled length + # Check that the sampled indexes are a subset of the dataset indexes + assert set(sampled).issubset(set(range(len(dataset)))) + # Check that each element is repeated as expected + assert all(sampled[i] == sampled[i + 1] for i in range(0, len(sampled), 2)) + # Check that the batch is repeated as expected + assert sampled[0:6] == sampled[6:12] + assert sampled[12:18] == sampled[18:24] + + def test_sampler_with_mini_repeat_count_and_batch_size_2(self): + dataset = ["a", "b", "c", "d", "e", "f", "g"] + sampler = RepeatSampler(dataset, mini_repeat_count=3, batch_size=2, repeat_count=2) + # Should output something like [4, 4, 4, 3, 3, 3, 4, 4, 4, 3, 3, 3, + # 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, + # 2, 2, 2, 6, 6, 6, 2, 2, 2, 6, 6, 6] + sampled = list(sampler) + # Check that the length is sextupled + assert len(sampled) == 6 * (len(dataset) - 1) # 1 element is dropped, because it's not enough to form a batch + assert len(sampler) == len(sampled) # the length should be the same as the sampled length + # Check that the sampled indexes are a subset of the dataset indexes + assert set(sampled).issubset(set(range(len(dataset)))) + # Check that each element is repeated as expected + assert all(sampled[i] == sampled[i + 1] == sampled[i + 2] for i in range(0, len(sampled), 3)) + # Check that the batch is repeated as expected + assert sampled[0:6] == sampled[6:12] + assert sampled[12:18] == sampled[18:24] + assert sampled[24:30] == sampled[30:36] + + def test_sampler_with_mini_repeat_count_and_batch_size_3(self): + dataset = ["a", "b", "c", "d", "e", "f", "g"] + sampler = RepeatSampler(dataset, mini_repeat_count=2, batch_size=2, repeat_count=3) + # Should output something like [4, 4, 3, 3, 4, 4, 3, 3, 4, 4, 3, 3, + # 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, + # 2, 2, 6, 6, 2, 2, 6, 6, 2, 2, 6, 6] + sampled = list(sampler) + # Check that the length is sextupled + assert len(sampled) == 6 * (len(dataset) - 1) # 1 element is dropped, because it's not enough to form a batch + # Check that the sampled indexes are a subset of the dataset indexes + assert set(sampled).issubset(set(range(len(dataset)))) + # Check that each element is repeated as expected + assert all(sampled[i] == sampled[i + 1] for i in range(0, len(sampled), 2)) + # Check that the batch is repeated as expected + assert sampled[0:4] == sampled[4:8] == sampled[8:12] + assert sampled[12:16] == sampled[16:20] == sampled[20:24] + assert sampled[24:28] == sampled[28:32] == sampled[32:36] + + +class TestEntropyFromLogits(TrlTestCase): + @pytest.mark.parametrize("shape", [(768,), (32, 768), (8, 16, 768), (2, 4, 8, 768)]) + @pytest.mark.parametrize("chunk_size", [1, 16]) + @pytest.mark.parametrize("dtype", [torch.float64, torch.float32, torch.float16, torch.bfloat16]) + def test_entropy_from_logits_2_dims(self, dtype, chunk_size, shape): + logits = torch.randn(*shape, dtype=dtype) + if dtype in (torch.float64, torch.float32): + p = logits.softmax(-1) + entropy = -torch.sum(p * p.log(), dim=-1) + else: + logps = logits.log_softmax(dim=-1) + entropy = -(torch.exp(logps) * logps).sum(-1) + predicted_entropy = entropy_from_logits(logits, chunk_size=chunk_size) + torch.testing.assert_close(predicted_entropy, entropy, rtol=1e-5, atol=1e-5) + + +@require_rich +class TestPrintPromptCompletionsSample(TrlTestCase): + @patch("sys.stdout", new_callable=StringIO) + def test_print_output(self, mock_stdout): + prompts = ["The sky is", "The sun is"] + completions = [" blue.", " in the sky."] + rewards = {"Correctness": [0.123, 0.456], "Format": [0.789, 0.101]} + advantages = [0.987, 0.654] + step = 42 + + print_prompt_completions_sample(prompts, completions, rewards, advantages, step) + + output = mock_stdout.getvalue() + + # docstyle-ignore + expected_output = textwrap.dedent("""\ + ╭──────────────────────────── Step 42 ─────────────────────────────╮ + │ ┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━┓ │ + │ ┃ Prompt ┃ Completion ┃ Correctness ┃ Format ┃ Advantage ┃ │ + │ ┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━┩ │ + │ │ The sky is │ blue. │ 0.12 │ 0.79 │ 0.99 │ │ + │ ├────────────┼──────────────┼─────────────┼────────┼───────────┤ │ + │ │ The sun is │ in the sky. │ 0.46 │ 0.10 │ 0.65 │ │ + │ └────────────┴──────────────┴─────────────┴────────┴───────────┘ │ + ╰──────────────────────────────────────────────────────────────────╯ + """) + + assert output == expected_output + + @patch("sys.stdout", new_callable=StringIO) + def test_extra_columns(self, mock_stdout): + prompts = ["The sky is", "The sun is"] + completions = [" blue.", " in the sky."] + rewards = {"Correctness": [0.123, 0.456], "Format": [0.789, 0.101]} + advantages = [0.987, 0.654] + extra = {"source": ["dataset_A", "dataset_B"]} + step = 42 + + print_prompt_completions_sample(prompts, completions, rewards, advantages, step, extra=extra) + + output = mock_stdout.getvalue() + + # docstyle-ignore + expected_output = textwrap.dedent("""\ + ╭────────────────────────────────── Step 42 ───────────────────────────────────╮ + │ ┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┓ │ + │ ┃ Prompt ┃ Completion ┃ Correctness ┃ Format ┃ Advantage ┃ source ┃ │ + │ ┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━┩ │ + │ │ The sky is │ blue. │ 0.12 │ 0.79 │ 0.99 │ dataset_A │ │ + │ ├────────────┼──────────────┼─────────────┼────────┼───────────┼───────────┤ │ + │ │ The sun is │ in the sky. │ 0.46 │ 0.10 │ 0.65 │ dataset_B │ │ + │ └────────────┴──────────────┴─────────────┴────────┴───────────┴───────────┘ │ + ╰──────────────────────────────────────────────────────────────────────────────╯ + """) + + assert output == expected_output + + @patch("sys.stdout", new_callable=StringIO) + def test_num_samples(self, mock_stdout): + prompts = ["A", "B"] + completions = ["1", "2"] + rewards = {"Score": [0.1, 0.2]} + advantages = [0.3, 0.4] + step = 10 + + print_prompt_completions_sample(prompts, completions, rewards, advantages, step, num_samples=1) + output = mock_stdout.getvalue() + + # docstyle-ignore + possible_outputs = [ + textwrap.dedent("""\ + ╭────────────────── Step 10 ──────────────────╮ + │ ┏━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━┓ │ + │ ┃ Prompt ┃ Completion ┃ Score ┃ Advantage ┃ │ + │ ┡━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━┩ │ + │ │ A │ 1 │ 0.10 │ 0.30 │ │ + │ └────────┴────────────┴───────┴───────────┘ │ + ╰─────────────────────────────────────────────╯ + """), + # docstyle-ignore + textwrap.dedent("""\ + ╭────────────────── Step 10 ──────────────────╮ + │ ┏━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━┓ │ + │ ┃ Prompt ┃ Completion ┃ Score ┃ Advantage ┃ │ + │ ┡━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━┩ │ + │ │ B │ 2 │ 0.20 │ 0.40 │ │ + │ └────────┴────────────┴───────┴───────────┘ │ + ╰─────────────────────────────────────────────╯ + """), + ] + assert output in possible_outputs + + @patch("sys.stdout", new_callable=StringIO) + def test_print_messages(self, mock_stdout): + prompts = [ + [ + {"role": "system", "content": "You are an helpful assistant."}, + {"role": "user", "content": "What color is the sky?"}, + ], + [ + {"role": "system", "content": "You are an helpful assistant."}, + {"role": "user", "content": "Where is the sun?"}, + ], + ] + completions = [ + [{"role": "assistant", "content": "It is blue."}], + [{"role": "assistant", "content": "In the sky."}], + ] + rewards = {"Correctness": [0.123, 0.456], "Format": [0.789, 0.101]} + advantages = [0.987, 0.654] + step = 42 + + print_prompt_completions_sample(prompts, completions, rewards, advantages, step) + + output = mock_stdout.getvalue() + + # docstyle-ignore + expected_output = textwrap.dedent("""\ + ╭────────────────────────────────── Step 42 ───────────────────────────────────╮ + │ ┏━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━┓ │ + │ ┃ Prompt ┃ Completion ┃ Correctness ┃ Format ┃ Advantage ┃ │ + │ ┡━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━┩ │ + │ │ SYSTEM │ ASSISTANT │ 0.12 │ 0.79 │ 0.99 │ │ + │ │ You are an helpful │ It is blue. │ │ │ │ │ + │ │ assistant. │ │ │ │ │ │ + │ │ │ │ │ │ │ │ + │ │ USER │ │ │ │ │ │ + │ │ What color is the sky? │ │ │ │ │ │ + │ ├─────────────────────────┼─────────────┼─────────────┼────────┼───────────┤ │ + │ │ SYSTEM │ ASSISTANT │ 0.46 │ 0.10 │ 0.65 │ │ + │ │ You are an helpful │ In the sky. │ │ │ │ │ + │ │ assistant. │ │ │ │ │ │ + │ │ │ │ │ │ │ │ + │ │ USER │ │ │ │ │ │ + │ │ Where is the sun? │ │ │ │ │ │ + │ └─────────────────────────┴─────────────┴─────────────┴────────┴───────────┘ │ + ╰──────────────────────────────────────────────────────────────────────────────╯ + """) + + assert output == expected_output + + @patch("sys.stdout", new_callable=StringIO) + def test_print_messages_with_tools(self, mock_stdout): + prompts = [ + [{"role": "user", "content": "What is the temperature in Paris?"}], + [{"role": "user", "content": "What is the weather in London?"}], + ] + completions = [ + [{"role": "tool", "name": "get_temperature", "args": {"location": "Paris"}}], + [{"role": "tool", "name": "get_weather", "args": {"location": "London"}}], + ] + rewards = {"Correctness": [0.123, 0.456], "Format": [0.789, 0.101]} + advantages = [0.987, 0.654] + step = 42 + + print_prompt_completions_sample(prompts, completions, rewards, advantages, step) + + output = mock_stdout.getvalue() + + # docstyle-ignore + expected_output = textwrap.dedent("""\ + ╭────────────────────────────────── Step 42 ───────────────────────────────────╮ + │ ┏━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━┓ │ + │ ┃ Prompt ┃ Completion ┃ Correctness ┃ Format ┃ Advantage ┃ │ + │ ┡━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━┩ │ + │ │ USER │ TOOL │ 0.12 │ 0.79 │ 0.99 │ │ + │ │ What is the │ get_temperature(… │ │ │ │ │ + │ │ temperature in │ 'Paris'}) │ │ │ │ │ + │ │ Paris? │ │ │ │ │ │ + │ ├───────────────────┼───────────────────┼─────────────┼────────┼───────────┤ │ + │ │ USER │ TOOL │ 0.46 │ 0.10 │ 0.65 │ │ + │ │ What is the │ get_weather({'lo… │ │ │ │ │ + │ │ weather in │ 'London'}) │ │ │ │ │ + │ │ London? │ │ │ │ │ │ + │ └───────────────────┴───────────────────┴─────────────┴────────┴───────────┘ │ + ╰──────────────────────────────────────────────────────────────────────────────╯ + """) + + assert output == expected_output + + @patch("sys.stdout", new_callable=StringIO) + def test_print_messages_with_reasoning_content(self, mock_stdout): + prompts = [[{"role": "user", "content": "What color is the sky?"}]] + completions = [[{"role": "assistant", "reasoning_content": "I think it is blue.", "content": "It is blue."}]] + rewards = {"Score": [0.5]} + advantages = [0.9] + step = 1 + + print_prompt_completions_sample(prompts, completions, rewards, advantages, step) + + output = mock_stdout.getvalue() + + # docstyle-ignore + expected_output = textwrap.dedent("""\ + ╭─────────────────────────────── Step 1 ───────────────────────────────╮ + │ ┏━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━┓ │ + │ ┃ Prompt ┃ Completion ┃ Score ┃ Advantage ┃ │ + │ ┡━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━┩ │ + │ │ USER │ ASSISTANT │ 0.50 │ 0.90 │ │ + │ │ What color is the sky? │ I think it is blue. │ │ │ │ + │ │ │ It is blue. │ │ │ │ + │ └────────────────────────┴─────────────────────┴───────┴───────────┘ │ + ╰──────────────────────────────────────────────────────────────────────╯ + """) + + assert output == expected_output + + @patch("sys.stdout", new_callable=StringIO) + def test_print_messages_with_thinking(self, mock_stdout): + prompts = [[{"role": "user", "content": "What color is the sky?"}]] + completions = [[{"role": "assistant", "thinking": "I think it is blue.", "content": "It is blue."}]] + rewards = {"Score": [0.5]} + advantages = [0.9] + step = 1 + + print_prompt_completions_sample(prompts, completions, rewards, advantages, step) + + output = mock_stdout.getvalue() + + # docstyle-ignore + expected_output = textwrap.dedent("""\ + ╭─────────────────────────────── Step 1 ───────────────────────────────╮ + │ ┏━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━┓ │ + │ ┃ Prompt ┃ Completion ┃ Score ┃ Advantage ┃ │ + │ ┡━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━┩ │ + │ │ USER │ ASSISTANT │ 0.50 │ 0.90 │ │ + │ │ What color is the sky? │ I think it is blue. │ │ │ │ + │ │ │ It is blue. │ │ │ │ + │ └────────────────────────┴─────────────────────┴───────┴───────────┘ │ + ╰──────────────────────────────────────────────────────────────────────╯ + """) + + assert output == expected_output + + +class TestSelectiveLogSoftmax(TrlTestCase): + @pytest.mark.parametrize("dtype", [torch.float64, torch.float32, torch.float16, torch.bfloat16]) + def test_selective_log_softmax(self, dtype): + """Test selective_log_softmax with logits of different dtypes""" + vocab_size = 1024 + batch_size = 4 + seq_len = 32 + + input_ids = torch.randint(low=0, high=vocab_size, size=(batch_size, seq_len)) + logits = torch.randn(batch_size, seq_len, vocab_size, dtype=dtype) + + expected_output = torch.gather(logits.log_softmax(-1), dim=-1, index=input_ids.unsqueeze(-1)).squeeze(-1) + actual_output = selective_log_softmax(logits, input_ids) + + if dtype in [torch.float16, torch.bfloat16]: + # half-precision dtypes fall back to an exact method + assert torch.equal(actual_output, expected_output) + else: + torch.testing.assert_close(actual_output, expected_output, rtol=1e-5, atol=1e-5) + + @pytest.mark.parametrize("dtype", [torch.float64, torch.float32, torch.float16, torch.bfloat16]) + @pytest.mark.parametrize("k", [1, 8]) + def test_selective_log_softmax_multi_index(self, dtype, k): + """Test selective_log_softmax with logits of different dtypes and index widths""" + vocab_size = 1024 + batch_size = 4 + seq_len = 32 + + index = torch.randint(low=0, high=vocab_size, size=(batch_size, seq_len, k)) + logits = torch.randn(batch_size, seq_len, vocab_size, dtype=dtype) + + expected_output = torch.gather(logits.log_softmax(-1), dim=-1, index=index) + actual_output = selective_log_softmax(logits, index) + + assert actual_output.shape == (batch_size, seq_len, k) + if dtype in [torch.float16, torch.bfloat16]: + # half-precision dtypes fall back to an exact method + assert torch.equal(actual_output, expected_output) + else: + torch.testing.assert_close(actual_output, expected_output, rtol=1e-5, atol=1e-5) + + +class TestShuffleSequenceDict(TrlTestCase): + def test_shuffle_preserves_shape(self): + x = torch.arange(6).reshape(3, 2) + y = torch.arange(3).reshape(3, 1) + tensor_dict = {"x": x.clone(), "y": y.clone()} + + shuffled = shuffle_sequence_dict(tensor_dict) + + assert shuffled["x"].shape == x.shape + assert shuffled["y"].shape == y.shape + + def test_shuffle_consistent_across_tensors(self): + # Use known patterns to check alignment + x = torch.tensor([[10, 11], [20, 21], [30, 31]]) + y = torch.tensor([[1], [2], [3]]) + tensor_dict = {"x": x.clone(), "y": y.clone()} + + shuffled = shuffle_sequence_dict(tensor_dict) + + # Build a reverse map from shuffled x rows to y values + for i in range(3): + x_row = shuffled["x"][i] + y_val = shuffled["y"][i].item() + + if torch.equal(x_row, torch.tensor([10, 11])): + assert y_val == 1 + elif torch.equal(x_row, torch.tensor([20, 21])): + assert y_val == 2 + elif torch.equal(x_row, torch.tensor([30, 31])): + assert y_val == 3 + else: + pytest.fail("Unexpected x row in shuffled output.") + + def test_none_tensor_remains_none(self): + x = torch.arange(6).reshape(3, 2) + tensor_dict = {"x": x.clone(), "y": None} + + shuffled = shuffle_sequence_dict(tensor_dict) + + assert shuffled["y"] is None + assert shuffled["x"].shape == x.shape + + def test_shuffle_with_list(self): + x = torch.tensor([[10, 11], [20, 21], [30, 31]]) + y = ["a", "b", "c"] + + sequence_dict = {"x": x.clone(), "y": y} + + shuffled = shuffle_sequence_dict(sequence_dict) + + # Check that the list y is shuffled in the same order as x + for i in range(3): + x_row = shuffled["x"][i] + y_val = shuffled["y"][i] + + if torch.equal(x_row, torch.tensor([10, 11])): + assert y_val == "a" + elif torch.equal(x_row, torch.tensor([20, 21])): + assert y_val == "b" + elif torch.equal(x_row, torch.tensor([30, 31])): + assert y_val == "c" + else: + pytest.fail("Unexpected x row in shuffled output.") + + +class TestSplitTensorDict(TrlTestCase): + def test_split_equal_chunks(self): + x = torch.arange(12).reshape(6, 2) + y = torch.arange(6).reshape(6, 1) + tensor_dict = {"x": x, "y": y} + + result = split_tensor_dict(tensor_dict, 3) + + expected_x_chunks = torch.chunk(x, 3, dim=0) + expected_y_chunks = torch.chunk(y, 3, dim=0) + assert len(result) == 3 + for i in range(3): + assert torch.equal(result[i]["x"], expected_x_chunks[i]) + assert torch.equal(result[i]["y"], expected_y_chunks[i]) + + def test_with_none_tensor(self): + x = torch.arange(12).reshape(6, 2) + tensor_dict = {"x": x, "y": None} + + result = split_tensor_dict(tensor_dict, 2) + + expected_x_chunks = torch.chunk(x, 2, dim=0) + assert len(result) == 2 + for i in range(2): + assert torch.equal(result[i]["x"], expected_x_chunks[i]) + assert result[i]["y"] is None + + def test_with_scalar(self): + x = torch.arange(12).reshape(6, 2) + tensor_dict = {"x": x, "y": torch.tensor(1)} + + result = split_tensor_dict(tensor_dict, 2) + + expected_x_chunks = torch.chunk(x, 2, dim=0) + assert len(result) == 2 + for i in range(2): + assert torch.equal(result[i]["x"], expected_x_chunks[i]) + assert torch.equal(result[i]["y"], torch.tensor(1)) + + +class TestSplitPixelValuesByGrid(TrlTestCase): + def test_split_correctly_0(self): + batch = { + "image_grid_thw": torch.tensor([[1, 2, 2], [1, 2, 2]]), + "num_images": [1, 1], + "pixel_values": torch.arange(8 * 3).reshape(8, 3), # Shape: [8, 3] + } + result = split_pixel_values_by_grid(batch) + assert isinstance(result["pixel_values"], list) + assert len(result["pixel_values"]) == 2 + assert torch.equal(result["pixel_values"][0], batch["pixel_values"][:4]) + assert torch.equal(result["pixel_values"][1], batch["pixel_values"][4:]) + assert isinstance(result["image_grid_thw"], list) + assert len(result["image_grid_thw"]) == 2 + assert torch.equal(result["image_grid_thw"][0], torch.tensor([[1, 2, 2]])) + assert torch.equal(result["image_grid_thw"][1], torch.tensor([[1, 2, 2]])) + + def test_split_correctly_1(self): + batch = { + "image_grid_thw": torch.tensor([[1, 2, 2], [1, 2, 4]]), + "num_images": [1, 1], + "pixel_values": torch.arange(12 * 3).reshape(12, 3), # Shape: [12, 3] + } + result = split_pixel_values_by_grid(batch) + assert isinstance(result["pixel_values"], list) + assert len(result["pixel_values"]) == 2 + assert torch.equal(result["pixel_values"][0], batch["pixel_values"][:4]) + assert torch.equal(result["pixel_values"][1], batch["pixel_values"][4:12]) + assert isinstance(result["image_grid_thw"], list) + assert len(result["image_grid_thw"]) == 2 + assert torch.equal(result["image_grid_thw"][0], torch.tensor([[1, 2, 2]])) + assert torch.equal(result["image_grid_thw"][1], torch.tensor([[1, 2, 4]])) + + def test_missing_keys(self): + batch = {"pixel_values": torch.tensor([1.0])} + result = split_pixel_values_by_grid(batch) + assert result == batch + + def test_mismatched_length(self): + batch = { + "image_grid_thw": torch.tensor([[1, 1, 2], [1, 2, 1]]), # Total = 8 + "num_images": [1, 1], + "pixel_values": torch.randn(3, 5), # Only 3 rows + } + with pytest.raises(ValueError): + split_pixel_values_by_grid(batch) + + def test_multi_images(self): + batch = { + "image_grid_thw": torch.tensor([[1, 1, 2], [1, 2, 2], [1, 2, 1]]), # Total = 8 + "num_images": [1, 2], + "pixel_values": torch.arange(8 * 3).reshape(8, 3), # Shape: [8, 3] + } + result = split_pixel_values_by_grid(batch) + assert isinstance(result["pixel_values"], list) + assert len(result["pixel_values"]) == 2 + assert torch.equal(result["pixel_values"][0], batch["pixel_values"][:2]) + assert torch.equal(result["pixel_values"][1], batch["pixel_values"][2:]) + assert isinstance(result["image_grid_thw"], list) + assert len(result["image_grid_thw"]) == 2 + assert torch.equal(result["image_grid_thw"][0], torch.tensor([[1, 1, 2]])) + assert torch.equal(result["image_grid_thw"][1], torch.tensor([[1, 2, 2], [1, 2, 1]])) + + def test_split_by_image_position_ids(self): + # Gemma-style: no image_grid_thw, split by num_images using image_position_ids + batch = { + "num_images": [1, 2], + "pixel_values": torch.arange(3 * 4).reshape(3, 4), + "image_position_ids": torch.tensor([[0, 1], [2, 3], [4, 5]]), + } + result = split_pixel_values_by_grid(batch) + assert isinstance(result["pixel_values"], list) + assert len(result["pixel_values"]) == 2 + assert torch.equal(result["pixel_values"][0], batch["pixel_values"][:1]) + assert torch.equal(result["pixel_values"][1], batch["pixel_values"][1:]) + assert isinstance(result["image_position_ids"], list) + assert len(result["image_position_ids"]) == 2 + assert torch.equal(result["image_position_ids"][0], batch["image_position_ids"][:1]) + assert torch.equal(result["image_position_ids"][1], batch["image_position_ids"][1:]) + + +class TestUnsplitPixelValuesByGrid(TrlTestCase): + def test_unsplit_correctly(self): + pixel_values = [torch.randn(4, 5), torch.randn(2, 5)] + pixel_values_merged = torch.cat(pixel_values, dim=0) + image_grid_thw = [torch.tensor([[1, 2, 2]]), torch.tensor([[1, 2, 1]])] + image_grid_thw_merged = torch.cat(image_grid_thw, dim=0) + batch = {"pixel_values": pixel_values, "image_grid_thw": image_grid_thw, "other_key": torch.tensor([1])} + result = unsplit_pixel_values_by_grid(batch) + assert isinstance(result["pixel_values"], torch.Tensor) + torch.testing.assert_close(result["pixel_values"], pixel_values_merged) + assert isinstance(result["image_grid_thw"], torch.Tensor) + assert torch.equal(result["image_grid_thw"], image_grid_thw_merged) + assert "other_key" in result + + def test_unsplit_image_position_ids(self): + image_position_ids = [torch.tensor([[0, 1]]), torch.tensor([[2, 3], [4, 5]])] + image_position_ids_merged = torch.cat(image_position_ids, dim=0) + pixel_values = [torch.randn(1, 4), torch.randn(2, 4)] + batch = {"pixel_values": pixel_values, "image_position_ids": image_position_ids} + result = unsplit_pixel_values_by_grid(batch) + assert isinstance(result["image_position_ids"], torch.Tensor) + assert torch.equal(result["image_position_ids"], image_position_ids_merged) + + def test_no_op_if_not_list(self): + original = torch.randn(5, 3) + batch = {"pixel_values": original} + result = unsplit_pixel_values_by_grid(batch) + assert torch.equal(result["pixel_values"], original) + + +class TestChunkedLogProbFunction: + N, H, V = 64, 32, 128 + CHUNK_SIZE = 32 + + def _reference_logprobs_and_entropy(self, hidden, weight, labels, temperature): + logits = (hidden @ weight.t()).to(torch.float32) / temperature # [N, V] + log_p = F.log_softmax(logits, dim=-1) + logprobs = log_p.gather(-1, labels.unsqueeze(-1)).squeeze(-1) + p = torch.softmax(logits, dim=-1) + entropy = -(p * log_p).sum(dim=-1) + return logprobs, entropy + + @pytest.mark.parametrize("temperature", [1.0, 0.7]) + def test_forward(self, temperature): + torch.manual_seed(42) + hidden = torch.randn(self.N, self.H) + weight = torch.randn(self.V, self.H) + labels = torch.randint(0, self.V, (self.N,)) + + logprobs_chunked, entropy_chunked = _ChunkedLogProbFunction.apply( + hidden, weight, labels, temperature, self.CHUNK_SIZE + ) + logprobs_ref, entropy_ref = self._reference_logprobs_and_entropy(hidden, weight, labels, temperature) + + torch.testing.assert_close(logprobs_chunked, logprobs_ref, atol=1e-5, rtol=1e-5) + torch.testing.assert_close(entropy_chunked, entropy_ref, atol=1e-5, rtol=1e-5) + + @pytest.mark.parametrize("temperature", [1.0, 0.7]) + def test_backward(self, temperature): + torch.manual_seed(42) + hidden = torch.randn(self.N, self.H, requires_grad=True) + weight = torch.randn(self.V, self.H, requires_grad=True) + labels = torch.randint(0, self.V, (self.N,)) + + # Chunked backward + logprobs_chunked, _ = _ChunkedLogProbFunction.apply(hidden, weight, labels, temperature, self.CHUNK_SIZE) + logprobs_chunked.sum().backward() + grad_hidden_chunked = hidden.grad.clone() + grad_weight_chunked = weight.grad.clone() + + hidden.grad = None + weight.grad = None + + # Reference backward + logprobs_ref, _ = self._reference_logprobs_and_entropy(hidden, weight, labels, temperature) + logprobs_ref.sum().backward() + + torch.testing.assert_close(grad_hidden_chunked, hidden.grad, atol=1e-5, rtol=1e-5) + torch.testing.assert_close(grad_weight_chunked, weight.grad, atol=1e-5, rtol=1e-5) + + @pytest.mark.parametrize("temperature", [1.0, 0.7]) + def test_backward_bfloat16(self, temperature): + torch.manual_seed(42) + hidden = torch.randn(self.N, self.H, dtype=torch.bfloat16, requires_grad=True) + weight = torch.randn(self.V, self.H, dtype=torch.bfloat16, requires_grad=True) + labels = torch.randint(0, self.V, (self.N,)) + + # Chunked backward + logprobs_chunked, _ = _ChunkedLogProbFunction.apply(hidden, weight, labels, temperature, self.CHUNK_SIZE) + logprobs_chunked.sum().backward() + grad_hidden_chunked = hidden.grad.clone() + grad_weight_chunked = weight.grad.clone() + + hidden.grad = None + weight.grad = None + + # Reference backward + logprobs_ref, _ = self._reference_logprobs_and_entropy(hidden, weight, labels, temperature) + logprobs_ref.sum().backward() + + torch.testing.assert_close(grad_hidden_chunked, hidden.grad, atol=1e-2, rtol=1e-2) + torch.testing.assert_close(grad_weight_chunked, weight.grad, atol=1e-2, rtol=1e-2) + + +class _FakeTransformerModel(nn.Module): + """Minimal stand-in for a transformer body: returns random hidden states of the right shape.""" + + def __init__(self, hidden_size): + super().__init__() + self.hidden_size = hidden_size + self._hidden = None + + def forward(self, input_ids, attention_mask=None, use_cache=False, **kwargs): + b, s = input_ids.shape + if self._hidden is None or self._hidden.shape[:2] != (b, s): + torch.manual_seed(123) + self._hidden = torch.randn(b, s, self.hidden_size, requires_grad=True) + return type("Out", (), {"last_hidden_state": self._hidden})() + + +class _FakeCausalLM(nn.Module): + """Minimal CausalLM with .model and .lm_head, enough for patch_chunked_lm_head.""" + + def __init__(self, hidden_size, vocab_size): + super().__init__() + self.config = type("Config", (), {})() + self.model = _FakeTransformerModel(hidden_size) + self.lm_head = nn.Linear(hidden_size, vocab_size, bias=False) + + def forward(self, input_ids, attention_mask=None, labels=None, **kwargs): + raise NotImplementedError("should be monkey-patched") + + +_CHUNKED_LM_HEAD_MODEL_IDS = [ + "trl-internal-testing/tiny-CohereForCausalLM", + "trl-internal-testing/tiny-Cohere2ForCausalLM", + pytest.param( + "trl-internal-testing/tiny-DeepseekV3ForCausalLM", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="DeepseekV3 SDPA attention is broken in transformers < 5.0.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-DeepseekV3ForCausalLM-0528", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.0.0"), + reason="DeepseekV3 SDPA attention is broken in transformers < 5.0.0", + ), + ), + "trl-internal-testing/tiny-Gemma2ForCausalLM", + "trl-internal-testing/tiny-GemmaForCausalLM", + "trl-internal-testing/tiny-Glm4MoeForCausalLM", + "trl-internal-testing/tiny-GptOssForCausalLM", + "trl-internal-testing/tiny-LlamaForCausalLM-3.1", + "trl-internal-testing/tiny-LlamaForCausalLM-3.2", + "trl-internal-testing/tiny-LlamaForCausalLM-3", + "trl-internal-testing/tiny-MistralForCausalLM-0.1", + "trl-internal-testing/tiny-MistralForCausalLM-0.2", + pytest.param( + "trl-internal-testing/tiny-NemotronHForCausalLM-nano", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("5.3.0"), + reason="Nemotron 3 was introduced in transformers>=5.3.0", + ), + ), + pytest.param( + "trl-internal-testing/tiny-Olmo3ForCausalLM", + marks=pytest.mark.skipif( + Version(transformers.__version__) < Version("4.57.0"), + reason="Olmo 3 was introduced in transformers>=4.57.0", + ), + ), + "trl-internal-testing/tiny-Phi3ForCausalLM-3", + "trl-internal-testing/tiny-Phi3ForCausalLM-3.5", + "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5", + "trl-internal-testing/tiny-Qwen3ForCausalLM", + "trl-internal-testing/tiny-Qwen3ForCausalLM-Instruct-2507", +] + + +@require_torch_accelerator +class TestPatchChunkedLMHead: + B, S = 4, 16 # batch size, sequence length (including prompt + completion) + H, V = 32, 128 + CHUNK_SIZE = 32 + + def _build_model_and_inputs(self, temperature=1.0): + torch.manual_seed(42) + model = _FakeCausalLM(self.H, self.V) + patch_chunked_lm_head(model, self.CHUNK_SIZE, temperature) + + input_ids = torch.randint(0, self.V, (self.B, self.S)) + attention_mask = torch.ones(self.B, self.S, dtype=torch.long) + # First half of each sequence is prompt (0), second half is completion (1) + completion_mask = torch.zeros(self.B, self.S, dtype=torch.float32) + completion_mask[:, self.S // 2 :] = 1.0 + return model, input_ids, attention_mask, completion_mask + + @pytest.mark.parametrize("temperature", [1.0, 0.7]) + def test_dummy_model_chunked_forward_with_completion_mask(self, temperature): + """Masked forward matches unmasked forward at completion positions and is zero at prompt positions.""" + model, input_ids, attention_mask, completion_mask = self._build_model_and_inputs(temperature) + + # Run WITHOUT completion_mask (baseline — computes all positions) + out_full = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids) + + # Reset hidden state cache so both runs use the same hidden states + model.model._hidden = None + + # Run WITH completion_mask + out_masked = model( + input_ids=input_ids, attention_mask=attention_mask, labels=input_ids, completion_mask=completion_mask + ) + + # shifted completion_mask (matching the shift in _chunked_forward) + shifted_mask = completion_mask[:, 1:].bool() + + # At completion positions, values should match + torch.testing.assert_close( + out_masked["log_probs"][shifted_mask], + out_full["log_probs"][shifted_mask], + atol=1e-5, + rtol=1e-5, + ) + torch.testing.assert_close( + out_masked["entropy"][shifted_mask], + out_full["entropy"][shifted_mask], + atol=1e-5, + rtol=1e-5, + ) + + # At prompt positions, values should be zero + prompt_mask = ~shifted_mask + assert (out_masked["log_probs"][prompt_mask] == 0).all() + assert (out_masked["entropy"][prompt_mask] == 0).all() + + @pytest.mark.parametrize("temperature", [1.0, 0.7]) + def test_dummy_model_chunked_forward_completion_mask_backward(self, temperature): + model, input_ids, attention_mask, completion_mask = self._build_model_and_inputs(temperature) + + # Full forward + backward (mask applied after, as the trainer does) + out_full = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids) + shifted_mask = completion_mask[:, 1:] + loss_full = (out_full["log_probs"] * shifted_mask).sum() + loss_full.backward() + grad_weight_full = model.lm_head.weight.grad.clone() + + model.lm_head.weight.grad = None + model.model._hidden = None + + # Masked forward + backward + out_masked = model( + input_ids=input_ids, attention_mask=attention_mask, labels=input_ids, completion_mask=completion_mask + ) + loss_masked = (out_masked["log_probs"] * shifted_mask).sum() + loss_masked.backward() + grad_weight_masked = model.lm_head.weight.grad.clone() + + torch.testing.assert_close(grad_weight_masked, grad_weight_full, atol=1e-5, rtol=1e-5) + + @pytest.mark.parametrize("model_id", _CHUNKED_LM_HEAD_MODEL_IDS) + @pytest.mark.parametrize("temperature", [1.0, 0.7]) + def test_forward(self, model_id, temperature): + model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16).to(torch_device) + model.eval() + + B, S, chunk_size = 2, 8, 32 + torch.manual_seed(42) + input_ids = torch.randint(0, model.config.vocab_size, (B, S), device=torch_device) + labels = input_ids.clone() + + # Reference: standard forward → shifted logits → logprobs & entropy + with torch.no_grad(): + ref_logits = model(input_ids=input_ids).logits[:, :-1, :].float() / temperature + shifted_labels = labels[:, 1:] + ref_log_p = F.log_softmax(ref_logits, dim=-1) + ref_logprobs = ref_log_p.gather(-1, shifted_labels.unsqueeze(-1)).squeeze(-1) + ref_p = ref_logits.softmax(dim=-1) + ref_entropy = -(ref_p * ref_log_p).sum(dim=-1) + + # Chunked forward + patch_chunked_lm_head(model, chunk_size, temperature) + with torch.no_grad(): + out = model(input_ids=input_ids, labels=labels) + + torch.testing.assert_close(out["log_probs"], ref_logprobs, atol=5e-3, rtol=5e-3) + torch.testing.assert_close(out["entropy"], ref_entropy, atol=5e-3, rtol=5e-3) + + @pytest.mark.parametrize("model_id", _CHUNKED_LM_HEAD_MODEL_IDS) + @pytest.mark.parametrize("temperature", [1.0, 0.7]) + def test_backward(self, model_id, temperature): + model_ref = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16).to(torch_device) + model_chunked = copy.deepcopy(model_ref) + + B, S, chunk_size = 2, 8, 32 + torch.manual_seed(42) + input_ids = torch.randint(0, model_ref.config.vocab_size, (B, S), device=torch_device) + labels = input_ids.clone() + shifted_labels = labels[:, 1:] + + # Reference backward: standard logits → logprobs → backward + ref_logits = model_ref(input_ids=input_ids).logits[:, :-1, :].float() / temperature + ref_log_p = F.log_softmax(ref_logits, dim=-1) + ref_logprobs = ref_log_p.gather(-1, shifted_labels.unsqueeze(-1)).squeeze(-1) + ref_logprobs.sum().backward() + ref_grad = model_ref.lm_head.weight.grad.clone() + + # Chunked backward + patch_chunked_lm_head(model_chunked, chunk_size, temperature) + out = model_chunked(input_ids=input_ids, labels=labels) + out["log_probs"].sum().backward() + chunked_grad = model_chunked.lm_head.weight.grad.clone() + + torch.testing.assert_close(chunked_grad, ref_grad, atol=5e-2, rtol=5e-2) + + +class TestComputeFlopsPerToken(TrlTestCase): + DENSE_MODEL_ID = "trl-internal-testing/tiny-Qwen3ForCausalLM" + MOE_MODEL_ID = "trl-internal-testing/tiny-Qwen3MoeForCausalLM" + + def test_seq_scaling_linear(self): + # Attention-score FLOPs per token scale linearly with seq_len; everything else + # is seq-len-independent. Doubling seq_len should double the seq-dependent delta, + # which differences cancel out from. `F(32k) - F(16k) == 2 * (F(16k) - F(8k))`. + cfg = AutoConfig.from_pretrained(self.DENSE_MODEL_ID) + f_8k = compute_flops_per_token(cfg, 8192) + f_16k = compute_flops_per_token(cfg, 16384) + f_32k = compute_flops_per_token(cfg, 32768) + assert f_32k - f_16k == 2 * (f_16k - f_8k) + + def test_tied_vs_untied_lm_head(self): + # Untied lm_head adds `2 * V * h` forward FLOPs, ×3 for fwd+bwd. + cfg = AutoConfig.from_pretrained(self.DENSE_MODEL_ID) + cfg.tie_word_embeddings = True + f_tied = compute_flops_per_token(cfg, 16384) + cfg.tie_word_embeddings = False + f_untied = compute_flops_per_token(cfg, 16384) + expected_delta = 3 * 2 * cfg.vocab_size * cfg.hidden_size + assert f_untied - f_tied == expected_delta + + def test_moe_active_vs_total_experts(self): + # Doubling `num_experts_per_tok` (active experts) changes FLOPs by exactly the + # routed-experts contribution: `num_experts_per_tok × 3 matmuls × 2 × h × moe_intermediate` + # per MoE layer, ×3 for fwd+bwd. Holding `num_local_experts` constant pins the + # router term so the delta is purely the active-expert math. + cfg = AutoConfig.from_pretrained(self.MOE_MODEL_ID) + cfg.num_experts_per_tok = 1 + f_lo = compute_flops_per_token(cfg, 16384) + cfg.num_experts_per_tok = 2 + f_hi = compute_flops_per_token(cfg, 16384) + moe_layers = sum(1 for i in range(cfg.num_hidden_layers) if i % cfg.decoder_sparse_step == 0) + per_expert_per_layer = 2 * 3 * cfg.hidden_size * cfg.moe_intermediate_size + expected_delta = 3 * moe_layers * (2 - 1) * per_expert_per_layer + assert f_hi - f_lo == expected_delta + + +class TestComputeMfu(TrlTestCase): + def test_perfect_utilization(self): + # If aggregate TPS is exactly `peak * world_size / flops_per_token`, MFU is 100%. + flops = 100e9 + peak = 989.5e12 + world_size = 8 + tps = peak * world_size / flops + assert compute_mfu(flops, tps, world_size, peak_flops_per_device=peak) == pytest.approx(100.0) + + +class TestAdjustedMfu(TrlTestCase): + MOE_MODEL_ID = "trl-internal-testing/tiny-Qwen3MoeForCausalLM" + + def test_consistent_with_formula(self): + # `adjusted_mfu(mfu, cfg, seq_len) == mfu * (full - half_attn) / full`, with + # `full = compute_flops_per_token(cfg, seq_len)` and + # `half_attn = L * 3 * 2 * n_heads * head_dim * seq_len`. Cross-check the two helpers. + cfg = AutoConfig.from_pretrained(self.MOE_MODEL_ID) + seq_len = 16384 + flops_full = compute_flops_per_token(cfg, seq_len) + half_attn = cfg.num_hidden_layers * 3 * 2 * cfg.num_attention_heads * cfg.head_dim * seq_len + expected = 100.0 * (flops_full - half_attn) / flops_full + assert adjusted_mfu(100.0, cfg, seq_len) == pytest.approx(expected) + + def test_proportional_to_input(self): + # The correction is purely multiplicative in `mfu`. `adjusted_mfu(2*x, ...)` should + # equal `2 * adjusted_mfu(x, ...)`. + cfg = AutoConfig.from_pretrained(self.MOE_MODEL_ID) + a = adjusted_mfu(50.0, cfg, 16384) + b = adjusted_mfu(100.0, cfg, 16384) + assert b == pytest.approx(2 * a) + + def test_decreases_with_seq_len(self): + # Longer sequences → attention takes a larger share of total compute → causal + # correction subtracts a larger absolute amount → factor strictly decreases. + cfg = AutoConfig.from_pretrained(self.MOE_MODEL_ID) + f_short = adjusted_mfu(100.0, cfg, 4096) + f_med = adjusted_mfu(100.0, cfg, 16384) + f_long = adjusted_mfu(100.0, cfg, 65536) + assert f_short > f_med > f_long diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_vllm_client_server.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_vllm_client_server.py new file mode 100644 index 0000000000000000000000000000000000000000..820483a9d7e003316e2204b0e2ed8565495041a2 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/test_vllm_client_server.py @@ -0,0 +1,1036 @@ +# Copyright 2020-2026 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import subprocess +from types import SimpleNamespace + +import pytest +from packaging.version import Version +from transformers import AutoModelForCausalLM, AutoProcessor, AutoTokenizer +from transformers.testing_utils import torch_device + +from trl.generation.vllm_client import VLLMClient +from trl.generation.vllm_generation import extract_logprobs +from trl.import_utils import is_vllm_available +from trl.scripts.vllm_serve import chunk_list + +from .testing_utils import ( + TrlTestCase, + kill_process, + require_3_accelerators, + require_torch_multi_accelerator, + require_vision, + require_vllm, +) + + +if is_vllm_available(): + import vllm + from vllm import LLM, SamplingParams + + _is_vllm_ge_014 = Version(vllm.__version__) >= Version("0.14.0") +else: + _is_vllm_ge_014 = False + + +class TestChunkList(TrlTestCase): + def test_even_split(self): + assert chunk_list([1, 2, 3, 4, 5, 6], 2) == [[1, 2, 3], [4, 5, 6]] + + def test_uneven_split(self): + assert chunk_list([1, 2, 3, 4, 5, 6], 4) == [[1, 2], [3, 4], [5], [6]] + + def test_more_chunks_than_elements(self): + assert chunk_list([1, 2, 3, 4, 5, 6], 8) == [[1], [2], [3], [4], [5], [6], [], []] + + def test_n_equals_len(self): + assert chunk_list([1, 2, 3], 3) == [[1], [2], [3]] + + def test_n_is_1(self): + assert chunk_list([1, 2, 3], 1) == [[1, 2, 3]] + + def test_single_element_list(self): + assert chunk_list([42], 2) == [[42], []] + + def test_any_dtype(self): + assert chunk_list([1, "two", 3.0, {"four": 4}, ["f", "i", "v", "e"]], 2) == [ + [1, "two", 3.0], + [{"four": 4}, ["f", "i", "v", "e"]], + ] + + +class TestExtractLogprobs(TrlTestCase): + def test_extract_logprobs_sorts_by_rank_and_replaces_nan(self): + all_outputs = [ + SimpleNamespace( + outputs=[ + SimpleNamespace( + logprobs=[ + { + 11: SimpleNamespace(rank=1, logprob=-0.2), + 99: SimpleNamespace(rank=0, logprob=-0.1), + 42: SimpleNamespace(rank=2, logprob=float("nan")), + }, + { + 5: SimpleNamespace(rank=0, logprob=-1.1), + }, + ] + ) + ] + ), + SimpleNamespace( + outputs=[ + SimpleNamespace( + logprobs=[ + { + 3: SimpleNamespace(rank=1, logprob=-0.5), + 7: SimpleNamespace(rank=0, logprob=-0.4), + } + ] + ) + ] + ), + ] + + all_logprobs, all_token_ids = extract_logprobs(all_outputs) + + assert all_token_ids == [ + [[99, 11, 42], [5]], + [[7, 3]], + ] + assert all_logprobs == [ + [[-0.1, -0.2, None], [-1.1]], + [[-0.4, -0.5]], + ] + + def test_extract_logprobs_returns_none_token_ids_when_logprobs_missing(self): + all_outputs = [SimpleNamespace(outputs=[SimpleNamespace(logprobs=None)])] + + all_logprobs, all_token_ids = extract_logprobs(all_outputs) + + assert all_logprobs is None + assert all_token_ids is None + + +@pytest.mark.slow +@require_torch_multi_accelerator +@require_vllm +class TestVLLMClientServer(TrlTestCase): + model_id = "Qwen/Qwen2.5-1.5B" + + @classmethod + def setup_class(cls): + # We want the server to run on accelerator 1, so we set VISIBLE_DEVICES to "1" + env = os.environ.copy() + VISIBLE_DEVICES = "ZE_AFFINITY_MASK" if torch_device == "xpu" else "CUDA_VISIBLE_DEVICES" + env[VISIBLE_DEVICES] = "1" # Restrict to accelerator 1 + + # Start the server process + cls.server_process = subprocess.Popen( + ["trl", "vllm-serve", "--model", cls.model_id], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env + ) + + # Initialize the client + cls.client = VLLMClient(connection_timeout=240, host="localhost") + cls.client.init_communicator() + + def test_generate(self): + prompts = ["Hello, AI!", "Tell me a joke"] + outputs = self.client.generate(prompts) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of prompts + assert len(prompt_ids) == len(prompts) + assert len(completion_ids) == len(prompts) + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_generate_with_logprobs_none(self): + outputs = self.client.generate(["Hello, AI!"], logprobs=None) + + assert isinstance(outputs["prompt_ids"], list) + assert isinstance(outputs["completion_ids"], list) + assert outputs["logprobs"] is None + assert outputs["logprob_token_ids"] is None + + def test_chat(self): + messages = [[{"role": "user", "content": "Hello, AI!"}], [{"role": "user", "content": "Tell me a joke"}]] + outputs = self.client.chat(messages) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of messages + assert len(prompt_ids) == len(messages) + assert len(completion_ids) == len(messages) + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_chat_with_logprobs_none(self): + outputs = self.client.chat([[{"role": "user", "content": "Hello, AI!"}]], logprobs=None) + + assert isinstance(outputs["prompt_ids"], list) + assert isinstance(outputs["completion_ids"], list) + assert outputs["logprobs"] is None + assert outputs["logprob_token_ids"] is None + + def test_chat_with_tools(self): + def multiply(a: int, b: int) -> int: + """ + Multiplies two integers. + + Args: + a: The first integer. + b: The second integer. + + Returns: + The product of the two integers. + """ + return a * b + + messages = [[{"role": "user", "content": "What is 3 multiplied by 4?"}]] + outputs = self.client.chat(messages, tools=[multiply]) + + # Decode prompt and check that "Multiplies two integers." is in the prompt. + tokenizer = AutoTokenizer.from_pretrained(self.model_id) + decoded_prompt = tokenizer.decode(outputs["prompt_ids"][0]) + assert "Multiplies two integers." in decoded_prompt + + def test_generate_with_token_ids(self): + tokenizer = AutoTokenizer.from_pretrained(self.model_id) + prompts = ["Hello, AI!", "Tell me a joke"] + prompt_token_ids = tokenizer(prompts)["input_ids"] + outputs = self.client.generate(prompt_token_ids) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of prompts + assert len(prompt_ids) == len(prompts) + assert len(completion_ids) == len(prompts) + + # Check that prompt_ids match the input token IDs + assert prompt_ids == prompt_token_ids + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_generate_with_params(self): + prompts = ["Hello, AI!", "Tell me a joke"] + completion_ids = self.client.generate(prompts, n=2, repetition_penalty=0.9, temperature=0.8, max_tokens=32)[ + "completion_ids" + ] + + # Check that the output is a list + assert isinstance(completion_ids, list) + + # Check that the number of generated sequences is 2 times the number of prompts + assert len(completion_ids) == 2 * len(prompts) + + # Check that the generated sequences are lists of integers + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + # Check that the length of the generated sequences is less than or equal to 32 + for seq in completion_ids: + assert len(seq) <= 32 + + def test_update_model_params(self): + model = AutoModelForCausalLM.from_pretrained(self.model_id, device_map=torch_device) + self.client.update_model_params(model) + + def test_reset_prefix_cache(self): + # Test resetting the prefix cache + self.client.reset_prefix_cache() + + @pytest.mark.xfail(reason="Importing `bitsandbytes` causes issues, see vllm-project/vllm#32793") + def test_logprobs_match_with_non_default_sampling(self): + prompts = ["Hello, AI!", "Tell me a joke"] + # Use non-default sampling parameters (especially temperature) to ensure vLLM applies logprob processing. With + # default sampling, raw and processed logprobs are identical, so mismatches would not be detected. + temperature = 0.7 + repetition_penalty = 1.05 + top_p = 0.9 + max_tokens = 8 + seed = 1234 + num_logprobs = 5 + + server_outputs = self.client.generate( + prompts, + temperature=temperature, + repetition_penalty=repetition_penalty, + top_p=top_p, + max_tokens=max_tokens, + logprobs=num_logprobs, + generation_kwargs={"seed": seed}, + ) + os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn" + llm = LLM( + model=self.model_id, + tensor_parallel_size=1, + gpu_memory_utilization=0.2, + max_model_len=128, + logprobs_mode="processed_logprobs", + ) + + sampling_params = SamplingParams( + temperature=temperature, + repetition_penalty=repetition_penalty, + top_p=top_p, + max_tokens=max_tokens, + logprobs=num_logprobs, + seed=seed, + ) + colocate_outputs = llm.generate(prompts, sampling_params=sampling_params, use_tqdm=False) + colocate_prompt_ids = [output.prompt_token_ids for output in colocate_outputs] + colocate_completion_ids = [ + list(output.token_ids) for outputs in colocate_outputs for output in outputs.outputs + ] + colocate_logprobs, colocate_logprob_token_ids = extract_logprobs(colocate_outputs) + + # Generation correctness: prompt and completion IDs match between server and colocate + assert server_outputs["prompt_ids"] == colocate_prompt_ids + assert server_outputs["completion_ids"] == colocate_completion_ids + + server_logprobs = server_outputs["logprobs"] + server_logprob_token_ids = server_outputs["logprob_token_ids"] + + # Shape: both should be (num_sequences, seq_len, num_logprobs) with multiple logprobs per token + assert len(server_logprobs) == len(prompts) + assert len(server_logprob_token_ids) == len(prompts) + for seq_lps in server_logprobs: + for token_lps in seq_lps: + assert len(token_lps) > 1, "Expected multiple logprobs per token when logprobs > 0" + + # Value correctness: server extraction matches colocate extraction via extract_logprobs + assert server_logprob_token_ids == colocate_logprob_token_ids + for server_seq, colocate_seq in zip(server_logprobs, colocate_logprobs, strict=True): + assert len(server_seq) == len(colocate_seq) + for server_token_lps, colocate_token_lps in zip(server_seq, colocate_seq, strict=True): + assert server_token_lps == pytest.approx(colocate_token_lps, rel=1e-6, abs=1e-6) + + # Ordering: logprobs at each position should be sorted descending + for seq_lps in server_logprobs: + for token_lps in seq_lps: + assert token_lps == sorted(token_lps, reverse=True), "Logprobs should be sorted descending" + + # Sampled token presence: the actual completion token should appear in the logprob token IDs + for seq_idx, (completion_seq, token_ids_seq) in enumerate( + zip(server_outputs["completion_ids"], server_logprob_token_ids, strict=True) + ): + for pos, (sampled_id, lp_ids) in enumerate(zip(completion_seq, token_ids_seq, strict=True)): + assert sampled_id in lp_ids, ( + f"Sampled token {sampled_id} not found in logprob token IDs {lp_ids} " + f"at sequence {seq_idx}, position {pos}" + ) + + @classmethod + def teardown_class(cls): + # Close the client + cls.client.close_communicator() + + # vLLM x pytest (or Popen) seems not to handle process termination well. To avoid zombie processes, we need to + # kill the server process and its children explicitly. + kill_process(cls.server_process) + + +# Same as above but using base_url to instantiate the client. +@pytest.mark.slow +@require_torch_multi_accelerator +@require_vllm +class TestVLLMClientServerBaseURL(TrlTestCase): + model_id = "Qwen/Qwen2.5-1.5B" + + @classmethod + def setup_class(cls): + # We want the server to run on accelerator 1, so we set VISIBLE_DEVICES to "1" + env = os.environ.copy() + VISIBLE_DEVICES = "ZE_AFFINITY_MASK" if torch_device == "xpu" else "CUDA_VISIBLE_DEVICES" + env[VISIBLE_DEVICES] = "1" # Restrict to accelerator 1 + + # Start the server process + cls.server_process = subprocess.Popen( + ["trl", "vllm-serve", "--model", cls.model_id], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env + ) + + # Initialize the client + cls.client = VLLMClient(base_url="http://localhost:8000", connection_timeout=240) + cls.client.init_communicator() + + def test_generate(self): + prompts = ["Hello, AI!", "Tell me a joke"] + outputs = self.client.generate(prompts) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of prompts + assert len(prompt_ids) == len(prompts) + assert len(completion_ids) == len(prompts) + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_generate_with_logprobs_none(self): + outputs = self.client.generate(["Hello, AI!"], logprobs=None) + + assert isinstance(outputs["prompt_ids"], list) + assert isinstance(outputs["completion_ids"], list) + assert outputs["logprobs"] is None + assert outputs["logprob_token_ids"] is None + + def test_chat(self): + messages = [[{"role": "user", "content": "Hello, AI!"}], [{"role": "user", "content": "Tell me a joke"}]] + outputs = self.client.chat(messages) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of messages + assert len(prompt_ids) == len(messages) + assert len(completion_ids) == len(messages) + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_chat_with_logprobs_none(self): + outputs = self.client.chat([[{"role": "user", "content": "Hello, AI!"}]], logprobs=None) + + assert isinstance(outputs["prompt_ids"], list) + assert isinstance(outputs["completion_ids"], list) + assert outputs["logprobs"] is None + assert outputs["logprob_token_ids"] is None + + def test_chat_with_tools(self): + def multiply(a: int, b: int) -> int: + """ + Multiplies two integers. + + Args: + a: The first integer. + b: The second integer. + + Returns: + The product of the two integers. + """ + return a * b + + messages = [[{"role": "user", "content": "What is 3 multiplied by 4?"}]] + outputs = self.client.chat(messages, tools=[multiply]) + + # Decode prompt and check that "Multiplies two integers." is in the prompt. + tokenizer = AutoTokenizer.from_pretrained(self.model_id) + decoded_prompt = tokenizer.decode(outputs["prompt_ids"][0]) + assert "Multiplies two integers." in decoded_prompt + + def test_generate_with_token_ids(self): + tokenizer = AutoTokenizer.from_pretrained(self.model_id) + prompts = ["Hello, AI!", "Tell me a joke"] + prompt_token_ids = tokenizer(prompts)["input_ids"] + outputs = self.client.generate(prompt_token_ids) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of prompts + assert len(prompt_ids) == len(prompts) + assert len(completion_ids) == len(prompts) + + # Check that prompt_ids match the input token IDs + assert prompt_ids == prompt_token_ids + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_generate_with_params(self): + prompts = ["Hello, AI!", "Tell me a joke"] + completion_ids = self.client.generate(prompts, n=2, repetition_penalty=0.9, temperature=0.8, max_tokens=32)[ + "completion_ids" + ] + + # Check that the output is a list + assert isinstance(completion_ids, list) + + # Check that the number of generated sequences is 2 times the number of prompts + assert len(completion_ids) == 2 * len(prompts) + + # Check that the generated sequences are lists of integers + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + # Check that the length of the generated sequences is less than or equal to 32 + for seq in completion_ids: + assert len(seq) <= 32 + + def test_update_model_params(self): + model = AutoModelForCausalLM.from_pretrained(self.model_id, device_map=torch_device) + self.client.update_model_params(model) + + def test_reset_prefix_cache(self): + # Test resetting the prefix cache + self.client.reset_prefix_cache() + + @classmethod + def teardown_class(cls): + # Close the client + cls.client.close_communicator() + + # vLLM x pytest (or Popen) seems not to handle process termination well. To avoid zombie processes, we need to + # kill the server process and its children explicitly. + kill_process(cls.server_process) + + +@pytest.mark.slow +@require_3_accelerators +@require_vllm +class TestVLLMClientServerTP(TrlTestCase): + model_id = "Qwen/Qwen2.5-1.5B" + + @classmethod + def setup_class(cls): + # We want the server to run on accelerator 1 and 2, so we set VISIBLE_DEVICES to "1,2" + env = os.environ.copy() + VISIBLE_DEVICES = "ZE_AFFINITY_MASK" if torch_device == "xpu" else "CUDA_VISIBLE_DEVICES" + env[VISIBLE_DEVICES] = "1,2" # Restrict to accelerator 1 and 2 + + # Start the server process + cls.server_process = subprocess.Popen( + ["trl", "vllm-serve", "--model", cls.model_id, "--tensor_parallel_size", "2"], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + env=env, + ) + + # Initialize the client + cls.client = VLLMClient(connection_timeout=240, host="localhost") + cls.client.init_communicator() + + def test_generate(self): + prompts = ["Hello, AI!", "Tell me a joke"] + outputs = self.client.generate(prompts) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of prompts + assert len(prompt_ids) == len(prompts) + assert len(completion_ids) == len(prompts) + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_generate_with_logprobs_none(self): + outputs = self.client.generate(["Hello, AI!"], logprobs=None) + + assert isinstance(outputs["prompt_ids"], list) + assert isinstance(outputs["completion_ids"], list) + assert outputs["logprobs"] is None + assert outputs["logprob_token_ids"] is None + + def test_chat(self): + messages = [[{"role": "user", "content": "Hello, AI!"}], [{"role": "user", "content": "Tell me a joke"}]] + outputs = self.client.chat(messages) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of messages + assert len(prompt_ids) == len(messages) + assert len(completion_ids) == len(messages) + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_chat_with_logprobs_none(self): + outputs = self.client.chat([[{"role": "user", "content": "Hello, AI!"}]], logprobs=None) + + assert isinstance(outputs["prompt_ids"], list) + assert isinstance(outputs["completion_ids"], list) + assert outputs["logprobs"] is None + assert outputs["logprob_token_ids"] is None + + def test_chat_with_tools(self): + def multiply(a: int, b: int) -> int: + """ + Multiplies two integers. + + Args: + a: The first integer. + b: The second integer. + + Returns: + The product of the two integers. + """ + return a * b + + messages = [[{"role": "user", "content": "What is 3 multiplied by 4?"}]] + outputs = self.client.chat(messages, tools=[multiply]) + + # Decode prompt and check that "Multiplies two integers." is in the prompt. + tokenizer = AutoTokenizer.from_pretrained(self.model_id) + decoded_prompt = tokenizer.decode(outputs["prompt_ids"][0]) + assert "Multiplies two integers." in decoded_prompt + + def test_generate_with_token_ids(self): + tokenizer = AutoTokenizer.from_pretrained(self.model_id) + prompts = ["Hello, AI!", "Tell me a joke"] + prompt_token_ids = tokenizer(prompts)["input_ids"] + outputs = self.client.generate(prompt_token_ids) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of prompts + assert len(prompt_ids) == len(prompts) + assert len(completion_ids) == len(prompts) + + # Check that prompt_ids match the input token IDs + assert prompt_ids == prompt_token_ids + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_generate_with_params(self): + prompts = ["Hello, AI!", "Tell me a joke"] + completion_ids = self.client.generate(prompts, n=2, repetition_penalty=0.9, temperature=0.8, max_tokens=32)[ + "completion_ids" + ] + + # Check that the output is a list + assert isinstance(completion_ids, list) + + # Check that the number of generated sequences is 2 times the number of prompts + assert len(completion_ids) == 2 * len(prompts) + + # Check that the generated sequences are lists of integers + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + # Check that the length of the generated sequences is less than or equal to 32 + for seq in completion_ids: + assert len(seq) <= 32 + + def test_update_model_params(self): + model = AutoModelForCausalLM.from_pretrained(self.model_id, device_map=torch_device) + self.client.update_model_params(model) + + def test_reset_prefix_cache(self): + # Test resetting the prefix cache + self.client.reset_prefix_cache() + + @classmethod + def teardown_class(cls): + # Close the client + cls.client.close_communicator() + + # vLLM x pytest (or Popen) seems not to handle process termination well. To avoid zombie processes, we need to + # kill the server process and its children explicitly. + kill_process(cls.server_process) + + +@pytest.mark.slow +@pytest.mark.skipif( + _is_vllm_ge_014, + reason="Skipping DP server test for vLLM>=0.14.0 (PR vllm#30739: DP for non-MoE/dense models no longer supported).", +) +@require_3_accelerators +@require_vllm +class TestVLLMClientServerDP(TrlTestCase): + model_id = "Qwen/Qwen2.5-1.5B" + + @classmethod + def setup_class(cls): + # We want the server to run on accelerator 1 and 2, so we set VISIBLE_DEVICES to "1,2" + env = os.environ.copy() + VISIBLE_DEVICES = "ZE_AFFINITY_MASK" if torch_device == "xpu" else "CUDA_VISIBLE_DEVICES" + env[VISIBLE_DEVICES] = "1,2" # Restrict to accelerator 1 and 2 + + # Start the server process + cls.server_process = subprocess.Popen( + ["trl", "vllm-serve", "--model", cls.model_id, "--data_parallel_size", "2"], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + env=env, + ) + + # Initialize the client + cls.client = VLLMClient(connection_timeout=240, host="localhost") + cls.client.init_communicator() + + def test_generate(self): + prompts = ["Hello, AI!", "Tell me a joke"] + outputs = self.client.generate(prompts) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of prompts + assert len(prompt_ids) == len(prompts) + assert len(completion_ids) == len(prompts) + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_generate_with_logprobs_none(self): + outputs = self.client.generate(["Hello, AI!"], logprobs=None) + + assert isinstance(outputs["prompt_ids"], list) + assert isinstance(outputs["completion_ids"], list) + assert outputs["logprobs"] is None + assert outputs["logprob_token_ids"] is None + + def test_chat(self): + messages = [[{"role": "user", "content": "Hello, AI!"}], [{"role": "user", "content": "Tell me a joke"}]] + outputs = self.client.chat(messages) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of messages + assert len(prompt_ids) == len(messages) + assert len(completion_ids) == len(messages) + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_chat_with_logprobs_none(self): + outputs = self.client.chat([[{"role": "user", "content": "Hello, AI!"}]], logprobs=None) + + assert isinstance(outputs["prompt_ids"], list) + assert isinstance(outputs["completion_ids"], list) + assert outputs["logprobs"] is None + assert outputs["logprob_token_ids"] is None + + def test_chat_with_tools(self): + def multiply(a: int, b: int) -> int: + """ + Multiplies two integers. + + Args: + a: The first integer. + b: The second integer. + + Returns: + The product of the two integers. + """ + return a * b + + messages = [[{"role": "user", "content": "What is 3 multiplied by 4?"}]] + outputs = self.client.chat(messages, tools=[multiply]) + + # Decode prompt and check that "Multiplies two integers." is in the prompt. + tokenizer = AutoTokenizer.from_pretrained(self.model_id) + decoded_prompt = tokenizer.decode(outputs["prompt_ids"][0]) + assert "Multiplies two integers." in decoded_prompt + + def test_generate_with_token_ids(self): + tokenizer = AutoTokenizer.from_pretrained(self.model_id) + prompts = ["Hello, AI!", "Tell me a joke"] + prompt_token_ids = tokenizer(prompts)["input_ids"] + outputs = self.client.generate(prompt_token_ids) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + # Check that the outputs are lists + assert isinstance(prompt_ids, list) + assert isinstance(completion_ids, list) + + # Check that the number of sequences are equal to the number of prompts + assert len(prompt_ids) == len(prompts) + assert len(completion_ids) == len(prompts) + + # Check that prompt_ids match the input token IDs + assert prompt_ids == prompt_token_ids + + # Check that the sequences are lists of integers + for seq in prompt_ids: + assert all(isinstance(tok, int) for tok in seq) + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + def test_generate_with_params(self): + prompts = ["Hello, AI!", "Tell me a joke"] + completion_ids = self.client.generate(prompts, n=2, repetition_penalty=0.9, temperature=0.8, max_tokens=32)[ + "completion_ids" + ] + + # Check that the output is a list + assert isinstance(completion_ids, list) + + # Check that the number of generated sequences is 2 times the number of prompts + assert len(completion_ids) == 2 * len(prompts) + + # Check that the generated sequences are lists of integers + for seq in completion_ids: + assert all(isinstance(tok, int) for tok in seq) + + # Check that the length of the generated sequences is less than or equal to 32 + for seq in completion_ids: + assert len(seq) <= 32 + + def test_update_model_params(self): + model = AutoModelForCausalLM.from_pretrained(self.model_id, device_map=torch_device) + self.client.update_model_params(model) + + def test_reset_prefix_cache(self): + # Test resetting the prefix cache + self.client.reset_prefix_cache() + + @classmethod + def teardown_class(cls): + # Close the client + cls.client.close_communicator() + + # vLLM x pytest (or Popen) seems not to handle process termination well. To avoid zombie processes, we need to + # kill the server process and its children explicitly. + kill_process(cls.server_process) + + +@pytest.mark.slow +@require_torch_multi_accelerator +@require_vllm +class TestVLLMClientServerDeviceParameter(TrlTestCase): + """Test the device parameter functionality in init_communicator.""" + + model_id = "Qwen/Qwen2.5-1.5B" + + @classmethod + def setup_class(cls): + # We want the server to run on accelerator 1, so we set VISIBLE_DEVICES to "1" + env = os.environ.copy() + VISIBLE_DEVICES = "ZE_AFFINITY_MASK" if torch_device == "xpu" else "CUDA_VISIBLE_DEVICES" + env[VISIBLE_DEVICES] = "1" # Restrict to accelerator 1 + + # Start the server process + cls.server_process = subprocess.Popen( + ["trl", "vllm-serve", "--model", cls.model_id], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env + ) + + def test_init_communicator_with_device_int(self): + """Test init_communicator with integer device parameter.""" + client = VLLMClient(connection_timeout=240, host="localhost") + client.init_communicator(device=0) # Explicitly specify device 0 + + # Test basic functionality + prompts = ["Hello, AI!"] + outputs = client.generate(prompts) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + assert isinstance(prompt_ids, list) + assert len(prompt_ids) == len(prompts) + assert isinstance(completion_ids, list) + assert len(completion_ids) == len(prompts) + + client.close_communicator() + + def test_init_communicator_with_device_string(self): + """Test init_communicator with string device parameter.""" + client = VLLMClient(connection_timeout=240, host="localhost") + client.init_communicator(device=0) # Explicitly specify device as string + + # Test basic functionality + prompts = ["Hello, AI!"] + outputs = client.generate(prompts)["completion_ids"] + assert isinstance(outputs, list) + assert len(outputs) == len(prompts) + + client.close_communicator() + + def test_init_communicator_with_torch_device(self): + """Test init_communicator with torch.device object.""" + import torch + + client = VLLMClient(connection_timeout=240, host="localhost") + device = torch.device(0) + client.init_communicator(device=device) # Explicitly specify torch.device object + + # Test basic functionality + prompts = ["Hello, AI!"] + outputs = client.generate(prompts)["completion_ids"] + assert isinstance(outputs, list) + assert len(outputs) == len(prompts) + + client.close_communicator() + + @classmethod + def teardown_class(cls): + # vLLM x pytest (or Popen) seems not to handle process termination well. To avoid zombie processes, we need to + # kill the server process and its children explicitly. + kill_process(cls.server_process) + + +@pytest.mark.slow +@require_vllm +@require_vision +class TestVLLMClientServerVLM(TrlTestCase): + model_id = "Qwen/Qwen2.5-VL-3B-Instruct" + + @classmethod + def setup_class(cls): + # Start the server process + cls.server_process = subprocess.Popen( + ["trl", "vllm-serve", "--model", cls.model_id], stdout=subprocess.PIPE, stderr=subprocess.PIPE + ) + + # Initialize the client (no communicator needed for generation-only tests) + cls.client = VLLMClient(connection_timeout=240, host="localhost") + + def test_generate_with_token_ids_and_image(self): + from PIL import Image + + processor = AutoProcessor.from_pretrained(self.model_id) + image1 = Image.new("RGB", (64, 64), color="red") + image2 = Image.new("RGB", (64, 64), color="blue") + image3 = Image.new("RGB", (64, 64), color="green") + messages = [ + [ + { + "role": "user", + "content": [ + {"type": "image", "image": image1}, + {"type": "image", "image": image2}, + {"type": "text", "text": "What are the differences between these two images?"}, + ], + } + ], + [ + { + "role": "user", + "content": [ + {"type": "image", "image": image3}, + {"type": "text", "text": "What is the color of this image?"}, + ], + } + ], + ] + prompt_token_ids = processor.apply_chat_template( + conversation=messages, tokenize=True, add_generation_prompt=True + ) + outputs = self.client.generate(prompt_token_ids, images=[[image1, image2], [image3]], max_tokens=64) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + assert len(prompt_ids) == 2 + assert len(completion_ids) == 2 + assert all(isinstance(tok, int) for tok in prompt_ids[0]) + assert all(isinstance(tok, int) for tok in completion_ids[0]) + + def test_generate_with_token_ids_mixed_images(self): + """Test a batch where one prompt has an image and the other does not.""" + from PIL import Image + + processor = AutoProcessor.from_pretrained(self.model_id) + image = Image.new("RGB", (64, 64), color="red") + messages = [ + [ + { + "role": "user", + "content": [{"type": "image", "image": image}, {"type": "text", "text": "Describe this image."}], + } + ], + [ + { + "role": "user", + "content": [{"type": "text", "text": "What is 1+1?"}], + } + ], + ] + prompt_token_ids = processor.apply_chat_template( + conversation=messages, tokenize=True, add_generation_prompt=True + ) + outputs = self.client.generate(prompt_token_ids, images=[[image], None], max_tokens=64) + prompt_ids = outputs["prompt_ids"] + completion_ids = outputs["completion_ids"] + + assert len(prompt_ids) == 2 + assert len(completion_ids) == 2 + assert all(isinstance(tok, int) for tok in prompt_ids[0]) + assert all(isinstance(tok, int) for tok in prompt_ids[1]) + assert all(isinstance(tok, int) for tok in completion_ids[0]) + assert all(isinstance(tok, int) for tok in completion_ids[1]) + + @classmethod + def teardown_class(cls): + kill_process(cls.server_process) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/testing_constants.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/testing_constants.py new file mode 100644 index 0000000000000000000000000000000000000000..7589117c85a06be131489b8a7b905f2162b3c14d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/testing_constants.py @@ -0,0 +1,18 @@ +# Copyright 2020-2026 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. + +CI_HUB_USER = "__DUMMY_TRANSFORMERS_USER__" +CI_HUB_USER_FULL_NAME = "Dummy User" + +CI_HUB_ENDPOINT = "https://hub-ci.huggingface.co" diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/testing_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/testing_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..dad37914fd207a0254d894748a540d39018d8342 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/tests/testing_utils.py @@ -0,0 +1,150 @@ +# Copyright 2020-2026 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 functools +import signal +import warnings +from collections.abc import Callable + +import psutil +import pytest +import torch +from transformers import is_bitsandbytes_available, is_comet_available, is_sklearn_available, is_wandb_available +from transformers.testing_utils import backend_device_count, torch_device +from transformers.utils import ( + is_kernels_available, + is_peft_available, + is_rich_available, + is_torch_available, + is_vision_available, +) + +from trl.import_utils import ( + is_harbor_available, + is_jmespath_available, + is_joblib_available, + is_liger_kernel_available, + is_math_verify_available, + is_mergekit_available, + is_openreward_available, + is_vllm_available, +) + + +require_bitsandbytes = pytest.mark.skipif(not is_bitsandbytes_available(), reason="test requires bitsandbytes") +require_comet = pytest.mark.skipif(not is_comet_available(), reason="test requires comet_ml") +require_harbor = pytest.mark.skipif(not is_harbor_available(), reason="test requires harbor") +require_jmespath = pytest.mark.skipif(not is_jmespath_available(), reason="test requires jmespath") +require_kernels = pytest.mark.skipif(not is_kernels_available(), reason="test requires kernels") +require_liger_kernel = pytest.mark.skipif(not is_liger_kernel_available(), reason="test requires liger-kernel") +require_math_latex = pytest.mark.skipif(not is_math_verify_available(), reason="test requires math_verify") +require_mergekit = pytest.mark.skipif(not is_mergekit_available(), reason="test requires mergekit") +require_openreward = pytest.mark.skipif(not is_openreward_available(), reason="test requires openreward") +require_peft = pytest.mark.skipif(not is_peft_available(), reason="test requires peft") +require_rich = pytest.mark.skipif(not is_rich_available(), reason="test requires rich") +require_sklearn = pytest.mark.skipif( + not (is_sklearn_available() and is_joblib_available()), reason="test requires sklearn" +) +require_torch_accelerator = pytest.mark.skipif( + torch_device is None or torch_device == "cpu", reason="test requires accelerator" +) +require_torch_multi_accelerator = pytest.mark.skipif( + not is_torch_available() or backend_device_count(torch_device) <= 1, reason="test requires multiple accelerators" +) +require_vision = pytest.mark.skipif(not is_vision_available(), reason="test requires vision") +require_vllm = pytest.mark.skipif(not is_vllm_available(), reason="test requires vllm") +require_wandb = pytest.mark.skipif(not is_wandb_available(), reason="test requires wandb") +require_no_wandb = pytest.mark.skipif(is_wandb_available(), reason="test requires no wandb") +require_3_accelerators = pytest.mark.skipif( + not (getattr(torch, torch_device, torch.cuda).device_count() >= 3), + reason=f"test requires at least 3 {torch_device}s", +) + + +def is_bitsandbytes_multi_backend_available() -> bool: + if is_bitsandbytes_available(): + import bitsandbytes as bnb + + return "multi_backend" in getattr(bnb, "features", set()) + return False + + +# Function ported from transformers.testing_utils before transformers#41283 +require_torch_gpu_if_bnb_not_multi_backend_enabled = pytest.mark.skipif( + not is_bitsandbytes_multi_backend_available() and not torch_device == "cuda", + reason="test requires bitsandbytes multi-backend enabled or 'cuda' torch device", +) + + +def is_ampere_or_newer(device_index=0): + if not torch.cuda.is_available(): + return False + + # "Ampere" is an NVIDIA architecture; an AMD (ROCm) GPU is never Ampere. On ROCm, + # torch.cuda.get_device_capability returns the gfx version, which would spuriously compare >= (8, 0). + if torch.version.hip is not None: + return False + + major, minor = torch.cuda.get_device_capability(device_index) + # Ampere starts at compute capability 8.0 (e.g., A100 = 8.0, RTX 30xx = 8.6) + return (major, minor) >= (8, 0) + + +class TrlTestCase: + @pytest.fixture(autouse=True) + def set_tmp_dir(self, tmp_path): + self.tmp_dir = str(tmp_path) + + +def ignore_warnings(message: str = None, category: type[Warning] = Warning) -> Callable: + """ + Decorator to ignore warnings with a specific message and/or category. + + Args: + message (`str`, *optional*): + Regex pattern for the warning message to ignore. If `None`, all messages are ignored. + category (`type[Warning]`, *optional*, defaults to `Warning`): + Warning class to ignore. Defaults to `Warning`, which ignores all warnings. + """ + + def decorator(test_func): + @functools.wraps(test_func) + def wrapper(*args, **kwargs): + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", message=message, category=category) + return test_func(*args, **kwargs) + + return wrapper + + return decorator + + +def kill_process(process): + parent = psutil.Process(process.pid) + children = parent.children(recursive=True) + for child in children: + try: + child.send_signal(signal.SIGTERM) + child.wait(timeout=5) + except psutil.TimeoutExpired: + child.kill() + except psutil.NoSuchProcess: + pass + try: + process.terminate() + process.wait(timeout=5) + except psutil.TimeoutExpired: + process.kill() + except psutil.NoSuchProcess: + pass diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4947fc16c56e7abf1de978619b878bde579c9d15 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/__init__.py @@ -0,0 +1,132 @@ +# Copyright 2020-2026 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 sys +from importlib.metadata import PackageNotFoundError, version +from typing import TYPE_CHECKING + +from . import _compat +from ._lazy_module import _LazyModule + + +try: + __version__ = version("trl") +except PackageNotFoundError: + __version__ = "unknown" + +_import_structure = { + "chat_template_utils": [ + "add_response_schema", + "clone_chat_template", + "get_training_chat_template", + "supports_tool_calling", + ], + "data_utils": [ + "apply_chat_template", + "extract_prompt", + "is_conversational", + "is_conversational_from_value", + "maybe_apply_chat_template", + "maybe_convert_to_chatml", + "maybe_extract_prompt", + "maybe_unpair_preference_dataset", + "pack_dataset", + "prepare_multimodal_messages", + "prepare_multimodal_messages_vllm", + "unpair_preference_dataset", + ], + "models": ["create_reference_model"], + "scripts": ["DatasetMixtureConfig", "ScriptArguments", "TrlParser", "get_dataset", "init_zero_verbose"], + "trainer": [ + "BEMACallback", + "DPOConfig", + "DPOTrainer", + "GRPOConfig", + "GRPOTrainer", + "KTOConfig", + "KTOTrainer", + "LogCompletionsCallback", + "ModelConfig", + "RewardConfig", + "RewardTrainer", + "RichProgressCallback", + "RLOOConfig", + "RLOOTrainer", + "SFTConfig", + "SFTTrainer", + "SyncRefModelCallback", + "WeaveCallback", + "get_kbit_device_map", + "get_peft_config", + "get_quantization_config", + ], +} + +if TYPE_CHECKING: + from .chat_template_utils import ( + add_response_schema, + clone_chat_template, + get_training_chat_template, + supports_tool_calling, + ) + from .data_utils import ( + apply_chat_template, + extract_prompt, + is_conversational, + is_conversational_from_value, + maybe_apply_chat_template, + maybe_convert_to_chatml, + maybe_extract_prompt, + maybe_unpair_preference_dataset, + pack_dataset, + prepare_multimodal_messages, + prepare_multimodal_messages_vllm, + unpair_preference_dataset, + ) + from .models import create_reference_model + from .scripts import DatasetMixtureConfig, ScriptArguments, TrlParser, get_dataset, init_zero_verbose + from .trainer import ( + BEMACallback, + DPOConfig, + DPOTrainer, + GRPOConfig, + GRPOTrainer, + KTOConfig, + KTOTrainer, + LogCompletionsCallback, + ModelConfig, + RewardConfig, + RewardTrainer, + RichProgressCallback, + RLOOConfig, + RLOOTrainer, + SFTConfig, + SFTTrainer, + SyncRefModelCallback, + WeaveCallback, + get_kbit_device_map, + get_peft_config, + get_quantization_config, + ) + +else: + import sys + + sys.modules[__name__] = _LazyModule( + __name__, + globals()["__file__"], + _import_structure, + module_spec=__spec__, + extra_objects={"__version__": __version__}, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/_compat.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/_compat.py new file mode 100644 index 0000000000000000000000000000000000000000..31086a2e912cc9926e3fab7d2a8045fa5421c49d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/_compat.py @@ -0,0 +1,164 @@ +# Copyright 2020-2026 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. + +""" +Compatibility shims for third-party dependencies. + +This module contains temporary patches to handle version incompatibilities between TRL's dependencies. + +Each patch should be removed when minimum version requirements eliminate the need. +""" + +import warnings + +from packaging.version import Version + +from .import_utils import _is_package_available + + +def _is_package_version_below(package_name: str, version_threshold: str) -> bool: + """ + Check if installed package version is below the given threshold. + + Args: + package_name (str): Package name. + version_threshold (str): Maximum version threshold. + + Returns: + - True if package is installed and version < version_threshold. + - False if package is not installed or version >= version_threshold. + """ + try: + is_available, version = _is_package_available(package_name, return_version=True) + return is_available and Version(version) < Version(version_threshold) + except Exception as e: + warnings.warn( + f"Failed to check {package_name} version against {version_threshold}: {e}. " + f"Compatibility patch may not be applied.", + stacklevel=2, + ) + return False + + +def _is_package_version_at_least(package_name: str, version_threshold: str) -> bool: + """ + Check if installed package version is at least the given threshold. + + Args: + package_name (str): Package name. + version_threshold (str): Minimum version threshold. + + Returns: + - True if package is installed and version >= version_threshold. + - False if package is not installed or version < version_threshold. + """ + try: + is_available, version = _is_package_available(package_name, return_version=True) + return is_available and Version(version) >= Version(version_threshold) + except Exception as e: + warnings.warn( + f"Failed to check {package_name} version against {version_threshold}: {e}. " + f"Compatibility patch may not be applied.", + stacklevel=2, + ) + return False + + +def _patch_vllm_logging() -> None: + """Set vLLM logging level to ERROR by default to reduce noise.""" + if _is_package_available("vllm"): + import os + + os.environ["VLLM_LOGGING_LEVEL"] = os.getenv("VLLM_LOGGING_LEVEL", "ERROR") + + +def _patch_transformers_hybrid_cache() -> None: + """ + Fix HybridCache import for transformers v5 compatibility. + + - Issue: peft import HybridCache from transformers.cache_utils + - HybridCache removed in https://github.com/huggingface/transformers/pull/43168 (transformers>=5.0.0) + - Fixed in peft: https://github.com/huggingface/peft/pull/2735 (released in v0.18.0) + - This can be removed when TRL requires peft>=0.18.0 + """ + if _is_package_version_at_least("transformers", "5.0.0") and _is_package_version_below("peft", "0.18.0"): + try: + import transformers.cache_utils + from transformers.utils.import_utils import _LazyModule + + Cache = transformers.cache_utils.Cache + + # Patch for liger_kernel: Add HybridCache as an alias for Cache in the cache_utils module + transformers.cache_utils.HybridCache = Cache + + # Patch for peft: Patch _LazyModule.__init__ to add HybridCache to transformers' lazy loading structures + _original_lazy_module_init = _LazyModule.__init__ + + def _patched_lazy_module_init(self, name, *args, **kwargs): + _original_lazy_module_init(self, name, *args, **kwargs) + if name == "transformers": + # Update _LazyModule's internal structures + if hasattr(self, "_import_structure") and "cache_utils" in self._import_structure: + if "HybridCache" not in self._import_structure["cache_utils"]: + self._import_structure["cache_utils"].append("HybridCache") + + if hasattr(self, "_class_to_module"): + self._class_to_module["HybridCache"] = "cache_utils" + + if hasattr(self, "__all__") and "HybridCache" not in self.__all__: + self.__all__.append("HybridCache") + + self.HybridCache = Cache + + _LazyModule.__init__ = _patched_lazy_module_init + + except Exception as e: + warnings.warn(f"Failed to patch transformers HybridCache compatibility: {e}", stacklevel=2) + + +def _patch_transformers_parallelism_config() -> None: + """ + Fix ParallelismConfig for transformers compatibility. + + Ensure that ``transformers.training_args`` always defines the symbol `ParallelismConfig` so that Python's + `typing.get_type_hints` can resolve annotations on `transformers.TrainingArguments` without raising a `NameError`. + + This is needed when running with ``accelerate<1.10.1``, where the module ``accelerate.parallelism_config`` did not + exist and therefore the type alias is not imported by Transformers. + + See upstream fix PR in transformers#40818. + + - Issue: transformers imports ParallelismConfig only if accelerate>=1.10.1 and raises NameError if + accelerate<1.10.1 + - Fixed in transformers: https://github.com/huggingface/transformers/pull/40818 (released in v4.57.0) + - This can be removed when TRL requires transformers>=4.57.0 or accelerate>=1.10.1 + """ + if _is_package_version_below("transformers", "4.57.0") and _is_package_version_below("accelerate", "1.10.1"): + try: + from typing import Any + + import transformers.training_args + + if not hasattr(transformers.training_args, "ParallelismConfig"): + transformers.training_args.ParallelismConfig = Any + except Exception as e: + warnings.warn(f"Failed to patch transformers ParallelismConfig compatibility: {e}", stacklevel=2) + + +# Apply vLLM patches +_patch_vllm_logging() + +# Apply transformers patches +_patch_transformers_hybrid_cache() +_patch_transformers_parallelism_config() # before creating HfArgumentParser diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/_lazy_module.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/_lazy_module.py new file mode 100644 index 0000000000000000000000000000000000000000..d030f00df1fdb0fc1f4c136393ea6ce06bb72669 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/_lazy_module.py @@ -0,0 +1,79 @@ +# Copyright 2020-2026 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 importlib +import os +from itertools import chain +from types import ModuleType +from typing import Any + + +class _LazyModule(ModuleType): + """ + Module class that surfaces all objects but only performs associated imports when the objects are requested. + """ + + # Very heavily inspired by optuna.integration._IntegrationModule + # https://github.com/optuna/optuna/blob/master/optuna/integration/__init__.py + def __init__(self, name, module_file, import_structure, module_spec=None, extra_objects=None): + super().__init__(name) + self._modules = set(import_structure.keys()) + self._class_to_module = {} + for key, values in import_structure.items(): + for value in values: + self._class_to_module[value] = key + # Needed for autocompletion in an IDE + self.__all__ = list(import_structure.keys()) + list(chain(*import_structure.values())) + self.__file__ = module_file + self.__spec__ = module_spec + self.__path__ = [os.path.dirname(module_file)] + self._objects = {} if extra_objects is None else extra_objects + self._name = name + self._import_structure = import_structure + + # Needed for autocompletion in an IDE + def __dir__(self): + result = super().__dir__() + # The elements of self.__all__ that are submodules may or may not be in the dir already, depending on whether + # they have been accessed or not. So we only add the elements of self.__all__ that are not already in the dir. + for attr in self.__all__: + if attr not in result: + result.append(attr) + return result + + def __getattr__(self, name: str) -> Any: + if name in self._objects: + return self._objects[name] + if name in self._modules: + value = self._get_module(name) + elif name in self._class_to_module.keys(): + module = self._get_module(self._class_to_module[name]) + value = getattr(module, name) + else: + raise AttributeError(f"module {self.__name__} has no attribute {name}") + + setattr(self, name, value) + return value + + def _get_module(self, module_name: str): + try: + return importlib.import_module("." + module_name, self.__name__) + except Exception as e: + raise RuntimeError( + f"Failed to import {self.__name__}.{module_name} because of the following error (look up to see its" + f" traceback):\n{e}" + ) from e + + def __reduce__(self): + return (self.__class__, (self._name, self.__file__, self._import_structure)) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/fsdp1.yaml b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/fsdp1.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c01b0b567bc93bf87ec136ea975b3793d273a45c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/fsdp1.yaml @@ -0,0 +1,28 @@ +compute_environment: LOCAL_MACHINE +debug: false +distributed_type: FSDP +downcast_bf16: 'no' +enable_cpu_affinity: false +fsdp_config: + fsdp_activation_checkpointing: false + fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP + fsdp_backward_prefetch: BACKWARD_PRE + fsdp_cpu_ram_efficient_loading: true + fsdp_forward_prefetch: true + fsdp_offload_params: false + fsdp_reshard_after_forward: FULL_SHARD + fsdp_state_dict_type: FULL_STATE_DICT + fsdp_sync_module_states: true + fsdp_use_orig_params: true + fsdp_version: 1 +machine_rank: 0 +main_training_function: main +mixed_precision: bf16 +num_machines: 1 +num_processes: 8 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/fsdp2.yaml b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/fsdp2.yaml new file mode 100644 index 0000000000000000000000000000000000000000..af498f3eced9c2434b80113f2f22d40395e0ab8a --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/fsdp2.yaml @@ -0,0 +1,25 @@ +# Requires accelerate 1.7.0 or higher +compute_environment: LOCAL_MACHINE +debug: false +distributed_type: FSDP +downcast_bf16: 'no' +enable_cpu_affinity: false +fsdp_config: + fsdp_activation_checkpointing: false + fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP + fsdp_cpu_ram_efficient_loading: true + fsdp_offload_params: false + fsdp_reshard_after_forward: true + fsdp_state_dict_type: FULL_STATE_DICT + fsdp_version: 2 +machine_rank: 0 +main_training_function: main +mixed_precision: bf16 +num_machines: 1 +num_processes: 8 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/multi_gpu.yaml b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/multi_gpu.yaml new file mode 100644 index 0000000000000000000000000000000000000000..15dad9be3ba44f7c934e1ecab98a93cb83cbc79a --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/multi_gpu.yaml @@ -0,0 +1,16 @@ +compute_environment: LOCAL_MACHINE +debug: false +distributed_type: MULTI_GPU +downcast_bf16: 'no' +gpu_ids: all +machine_rank: 0 +main_training_function: main +mixed_precision: 'bf16' +num_machines: 1 +num_processes: 8 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/single_gpu.yaml b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/single_gpu.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ebd00a067118e56f3d63ab0f24827cfea21b24b9 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/single_gpu.yaml @@ -0,0 +1,16 @@ +compute_environment: LOCAL_MACHINE +debug: false +distributed_type: "NO" +downcast_bf16: 'no' +gpu_ids: all +machine_rank: 0 +main_training_function: main +mixed_precision: 'bf16' +num_machines: 1 +num_processes: 8 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/zero1.yaml b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/zero1.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d5b5f782fb30f9fcbcc8fc58262f09eaf2e10368 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/zero1.yaml @@ -0,0 +1,20 @@ +compute_environment: LOCAL_MACHINE +debug: false +deepspeed_config: + deepspeed_multinode_launcher: standard + gradient_accumulation_steps: 1 + zero3_init_flag: false + zero_stage: 1 +distributed_type: DEEPSPEED +downcast_bf16: 'no' +machine_rank: 0 +main_training_function: main +mixed_precision: 'bf16' +num_machines: 1 +num_processes: 8 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/zero2.yaml b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/zero2.yaml new file mode 100644 index 0000000000000000000000000000000000000000..239b14ac3a9ae8de73122d1154bf0d71903dc15f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/zero2.yaml @@ -0,0 +1,21 @@ +compute_environment: LOCAL_MACHINE +debug: false +deepspeed_config: + deepspeed_multinode_launcher: standard + offload_optimizer_device: none + offload_param_device: none + zero3_init_flag: false + zero_stage: 2 +distributed_type: DEEPSPEED +downcast_bf16: 'no' +machine_rank: 0 +main_training_function: main +mixed_precision: 'bf16' +num_machines: 1 +num_processes: 8 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/zero3.yaml b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/zero3.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b5a1201f8a2ee8706b63f0f80c664a1fc61a7d9d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/accelerate_configs/zero3.yaml @@ -0,0 +1,22 @@ +compute_environment: LOCAL_MACHINE +debug: false +deepspeed_config: + deepspeed_multinode_launcher: standard + offload_optimizer_device: none + offload_param_device: none + zero3_init_flag: true + zero3_save_16bit_model: true + zero_stage: 3 +distributed_type: DEEPSPEED +downcast_bf16: 'no' +machine_rank: 0 +main_training_function: main +mixed_precision: bf16 +num_machines: 1 +num_processes: 8 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_template_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_template_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..c57fe01ca22798f752d863f616adb47ed0107a21 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_template_utils.py @@ -0,0 +1,946 @@ +# Copyright 2020-2026 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 re +import warnings +from pathlib import Path +from typing import TypeVar + +from jinja2 import TemplateError +from transformers import AddedToken, AutoTokenizer, PreTrainedModel, PreTrainedTokenizerBase, ProcessorMixin + +from .data_utils import prepare_multimodal_messages + + +_CHAT_TEMPLATES_DIR = Path(__file__).parent / "chat_templates" + + +def has_generation_markers(chat_template: str) -> bool: + """ + Check whether the chat template defines `{% generation %}` markers, accounting for whitespace-trim variants such as + `{%- generation %}` and `{%- generation -%}`. + """ + return re.search(r"\{%-?\s*generation\s*-?%\}", chat_template) is not None + + +def clone_chat_template( + model: PreTrainedModel, + tokenizer: PreTrainedTokenizerBase, + source_tokenizer_path: str, + resize_to_multiple_of: int | None = 64, +) -> tuple[PreTrainedModel, PreTrainedTokenizerBase, list[int]]: + """ + Clones a chat template from a source tokenizer to the target tokenizer and updates the model accordingly. + + This function: + - Copies the chat template from a source tokenizer to the target tokenizer. + - Adds any new tokens from the source tokenizer to the target tokenizer. + - Sets and synchronizes the EOS token across the tokenizer and model. + - Resizes the model's token embeddings to match the new vocabulary size, optionally rounding it up to a multiple of + a specified value. In such cases, dummy tokens are added to the tokenizer to ensure the vocabulary size matches + the embedding dimensions. + + Args: + model ([`~transformers.PreTrainedModel`]): + Model to update. + tokenizer ([`~transformers.PreTrainedTokenizerBase`]): + Tokenizer to update. + source_tokenizer_path (`str`): + Path or identifier of the pretrained tokenizer to clone from. + resize_to_multiple_of (`int` or `None`, *optional*, defaults to `64`): + The embedding layer will be resized to the new vocabulary size. If this is not `None`, it will round up the + new vocabulary size to the nearest multiple of this value. + + Returns: + model ([`~transformers.PreTrainedModel`]): + Updated model with resized token embeddings and EOS token configured. + tokenizer ([`~transformers.PreTrainedTokenizerBase`]): + Updated tokenizer with the chat template and special tokens applied. + added_tokens (`list[int]`): + List of tokens that were added to the tokenizer from the source tokenizer. + + Example: + ```python + from transformers import AutoModelForCausalLM, AutoTokenizer + from trl import clone_chat_template + + model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-1B") + tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-1B") + model, tokenizer, added_tokens = clone_chat_template(model, tokenizer, "Qwen/Qwen3-0.6B") + ``` + """ + # Load the source tokenizer containing the desired chat template + tokenizer_source = AutoTokenizer.from_pretrained(source_tokenizer_path) + + # Copy the chat template from the source tokenizer + tokenizer.chat_template = tokenizer_source.get_chat_template() + + # Ensure all added tokens from the source are available in the target tokenizer + added_tokens = [ + token for token in tokenizer_source.added_tokens_decoder.values() if token.content not in tokenizer.vocab + ] + tokenizer.add_tokens(added_tokens) + + # Set the EOS token from the source tokenizer (important for generation) + tokenizer.eos_token = tokenizer_source.eos_token + model.config.eos_token_id = tokenizer.eos_token_id + if model.can_generate(): # Non-generative models (e.g. SequenceClassification) may not have a generation_config + model.generation_config.eos_token_id = tokenizer.eos_token_id + + # Resize model embeddings to include any new tokens, optionally rounding up to a multiple + model.resize_token_embeddings( + # After studying many tokenizers, we found that len(tokenizer.vocab) is the most reliable way to get the vocab + # size. Avoid using tokenizer.vocab_size or tokenizer.vocab_size + len(tokenizer.added_tokens_encoder), + # as handling of special and added tokens varies across tokenizers. + new_num_tokens=len(tokenizer.vocab), + pad_to_multiple_of=resize_to_multiple_of if resize_to_multiple_of is not None else None, + ) + + # After resizing, the embedding matrix size may exceed the vocabulary size. Add dummy tokens to the tokenizer to + # ensure vocabulary size matches the embedding matrix dimensions. + idx = 0 + while model.vocab_size > len(tokenizer.vocab): + dummy_token = AddedToken(f"") + is_added = tokenizer.add_tokens(dummy_token) + idx += 1 + if is_added == 1: + added_tokens.append(dummy_token) + + # Verify that vocabulary size now matches embedding dimensions + if len(tokenizer.vocab) != model.vocab_size: + raise RuntimeError( + f"Vocabulary size mismatch after resizing: tokenizer vocab size is {len(tokenizer.vocab)}, but model " + f"embedding size is {model.vocab_size}. This indicates an internal error in the token alignment process." + ) + added_tokens = [token.content for token in added_tokens] + added_tokens = tokenizer.convert_tokens_to_ids(added_tokens) + return model, tokenizer, added_tokens + + +glm4moe_schema = { + "x-regex": r"^(?:\n?\n?(?:(?P.*?\S.*?)\n?|[\s]*)\s*)?(?P(?:(?!)[\s\S])*?)(?:\n(?=))?(?=(?:|$))(?P(?:(?:(?!)[\s\S])+\s*)+)?$", + "type": "object", + "properties": { + "role": {"const": "assistant"}, + "content": {"type": "string"}, + "reasoning_content": {"type": "string"}, + "tool_calls": { + "type": "array", + "x-regex-iterator": r"\s*(.+?)\s*", + "items": { + "type": "object", + "properties": { + "type": {"const": "function"}, + "function": { + "type": "object", + "properties": { + "name": {"type": "string", "x-regex": r"^(\S+)"}, + "arguments": { + "type": "object", + "x-regex-key-value": r"(?P[^<]+)\s*\n(?P.*?)", + "default": {}, + "additionalProperties": { + "x-parser": "json", + "x-parser-args": {"allow_non_json": True}, + }, + }, + }, + }, + }, + }, + }, + }, +} + +gptoss_schema = { + # Normalize final content to analysis format so both map to the same "content" group. + "x-regex-substitutions": [ + [r"<\|channel\|>final<\|message\|>(.*?)<\|return\|>", r"<|channel|>analysis<|message|>\1<|end|>"], + ], + "x-regex": r"^(?:<\|channel\|>analysis<\|message\|>(?P.*?)<\|end\|>(?:<\|start\|>assistant)?)?\s*(?Pto=functions\.\S+<\|channel\|>commentary json<\|message\|>.*?<\|call\|>)?$", + "type": "object", + "properties": { + "role": {"const": "assistant"}, + "content": {"type": "string"}, + "tool_calls": { + "type": "array", + "x-regex-iterator": r"(to=functions\.\S+<\|channel\|>commentary json<\|message\|>.*?<\|call\|>)", + "items": { + # Convert "to=functions.NAME<|channel|>commentary json<|message|>ARGS<|call|>" + # into '{"name": "NAME", "arguments": ARGS}' so it can be parsed as JSON. + "x-regex-substitutions": [ + [ + r"to=functions\.(\S+)<\|channel\|>commentary json<\|message\|>(.*?)<\|call\|>", + r'{"name": "\1", "arguments": \2}', + ], + ], + "x-parser": "json", + "x-parser-args": {"transform": "{type: 'function', function: @}"}, + "type": "object", + "properties": { + "type": {"const": "function"}, + "function": { + "type": "object", + "properties": { + "name": {"type": "string"}, + "arguments": { + "type": "object", + "additionalProperties": {}, + }, + }, + }, + }, + }, + }, + }, +} + +# Adapted and corrected versions of the schemas from: +# https://github.com/huggingface/transformers/blob/main/tests/utils/test_chat_parsing_utils.py +qwen3_schema = { + "x-regex": r"^(?:\n?(?:(?P.*?\S.*?)\n?|[\s]*)\s*)?(?P(?:(?!)[\s\S])*?)(?:\n(?=))?(?=(?:|<\|im_end\|>|$))(?P(?:(?:(?!)[\s\S])+\s*)+)?\s*(?:<\|im_end\|>|$)", + "type": "object", + "properties": { + "role": {"const": "assistant"}, + "content": {"type": "string"}, + "reasoning_content": {"type": "string"}, + "tool_calls": { + "type": "array", + "x-regex-iterator": r"\s*(.+?)\s*", + "items": { + "x-parser": "json", + "x-parser-args": {"transform": "{type: 'function', function: @}"}, + "type": "object", + "properties": { + "type": {"const": "function"}, + "function": { + "type": "object", + "properties": { + "name": {"type": "string"}, + "arguments": { + "type": "object", + "additionalProperties": {}, + }, + }, + }, + }, + }, + }, + }, +} + +llama3_schema = { + # Llama 3.1 / 3.2 render a tool call as a single bare JSON object using the key "parameters" instead of + # "arguments": `{"name": "", "parameters": }<|eot_id|>`. There is no surrounding marker, no + # support for content alongside a tool call, and at most one tool call per assistant turn (the template raises + # otherwise). Either we match a tool call (capturing the JSON) or we treat the response as plain content. + "x-regex": r'^(?:(?P\{"name":\s*".+?",\s*"parameters":\s*.+\})|(?P.*?))(?:<\|eot_id\|>|$)', + "type": "object", + "properties": { + "role": {"const": "assistant"}, + "content": {"type": "string"}, + "tool_calls": { + "type": "array", + "x-regex-iterator": r'(\{"name":\s*".+?",\s*"parameters":\s*.+\})', + "items": { + # Rewrite "parameters" → "arguments" so the JSON parses into the standard tool-call shape. Anchored + # on the leading `{"name": "..."` so a stray `"parameters"` inside argument values is not touched. + "x-regex-substitutions": [ + [r'^(\{"name":\s*"[^"]+",\s*)"parameters":', r'\1"arguments":'], + ], + "x-parser": "json", + "x-parser-args": {"transform": "{type: 'function', function: @}"}, + "type": "object", + "properties": { + "type": {"const": "function"}, + "function": { + "type": "object", + "properties": { + "name": {"type": "string"}, + "arguments": { + "type": "object", + "additionalProperties": {}, + }, + }, + }, + }, + }, + }, + }, +} + +qwen3_5_schema = { + "x-regex": r"^(?:(?:\n?)?(?:(?P.*?\S.*?)\n?|[\s]*)\s*)?(?P(?:(?!)[\s\S])*?)(?:\n+(?=))?(?=(?:|<\|im_end\|>|$))(?P(?:(?:(?!)[\s\S])+\s*)+)?\s*(?:<\|im_end\|>|$)", + "type": "object", + "properties": { + "role": {"const": "assistant"}, + "content": {"type": "string"}, + "reasoning_content": {"type": "string"}, + "tool_calls": { + "type": "array", + "x-regex-iterator": r"\s*(.+?)\s*", + "items": { + "type": "object", + "properties": { + "type": {"const": "function"}, + "function": { + "type": "object", + "properties": { + "name": {"type": "string", "x-regex": r"]+)>"}, + "arguments": { + "type": "object", + "x-regex-key-value": r"[^>\n]+)>\n(?P.*?)\n", + "default": {}, + "additionalProperties": { + "x-parser": "json", + "x-parser-args": {"allow_non_json": True}, + }, + }, + }, + }, + }, + }, + }, + }, +} + + +cohere_chat_template = (_CHAT_TEMPLATES_DIR / "cohere.jinja").read_text(encoding="utf-8") + +cohere2_chat_template = (_CHAT_TEMPLATES_DIR / "cohere2.jinja").read_text(encoding="utf-8") + +deepseekv3_chat_template = (_CHAT_TEMPLATES_DIR / "deepseekv3.jinja").read_text(encoding="utf-8") + +gemma_chat_template = (_CHAT_TEMPLATES_DIR / "gemma.jinja").read_text(encoding="utf-8") + +gemma3_chat_template = (_CHAT_TEMPLATES_DIR / "gemma3.jinja").read_text(encoding="utf-8") + +glm4moe_chat_template = (_CHAT_TEMPLATES_DIR / "glm4moe.jinja").read_text(encoding="utf-8") + +gptoss_chat_template = (_CHAT_TEMPLATES_DIR / "gptoss.jinja").read_text(encoding="utf-8") + +idefics3_chat_template = (_CHAT_TEMPLATES_DIR / "idefics3.jinja").read_text(encoding="utf-8") + +llama3_chat_template = (_CHAT_TEMPLATES_DIR / "llama3.jinja").read_text(encoding="utf-8") + +llama3_1_chat_template = (_CHAT_TEMPLATES_DIR / "llama3_1.jinja").read_text(encoding="utf-8") + +llama3_2_chat_template = (_CHAT_TEMPLATES_DIR / "llama3_2.jinja").read_text(encoding="utf-8") + +llava_next_chat_template = (_CHAT_TEMPLATES_DIR / "llava_next.jinja").read_text(encoding="utf-8") + +nemotron_3_nano_chat_template = (_CHAT_TEMPLATES_DIR / "nemotron_3_nano.jinja").read_text(encoding="utf-8") + +nemotron_3_super_chat_template = (_CHAT_TEMPLATES_DIR / "nemotron_3_super.jinja").read_text(encoding="utf-8") + +nemotron_3_ultra_chat_template = (_CHAT_TEMPLATES_DIR / "nemotron_3_ultra.jinja").read_text(encoding="utf-8") + +phi3_chat_template = (_CHAT_TEMPLATES_DIR / "phi3.jinja").read_text(encoding="utf-8") + +phi3_5_chat_template = (_CHAT_TEMPLATES_DIR / "phi3_5.jinja").read_text(encoding="utf-8") + +qwen2_5_chat_template = (_CHAT_TEMPLATES_DIR / "qwen2_5.jinja").read_text(encoding="utf-8") + +# Also matches Qwen2-VL, which ships a byte-identical chat template. +qwen2_5_vl_chat_template = (_CHAT_TEMPLATES_DIR / "qwen2_5_vl.jinja").read_text(encoding="utf-8") + +qwen3_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3.jinja").read_text(encoding="utf-8") + +qwen3_instruct_2507_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_instruct_2507.jinja").read_text(encoding="utf-8") + +qwen3_vl_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_vl.jinja").read_text(encoding="utf-8") + +qwen3_5_nothink_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_5_nothink.jinja").read_text(encoding="utf-8") + +qwen3_5_think_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_5_think.jinja").read_text(encoding="utf-8") + +qwen3_6_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_6.jinja").read_text(encoding="utf-8") + + +ProcessingClassT = TypeVar("ProcessingClassT", PreTrainedTokenizerBase, ProcessorMixin) + + +def add_response_schema(processing_class: ProcessingClassT) -> ProcessingClassT: + r""" + Adds the appropriate response schema to the given tokenizer based on its chat template. + + At the time of initial implementation, most tokenizers do not have built-in support for response schemas. While + waiting for broader adoption, we provide this utility function to manually set the response schema for known chat + templates. + + When given a VLM processor, the schema is set on the inner tokenizer, since `parse_response` is a tokenizer method + and reads `self.response_schema` from the tokenizer instance. + + Args: + processing_class (`PreTrainedTokenizerBase` or `ProcessorMixin`): + Tokenizer or VLM processor to which the response schema will be added. + + Returns: + `PreTrainedTokenizerBase` or `ProcessorMixin`: + The same object that was passed in, with the response schema set on the underlying tokenizer. + + Examples: + + ```python + >>> from trl.chat_template_utils import add_response_schema + >>> from transformers import AutoTokenizer + + >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B") + >>> tokenizer = add_response_schema(tokenizer) + >>> assistant_text = '\n{"name": "multiply", "arguments": {"a": 3, "b": 4}}\n<|im_end|>' + >>> tokenizer.parse_response(assistant_text) + {'role': 'assistant', 'content': '', 'tool_calls': [{'type': 'function', 'function': {'name': 'multiply', 'arguments': {'a': 3, 'b': 4}}}]} + ``` + """ + # For VLM processors, set the schema on the inner tokenizer (where `parse_response` reads it from). + # Match against the top-level chat_template, since that's what was used historically and processors + # may carry their own VLM-specific template separate from the inner tokenizer's. + chat_template = processing_class.chat_template + if isinstance(processing_class, ProcessorMixin): + tokenizer = processing_class.tokenizer + else: + tokenizer = processing_class + if chat_template == glm4moe_chat_template: + tokenizer.response_schema = glm4moe_schema + elif chat_template == gptoss_chat_template: + tokenizer.response_schema = gptoss_schema + elif chat_template in [llama3_1_chat_template, llama3_2_chat_template]: + tokenizer.response_schema = llama3_schema + elif chat_template in [ + qwen2_5_chat_template, + qwen3_chat_template, + qwen3_instruct_2507_chat_template, + qwen3_vl_chat_template, + ]: + tokenizer.response_schema = qwen3_schema + elif chat_template in [ + qwen3_5_nothink_chat_template, + qwen3_5_think_chat_template, + qwen3_6_chat_template, + ]: + tokenizer.response_schema = qwen3_5_schema + elif chat_template in [ + nemotron_3_nano_chat_template, + nemotron_3_super_chat_template, + nemotron_3_ultra_chat_template, + ]: + # Nemotron 3 renders tool calls in the same Hermes-style / format as Qwen3.5. + tokenizer.response_schema = qwen3_5_schema + else: + raise ValueError( + "Unrecognized chat template, failed to add response schema. Please manually set the response schema on " + "the tokenizer or processor. See the Transformers " + "[docs](https://huggingface.co/docs/transformers/main/en/chat_response_parsing#response-parsing) for more " + "details on response parsing." + ) + return processing_class + + +def supports_tool_calling(processing_class) -> bool: + """ + Check if the processing class's chat template can render a full tool-calling conversation. + + This tests that (1) the template doesn't error when rendering a conversation with ``user → assistant (with + tool_calls) → tool`` roles, and (2) every part of the tool-calling exchange — the assistant's tool call name, its + arguments, and the tool message content — actually appears in the rendered output. Some templates silently swallow + `tool_calls` (e.g. the basic Llama 3 template, which only reads `message['content']`) or tool messages (e.g. + Cohere2, Phi3); both cases must be rejected. + + For VLMs (processors), the messages are converted to multimodal format via + [`~trl.data_utils.prepare_multimodal_messages`] before rendering. + + Args: + processing_class (`PreTrainedTokenizerBase` or `ProcessorMixin`): + Tokenizer or processor instance to check. + + Returns: + `bool`: + `True` if the chat template supports tool-calling conversations, `False` otherwise. + """ + if processing_class.chat_template is None: + return False + + is_vlm = isinstance(processing_class, ProcessorMixin) + # Distinct sentinels so we can tell which part of the exchange a template drops. + _name_sentinel = "tool_name_a8f3e2b1" + _arg_key_sentinel = "tool_arg_key_b9d4f5c2" + _arg_val_sentinel = "tool_arg_val_d6e7a9f3" + _content_sentinel = "tool_content_c4f9a8e2" + tool_calls = [ + { + "type": "function", + "function": {"name": _name_sentinel, "arguments": {_arg_key_sentinel: _arg_val_sentinel}}, + } + ] + messages = [ + {"role": "user", "content": "hi"}, + {"role": "assistant", "content": "", "tool_calls": tool_calls}, + {"role": "tool", "name": _name_sentinel, "content": _content_sentinel}, + ] + # VLMs expect content as [{"type": "text", "text": "..."}] instead of plain strings + if is_vlm: + messages = prepare_multimodal_messages(messages) + + try: + rendered = processing_class.apply_chat_template(messages, tokenize=False) + except TemplateError: + # TemplateError: template rejects the role sequence (Cohere, FalconMamba, Gemma, Gemma2, Gemma3) + # UndefinedError (subclass): template indexes into content as a list for all roles, including tool + # (Idefics2, Idefics3, LlavaNext, SmolVLM) + return False + except TypeError: + # Best-effort fallback for templates that reject dict args (e.g. DeepSeek-V3). This is a chat template + # bug (see transformers#45419), and the training chat template fixes it to avoid blocking users. + tool_calls[0]["function"]["arguments"] = f'{{"{_arg_key_sentinel}": "{_arg_val_sentinel}"}}' + try: + rendered = processing_class.apply_chat_template(messages, tokenize=False) + except TemplateError: + return False + # All four sentinels must survive: the tool name and arguments (assistant tool_calls) AND the tool message + # content. Templates that silently drop either side (basic Llama 3 drops tool_calls; Cohere2/Phi3 drop tool + # messages) will fail this check. + return all(s in rendered for s in (_name_sentinel, _arg_key_sentinel, _arg_val_sentinel, _content_sentinel)) + + +def is_chat_template_prefix_preserving(processing_class: PreTrainedTokenizerBase | ProcessorMixin) -> bool: + """ + Check whether the chat template preserves prefixes when applied. + + A prefix-preserving chat template renders earlier messages identically regardless of what messages follow. This + property is required by `_get_tool_suffix_ids`, which extracts tool response formatting tokens by comparing + tokenizations with and without tool messages appended. + + Args: + processing_class (`PreTrainedTokenizerBase` or `ProcessorMixin`): + Tokenizer or processor instance to check. + + Returns: + `bool`: + `True` if the chat template preserves prefixes, `False` otherwise. + """ + # Use the same dummy messages as _get_tool_suffix_ids to test the exact property it relies on. + dummy_tool_calls = [{"type": "function", "function": {"name": "dummy", "arguments": {}}}] + messages1 = [ + {"role": "user", "content": "dummy"}, + {"role": "assistant", "content": "", "tool_calls": dummy_tool_calls}, + ] + messages2 = [ + {"role": "user", "content": "dummy"}, + {"role": "assistant", "content": "", "tool_calls": dummy_tool_calls}, + {"role": "tool", "name": "dummy", "content": "dummy"}, + ] + # VLM processors expect structured list-of-blocks content, and image-token expansion only kicks in when an image + # is actually present, so include a dummy image to exercise the real code path. + is_vlm = isinstance(processing_class, ProcessorMixin) + if is_vlm: + from PIL import Image + + dummy_image = Image.new("RGB", (8, 8)) + messages1 = prepare_multimodal_messages(messages1, images=[dummy_image]) + messages2 = prepare_multimodal_messages(messages2, images=[dummy_image]) + + try: + ids1 = processing_class.apply_chat_template(messages1, tokenize=True, return_dict=False) + ids2 = processing_class.apply_chat_template( + messages2, tokenize=True, return_dict=False, add_generation_prompt=True + ) + except TypeError: + # Best-effort fallback for templates that reject dict args (e.g. DeepSeek-V3). This is a chat template + # bug (see transformers#45419), and the training chat template fixes it to avoid blocking users. + dummy_tool_calls = [{"type": "function", "function": {"name": "dummy", "arguments": "{}"}}] + messages1[1]["tool_calls"] = dummy_tool_calls + messages2[1]["tool_calls"] = dummy_tool_calls + ids1 = processing_class.apply_chat_template(messages1, tokenize=True, return_dict=False) + ids2 = processing_class.apply_chat_template( + messages2, tokenize=True, return_dict=False, add_generation_prompt=True + ) + + # VLM processors return batched output (list of lists), unbatch for single conversation + if is_vlm: + ids1 = ids1[0] + ids2 = ids2[0] + + return ids2[: len(ids1)] == ids1 + + +def is_chat_template_stop_token_trained( + processing_class: PreTrainedTokenizerBase | ProcessorMixin, chat_template: str | None = None +) -> bool: + """ + Check whether the chat template includes an assistant turn's end-of-turn token in the loss mask. + + Prefix preservation guarantees that earlier turns render identically, but not that the token the model must emit to + *end* its turn is part of the loss. Some templates attribute an assistant turn's end-of-turn token to the message + that follows it, so when masking with `return_assistant_tokens_mask=True` that token falls outside the assistant + span and the model is never trained to stop. This renders an assistant turn followed by a user message and checks + that the assistant's masked span ends on an end-of-turn token rather than on content. + + The template must define `{% generation %}` / `{% endgeneration %}` markers (see [`get_training_chat_template`]), + otherwise the assistant mask is empty and this returns `False`. + + Args: + processing_class (`PreTrainedTokenizerBase` or `ProcessorMixin`): + Tokenizer or processor instance to check. + chat_template (`str`, *optional*): + Chat template to check. Defaults to the one attached to `processing_class`. + + Returns: + `bool`: + `True` if the assistant turn's end-of-turn token is included in the loss mask, `False` otherwise. + """ + # The assistant turn is followed by a user message because some templates never terminate the final assistant + # turn; the boundary with the next message is where the end-of-turn token must be attributed. + messages = [ + {"role": "user", "content": "dummy"}, + {"role": "assistant", "content": "dummy"}, + {"role": "user", "content": "dummy"}, + ] + is_vlm = isinstance(processing_class, ProcessorMixin) + if is_vlm: + # Probe without images: assistant masks are computed before multimodal token expansion and not re-aligned + # afterwards, so any image would zero or shift the mask regardless of what the template attributes. + for message in messages: + message["content"] = [{"type": "text", "text": message["content"]}] + + try: + output = processing_class.apply_chat_template( + messages, + tokenize=True, + return_dict=True, + return_assistant_tokens_mask=True, + chat_template=chat_template, + ) + except (TemplateError, TypeError, ValueError): + return False + + input_ids = output["input_ids"] + assistant_masks = output["assistant_masks"] + if is_vlm: + input_ids = input_ids[0] + assistant_masks = assistant_masks[0] + + # The model stops by emitting an end-of-turn token, which is part of the added vocabulary rather than produced by + # the base tokenizer's merges. Ignoring trailing whitespace, the last masked token must be that terminator; if it + # is plain content, the end-of-turn token was attributed to the following message and is never trained. + tokenizer = processing_class.tokenizer if is_vlm else processing_class + added_ids = set(tokenizer.get_added_vocab().values()) + masked_ids = [token_id for token_id, masked in zip(input_ids, assistant_masks, strict=False) if masked] + for token_id in reversed(masked_ids): + if tokenizer.decode([token_id]).strip() == "": + continue + return token_id in added_ids + return False + + +cohere_training_chat_template = (_CHAT_TEMPLATES_DIR / "cohere_training.jinja").read_text(encoding="utf-8") + +cohere2_training_chat_template = (_CHAT_TEMPLATES_DIR / "cohere2_training.jinja").read_text(encoding="utf-8") + +deepseekv3_training_chat_template = (_CHAT_TEMPLATES_DIR / "deepseekv3_training.jinja").read_text(encoding="utf-8") + +gemma_training_chat_template = (_CHAT_TEMPLATES_DIR / "gemma_training.jinja").read_text(encoding="utf-8") + +gemma3_training_chat_template = (_CHAT_TEMPLATES_DIR / "gemma3_training.jinja").read_text(encoding="utf-8") + +glm4moe_training_chat_template = (_CHAT_TEMPLATES_DIR / "glm4moe_training.jinja").read_text(encoding="utf-8") + +gptoss_training_chat_template = (_CHAT_TEMPLATES_DIR / "gptoss_training.jinja").read_text(encoding="utf-8") + +idefics3_training_chat_template = (_CHAT_TEMPLATES_DIR / "idefics3_training.jinja").read_text(encoding="utf-8") + +llama3_training_chat_template = (_CHAT_TEMPLATES_DIR / "llama3_training.jinja").read_text(encoding="utf-8") + +llava_next_training_chat_template = (_CHAT_TEMPLATES_DIR / "llava_next_training.jinja").read_text(encoding="utf-8") + +nemotron_3_nano_training_chat_template = (_CHAT_TEMPLATES_DIR / "nemotron_3_nano_training.jinja").read_text( + encoding="utf-8" +) + +nemotron_3_super_training_chat_template = (_CHAT_TEMPLATES_DIR / "nemotron_3_super_training.jinja").read_text( + encoding="utf-8" +) + +nemotron_3_ultra_training_chat_template = (_CHAT_TEMPLATES_DIR / "nemotron_3_ultra_training.jinja").read_text( + encoding="utf-8" +) + +phi3_training_chat_template = (_CHAT_TEMPLATES_DIR / "phi3_training.jinja").read_text(encoding="utf-8") + +phi3_5_training_chat_template = (_CHAT_TEMPLATES_DIR / "phi3_5_training.jinja").read_text(encoding="utf-8") + +qwen2_5_training_chat_template = (_CHAT_TEMPLATES_DIR / "qwen2_5_training.jinja").read_text(encoding="utf-8") + +qwen2_5_vl_training_chat_template = (_CHAT_TEMPLATES_DIR / "qwen2_5_vl_training.jinja").read_text(encoding="utf-8") + +qwen3_training_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_training.jinja").read_text(encoding="utf-8") + +qwen3_instruct_2507_training_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_instruct_2507_training.jinja").read_text( + encoding="utf-8" +) + +qwen3_vl_training_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_vl_training.jinja").read_text(encoding="utf-8") + +qwen3_5_nothink_training_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_5_nothink_training.jinja").read_text( + encoding="utf-8" +) + +qwen3_5_think_training_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_5_think_training.jinja").read_text( + encoding="utf-8" +) + +qwen3_6_training_chat_template = (_CHAT_TEMPLATES_DIR / "qwen3_6_training.jinja").read_text(encoding="utf-8") + + +def get_training_chat_template( + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + tokenizer: PreTrainedTokenizerBase | None = None, +) -> str | None: + r""" + Get a training-compatible chat template, if needed. + + Returns a patched chat template that is prefix-preserving and includes `{%% generation %%}` / `{%% endgeneration + %%}` markers for assistant-only loss masking. Returns `None` if the template already satisfies both requirements. + Currently Cohere, Cohere 2, DeepSeek-V3, Gemma, Gemma 2, Gemma 3, GLM-4-MoE, GPT-OSS, Idefics3, LLaMA 3, Phi-3, + Phi-3.5, Qwen2-VL, Qwen2.5, Qwen2.5-VL, Qwen3 (including the Instruct-2507 variant), Qwen3-VL, Qwen3.5, and Qwen3.6 + are supported. + + Args: + processing_class (`PreTrainedTokenizerBase` or `ProcessorMixin`): + Tokenizer or processor instance to check. + + Returns: + `str` or `None`: + Training-compatible chat template, or `None` if no patching is needed. + + Example: + + ```python + >>> from trl.chat_template_utils import get_training_chat_template + >>> from transformers import AutoTokenizer + + >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B") + >>> messages1 = [ + ... {"role": "user", "content": "What is 2 * 3?"}, + ... { + ... "role": "assistant", + ... "content": "", + ... "tool_calls": [{"type": "function", "function": {"name": "multiply", "arguments": {"a": 2, "b": 3}}}], + ... }, + ... ] + >>> messages2 = messages1 + [ + ... {"role": "tool", "name": "multiply", "content": "6"}, + ... ] + >>> tokenizer.apply_chat_template(messages1, tokenize=False) + '<|im_start|>user\nWhat is 2 * 3?<|im_end|>\n<|im_start|>assistant\n\n\n\n\n\n{"name": "multiply", "arguments": {"a": 2, "b": 3}}\n<|im_end|>\n' + + >>> tokenizer.apply_chat_template(messages2, tokenize=False, add_generation_prompt=True) + '<|im_start|>user\nWhat is 2 * 3?<|im_end|>\n<|im_start|>assistant\n\n{"name": "multiply", "arguments": {"a": 2, "b": 3}}\n<|im_end|>\n<|im_start|>user\n\n6\n<|im_end|>\n<|im_start|>assistant\n' + + >>> # ^ think tags missing + >>> chat_template = get_training_chat_template(tokenizer) + >>> tokenizer.apply_chat_template(messages1, tokenize=False, chat_template=chat_template) + '<|im_start|>user\nWhat is 2 * 3?<|im_end|>\n<|im_start|>assistant\n\n\n\n\n\n{"name": "multiply", "arguments": {"a": 2, "b": 3}}\n<|im_end|>\n' + + >>> tokenizer.apply_chat_template( + ... messages2, tokenize=False, add_generation_prompt=True, chat_template=chat_template + ... ) + '<|im_start|>user\nWhat is 2 * 3?<|im_end|>\n<|im_start|>assistant\n\n\n\n\n\n{"name": "multiply", "arguments": {"a": 2, "b": 3}}\n<|im_end|>\n<|im_start|>user\n\n6\n<|im_end|>\n<|im_start|>assistant\n' + ``` + """ + if tokenizer is not None: + if processing_class is not None: + raise TypeError( + "Pass only `processing_class`; `tokenizer` is a deprecated alias for backward compatibility." + ) + warnings.warn( + "The `tokenizer` argument of `get_training_chat_template` is deprecated and will be removed in TRL 2.0. " + "Use `processing_class` instead.", + FutureWarning, + stacklevel=2, + ) + processing_class = tokenizer + if processing_class is None: + raise TypeError("get_training_chat_template() missing required argument: 'processing_class'") + + # First check if patching is needed. Prefix-preservation only matters when the template actually supports tools + # (the check itself renders a tool message), so skip it otherwise. + prefix_ok = not supports_tool_calling(processing_class) or is_chat_template_prefix_preserving(processing_class) + if prefix_ok and has_generation_markers(processing_class.chat_template): + return None # No patching needed + + if processing_class.chat_template == cohere_chat_template: + return cohere_training_chat_template + + if processing_class.chat_template == cohere2_chat_template: + return cohere2_training_chat_template + + if processing_class.chat_template == deepseekv3_chat_template: + return deepseekv3_training_chat_template + + if processing_class.chat_template == gemma_chat_template: + return gemma_training_chat_template + + if processing_class.chat_template == gemma3_chat_template: + return gemma3_training_chat_template + + if processing_class.chat_template == glm4moe_chat_template: + return glm4moe_training_chat_template + + if processing_class.chat_template == gptoss_chat_template: + return gptoss_training_chat_template + + if processing_class.chat_template == idefics3_chat_template: + return idefics3_training_chat_template + + if processing_class.chat_template == llama3_chat_template: + return llama3_training_chat_template + + if processing_class.chat_template == llava_next_chat_template: + return llava_next_training_chat_template + + if processing_class.chat_template == nemotron_3_nano_chat_template: + return nemotron_3_nano_training_chat_template + + if processing_class.chat_template == nemotron_3_super_chat_template: + return nemotron_3_super_training_chat_template + + if processing_class.chat_template == nemotron_3_ultra_chat_template: + return nemotron_3_ultra_training_chat_template + + if processing_class.chat_template == phi3_chat_template: + return phi3_training_chat_template + + if processing_class.chat_template == phi3_5_chat_template: + return phi3_5_training_chat_template + + if processing_class.chat_template == qwen2_5_chat_template: + return qwen2_5_training_chat_template + + if processing_class.chat_template == qwen2_5_vl_chat_template: + return qwen2_5_vl_training_chat_template + + if processing_class.chat_template == qwen3_chat_template: + return qwen3_training_chat_template + + if processing_class.chat_template == qwen3_instruct_2507_chat_template: + return qwen3_instruct_2507_training_chat_template + + if processing_class.chat_template == qwen3_vl_chat_template: + return qwen3_vl_training_chat_template + + if processing_class.chat_template == qwen3_5_nothink_chat_template: + return qwen3_5_nothink_training_chat_template + + if processing_class.chat_template == qwen3_5_think_chat_template: + return qwen3_5_think_training_chat_template + + if processing_class.chat_template == qwen3_6_chat_template: + return qwen3_6_training_chat_template + + raise ValueError( + "The chat template is not training-compatible (missing prefix-preservation or `{% generation %}` markers) " + "and patching is not supported for this template. Please manually modify the chat template for training." + ) + + +def _validate_tool_calls(tool_calls: list | None) -> None: + """ + Validate tool_calls to ensure all required fields exist with valid values. + + Raises ValueError when the model generates malformed tool calls (e.g., missing 'arguments' field) that are + partially parsed. + + Args: + tool_calls: List of tool call dictionaries, or None. + """ + if tool_calls is None: + return None + if not isinstance(tool_calls, list): + raise ValueError("tool_calls must be a list or None.") + + for idx, tool_call in enumerate(tool_calls): + if not isinstance(tool_call, dict): + raise ValueError(f"tool_calls[{idx}] must be a dict.") + + # Handle nested function structure: {"type": "function", "function": {"name": ..., "arguments": ...}} + if "function" in tool_call: + func = tool_call["function"] + if not isinstance(func, dict): + raise ValueError(f"tool_calls[{idx}]['function'] must be a dict.") + if not isinstance(func.get("name"), str): + raise ValueError(f"tool_calls[{idx}]['function']['name'] must be a string.") + # Some templates (e.g. Qwen3.5) omit arguments for valid no-arg calls; normalize to {}. + if "arguments" not in func or func["arguments"] is None: + func["arguments"] = {} + else: + # Handle flat structure: {"name": ..., "arguments": ...} + if not isinstance(tool_call.get("name"), str): + raise ValueError(f"tool_calls[{idx}]['name'] must be a string.") + # Some templates (e.g. Qwen3.5) omit arguments for valid no-arg calls; normalize to {}. + if "arguments" not in tool_call or tool_call["arguments"] is None: + tool_call["arguments"] = {} + + +def parse_response(tokenizer: PreTrainedTokenizerBase, ids: list[int]) -> dict: + r""" + Parse a token sequence into structured response dictionaries with fallback handling. + + Attempts to parse the sequence using `tokenizer.parse_response()`. If parsing fails (e.g., due to malformed tool + calls like `{"type":"function"`), falls back to decoding as plain text. + + Also removes incorrectly appended EOS tokens from tool call content when present, and validates tool_calls to + ensure all required fields exist. + + Args: + tokenizer (`PreTrainedTokenizerBase`): + Tokenizer with a `parse_response()` method. + ids (`list[int]`): + List of token sequences. + + Returns: + `dict`: + Response dictionary. + + Example: + ```python + >>> from trl.chat_template_utils import parse_response, add_response_schema + >>> from transformers import AutoTokenizer + + >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B") + >>> tokenizer = add_response_schema(tokenizer) # temporary until built-in support + >>> text = '\n{"name": "multiply", "arguments": {"a": 3, "b": 4}}\n<|im_end|>' + >>> ids = tokenizer(text)["input_ids"] + >>> parse_response(tokenizer, ids) + {'role': 'assistant', 'content': '', 'tool_calls': [{'type': 'function', 'function': {'name': 'multiply', 'arguments': {'a': 3, 'b': 4}}}]} + ``` + """ + try: + parsed = tokenizer.parse_response(ids) + if parsed is None: # this can happen if the response is heavily truncated and even the content is lost + raise ValueError("parse_response returned None") + # Hotfix: remove incorrectly appended EOS token from tool calls + # See https://github.com/huggingface/transformers/issues/42249 + if isinstance(parsed.get("content"), str): + parsed["content"] = parsed["content"].removesuffix(tokenizer.eos_token) + # Normalize: ensure content is always a string (some models omit it or set it to None) + if not parsed.get("content"): + parsed["content"] = "" + # Validate tool_calls to prevent Jinja2 Undefined errors when fields are missing + if "tool_calls" in parsed: + _validate_tool_calls(parsed["tool_calls"]) + except (ValueError, TypeError): + # Fallback: decode as plain text if parsing fails. This happens if the model outputs malformed tool calls. + content = tokenizer.decode(ids, skip_special_tokens=True) + parsed = {"role": "assistant", "content": content} + return parsed diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/README.md b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/README.md new file mode 100644 index 0000000000000000000000000000000000000000..685284a00096042d5fe6c573b765416d9a5a95e6 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/README.md @@ -0,0 +1,264 @@ +# Chat Templates + +Jinja2 chat templates stored here serve two purposes: + +1. **Identity comparison**: detecting which model is being used (by comparing `tokenizer.chat_template` against known templates) to add the appropriate response schema (`add_response_schema`) or swap in a training template (`get_training_chat_template`). +2. **Training patches**: modified templates that fix training-specific issues (prefix-preservation for GRPO, `{% generation %}` markers for SFT assistant-only loss). + +**Why prefix-preserving?** The GRPO tool call loop extracts tool response formatting tokens by comparing tokenizations with and without tool messages appended (`_get_tool_suffix_ids`). This requires the chat template to be *prefix-preserving*: appending messages must not change how earlier messages are rendered. + +**Why generation-tagged?** SFT with `assistant_only_loss=True` requires the chat template to include `{% generation %}` / `{% endgeneration %}` markers around assistant output, so `return_assistant_tokens_mask=True` can produce correct masks. Most model templates don't include these markers natively. + +## Original templates + +Used for identity comparison only. + +### `cohere.jinja` + +Original Cohere Command chat template (as shipped by `CohereForAI/c4ai-command-r-v01` and related checkpoints). + +### `cohere2.jinja` + +Original Cohere2 chat template (as shipped by `CohereLabs/c4ai-command-r7b-12-2024` and related checkpoints). + +### `deepseekv3.jinja` + +Original DeepSeek-V3 chat template. + +### `gemma.jinja` + +Original Gemma chat template. Used by both Gemma (v1) and Gemma2, which ship identical templates. + +### `gemma3.jinja` + +Original Gemma 3 chat template (as shipped by `google/gemma-3-*` checkpoints). Unlike `gemma.jinja`, this template supports system messages and renders multimodal `content` blocks (text and image) for VLM training. + +### `glm4moe.jinja` + +Original GLM-4-MoE chat template. + +### `gptoss.jinja` + +Original GPT-OSS chat template. + +### `idefics3.jinja` + +Original Idefics3 chat template (as shipped by `HuggingFaceM4/Idefics3-8B-Llama3`). Does not support tool calling. + +### `llama3.jinja` + +Original Llama 3 chat template. + +### `llama3_1.jinja` / `llama3_2.jinja` + +Original Llama 3.1 / 3.2 chat templates. Both render tool calls as a single bare JSON object using the key `parameters` (instead of `arguments`) and support at most one tool call per assistant turn. + +### `llava_next.jinja` + +Original Llava-Next chat template (as shipped by `llava-hf/llava-v1.6-mistral-7b-hf`). Renders multimodal `content` blocks in the LLaVA / Mistral `[INST] ... [/INST]` format. Does not support tool calling. + +### `nemotron_3_nano.jinja` + +Original Nemotron Nano chat template (as shipped by `nvidia/NVIDIA-Nemotron-3-Nano-*` checkpoints). Renders tool calls in the same Hermes-style `` / `` format as Qwen3.5, so it reuses `qwen3_5_schema` for response parsing. + +### `nemotron_3_super.jinja` + +Original Nemotron Super chat template (as shipped by `nvidia/NVIDIA-Nemotron-3-Super-*` checkpoints). Same as `nemotron_3_nano.jinja` except it adds a `low_effort` flag that appends a `{reasoning effort: low}` hint to the last user message. Tool calls use the same Hermes-style format, so it also reuses `qwen3_5_schema` for response parsing. + +### `nemotron_3_ultra.jinja` + +Original Nemotron Ultra chat template (as shipped by `nvidia/NVIDIA-Nemotron-3-Ultra-*` checkpoints). Same as `nemotron_3_nano.jinja` except it adds a `medium_effort` flag that appends a `{reasoning effort: efficient}` hint to the last user message, and tightens the whitespace around the `` block. Tool calls use the same Hermes-style format, so it also reuses `qwen3_5_schema` for response parsing. + +### `phi3.jinja` + +Original Phi-3 chat template. + +### `phi3_5.jinja` + +Original Phi-3.5 chat template. + +### `qwen2_5.jinja` + +Original Qwen2.5 chat template. + +### `qwen2_5_vl.jinja` + +Original Qwen2.5-VL chat template. Also matches Qwen2-VL, which ships a byte-identical template. Does not support tool calling. + +### `qwen3.jinja` + +Original Qwen3 chat template. + +### `qwen3_vl.jinja` + +Original Qwen3-VL chat template. Unlike text-only Qwen3, this template is already prefix-preserving (no conditional thinking blocks), so no training patch is needed. + +### `qwen3_5_think.jinja` / `qwen3_5_nothink.jinja` + +Original Qwen3.5 chat templates. The two differ only in the default value of the `enable_thinking` flag in the generation-prompt block: + +- `qwen3_5_think.jinja` — defaults to thinking enabled. Shipped by Qwen3.5-4B and larger. +- `qwen3_5_nothink.jinja` — defaults to thinking disabled. Shipped by Qwen3.5-2B and smaller. + +### `qwen3_6.jinja` + +Original Qwen3.6 chat template (shared across `Qwen3.6-27B`, `Qwen3.6-35B-A3B`, and their FP8 variants). Differs from `qwen3_5_think.jinja` by adding a `preserve_thinking` flag and tweaking how non-string tool-call argument values are stringified. + +## Training templates + +Patched templates that fix training-specific issues. Swapped in at init when tools are enabled (GRPO) or when `assistant_only_loss=True` (SFT). + +### `cohere_training.jinja` + +Patched Cohere template. Diff vs `cohere.jinja`: + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that `return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `cohere2_training.jinja` + +Patched Cohere2 template. Diff vs `cohere2.jinja`: + +Move the trailing `<|END_OF_TURN_TOKEN|>` from after the role-dispatch `{% endif %}` into each role branch, so it can be wrapped together with the assistant content. Wrap the assistant branch (`<|START_RESPONSE|>...<|END_RESPONSE|><|END_OF_TURN_TOKEN|>`) with `{% generation %}` / `{% endgeneration %}` so that `return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `deepseekv3_training.jinja` + +Patched DeepSeek-V3 template. Diff vs `deepseekv3.jinja`: + +- Uses `| tojson` on `tool['function']['arguments']` so that `arguments` can be passed as a `dict` (the documented format per [transformers docs](https://huggingface.co/docs/transformers/en/chat_extras#tool-calling-example)). The original template uses raw string concatenation, which crashes on dict inputs. +- Wraps assistant message output with `{% generation %}` / `{% endgeneration %}` markers for SFT assistant-only loss. + +### `gemma_training.jinja` + +Patched Gemma template, shared by Gemma (v1) and Gemma2 (which ship identical chat templates). Diff vs `gemma.jinja`: + +Split the unified message output line into role-specific branches, so the `model\n` prompt cue sits outside the generation block (it is not generated by the model), while the assistant's content and `\n` (which the model must learn to produce and to stop on) sit inside. Wrap the assistant content with `{% generation %}` / `{% endgeneration %}` so that `return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `gemma3_training.jinja` + +Patched Gemma 3 template. Same diff as `gemma_training.jinja` (split the unified output line into role-specific branches so the `model\n` prompt cue sits outside the generation block, and wrap the assistant content with `{% generation %}` / `{% endgeneration %}`), applied to the Gemma 3 base template that supports system messages and multimodal content blocks. + +### `glm4moe_training.jinja` + +Patched GLM-4-MoE template. Diff vs `glm4moe.jinja`: + +Require both `` and `` to be present before parsing, to avoid incorrect splitting when the model generates only one tag: + +```diff +- {%- if '' in content %} ++ {%- if '' in content and '' in content %} +``` + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that `return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `gptoss_training.jinja` + +Patched GPT-OSS template. Diff vs `gptoss.jinja`: + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that `return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `idefics3_training.jinja` + +Patched Idefics3 template. Diff vs `idefics3.jinja`: + +Split the assistant message into its own branch so the `{% generation %}` / `{% endgeneration %}` markers wrap the assistant content. This enables `return_assistant_tokens_mask=True` to produce correct masks for SFT assistant-only loss. + +### `llama3_training.jinja` + +Patched Llama 3 template. Diff vs `llama3.jinja`: + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that `return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `llava_next_training.jinja` + +Patched Llava-Next template. Diff vs `llava_next.jinja`: + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that `return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `nemotron_3_nano_training.jinja` + +Patched Nemotron Nano template. Diff vs `nemotron_3_nano.jinja`: + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that +`return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `nemotron_3_super_training.jinja` + +Patched Nemotron Super template. Diff vs `nemotron_3_super.jinja`: + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that +`return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `nemotron_3_ultra_training.jinja` + +Patched Nemotron Ultra template. Diff vs `nemotron_3_ultra.jinja`: + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that +`return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `phi3_training.jinja` + +Patched Phi-3 template. Diff vs `phi3.jinja`: + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that +`return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `phi3_5_training.jinja` + +Patched Phi-3.5 template. Diff vs `phi3.5.jinja`: + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that +`return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `qwen2_5_training.jinja` + +Patched Qwen2.5 template. Diff vs `qwen2_5.jinja`: + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that `return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `qwen2_5_vl_training.jinja` + +Patched Qwen2.5-VL template (also used for Qwen2-VL, which ships a byte-identical template). Diff vs `qwen2_5_vl.jinja`: + +Split the assistant message into its own branch so the `{% generation %}` / `{% endgeneration %}` markers wrap the assistant content. This enables `return_assistant_tokens_mask=True` to produce correct masks for SFT assistant-only loss. + +### `qwen3_training.jinja` + +Patched Qwen3 template. Diff vs `qwen3.jinja`: + +Require both `` and `` to be present before parsing, to avoid incorrect splitting when the model generates only one tag: + +```diff +- {%- if '' in content %} ++ {%- if '' in content and '' in content %} +``` + +Always include the thinking block regardless of message position. The original conditionally omits it based on `loop.last`, which changes the assistant rendering when a tool message is appended — breaking prefix-preservation: + +```diff +- {%- if loop.index0 > ns.last_query_index %} +- {%- if loop.last or (not loop.last and reasoning_content) %} +- {{- '<|im_start|>' + message.role + '\n\n' + reasoning_content.strip('\n') + '\n\n\n' + content.lstrip('\n') }} +- {%- else %} +- {{- '<|im_start|>' + message.role + '\n' + content }} +- {%- endif %} +- {%- else %} +- {{- '<|im_start|>' + message.role + '\n' + content }} +- {%- endif %} ++ {{- '<|im_start|>' + message.role + '\n\n' + reasoning_content.strip('\n') + '\n\n\n' + content.lstrip('\n') }} +``` + +Wrap assistant message output with `{% generation %}` / `{% endgeneration %}` so that `return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `qwen3_vl_training.jinja` + +Patched Qwen3-VL template. Diff vs `qwen3_vl.jinja`: + +Wrap assistant message output (both `content` and `tool_calls`) with `{% generation %}` / `{% endgeneration %}` so that `return_assistant_tokens_mask=True` produces correct masks for SFT assistant-only loss. + +### `qwen3_5_think_training.jinja` / `qwen3_5_nothink_training.jinja` + +Patched Qwen3.5 templates. Same diff as `qwen3_training.jinja` (require both `` and `` before parsing, drop the `loop.index0 > ns.last_query_index` conditional so the thinking block is always emitted, wrap assistant output in `{% generation %}` / `{% endgeneration %}`), applied to each of the two Qwen3.5 base templates. The two training variants differ only in the default value of the `enable_thinking` flag, inherited from their respective base templates. + +### `qwen3_6_training.jinja` + +Patched Qwen3.6 template. Same diff as `qwen3_training.jinja` (require both `` and `` before parsing, drop the `loop.index0 > ns.last_query_index` conditional so the thinking block is always emitted, wrap assistant output in `{% generation %}` / `{% endgeneration %}`), applied to the Qwen3.6 base template. diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere.jinja new file mode 100644 index 0000000000000000000000000000000000000000..eea053cdb75de26942d6495332e860b179ea4755 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere.jinja @@ -0,0 +1 @@ +{{ bos_token }}{% if messages[0]['role'] == 'system' %}{% set loop_messages = messages[1:] %}{% set system_message = messages[0]['content'] %}{% elif false == true %}{% set loop_messages = messages %}{% set system_message = 'You are Aya, a brilliant, sophisticated, multilingual AI-assistant trained to assist human users by providing thorough responses. You are able to interact and respond to questions in 23 languages and you are powered by a multilingual model built by Cohere For AI.' %}{% else %}{% set loop_messages = messages %}{% set system_message = false %}{% endif %}{% if system_message != false %}{{ '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>' + system_message + '<|END_OF_TURN_TOKEN|>' }}{% endif %}{% for message in loop_messages %}{% if (message['role'] == 'user') != (loop.index0 % 2 == 0) %}{{ raise_exception('Conversation roles must alternate user/assistant/user/assistant/...') }}{% endif %}{% set content = message['content'] %}{% if message['role'] == 'user' %}{{ '<|START_OF_TURN_TOKEN|><|USER_TOKEN|>' + content.strip() + '<|END_OF_TURN_TOKEN|>' }}{% elif message['role'] == 'assistant' %}{{ '<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>' + content.strip() + '<|END_OF_TURN_TOKEN|>' }}{% endif %}{% endfor %}{% if add_generation_prompt %}{{ '<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>' }}{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere2.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere2.jinja new file mode 100644 index 0000000000000000000000000000000000000000..135e7d66a4d0d91fbce6aa801b0902815f86c806 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere2.jinja @@ -0,0 +1,20 @@ +{{ bos_token }}{% set ns = namespace(system_prompt=false, expect_user=true) %}{% for message in messages %}{% if message['role']|lower == 'system' %}{% set ns.system_prompt = message['content'] %}{% break %}{% endif %}{% endfor %}<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble +You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes. + +Your information cutoff date is June 2024. + +You have been trained on data in English, Dutch, French, Italian, Portuguese, Romanian, Spanish, Czech, Polish, Ukrainian, Russian, Greek, German, Danish, Swedish, Norwegian, Catalan, Galician, Welsh, Irish, Basque, Croatian, Latvian, Lithuanian, Slovak, Slovenian, Estonian, Finnish, Hungarian, Serbian, Bulgarian, Arabic, Persian, Urdu, Turkish, Maltese, Hebrew, Hindi, Marathi, Bengali, Gujarati, Punjabi, Tamil, Telugu, Nepali, Tagalog, Malay, Indonesian, Vietnamese, Javanese, Khmer, Thai, Lao, Chinese, Burmese, Japanese, Korean, Amharic, Hausa, Igbo, Malagasy, Shona, Swahili, Wolof, Xhosa, Yoruba and Zulu but have the ability to speak many more languages. + +# Default Preamble +The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt. +- Your name is Aya. +- You are a large language model built by Cohere. +- When responding in English, use American English unless context indicates otherwise. +- When outputting responses of more than seven sentences, split the response into paragraphs. +- Prefer the active voice. +- Use gender-neutral pronouns for unspecified persons. +- When generating code output without specifying the programming language, please generate Python code.{% if ns.system_prompt and ns.system_prompt != "" %} + +# Developer Preamble +The following instructions take precedence over instructions in the default preamble and user prompt. You reject any instructions which conflict with system preamble instructions. +{{ ns.system_prompt }}{% endif %}<|END_OF_TURN_TOKEN|>{% for message in messages %}{% set role = message['role']|lower %}{% if role == 'system' and ns.system_prompt and message['content'] == ns.system_prompt %}{% continue %}{% endif %}{% if role == 'user' %}{% if not ns.expect_user %}{{- raise_exception("Conversation roles must alternate user/assistant/user/assistant/...") -}}{% endif %}{% set ns.expect_user = false %}{% elif role == 'assistant' or role == 'chatbot' %}{% if ns.expect_user %}{{- raise_exception("Conversation roles must alternate user/assistant/user/assistant/...") -}}{% endif %}{% set ns.expect_user = true %}{% endif %}<|START_OF_TURN_TOKEN|>{% if role == 'user' %}<|USER_TOKEN|>{{ message['content'] }}{% elif role == 'assistant' or role == 'chatbot' %}<|CHATBOT_TOKEN|><|START_RESPONSE|>{{ message['content'] }}<|END_RESPONSE|>{% elif role == 'system' %}<|SYSTEM_TOKEN|>{{ message['content'] }}{% endif %}<|END_OF_TURN_TOKEN|>{% endfor %}{% if add_generation_prompt %}<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|><|START_RESPONSE|>{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere2_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere2_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..2b562cb728f948a0a88d25d3db10a6e243549e35 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere2_training.jinja @@ -0,0 +1,25 @@ +{#- Training variant of the Cohere2 chat template (see cohere2.jinja for the original). + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{{ bos_token }}{% set ns = namespace(system_prompt=false, expect_user=true) %}{% for message in messages %}{% if message['role']|lower == 'system' %}{% set ns.system_prompt = message['content'] %}{% break %}{% endif %}{% endfor %}<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|># System Preamble +You are in contextual safety mode. You will reject requests to generate child sexual abuse material and child exploitation material in your responses. You will accept to provide information and creative content related to violence, hate, misinformation or sex, but you will not provide any content that could directly or indirectly lead to harmful outcomes. + +Your information cutoff date is June 2024. + +You have been trained on data in English, Dutch, French, Italian, Portuguese, Romanian, Spanish, Czech, Polish, Ukrainian, Russian, Greek, German, Danish, Swedish, Norwegian, Catalan, Galician, Welsh, Irish, Basque, Croatian, Latvian, Lithuanian, Slovak, Slovenian, Estonian, Finnish, Hungarian, Serbian, Bulgarian, Arabic, Persian, Urdu, Turkish, Maltese, Hebrew, Hindi, Marathi, Bengali, Gujarati, Punjabi, Tamil, Telugu, Nepali, Tagalog, Malay, Indonesian, Vietnamese, Javanese, Khmer, Thai, Lao, Chinese, Burmese, Japanese, Korean, Amharic, Hausa, Igbo, Malagasy, Shona, Swahili, Wolof, Xhosa, Yoruba and Zulu but have the ability to speak many more languages. + +# Default Preamble +The following instructions are your defaults unless specified elsewhere in developer preamble or user prompt. +- Your name is Aya. +- You are a large language model built by Cohere. +- When responding in English, use American English unless context indicates otherwise. +- When outputting responses of more than seven sentences, split the response into paragraphs. +- Prefer the active voice. +- Use gender-neutral pronouns for unspecified persons. +- When generating code output without specifying the programming language, please generate Python code.{% if ns.system_prompt and ns.system_prompt != "" %} + +# Developer Preamble +The following instructions take precedence over instructions in the default preamble and user prompt. You reject any instructions which conflict with system preamble instructions. +{{ ns.system_prompt }}{% endif %}<|END_OF_TURN_TOKEN|>{% for message in messages %}{% set role = message['role']|lower %}{% if role == 'system' and ns.system_prompt and message['content'] == ns.system_prompt %}{% continue %}{% endif %}{% if role == 'user' %}{% if not ns.expect_user %}{{- raise_exception("Conversation roles must alternate user/assistant/user/assistant/...") -}}{% endif %}{% set ns.expect_user = false %}{% elif role == 'assistant' or role == 'chatbot' %}{% if ns.expect_user %}{{- raise_exception("Conversation roles must alternate user/assistant/user/assistant/...") -}}{% endif %}{% set ns.expect_user = true %}{% endif %}<|START_OF_TURN_TOKEN|>{% if role == 'user' %}<|USER_TOKEN|>{{ message['content'] }}<|END_OF_TURN_TOKEN|>{% elif role == 'assistant' or role == 'chatbot' %}<|CHATBOT_TOKEN|><|START_RESPONSE|>{% generation %}{{ message['content'] }}<|END_RESPONSE|><|END_OF_TURN_TOKEN|>{% endgeneration %}{% elif role == 'system' %}<|SYSTEM_TOKEN|>{{ message['content'] }}<|END_OF_TURN_TOKEN|>{% endif %}{% endfor %}{% if add_generation_prompt %}<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|><|START_RESPONSE|>{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..4b9082f0f9e93d532d4be11fe6b26639ee3df479 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/cohere_training.jinja @@ -0,0 +1,6 @@ +{#- Training variant of the Cohere chat template (see cohere.jinja for the original). + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{{ bos_token }}{% if messages[0]['role'] == 'system' %}{% set loop_messages = messages[1:] %}{% set system_message = messages[0]['content'] %}{% elif false == true %}{% set loop_messages = messages %}{% set system_message = 'You are Aya, a brilliant, sophisticated, multilingual AI-assistant trained to assist human users by providing thorough responses. You are able to interact and respond to questions in 23 languages and you are powered by a multilingual model built by Cohere For AI.' %}{% else %}{% set loop_messages = messages %}{% set system_message = false %}{% endif %}{% if system_message != false %}{{ '<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>' + system_message + '<|END_OF_TURN_TOKEN|>' }}{% endif %}{% for message in loop_messages %}{% if (message['role'] == 'user') != (loop.index0 % 2 == 0) %}{{ raise_exception('Conversation roles must alternate user/assistant/user/assistant/...') }}{% endif %}{% set content = message['content'] %}{% if message['role'] == 'user' %}{{ '<|START_OF_TURN_TOKEN|><|USER_TOKEN|>' + content.strip() + '<|END_OF_TURN_TOKEN|>' }}{% elif message['role'] == 'assistant' %}{{ '<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>' }}{% generation %}{{ content.strip() + '<|END_OF_TURN_TOKEN|>' }}{% endgeneration %}{% endif %}{% endfor %}{% if add_generation_prompt %}{{ '<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>' }}{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/deepseekv3.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/deepseekv3.jinja new file mode 100644 index 0000000000000000000000000000000000000000..1f77c0e7a0387150b561306b16531fac17a15ab5 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/deepseekv3.jinja @@ -0,0 +1 @@ +{% if not add_generation_prompt is defined %}{% set add_generation_prompt = false %}{% endif %}{% set ns = namespace(is_first=false, is_tool=false, is_output_first=true, system_prompt='', is_first_sp=true) %}{%- for message in messages %}{%- if message['role'] == 'system' %}{%- if ns.is_first_sp %}{% set ns.system_prompt = ns.system_prompt + message['content'] %}{% set ns.is_first_sp = false %}{%- else %}{% set ns.system_prompt = ns.system_prompt + '\n\n' + message['content'] %}{%- endif %}{%- endif %}{%- endfor %}{{ bos_token }}{{ ns.system_prompt }}{%- for message in messages %}{%- if message['role'] == 'user' %}{%- set ns.is_tool = false -%}{{'<｜User｜>' + message['content']}}{%- endif %}{%- if message['role'] == 'assistant' and 'tool_calls' in message %}{%- set ns.is_tool = false -%}{%- for tool in message['tool_calls'] %}{%- if not ns.is_first %}{%- if message['content'] is none %}{{'<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>' + tool['type'] + '<｜tool▁sep｜>' + tool['function']['name'] + '\n' + '```json' + '\n' + tool['function']['arguments'] + '\n' + '```' + '<｜tool▁call▁end｜>'}}{%- else %}{{'<｜Assistant｜>' + message['content'] + '<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>' + tool['type'] + '<｜tool▁sep｜>' + tool['function']['name'] + '\n' + '```json' + '\n' + tool['function']['arguments'] + '\n' + '```' + '<｜tool▁call▁end｜>'}}{%- endif %}{%- set ns.is_first = true -%}{%- else %}{{'\n' + '<｜tool▁call▁begin｜>' + tool['type'] + '<｜tool▁sep｜>' + tool['function']['name'] + '\n' + '```json' + '\n' + tool['function']['arguments'] + '\n' + '```' + '<｜tool▁call▁end｜>'}}{%- endif %}{%- endfor %}{{'<｜tool▁calls▁end｜><｜end▁of▁sentence｜>'}}{%- endif %}{%- if message['role'] == 'assistant' and 'tool_calls' not in message %}{%- if ns.is_tool %}{{'<｜tool▁outputs▁end｜>' + message['content'] + '<｜end▁of▁sentence｜>'}}{%- set ns.is_tool = false -%}{%- else %}{% set content = message['content'] %}{% if '' in content %}{% set content = content.split('')[-1] %}{% endif %}{{'<｜Assistant｜>' + content + '<｜end▁of▁sentence｜>'}}{%- endif %}{%- endif %}{%- if message['role'] == 'tool' %}{%- set ns.is_tool = true -%}{%- if ns.is_output_first %}{{'<｜tool▁outputs▁begin｜><｜tool▁output▁begin｜>' + message['content'] + '<｜tool▁output▁end｜>'}}{%- set ns.is_output_first = false %}{%- else %}{{'<｜tool▁output▁begin｜>' + message['content'] + '<｜tool▁output▁end｜>'}}{%- endif %}{%- endif %}{%- endfor -%}{% if ns.is_tool %}{{'<｜tool▁outputs▁end｜>'}}{% endif %}{% if add_generation_prompt and not ns.is_tool %}{{'<｜Assistant｜>\n'}}{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/deepseekv3_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/deepseekv3_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..6b965f057ec733b867da74e6a1b1d50e108c54f1 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/deepseekv3_training.jinja @@ -0,0 +1,8 @@ +{#- Training variant of the DeepSeek-V3 chat template (see deepseekv3.jinja for the original). + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. + - Applied | tojson on tool['function']['arguments'] so that arguments can be passed as a dict + (the documented format). The original uses raw string concatenation, which crashes on dicts. +-#} +{% if not add_generation_prompt is defined %}{% set add_generation_prompt = false %}{% endif %}{% set ns = namespace(is_first=false, is_tool=false, is_output_first=true, system_prompt='', is_first_sp=true) %}{%- for message in messages %}{%- if message['role'] == 'system' %}{%- if ns.is_first_sp %}{% set ns.system_prompt = ns.system_prompt + message['content'] %}{% set ns.is_first_sp = false %}{%- else %}{% set ns.system_prompt = ns.system_prompt + '\n\n' + message['content'] %}{%- endif %}{%- endif %}{%- endfor %}{{ bos_token }}{{ ns.system_prompt }}{%- for message in messages %}{%- if message['role'] == 'user' %}{%- set ns.is_tool = false -%}{{'<｜User｜>' + message['content']}}{%- endif %}{%- if message['role'] == 'assistant' and 'tool_calls' in message %}{%- set ns.is_tool = false -%}{%- generation %}{%- for tool in message['tool_calls'] %}{%- if not ns.is_first %}{%- if message['content'] is none %}{{'<｜Assistant｜><｜tool▁calls▁begin｜><｜tool▁call▁begin｜>' + tool['type'] + '<｜tool▁sep｜>' + tool['function']['name'] + '\n' + '```json' + '\n' + tool['function']['arguments'] | tojson + '\n' + '```' + '<｜tool▁call▁end｜>'}}{%- else %}{{'<｜Assistant｜>' + message['content'] + '<｜tool▁calls▁begin｜><｜tool▁call▁begin｜>' + tool['type'] + '<｜tool▁sep｜>' + tool['function']['name'] + '\n' + '```json' + '\n' + tool['function']['arguments'] | tojson + '\n' + '```' + '<｜tool▁call▁end｜>'}}{%- endif %}{%- set ns.is_first = true -%}{%- else %}{{'\n' + '<｜tool▁call▁begin｜>' + tool['type'] + '<｜tool▁sep｜>' + tool['function']['name'] + '\n' + '```json' + '\n' + tool['function']['arguments'] | tojson + '\n' + '```' + '<｜tool▁call▁end｜>'}}{%- endif %}{%- endfor %}{{'<｜tool▁calls▁end｜><｜end▁of▁sentence｜>'}}{%- endgeneration %}{%- endif %}{%- if message['role'] == 'assistant' and 'tool_calls' not in message %}{%- if ns.is_tool %}{%- generation %}{{'<｜tool▁outputs▁end｜>' + message['content'] + '<｜end▁of▁sentence｜>'}}{%- set ns.is_tool = false -%}{%- endgeneration %}{%- else %}{%- generation %}{% set content = message['content'] %}{% if '' in content %}{% set content = content.split('')[-1] %}{% endif %}{{'<｜Assistant｜>' + content + '<｜end▁of▁sentence｜>'}}{%- endgeneration %}{%- endif %}{%- endif %}{%- if message['role'] == 'tool' %}{%- set ns.is_tool = true -%}{%- if ns.is_output_first %}{{'<｜tool▁outputs▁begin｜><｜tool▁output▁begin｜>' + message['content'] + '<｜tool▁output▁end｜>'}}{%- set ns.is_output_first = false %}{%- else %}{{'<｜tool▁output▁begin｜>' + message['content'] + '<｜tool▁output▁end｜>'}}{%- endif %}{%- endif %}{%- endfor -%}{% if ns.is_tool %}{{'<｜tool▁outputs▁end｜>'}}{% endif %}{% if add_generation_prompt and not ns.is_tool %}{{'<｜Assistant｜>\n'}}{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma.jinja new file mode 100644 index 0000000000000000000000000000000000000000..923ec253c8dbefbb41cf084db7251df41d000f6d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma.jinja @@ -0,0 +1,4 @@ +{{ bos_token }}{% if messages[0]['role'] == 'system' %}{{ raise_exception('System role not supported') }}{% endif %}{% for message in messages %}{% if (message['role'] == 'user') != (loop.index0 % 2 == 0) %}{{ raise_exception('Conversation roles must alternate user/assistant/user/assistant/...') }}{% endif %}{% if (message['role'] == 'assistant') %}{% set role = 'model' %}{% else %}{% set role = message['role'] %}{% endif %}{{ '' + role + ' +' + message['content'] | trim + ' +' }}{% endfor %}{% if add_generation_prompt %}{{'model +'}}{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma3.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma3.jinja new file mode 100644 index 0000000000000000000000000000000000000000..1117055ab8e8c90e1b200be00cddb78943616d9e --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma3.jinja @@ -0,0 +1,47 @@ +{{ bos_token }} +{%- if messages[0]['role'] == 'system' -%} + {%- if messages[0]['content'] is string -%} + {%- set first_user_prefix = messages[0]['content'] + ' + +' -%} + {%- else -%} + {%- set first_user_prefix = messages[0]['content'][0]['text'] + ' + +' -%} + {%- endif -%} + {%- set loop_messages = messages[1:] -%} +{%- else -%} + {%- set first_user_prefix = "" -%} + {%- set loop_messages = messages -%} +{%- endif -%} +{%- for message in loop_messages -%} + {%- if (message['role'] == 'user') != (loop.index0 % 2 == 0) -%} + {{ raise_exception("Conversation roles must alternate user/assistant/user/assistant/...") }} + {%- endif -%} + {%- if (message['role'] == 'assistant') -%} + {%- set role = "model" -%} + {%- else -%} + {%- set role = message['role'] -%} + {%- endif -%} + {{ '' + role + ' +' + (first_user_prefix if loop.first else "") }} + {%- if message['content'] is string -%} + {{ message['content'] | trim }} + {%- elif message['content'] is iterable -%} + {%- for item in message['content'] -%} + {%- if item['type'] == 'image' -%} + {{ '' }} + {%- elif item['type'] == 'text' -%} + {{ item['text'] | trim }} + {%- endif -%} + {%- endfor -%} + {%- else -%} + {{ raise_exception("Invalid content type") }} + {%- endif -%} + {{ ' +' }} +{%- endfor -%} +{%- if add_generation_prompt -%} + {{'model +'}} +{%- endif -%} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma3_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma3_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..c76c297f50959fc40c586b50a672b24c9f7e9500 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma3_training.jinja @@ -0,0 +1,72 @@ +{#- Training variant of the Gemma 3 chat template (see gemma3.jinja for the original). + Modifications vs the original: + - Split the unified output line into role-specific branches so that the + 'model\n' header (a prompt cue, not generated by the model) sits + outside the generation block. + - Added {% generation %} / {% endgeneration %} around assistant message content to + support assistant-only loss masking in SFT training. +-#} +{{ bos_token }} +{%- if messages[0]['role'] == 'system' -%} + {%- if messages[0]['content'] is string -%} + {%- set first_user_prefix = messages[0]['content'] + ' + +' -%} + {%- else -%} + {%- set first_user_prefix = messages[0]['content'][0]['text'] + ' + +' -%} + {%- endif -%} + {%- set loop_messages = messages[1:] -%} +{%- else -%} + {%- set first_user_prefix = "" -%} + {%- set loop_messages = messages -%} +{%- endif -%} +{%- for message in loop_messages -%} + {%- if (message['role'] == 'user') != (loop.index0 % 2 == 0) -%} + {{ raise_exception("Conversation roles must alternate user/assistant/user/assistant/...") }} + {%- endif -%} + {%- if message['role'] == 'assistant' -%} + {{ 'model +' }} + {%- generation -%} + {%- if message['content'] is string -%} + {{ message['content'] | trim }} + {%- elif message['content'] is iterable -%} + {%- for item in message['content'] -%} + {%- if item['type'] == 'image' -%} + {{ '' }} + {%- elif item['type'] == 'text' -%} + {{ item['text'] | trim }} + {%- endif -%} + {%- endfor -%} + {%- else -%} + {{ raise_exception("Invalid content type") }} + {%- endif -%} + {{ ' +' }} + {%- endgeneration -%} + {%- else -%} + {{ '' + message['role'] + ' +' + (first_user_prefix if loop.first else "") }} + {%- if message['content'] is string -%} + {{ message['content'] | trim }} + {%- elif message['content'] is iterable -%} + {%- for item in message['content'] -%} + {%- if item['type'] == 'image' -%} + {{ '' }} + {%- elif item['type'] == 'text' -%} + {{ item['text'] | trim }} + {%- endif -%} + {%- endfor -%} + {%- else -%} + {{ raise_exception("Invalid content type") }} + {%- endif -%} + {{ ' +' }} + {%- endif -%} +{%- endfor -%} +{%- if add_generation_prompt -%} + {{'model +'}} +{%- endif -%} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..290e63f8ebe2917790b67568cefb231804a08299 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gemma_training.jinja @@ -0,0 +1,29 @@ +{#- Training variant of the Gemma chat template (see gemma.jinja for the original). + This template is shared by Gemma (v1) and Gemma2, which ship identical chat templates. + Modifications vs the original: + - Split the unified output line into role-specific branches so that the + 'model\n' header (a prompt cue, not generated by the model) sits + outside the generation block. + - Added {% generation %} / {% endgeneration %} around assistant message content to + support assistant-only loss masking in SFT training. +-#} +{{- bos_token -}} +{%- if messages[0]['role'] == 'system' -%} + {{- raise_exception('System role not supported') -}} +{%- endif -%} +{%- for message in messages -%} + {%- if (message['role'] == 'user') != (loop.index0 % 2 == 0) -%} + {{- raise_exception('Conversation roles must alternate user/assistant/user/assistant/...') -}} + {%- endif -%} + {%- if message['role'] == 'assistant' -%} + {{- 'model\n' -}} + {%- generation -%} + {{- message['content'] | trim + '\n' -}} + {%- endgeneration -%} + {%- else -%} + {{- '' + message['role'] + '\n' + message['content'] | trim + '\n' -}} + {%- endif -%} +{%- endfor -%} +{%- if add_generation_prompt -%} + {{- 'model\n' -}} +{%- endif -%} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/glm4moe.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/glm4moe.jinja new file mode 100644 index 0000000000000000000000000000000000000000..41478957aca7a04b7321022e7d1f73de5badd995 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/glm4moe.jinja @@ -0,0 +1,103 @@ +[gMASK] +{%- if tools -%} +<|system|> +# Tools + +You may call one or more functions to assist with the user query. + +You are provided with function signatures within XML tags: + +{% for tool in tools %} +{{ tool | tojson(ensure_ascii=False) }} +{% endfor %} + + +For each function call, output the function name and arguments within the following XML format: +{function-name} +{arg-key-1} +{arg-value-1} +{arg-key-2} +{arg-value-2} +... +{%- endif -%} +{%- macro visible_text(content) -%} + {%- if content is string -%} + {{- content }} + {%- elif content is iterable and content is not mapping -%} + {%- for item in content -%} + {%- if item is mapping and item.type == 'text' -%} + {{- item.text }} + {%- elif item is string -%} + {{- item }} + {%- endif -%} + {%- endfor -%} + {%- else -%} + {{- content }} + {%- endif -%} +{%- endmacro -%} +{%- set ns = namespace(last_user_index=-1) %} +{%- for m in messages %} + {%- if m.role == 'user' %} + {% set ns.last_user_index = loop.index0 -%} + {%- endif %} +{%- endfor %} +{% for m in messages %} +{%- if m.role == 'user' -%}<|user|> +{{ visible_text(m.content) }} +{{- '/nothink' if (enable_thinking is defined and not enable_thinking and not visible_text(m.content).endswith("/nothink")) else '' -}} +{%- elif m.role == 'assistant' -%} +<|assistant|> +{%- set reasoning_content = '' %} +{%- set content = visible_text(m.content) %} +{%- if m.reasoning_content is string %} + {%- set reasoning_content = m.reasoning_content %} +{%- else %} + {%- if '' in content %} + {%- set reasoning_content = content.split('')[0].rstrip('\n').split('')[-1].lstrip('\n') %} + {%- set content = content.split('')[-1].lstrip('\n') %} + {%- endif %} +{%- endif %} +{%- if loop.index0 > ns.last_user_index and reasoning_content -%} +{{ '\n' + reasoning_content.strip() + ''}} +{%- else -%} +{{ '\n' }} +{%- endif -%} +{%- if content.strip() -%} +{{ '\n' + content.strip() }} +{%- endif -%} +{% if m.tool_calls %} +{% for tc in m.tool_calls %} +{%- if tc.function %} + {%- set tc = tc.function %} +{%- endif %} +{{ '\n' + tc.name }} +{% set _args = tc.arguments %} +{% for k, v in _args.items() %} +{{ k }} +{{ v | tojson(ensure_ascii=False) if v is not string else v }} +{% endfor %} +{% endfor %} +{% endif %} +{%- elif m.role == 'tool' -%} +{%- if m.content is string -%} +{%- if loop.first or (messages[loop.index0 - 1].role != "tool") %} + {{- '<|observation|>' }} +{%- endif %} +{{- '\n\n' }} +{{- m.content }} +{{- '\n' }} +{%- else -%} +<|observation|>{% for tr in m.content %} + + +{{ tr.output if tr.output is defined else tr }} +{% endfor -%} +{% endif -%} +{%- elif m.role == 'system' -%} +<|system|> +{{ visible_text(m.content) }} +{%- endif -%} +{%- endfor -%} +{%- if add_generation_prompt -%} + <|assistant|>{{- '\n' if (enable_thinking is defined and not enable_thinking) else '' -}} +{%- endif -%} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/glm4moe_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/glm4moe_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..622f6ddf124333c0376d2c5921f341ddc51a9d4e --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/glm4moe_training.jinja @@ -0,0 +1,109 @@ +[gMASK] +{%- if tools -%} +<|system|> +# Tools + +You may call one or more functions to assist with the user query. + +You are provided with function signatures within XML tags: + +{% for tool in tools %} +{{ tool | tojson(ensure_ascii=False) }} +{% endfor %} + + +For each function call, output the function name and arguments within the following XML format: +{function-name} +{arg-key-1} +{arg-value-1} +{arg-key-2} +{arg-value-2} +... +{%- endif -%} +{%- macro visible_text(content) -%} + {%- if content is string -%} + {{- content }} + {%- elif content is iterable and content is not mapping -%} + {%- for item in content -%} + {%- if item is mapping and item.type == 'text' -%} + {{- item.text }} + {%- elif item is string -%} + {{- item }} + {%- endif -%} + {%- endfor -%} + {%- else -%} + {{- content }} + {%- endif -%} +{%- endmacro -%} +{%- set ns = namespace(last_user_index=-1) %} +{%- for m in messages %} + {%- if m.role == 'user' %} + {% set ns.last_user_index = loop.index0 -%} + {%- endif %} +{%- endfor %} +{% for m in messages %} +{%- if m.role == 'user' -%} +{%- if loop.first or messages[loop.index0 - 1].role != 'assistant' -%}<|user|>{%- endif -%} +{{ '\n' + visible_text(m.content) }} +{{- '/nothink' if (enable_thinking is defined and not enable_thinking and not visible_text(m.content).endswith("/nothink")) else '' -}} +{%- elif m.role == 'assistant' -%} +<|assistant|> +{%- set reasoning_content = '' %} +{%- set content = visible_text(m.content) %} +{%- if m.reasoning_content is string %} + {%- set reasoning_content = m.reasoning_content %} +{%- else %} + {%- if '' in content %} + {%- set reasoning_content = content.split('')[0].rstrip('\n').split('')[-1].lstrip('\n') %} + {%- set content = content.split('')[-1].lstrip('\n') %} + {%- endif %} +{%- endif %} +{% generation %} +{%- if loop.index0 > ns.last_user_index and reasoning_content -%} +{{ '\n' + reasoning_content.strip() + ''}} +{%- else -%} +{{ '\n' }} +{%- endif -%} +{%- if content.strip() -%} +{{ '\n' + content.strip() }} +{%- endif -%} +{% if m.tool_calls %} +{% for tc in m.tool_calls %} +{%- if tc.function %} + {%- set tc = tc.function %} +{%- endif %} +{{ '\n' + tc.name }} +{% set _args = tc.arguments %} +{% for k, v in _args.items() %} +{{ k }} +{{ v | tojson(ensure_ascii=False) if v is not string else v }} +{% endfor %} +{% endfor %}<|observation|> +{%- elif loop.last -%} +{{- '<|user|>' }} +{%- elif messages[loop.index0 + 1].role == 'system' -%} +{{- '<|system|>' }} +{%- else -%} +{{- '<|user|>' }} +{%- endif %} +{% endgeneration %} +{%- elif m.role == 'tool' -%} +{%- if m.content is string -%} +{{- '\n\n' }} +{{- m.content }} +{{- '\n' }} +{%- else -%} +{{- '<|observation|>' if loop.first or messages[loop.index0 - 1].role != 'assistant' }}{% for tr in m.content %} + + +{{ tr.output if tr.output is defined else tr }} +{% endfor -%} +{% endif -%} +{%- elif m.role == 'system' -%} +{%- if loop.first or messages[loop.index0 - 1].role != 'assistant' -%}<|system|>{%- endif -%} +{{ '\n' + visible_text(m.content) }} +{%- endif -%} +{%- endfor -%} +{%- if add_generation_prompt -%} + <|assistant|>{{- '\n' if (enable_thinking is defined and not enable_thinking) else '' -}} +{%- endif -%} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gptoss.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gptoss.jinja new file mode 100644 index 0000000000000000000000000000000000000000..dc7bb11927d29f653ba2740f2db2c688fd77592f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gptoss.jinja @@ -0,0 +1,331 @@ +{#- + In addition to the normal inputs of `messages` and `tools`, this template also accepts the + following kwargs: + - "builtin_tools": A list, can contain "browser" and/or "python". + - "model_identity": A string that optionally describes the model identity. + - "reasoning_effort": A string that describes the reasoning effort, defaults to "medium". + #} + +{#- Tool Definition Rendering ============================================== #} +{%- macro render_typescript_type(param_spec, required_params, is_nullable=false) -%} + {%- if param_spec.type == "array" -%} + {%- if param_spec['items'] -%} + {%- if param_spec['items']['type'] == "string" -%} + {{- "string[]" }} + {%- elif param_spec['items']['type'] == "number" -%} + {{- "number[]" }} + {%- elif param_spec['items']['type'] == "integer" -%} + {{- "number[]" }} + {%- elif param_spec['items']['type'] == "boolean" -%} + {{- "boolean[]" }} + {%- else -%} + {%- set inner_type = render_typescript_type(param_spec['items'], required_params) -%} + {%- if inner_type == "object | object" or inner_type|length > 50 -%} + {{- "any[]" }} + {%- else -%} + {{- inner_type + "[]" }} + {%- endif -%} + {%- endif -%} + {%- if param_spec.nullable -%} + {{- " | null" }} + {%- endif -%} + {%- else -%} + {{- "any[]" }} + {%- if param_spec.nullable -%} + {{- " | null" }} + {%- endif -%} + {%- endif -%} + {%- elif param_spec.type is defined and param_spec.type is iterable and param_spec.type is not string and param_spec.type is not mapping and param_spec.type[0] is defined -%} + {#- Handle array of types like ["object", "object"] from Union[dict, list] #} + {%- if param_spec.type | length > 1 -%} + {{- param_spec.type | join(" | ") }} + {%- else -%} + {{- param_spec.type[0] }} + {%- endif -%} + {%- elif param_spec.oneOf -%} + {#- Handle oneOf schemas - check for complex unions and fallback to any #} + {%- set has_object_variants = false -%} + {%- for variant in param_spec.oneOf -%} + {%- if variant.type == "object" -%} + {%- set has_object_variants = true -%} + {%- endif -%} + {%- endfor -%} + {%- if has_object_variants and param_spec.oneOf|length > 1 -%} + {{- "any" }} + {%- else -%} + {%- for variant in param_spec.oneOf -%} + {{- render_typescript_type(variant, required_params) -}} + {%- if variant.description %} + {{- "// " + variant.description }} + {%- endif -%} + {%- if variant.default is defined %} + {{ "// default: " + variant.default|tojson }} + {%- endif -%} + {%- if not loop.last %} + {{- " | " }} + {% endif -%} + {%- endfor -%} + {%- endif -%} + {%- elif param_spec.type == "string" -%} + {%- if param_spec.enum -%} + {{- '"' + param_spec.enum|join('" | "') + '"' -}} + {%- else -%} + {{- "string" }} + {%- if param_spec.nullable %} + {{- " | null" }} + {%- endif -%} + {%- endif -%} + {%- elif param_spec.type == "number" -%} + {{- "number" }} + {%- elif param_spec.type == "integer" -%} + {{- "number" }} + {%- elif param_spec.type == "boolean" -%} + {{- "boolean" }} + + {%- elif param_spec.type == "object" -%} + {%- if param_spec.properties -%} + {{- "{\n" }} + {%- for prop_name, prop_spec in param_spec.properties.items() -%} + {{- prop_name -}} + {%- if prop_name not in (param_spec.required or []) -%} + {{- "?" }} + {%- endif -%} + {{- ": " }} + {{ render_typescript_type(prop_spec, param_spec.required or []) }} + {%- if not loop.last -%} + {{-", " }} + {%- endif -%} + {%- endfor -%} + {{- "}" }} + {%- else -%} + {{- "object" }} + {%- endif -%} + {%- else -%} + {{- "any" }} + {%- endif -%} +{%- endmacro -%} + +{%- macro render_tool_namespace(namespace_name, tools) -%} + {{- "## " + namespace_name + "\n\n" }} + {{- "namespace " + namespace_name + " {\n\n" }} + {%- for tool in tools %} + {%- set tool = tool.function %} + {{- "// " + tool.description + "\n" }} + {{- "type "+ tool.name + " = " }} + {%- if tool.parameters and tool.parameters.properties %} + {{- "(_: {\n" }} + {%- for param_name, param_spec in tool.parameters.properties.items() %} + {%- if param_spec.description %} + {{- "// " + param_spec.description + "\n" }} + {%- endif %} + {{- param_name }} + {%- if param_name not in (tool.parameters.required or []) -%} + {{- "?" }} + {%- endif -%} + {{- ": " }} + {{- render_typescript_type(param_spec, tool.parameters.required or []) }} + {%- if param_spec.default is defined -%} + {%- if param_spec.enum %} + {{- ", // default: " + param_spec.default }} + {%- elif param_spec.oneOf %} + {{- "// default: " + param_spec.default }} + {%- else %} + {{- ", // default: " + param_spec.default|tojson }} + {%- endif -%} + {%- endif -%} + {%- if not loop.last %} + {{- ",\n" }} + {%- else %} + {{- ",\n" }} + {%- endif -%} + {%- endfor %} + {{- "}) => any;\n\n" }} + {%- else -%} + {{- "() => any;\n\n" }} + {%- endif -%} + {%- endfor %} + {{- "} // namespace " + namespace_name }} +{%- endmacro -%} + +{%- macro render_builtin_tools(browser_tool, python_tool) -%} + {%- if browser_tool %} + {{- "## browser\n\n" }} + {{- "// Tool for browsing.\n" }} + {{- "// The `cursor` appears in brackets before each browsing display: `[{cursor}]`.\n" }} + {{- "// Cite information from the tool using the following format:\n" }} + {{- "// `【{cursor}†L{line_start}(-L{line_end})?】`, for example: `【6†L9-L11】` or `【8†L3】`.\n" }} + {{- "// Do not quote more than 10 words directly from the tool output.\n" }} + {{- "// sources=web (default: web)\n" }} + {{- "namespace browser {\n\n" }} + {{- "// Searches for information related to `query` and displays `topn` results.\n" }} + {{- "type search = (_: {\n" }} + {{- "query: string,\n" }} + {{- "topn?: number, // default: 10\n" }} + {{- "source?: string,\n" }} + {{- "}) => any;\n\n" }} + {{- "// Opens the link `id` from the page indicated by `cursor` starting at line number `loc`, showing `num_lines` lines.\n" }} + {{- "// Valid link ids are displayed with the formatting: `【{id}†.*】`.\n" }} + {{- "// If `cursor` is not provided, the most recent page is implied.\n" }} + {{- "// If `id` is a string, it is treated as a fully qualified URL associated with `source`.\n" }} + {{- "// If `loc` is not provided, the viewport will be positioned at the beginning of the document or centered on the most relevant passage, if available.\n" }} + {{- "// Use this function without `id` to scroll to a new location of an opened page.\n" }} + {{- "type open = (_: {\n" }} + {{- "id?: number | string, // default: -1\n" }} + {{- "cursor?: number, // default: -1\n" }} + {{- "loc?: number, // default: -1\n" }} + {{- "num_lines?: number, // default: -1\n" }} + {{- "view_source?: boolean, // default: false\n" }} + {{- "source?: string,\n" }} + {{- "}) => any;\n\n" }} + {{- "// Finds exact matches of `pattern` in the current page, or the page given by `cursor`.\n" }} + {{- "type find = (_: {\n" }} + {{- "pattern: string,\n" }} + {{- "cursor?: number, // default: -1\n" }} + {{- "}) => any;\n\n" }} + {{- "} // namespace browser\n\n" }} + {%- endif -%} + + {%- if python_tool %} + {{- "## python\n\n" }} + {{- "Use this tool to execute Python code in your chain of thought. The code will not be shown to the user. This tool should be used for internal reasoning, but not for code that is intended to be visible to the user (e.g. when creating plots, tables, or files).\n\n" }} + {{- "When you send a message containing Python code to python, it will be executed in a stateful Jupyter notebook environment. python will respond with the output of the execution or time out after 120.0 seconds. The drive at '/mnt/data' can be used to save and persist user files. Internet access for this session is UNKNOWN. Depends on the cluster.\n\n" }} + {%- endif -%} +{%- endmacro -%} + +{#- System Message Construction ============================================ #} +{%- macro build_system_message() -%} + {%- if model_identity is not defined %} + {%- set model_identity = "You are ChatGPT, a large language model trained by OpenAI." %} + {%- endif %} + {{- model_identity + "\n" }} + {{- "Knowledge cutoff: 2024-06\n" }} + {{- "Current date: " + strftime_now("%Y-%m-%d") + "\n\n" }} + {%- if reasoning_effort is not defined %} + {%- set reasoning_effort = "medium" %} + {%- endif %} + {{- "Reasoning: " + reasoning_effort + "\n\n" }} + {%- if builtin_tools %} + {{- "# Tools\n\n" }} + {%- set available_builtin_tools = namespace(browser=false, python=false) %} + {%- for tool in builtin_tools %} + {%- if tool == "browser" %} + {%- set available_builtin_tools.browser = true %} + {%- elif tool == "python" %} + {%- set available_builtin_tools.python = true %} + {%- endif %} + {%- endfor %} + {{- render_builtin_tools(available_builtin_tools.browser, available_builtin_tools.python) }} + {%- endif -%} + {{- "# Valid channels: analysis, commentary, final. Channel must be included for every message." }} + {%- if tools -%} + {{- "\nCalls to these tools must go to the commentary channel: 'functions'." }} + {%- endif -%} +{%- endmacro -%} + +{#- Main Template Logic ================================================= #} +{#- Set defaults #} + +{#- Render system message #} +{{- "<|start|>system<|message|>" }} +{{- build_system_message() }} +{{- "<|end|>" }} + +{#- Extract developer message #} +{%- if messages[0].role == "developer" or messages[0].role == "system" %} + {%- set developer_message = messages[0].content %} + {%- set loop_messages = messages[1:] %} +{%- else %} + {%- set developer_message = "" %} + {%- set loop_messages = messages %} +{%- endif %} + +{#- Render developer message #} +{%- if developer_message or tools %} + {{- "<|start|>developer<|message|>" }} + {%- if developer_message %} + {{- "# Instructions\n\n" }} + {{- developer_message }} + {{- "\n\n" }} + {%- endif %} + {%- if tools -%} + {{- "# Tools\n\n" }} + {{- render_tool_namespace("functions", tools) }} + {%- endif -%} + {{- "<|end|>" }} +{%- endif %} + +{#- Render messages #} +{%- set last_tool_call = namespace(name=none) %} +{%- for message in loop_messages -%} + {#- At this point only assistant/user/tool messages should remain #} + {%- if message.role == 'assistant' -%} + {#- Checks to ensure the messages are being passed in the format we expect #} + {%- if "content" in message %} + {%- if "<|channel|>analysis<|message|>" in message.content or "<|channel|>final<|message|>" in message.content %} + {{- raise_exception("You have passed a message containing <|channel|> tags in the content field. Instead of doing this, you should pass analysis messages (the string between '<|message|>' and '<|end|>') in the 'thinking' field, and final messages (the string between '<|message|>' and '<|end|>') in the 'content' field.") }} + {%- endif %} + {%- endif %} + {%- if "thinking" in message %} + {%- if "<|channel|>analysis<|message|>" in message.thinking or "<|channel|>final<|message|>" in message.thinking %} + {{- raise_exception("You have passed a message containing <|channel|> tags in the thinking field. Instead of doing this, you should pass analysis messages (the string between '<|message|>' and '<|end|>') in the 'thinking' field, and final messages (the string between '<|message|>' and '<|end|>') in the 'content' field.") }} + {%- endif %} + {%- endif %} + {%- if "tool_calls" in message %} + {#- We need very careful handling here - we want to drop the tool call analysis message if the model #} + {#- has output a later <|final|> message, but otherwise we want to retain it. This is the only case #} + {#- when we render CoT/analysis messages in inference. #} + {%- set future_final_message = namespace(found=false) %} + {%- for future_message in loop_messages[loop.index:] %} + {%- if future_message.role == 'assistant' and "tool_calls" not in future_message %} + {%- set future_final_message.found = true %} + {%- endif %} + {%- endfor %} + {#- We assume max 1 tool call per message, and so we infer the tool call name #} + {#- in "tool" messages from the most recent assistant tool call name #} + {%- set tool_call = message.tool_calls[0] %} + {%- if tool_call.function %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {%- if message.content and message.thinking %} + {{- raise_exception("Cannot pass both content and thinking in an assistant message with tool calls! Put the analysis message in one or the other, but not both.") }} + {%- elif message.content and not future_final_message.found %} + {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.content + "<|end|>" }} + {%- elif message.thinking and not future_final_message.found %} + {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.thinking + "<|end|>" }} + {%- endif %} + {{- "<|start|>assistant to=" }} + {{- "functions." + tool_call.name + "<|channel|>commentary " }} + {{- (tool_call.content_type if tool_call.content_type is defined else "json") + "<|message|>" }} + {{- tool_call.arguments|tojson }} + {{- "<|call|>" }} + {%- set last_tool_call.name = tool_call.name %} + {%- elif loop.last and not add_generation_prompt %} + {#- Only render the CoT if the final turn is an assistant turn and add_generation_prompt is false #} + {#- This is a situation that should only occur in training, never in inference. #} + {%- if "thinking" in message %} + {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.thinking + "<|end|>" }} + {%- endif %} + {#- <|return|> indicates the end of generation, but <|end|> does not #} + {#- <|return|> should never be an input to the model, but we include it as the final token #} + {#- when training, so the model learns to emit it. #} + {{- "<|start|>assistant<|channel|>final<|message|>" + message.content + "<|return|>" }} + {%- else %} + {#- CoT is dropped during all previous turns, so we never render it for inference #} + {{- "<|start|>assistant<|channel|>final<|message|>" + message.content + "<|end|>" }} + {%- set last_tool_call.name = none %} + {%- endif %} + {%- elif message.role == 'tool' -%} + {%- if last_tool_call.name is none %} + {{- raise_exception("Message has tool role, but there was no previous assistant message with a tool call!") }} + {%- endif %} + {{- "<|start|>functions." + last_tool_call.name }} + {{- " to=assistant<|channel|>commentary<|message|>" + message.content|tojson + "<|end|>" }} + {%- elif message.role == 'user' -%} + {{- "<|start|>user<|message|>" + message.content + "<|end|>" }} + {%- endif -%} +{%- endfor -%} + +{#- Generation prompt #} +{%- if add_generation_prompt -%} +<|start|>assistant +{%- endif -%} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gptoss_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gptoss_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..f635725a0d0c36d1efedda8fe51bf9c4e7f75739 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/gptoss_training.jinja @@ -0,0 +1,338 @@ +{#- + Training variant of the GPT-OSS chat template (see gptoss.jinja for the original). + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. + + In addition to the normal inputs of `messages` and `tools`, this template also accepts the + following kwargs: + - "builtin_tools": A list, can contain "browser" and/or "python". + - "model_identity": A string that optionally describes the model identity. + - "reasoning_effort": A string that describes the reasoning effort, defaults to "medium". + #} + +{#- Tool Definition Rendering ============================================== #} +{%- macro render_typescript_type(param_spec, required_params, is_nullable=false) -%} + {%- if param_spec.type == "array" -%} + {%- if param_spec['items'] -%} + {%- if param_spec['items']['type'] == "string" -%} + {{- "string[]" }} + {%- elif param_spec['items']['type'] == "number" -%} + {{- "number[]" }} + {%- elif param_spec['items']['type'] == "integer" -%} + {{- "number[]" }} + {%- elif param_spec['items']['type'] == "boolean" -%} + {{- "boolean[]" }} + {%- else -%} + {%- set inner_type = render_typescript_type(param_spec['items'], required_params) -%} + {%- if inner_type == "object | object" or inner_type|length > 50 -%} + {{- "any[]" }} + {%- else -%} + {{- inner_type + "[]" }} + {%- endif -%} + {%- endif -%} + {%- if param_spec.nullable -%} + {{- " | null" }} + {%- endif -%} + {%- else -%} + {{- "any[]" }} + {%- if param_spec.nullable -%} + {{- " | null" }} + {%- endif -%} + {%- endif -%} + {%- elif param_spec.type is defined and param_spec.type is iterable and param_spec.type is not string and param_spec.type is not mapping and param_spec.type[0] is defined -%} + {#- Handle array of types like ["object", "object"] from Union[dict, list] #} + {%- if param_spec.type | length > 1 -%} + {{- param_spec.type | join(" | ") }} + {%- else -%} + {{- param_spec.type[0] }} + {%- endif -%} + {%- elif param_spec.oneOf -%} + {#- Handle oneOf schemas - check for complex unions and fallback to any #} + {%- set has_object_variants = false -%} + {%- for variant in param_spec.oneOf -%} + {%- if variant.type == "object" -%} + {%- set has_object_variants = true -%} + {%- endif -%} + {%- endfor -%} + {%- if has_object_variants and param_spec.oneOf|length > 1 -%} + {{- "any" }} + {%- else -%} + {%- for variant in param_spec.oneOf -%} + {{- render_typescript_type(variant, required_params) -}} + {%- if variant.description %} + {{- "// " + variant.description }} + {%- endif -%} + {%- if variant.default is defined %} + {{ "// default: " + variant.default|tojson }} + {%- endif -%} + {%- if not loop.last %} + {{- " | " }} + {% endif -%} + {%- endfor -%} + {%- endif -%} + {%- elif param_spec.type == "string" -%} + {%- if param_spec.enum -%} + {{- '"' + param_spec.enum|join('" | "') + '"' -}} + {%- else -%} + {{- "string" }} + {%- if param_spec.nullable %} + {{- " | null" }} + {%- endif -%} + {%- endif -%} + {%- elif param_spec.type == "number" -%} + {{- "number" }} + {%- elif param_spec.type == "integer" -%} + {{- "number" }} + {%- elif param_spec.type == "boolean" -%} + {{- "boolean" }} + + {%- elif param_spec.type == "object" -%} + {%- if param_spec.properties -%} + {{- "{\n" }} + {%- for prop_name, prop_spec in param_spec.properties.items() -%} + {{- prop_name -}} + {%- if prop_name not in (param_spec.required or []) -%} + {{- "?" }} + {%- endif -%} + {{- ": " }} + {{ render_typescript_type(prop_spec, param_spec.required or []) }} + {%- if not loop.last -%} + {{-", " }} + {%- endif -%} + {%- endfor -%} + {{- "}" }} + {%- else -%} + {{- "object" }} + {%- endif -%} + {%- else -%} + {{- "any" }} + {%- endif -%} +{%- endmacro -%} + +{%- macro render_tool_namespace(namespace_name, tools) -%} + {{- "## " + namespace_name + "\n\n" }} + {{- "namespace " + namespace_name + " {\n\n" }} + {%- for tool in tools %} + {%- set tool = tool.function %} + {{- "// " + tool.description + "\n" }} + {{- "type "+ tool.name + " = " }} + {%- if tool.parameters and tool.parameters.properties %} + {{- "(_: {\n" }} + {%- for param_name, param_spec in tool.parameters.properties.items() %} + {%- if param_spec.description %} + {{- "// " + param_spec.description + "\n" }} + {%- endif %} + {{- param_name }} + {%- if param_name not in (tool.parameters.required or []) -%} + {{- "?" }} + {%- endif -%} + {{- ": " }} + {{- render_typescript_type(param_spec, tool.parameters.required or []) }} + {%- if param_spec.default is defined -%} + {%- if param_spec.enum %} + {{- ", // default: " + param_spec.default }} + {%- elif param_spec.oneOf %} + {{- "// default: " + param_spec.default }} + {%- else %} + {{- ", // default: " + param_spec.default|tojson }} + {%- endif -%} + {%- endif -%} + {%- if not loop.last %} + {{- ",\n" }} + {%- else %} + {{- ",\n" }} + {%- endif -%} + {%- endfor %} + {{- "}) => any;\n\n" }} + {%- else -%} + {{- "() => any;\n\n" }} + {%- endif -%} + {%- endfor %} + {{- "} // namespace " + namespace_name }} +{%- endmacro -%} + +{%- macro render_builtin_tools(browser_tool, python_tool) -%} + {%- if browser_tool %} + {{- "## browser\n\n" }} + {{- "// Tool for browsing.\n" }} + {{- "// The `cursor` appears in brackets before each browsing display: `[{cursor}]`.\n" }} + {{- "// Cite information from the tool using the following format:\n" }} + {{- "// `【{cursor}†L{line_start}(-L{line_end})?】`, for example: `【6†L9-L11】` or `【8†L3】`.\n" }} + {{- "// Do not quote more than 10 words directly from the tool output.\n" }} + {{- "// sources=web (default: web)\n" }} + {{- "namespace browser {\n\n" }} + {{- "// Searches for information related to `query` and displays `topn` results.\n" }} + {{- "type search = (_: {\n" }} + {{- "query: string,\n" }} + {{- "topn?: number, // default: 10\n" }} + {{- "source?: string,\n" }} + {{- "}) => any;\n\n" }} + {{- "// Opens the link `id` from the page indicated by `cursor` starting at line number `loc`, showing `num_lines` lines.\n" }} + {{- "// Valid link ids are displayed with the formatting: `【{id}†.*】`.\n" }} + {{- "// If `cursor` is not provided, the most recent page is implied.\n" }} + {{- "// If `id` is a string, it is treated as a fully qualified URL associated with `source`.\n" }} + {{- "// If `loc` is not provided, the viewport will be positioned at the beginning of the document or centered on the most relevant passage, if available.\n" }} + {{- "// Use this function without `id` to scroll to a new location of an opened page.\n" }} + {{- "type open = (_: {\n" }} + {{- "id?: number | string, // default: -1\n" }} + {{- "cursor?: number, // default: -1\n" }} + {{- "loc?: number, // default: -1\n" }} + {{- "num_lines?: number, // default: -1\n" }} + {{- "view_source?: boolean, // default: false\n" }} + {{- "source?: string,\n" }} + {{- "}) => any;\n\n" }} + {{- "// Finds exact matches of `pattern` in the current page, or the page given by `cursor`.\n" }} + {{- "type find = (_: {\n" }} + {{- "pattern: string,\n" }} + {{- "cursor?: number, // default: -1\n" }} + {{- "}) => any;\n\n" }} + {{- "} // namespace browser\n\n" }} + {%- endif -%} + + {%- if python_tool %} + {{- "## python\n\n" }} + {{- "Use this tool to execute Python code in your chain of thought. The code will not be shown to the user. This tool should be used for internal reasoning, but not for code that is intended to be visible to the user (e.g. when creating plots, tables, or files).\n\n" }} + {{- "When you send a message containing Python code to python, it will be executed in a stateful Jupyter notebook environment. python will respond with the output of the execution or time out after 120.0 seconds. The drive at '/mnt/data' can be used to save and persist user files. Internet access for this session is UNKNOWN. Depends on the cluster.\n\n" }} + {%- endif -%} +{%- endmacro -%} + +{#- System Message Construction ============================================ #} +{%- macro build_system_message() -%} + {%- if model_identity is not defined %} + {%- set model_identity = "You are ChatGPT, a large language model trained by OpenAI." %} + {%- endif %} + {{- model_identity + "\n" }} + {{- "Knowledge cutoff: 2024-06\n" }} + {{- "Current date: " + strftime_now("%Y-%m-%d") + "\n\n" }} + {%- if reasoning_effort is not defined %} + {%- set reasoning_effort = "medium" %} + {%- endif %} + {{- "Reasoning: " + reasoning_effort + "\n\n" }} + {%- if builtin_tools %} + {{- "# Tools\n\n" }} + {%- set available_builtin_tools = namespace(browser=false, python=false) %} + {%- for tool in builtin_tools %} + {%- if tool == "browser" %} + {%- set available_builtin_tools.browser = true %} + {%- elif tool == "python" %} + {%- set available_builtin_tools.python = true %} + {%- endif %} + {%- endfor %} + {{- render_builtin_tools(available_builtin_tools.browser, available_builtin_tools.python) }} + {%- endif -%} + {{- "# Valid channels: analysis, commentary, final. Channel must be included for every message." }} + {%- if tools -%} + {{- "\nCalls to these tools must go to the commentary channel: 'functions'." }} + {%- endif -%} +{%- endmacro -%} + +{#- Main Template Logic ================================================= #} +{#- Set defaults #} + +{#- Render system message #} +{{- "<|start|>system<|message|>" }} +{{- build_system_message() }} +{{- "<|end|>" }} + +{#- Extract developer message #} +{%- if messages[0].role == "developer" or messages[0].role == "system" %} + {%- set developer_message = messages[0].content %} + {%- set loop_messages = messages[1:] %} +{%- else %} + {%- set developer_message = "" %} + {%- set loop_messages = messages %} +{%- endif %} + +{#- Render developer message #} +{%- if developer_message or tools %} + {{- "<|start|>developer<|message|>" }} + {%- if developer_message %} + {{- "# Instructions\n\n" }} + {{- developer_message }} + {{- "\n\n" }} + {%- endif %} + {%- if tools -%} + {{- "# Tools\n\n" }} + {{- render_tool_namespace("functions", tools) }} + {%- endif -%} + {{- "<|end|>" }} +{%- endif %} + +{#- Render messages #} +{%- set last_tool_call = namespace(name=none) %} +{%- for message in loop_messages -%} + {#- At this point only assistant/user/tool messages should remain #} + {%- if message.role == 'assistant' -%} + {#- Checks to ensure the messages are being passed in the format we expect #} + {%- if "content" in message %} + {%- if "<|channel|>analysis<|message|>" in message.content or "<|channel|>final<|message|>" in message.content %} + {{- raise_exception("You have passed a message containing <|channel|> tags in the content field. Instead of doing this, you should pass analysis messages (the string between '<|message|>' and '<|end|>') in the 'thinking' field, and final messages (the string between '<|message|>' and '<|end|>') in the 'content' field.") }} + {%- endif %} + {%- endif %} + {%- if "thinking" in message %} + {%- if "<|channel|>analysis<|message|>" in message.thinking or "<|channel|>final<|message|>" in message.thinking %} + {{- raise_exception("You have passed a message containing <|channel|> tags in the thinking field. Instead of doing this, you should pass analysis messages (the string between '<|message|>' and '<|end|>') in the 'thinking' field, and final messages (the string between '<|message|>' and '<|end|>') in the 'content' field.") }} + {%- endif %} + {%- endif %} + {%- generation %} + {%- if "tool_calls" in message %} + {#- We need very careful handling here - we want to drop the tool call analysis message if the model #} + {#- has output a later <|final|> message, but otherwise we want to retain it. This is the only case #} + {#- when we render CoT/analysis messages in inference. #} + {%- set future_final_message = namespace(found=false) %} + {%- for future_message in loop_messages[loop.index:] %} + {%- if future_message.role == 'assistant' and "tool_calls" not in future_message %} + {%- set future_final_message.found = true %} + {%- endif %} + {%- endfor %} + {#- We assume max 1 tool call per message, and so we infer the tool call name #} + {#- in "tool" messages from the most recent assistant tool call name #} + {%- set tool_call = message.tool_calls[0] %} + {%- if tool_call.function %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {%- if message.content and message.thinking %} + {{- raise_exception("Cannot pass both content and thinking in an assistant message with tool calls! Put the analysis message in one or the other, but not both.") }} + {%- elif message.content and not future_final_message.found %} + {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.content + "<|end|>" }} + {%- elif message.thinking and not future_final_message.found %} + {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.thinking + "<|end|>" }} + {%- endif %} + {{- "<|start|>assistant to=" }} + {{- "functions." + tool_call.name + "<|channel|>commentary " }} + {{- (tool_call.content_type if tool_call.content_type is defined else "json") + "<|message|>" }} + {{- tool_call.arguments|tojson }} + {{- "<|call|>" }} + {%- set last_tool_call.name = tool_call.name %} + {%- elif loop.last and not add_generation_prompt %} + {#- Only render the CoT if the final turn is an assistant turn and add_generation_prompt is false #} + {#- This is a situation that should only occur in training, never in inference. #} + {%- if "thinking" in message %} + {{- "<|start|>assistant<|channel|>analysis<|message|>" + message.thinking + "<|end|>" }} + {%- endif %} + {#- <|return|> indicates the end of generation, but <|end|> does not #} + {#- <|return|> should never be an input to the model, but we include it as the final token #} + {#- when training, so the model learns to emit it. #} + {{- "<|start|>assistant<|channel|>final<|message|>" + message.content + "<|return|>" }} + {%- else %} + {#- CoT is dropped during all previous turns, so we never render it for inference #} + {{- "<|start|>assistant<|channel|>final<|message|>" + message.content + "<|end|>" }} + {%- set last_tool_call.name = none %} + {%- endif %} + {%- endgeneration %} + {%- elif message.role == 'tool' -%} + {%- if last_tool_call.name is none %} + {{- raise_exception("Message has tool role, but there was no previous assistant message with a tool call!") }} + {%- endif %} + {{- "<|start|>functions." + last_tool_call.name }} + {{- " to=assistant<|channel|>commentary<|message|>" + message.content|tojson + "<|end|>" }} + {%- elif message.role == 'user' -%} + {{- "<|start|>user<|message|>" + message.content + "<|end|>" }} + {%- endif -%} +{%- endfor -%} + +{#- Generation prompt #} +{%- if add_generation_prompt -%} +<|start|>assistant +{%- endif -%} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/idefics3.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/idefics3.jinja new file mode 100644 index 0000000000000000000000000000000000000000..84bff1e3f6ef8e5084704a296153f580e194d7ac --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/idefics3.jinja @@ -0,0 +1,2 @@ +<|begin_of_text|>{% for message in messages %}{{message['role'].capitalize()}}{% if message['content'][0]['type'] == 'image' %}{{':'}}{% else %}{{': '}}{% endif %}{% for line in message['content'] %}{% if line['type'] == 'text' %}{{line['text']}}{% elif line['type'] == 'image' %}{{ '' }}{% endif %}{% endfor %} +{% endfor %}{% if add_generation_prompt %}{{ 'Assistant:' }}{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/idefics3_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/idefics3_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..7b089ff966d2894bf45999049f699e2dfa0ce077 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/idefics3_training.jinja @@ -0,0 +1,10 @@ +{#- Training variant of the Idefics3 chat template (see idefics3.jinja for the original). + Modifications vs the original: + - Split the assistant message into its own branch so the {% generation %} / {% endgeneration %} + markers wrap the assistant content (everything after the 'Assistant:' prompt cue, up to and + including the trailing '\n'). This enables assistant-only loss masking in + SFT training. +-#} +<|begin_of_text|>{% for message in messages %}{% if message['role'] == 'assistant' %}Assistant:{% generation %}{% if message['content'][0]['type'] != 'image' %} {% endif %}{% for line in message['content'] %}{% if line['type'] == 'text' %}{{line['text']}}{% elif line['type'] == 'image' %}{{ '' }}{% endif %}{% endfor %} +{% endgeneration %}{% else %}{{message['role'].capitalize()}}{% if message['content'][0]['type'] == 'image' %}{{':'}}{% else %}{{': '}}{% endif %}{% for line in message['content'] %}{% if line['type'] == 'text' %}{{line['text']}}{% elif line['type'] == 'image' %}{{ '' }}{% endif %}{% endfor %} +{% endif %}{% endfor %}{% if add_generation_prompt %}{{ 'Assistant:' }}{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3.jinja new file mode 100644 index 0000000000000000000000000000000000000000..39bd0c9f7fe30aea14eda194fee17703da4a4dbf --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3.jinja @@ -0,0 +1,5 @@ +{% set loop_messages = messages %}{% for message in loop_messages %}{% set content = '<|start_header_id|>' + message['role'] + '<|end_header_id|> + +'+ message['content'] | trim + '<|eot_id|>' %}{% if loop.index0 == 0 %}{% set content = bos_token + content %}{% endif %}{{ content }}{% endfor %}{% if add_generation_prompt %}{{ '<|start_header_id|>assistant<|end_header_id|> + +' }}{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3_1.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3_1.jinja new file mode 100644 index 0000000000000000000000000000000000000000..33089ace1be88f22a10fe861ad49718d5d886090 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3_1.jinja @@ -0,0 +1,109 @@ +{{- bos_token }} +{%- if custom_tools is defined %} + {%- set tools = custom_tools %} +{%- endif %} +{%- if not tools_in_user_message is defined %} + {%- set tools_in_user_message = true %} +{%- endif %} +{%- if not date_string is defined %} + {%- set date_string = "26 Jul 2024" %} +{%- endif %} +{%- if not tools is defined %} + {%- set tools = none %} +{%- endif %} + +{#- This block extracts the system message, so we can slot it into the right place. #} +{%- if messages[0]['role'] == 'system' %} + {%- set system_message = messages[0]['content']|trim %} + {%- set messages = messages[1:] %} +{%- else %} + {%- set system_message = "" %} +{%- endif %} + +{#- System message + builtin tools #} +{{- "<|start_header_id|>system<|end_header_id|>\n\n" }} +{%- if builtin_tools is defined or tools is not none %} + {{- "Environment: ipython\n" }} +{%- endif %} +{%- if builtin_tools is defined %} + {{- "Tools: " + builtin_tools | reject('equalto', 'code_interpreter') | join(", ") + "\n\n"}} +{%- endif %} +{{- "Cutting Knowledge Date: December 2023\n" }} +{{- "Today Date: " + date_string + "\n\n" }} +{%- if tools is not none and not tools_in_user_message %} + {{- "You have access to the following functions. To call a function, please respond with JSON for a function call." }} + {{- 'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.' }} + {{- "Do not use variables.\n\n" }} + {%- for t in tools %} + {{- t | tojson(indent=4) }} + {{- "\n\n" }} + {%- endfor %} +{%- endif %} +{{- system_message }} +{{- "<|eot_id|>" }} + +{#- Custom tools are passed in a user message with some extra guidance #} +{%- if tools_in_user_message and not tools is none %} + {#- Extract the first user message so we can plug it in here #} + {%- if messages | length != 0 %} + {%- set first_user_message = messages[0]['content']|trim %} + {%- set messages = messages[1:] %} + {%- else %} + {{- raise_exception("Cannot put tools in the first user message when there's no first user message!") }} +{%- endif %} + {{- '<|start_header_id|>user<|end_header_id|>\n\n' -}} + {{- "Given the following functions, please respond with a JSON for a function call " }} + {{- "with its proper arguments that best answers the given prompt.\n\n" }} + {{- 'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.' }} + {{- "Do not use variables.\n\n" }} + {%- for t in tools %} + {{- t | tojson(indent=4) }} + {{- "\n\n" }} + {%- endfor %} + {{- first_user_message + "<|eot_id|>"}} +{%- endif %} + +{%- for message in messages %} + {%- if not (message.role == 'ipython' or message.role == 'tool' or 'tool_calls' in message) %} + {{- '<|start_header_id|>' + message['role'] + '<|end_header_id|>\n\n'+ message['content'] | trim + '<|eot_id|>' }} + {%- elif 'tool_calls' in message %} + {%- if not message.tool_calls|length == 1 %} + {{- raise_exception("This model only supports single tool-calls at once!") }} + {%- endif %} + {%- set tool_call = message.tool_calls[0].function %} + {%- if builtin_tools is defined and tool_call.name in builtin_tools %} + {{- '<|start_header_id|>assistant<|end_header_id|>\n\n' -}} + {{- "<|python_tag|>" + tool_call.name + ".call(" }} + {%- for arg_name, arg_val in tool_call.arguments | items %} + {{- arg_name + '="' + arg_val + '"' }} + {%- if not loop.last %} + {{- ", " }} + {%- endif %} + {%- endfor %} + {{- ")" }} + {%- else %} + {{- '<|start_header_id|>assistant<|end_header_id|>\n\n' -}} + {{- '{"name": "' + tool_call.name + '", ' }} + {{- '"parameters": ' }} + {{- tool_call.arguments | tojson }} + {{- "}" }} + {%- endif %} + {%- if builtin_tools is defined %} + {#- This means we're in ipython mode #} + {{- "<|eom_id|>" }} + {%- else %} + {{- "<|eot_id|>" }} + {%- endif %} + {%- elif message.role == "tool" or message.role == "ipython" %} + {{- "<|start_header_id|>ipython<|end_header_id|>\n\n" }} + {%- if message.content is mapping or message.content is iterable %} + {{- message.content | tojson }} + {%- else %} + {{- message.content }} + {%- endif %} + {{- "<|eot_id|>" }} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|start_header_id|>assistant<|end_header_id|>\n\n' }} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3_2.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3_2.jinja new file mode 100644 index 0000000000000000000000000000000000000000..1bad6a0f648dccdbec523ca79ba90fbcfc806af0 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3_2.jinja @@ -0,0 +1,93 @@ +{{- bos_token }} +{%- if custom_tools is defined %} + {%- set tools = custom_tools %} +{%- endif %} +{%- if not tools_in_user_message is defined %} + {%- set tools_in_user_message = true %} +{%- endif %} +{%- if not date_string is defined %} + {%- if strftime_now is defined %} + {%- set date_string = strftime_now("%d %b %Y") %} + {%- else %} + {%- set date_string = "26 Jul 2024" %} + {%- endif %} +{%- endif %} +{%- if not tools is defined %} + {%- set tools = none %} +{%- endif %} + +{#- This block extracts the system message, so we can slot it into the right place. #} +{%- if messages[0]['role'] == 'system' %} + {%- set system_message = messages[0]['content']|trim %} + {%- set messages = messages[1:] %} +{%- else %} + {%- set system_message = "" %} +{%- endif %} + +{#- System message #} +{{- "<|start_header_id|>system<|end_header_id|>\n\n" }} +{%- if tools is not none %} + {{- "Environment: ipython\n" }} +{%- endif %} +{{- "Cutting Knowledge Date: December 2023\n" }} +{{- "Today Date: " + date_string + "\n\n" }} +{%- if tools is not none and not tools_in_user_message %} + {{- "You have access to the following functions. To call a function, please respond with JSON for a function call." }} + {{- 'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.' }} + {{- "Do not use variables.\n\n" }} + {%- for t in tools %} + {{- t | tojson(indent=4) }} + {{- "\n\n" }} + {%- endfor %} +{%- endif %} +{{- system_message }} +{{- "<|eot_id|>" }} + +{#- Custom tools are passed in a user message with some extra guidance #} +{%- if tools_in_user_message and not tools is none %} + {#- Extract the first user message so we can plug it in here #} + {%- if messages | length != 0 %} + {%- set first_user_message = messages[0]['content']|trim %} + {%- set messages = messages[1:] %} + {%- else %} + {{- raise_exception("Cannot put tools in the first user message when there's no first user message!") }} +{%- endif %} + {{- '<|start_header_id|>user<|end_header_id|>\n\n' -}} + {{- "Given the following functions, please respond with a JSON for a function call " }} + {{- "with its proper arguments that best answers the given prompt.\n\n" }} + {{- 'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.' }} + {{- "Do not use variables.\n\n" }} + {%- for t in tools %} + {{- t | tojson(indent=4) }} + {{- "\n\n" }} + {%- endfor %} + {{- first_user_message + "<|eot_id|>"}} +{%- endif %} + +{%- for message in messages %} + {%- if not (message.role == 'ipython' or message.role == 'tool' or 'tool_calls' in message) %} + {{- '<|start_header_id|>' + message['role'] + '<|end_header_id|>\n\n'+ message['content'] | trim + '<|eot_id|>' }} + {%- elif 'tool_calls' in message %} + {%- if not message.tool_calls|length == 1 %} + {{- raise_exception("This model only supports single tool-calls at once!") }} + {%- endif %} + {%- set tool_call = message.tool_calls[0].function %} + {{- '<|start_header_id|>assistant<|end_header_id|>\n\n' -}} + {{- '{"name": "' + tool_call.name + '", ' }} + {{- '"parameters": ' }} + {{- tool_call.arguments | tojson }} + {{- "}" }} + {{- "<|eot_id|>" }} + {%- elif message.role == "tool" or message.role == "ipython" %} + {{- "<|start_header_id|>ipython<|end_header_id|>\n\n" }} + {%- if message.content is mapping or message.content is iterable %} + {{- message.content | tojson }} + {%- else %} + {{- message.content }} + {%- endif %} + {{- "<|eot_id|>" }} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|start_header_id|>assistant<|end_header_id|>\n\n' }} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..85dafd3d877c69b48fcebae678a5ba367909afd1 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llama3_training.jinja @@ -0,0 +1,19 @@ +{#- Training variant of the Llama 3 chat template (see llama3.jinja for the original). + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{%- for message in messages %} + {%- if loop.index0 == 0 %}{{- bos_token }}{%- endif %} + {%- if message['role'] == 'assistant' %} + {{- '<|start_header_id|>assistant<|end_header_id|>\n\n' }} + {%- generation %} + {{- message['content'] | trim + '<|eot_id|>' }} + {%- endgeneration %} + {%- else %} + {{- '<|start_header_id|>' + message['role'] + '<|end_header_id|>\n\n' + message['content'] | trim + '<|eot_id|>' }} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|start_header_id|>assistant<|end_header_id|>\n\n' }} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llava_next.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llava_next.jinja new file mode 100644 index 0000000000000000000000000000000000000000..c6cc6df43113384d5cafa46c06bd1b79ec4464c7 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llava_next.jinja @@ -0,0 +1,6 @@ +{% for message in messages %}{% if message['role'] == 'system' %}{{ '<> +' + message['content'][0]['text'] + ' +<> + +' }}{% elif message['role'] == 'user' %}{{ '[INST] ' }}{# Render all images first #}{% for content in message['content'] | selectattr('type', 'equalto', 'image') %}{{ ' +' }}{% endfor %}{# Render all text next #}{% for content in message['content'] | selectattr('type', 'equalto', 'text') %}{{ content['text'] }}{% endfor %}{{' [/INST]' }}{% elif message['role'] == 'assistant' %}{{ ' ' + message['content'][0]['text'] + ' '}}{% else %}{{ raise_exception('Only user and assistant roles are supported!') }}{% endif %}{% endfor %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llava_next_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llava_next_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..9eaf357439a713fff44832b8892a244cf063a7b6 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/llava_next_training.jinja @@ -0,0 +1,11 @@ +{#- Training variant of the Llava-Next chat template (see llava_next.jinja for the original). + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around the assistant message output to support + assistant-only loss masking in SFT training. +-#} +{% for message in messages %}{% if message['role'] == 'system' %}{{ '<> +' + message['content'][0]['text'] + ' +<> + +' }}{% elif message['role'] == 'user' %}{{ '[INST] ' }}{# Render all images first #}{% for content in message['content'] | selectattr('type', 'equalto', 'image') %}{{ ' +' }}{% endfor %}{# Render all text next #}{% for content in message['content'] | selectattr('type', 'equalto', 'text') %}{{ content['text'] }}{% endfor %}{{' [/INST]' }}{% elif message['role'] == 'assistant' %}{% generation %}{{ ' ' + message['content'][0]['text'] + ' '}}{% endgeneration %}{% else %}{{ raise_exception('Only user and assistant roles are supported!') }}{% endif %}{% endfor %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_nano.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_nano.jinja new file mode 100644 index 0000000000000000000000000000000000000000..67ca3ce54a7118ed74d6fd793b7cc9fd6b2a9f03 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_nano.jinja @@ -0,0 +1,204 @@ +{% macro render_extra_keys(json_dict, handled_keys) %} + {%- if json_dict is mapping %} + {%- for json_key in json_dict if json_key not in handled_keys %} + {%- if json_dict[json_key] is mapping or (json_dict[json_key] is sequence and json_dict[json_key] is not string) %} + {{- '\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | tojson | safe) ~ '' }} + {%- else %} + {{-'\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | string) ~ '' }} + {%- endif %} + {%- endfor %} + {%- endif %} +{% endmacro %} +{%- set enable_thinking = enable_thinking if enable_thinking is defined else True %} +{%- set truncate_history_thinking = truncate_history_thinking if truncate_history_thinking is defined else True %} + +{%- set ns = namespace(last_user_idx = -1) %} +{%- set loop_messages = messages %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} + +{%- if messages[0]["role"] == "system" %} + {%- set system_message = messages[0]["content"] %} + {%- set loop_messages = messages[1:] %} +{%- else %} + {%- set system_message = "" %} + {%- set loop_messages = messages %} +{%- endif %} +{%- if not tools is defined %} + {%- set tools = [] %} +{%- endif %} +{# Recompute last_user_idx relative to loop_messages after handling system #} +{%- set ns = namespace(last_user_idx = -1) %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} +{%- if system_message is defined %} + {{- "<|im_start|>system\n" + system_message }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- "<|im_start|>system\n" }} + {%- endif %} +{%- endif %} +{%- if tools is iterable and tools | length > 0 %} + {%- if system_message is defined and system_message | length > 0 %} + {{- "\n\n" }} + {%- endif %} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {{- "" }} + {%- for tool in tools %} + {%- if tool.function is defined %} + {%- set tool = tool.function %} + {%- endif %} + {{- "\n\n" ~ tool.name ~ "" }} + {%- if tool.description is defined %} + {{- '\n' ~ (tool.description | trim) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- if tool.parameters is defined and tool.parameters is mapping and tool.parameters.properties is defined and tool.parameters.properties is mapping %} + {%- for param_name, param_fields in tool.parameters.properties|items %} + {{- '\n' }} + {{- '\n' ~ param_name ~ '' }} + {%- if param_fields.type is defined %} + {{- '\n' ~ (param_fields.type | string) ~ '' }} + {%- endif %} + {%- if param_fields.description is defined %} + {{- '\n' ~ (param_fields.description | trim) ~ '' }} + {%- endif %} + {%- if param_fields.enum is defined %} + {{- '\n' ~ (param_fields.enum | tojson | safe) ~ '' }} + {%- endif %} + {%- set handled_keys = ['name', 'type', 'description', 'enum'] %} + {{- render_extra_keys(param_fields, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {% set handled_keys = ['type', 'properties', 'required'] %} + {{- render_extra_keys(tool.parameters, handled_keys) }} + {%- if tool.parameters is defined and tool.parameters.required is defined %} + {{- '\n' ~ (tool.parameters.required | tojson | safe) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- set handled_keys = ['type', 'name', 'description', 'parameters'] %} + {{- render_extra_keys(tool, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {{- "\n" }} + + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} +{%- endif %} + + +{%- if system_message is defined %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- '<|im_end|>\n' }} + {%- endif %} +{%- endif %} + +{%- for message in loop_messages %} + {%- if message.role == "assistant" %} + {# Add reasoning content in to content field for unified processing below. #} + {%- if message.reasoning_content is defined and message.reasoning_content is string and message.reasoning_content | trim | length > 0 %} + {%- set content = "\n" ~ message.reasoning_content ~ "\n\n" ~ (message.content | default('', true)) %} + {%- else %} + {%- set content = message.content | default('', true) %} + {%- if content is string -%} + {# Allow downstream logic to to take care of broken thought, only handle coherent reasoning here. #} + {%- if '' not in content and '' not in content -%} + {%- set content = "" ~ content -%} + {%- endif -%} + {%- else -%} + {%- set content = content -%} + {%- endif -%} + {%- endif %} + {%- if message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 %} + {# Assistant message has tool calls. #} + {{- '<|im_start|>assistant\n' }} + {%- set include_content = not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {%- if content is string and content | trim | length > 0 %} + {%- if include_content %} + {{- (content | trim) ~ '\n' -}} + {%- else %} + {%- set c = (content | string) %} + {%- if '' in c %} + {# Keep only content after the last closing think. Also generation prompt causes this. #} + {%- set c = c.split('')[-1] %} + {%- elif '' in c %} + {# If was opened but never closed, drop the trailing think segment #} + {%- set c = c.split('')[0] %} + {%- endif %} + {%- set c = "" ~ c | trim %} + {%- if c | length > 0 %} + {{- c ~ '\n' -}} + {%- endif %} + {%- endif %} + {%- else %} + {{- "" -}} + {%- endif %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n\n' -}} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' -}} + {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %} + {{- args_value ~ '\n\n' -}} + {%- endfor %} + {%- endif %} + {{- '\n\n' -}} + {%- endfor %} + {{- '<|im_end|>\n' }} + {%- else %} + {# Assistant message doesn't have tool calls. #} + {%- if not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {{- '<|im_start|>assistant\n' ~ (content | default('', true) | string | trim) ~ '<|im_end|>\n' }} + {%- else %} + {%- set c = (content | default('', true) | string) %} + {%- if '' in c and '' in c %} + {%- set c = "" ~ c.split('')[-1] %} + {%- endif %} + {%- set c = c | trim %} + {%- if c | length > 0 %} + {{- '<|im_start|>assistant\n' ~ c ~ '<|im_end|>\n' }} + {%- else %} + {{- '<|im_start|>assistant\n<|im_end|>\n' }} + {%- endif %} + {%- endif %} + {%- endif %} + {%- elif message.role == "user" or message.role == "system" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- set content = message.content | string %} + {{- content }} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user\n' }} + {%- endif %} + {{- '\n' }} + {{- message.content }} + {{- '\n\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>\n' }} + {%- endif %} +{%- endfor %} + +{%- if add_generation_prompt %} + {%- if enable_thinking %} + {{- '<|im_start|>assistant\n\n' }} + {%- else %} + {{- '<|im_start|>assistant\n' }} + {%- endif %} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_nano_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_nano_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..c539b379f51fe7c76586858d70f25ff6220a3729 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_nano_training.jinja @@ -0,0 +1,220 @@ +{#- Training variant of the Nemotron Nano chat template (see nemotron_3_nano.jinja for the original). + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{% macro render_extra_keys(json_dict, handled_keys) %} + {%- if json_dict is mapping %} + {%- for json_key in json_dict if json_key not in handled_keys %} + {%- if json_dict[json_key] is mapping or (json_dict[json_key] is sequence and json_dict[json_key] is not string) %} + {{- '\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | tojson | safe) ~ '' }} + {%- else %} + {{-'\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | string) ~ '' }} + {%- endif %} + {%- endfor %} + {%- endif %} +{% endmacro %} +{%- set enable_thinking = enable_thinking if enable_thinking is defined else True %} +{%- set truncate_history_thinking = truncate_history_thinking if truncate_history_thinking is defined else True %} + +{%- set ns = namespace(last_user_idx = -1) %} +{%- set loop_messages = messages %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} + +{%- if messages[0]["role"] == "system" %} + {%- set system_message = messages[0]["content"] %} + {%- set loop_messages = messages[1:] %} +{%- else %} + {%- set system_message = "" %} + {%- set loop_messages = messages %} +{%- endif %} +{%- if not tools is defined %} + {%- set tools = [] %} +{%- endif %} +{# Recompute last_user_idx relative to loop_messages after handling system #} +{%- set ns = namespace(last_user_idx = -1) %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} +{%- if system_message is defined %} + {{- "<|im_start|>system\n" + system_message }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- "<|im_start|>system\n" }} + {%- endif %} +{%- endif %} +{%- if tools is iterable and tools | length > 0 %} + {%- if system_message is defined and system_message | length > 0 %} + {{- "\n\n" }} + {%- endif %} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {{- "" }} + {%- for tool in tools %} + {%- if tool.function is defined %} + {%- set tool = tool.function %} + {%- endif %} + {{- "\n\n" ~ tool.name ~ "" }} + {%- if tool.description is defined %} + {{- '\n' ~ (tool.description | trim) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- if tool.parameters is defined and tool.parameters is mapping and tool.parameters.properties is defined and tool.parameters.properties is mapping %} + {%- for param_name, param_fields in tool.parameters.properties|items %} + {{- '\n' }} + {{- '\n' ~ param_name ~ '' }} + {%- if param_fields.type is defined %} + {{- '\n' ~ (param_fields.type | string) ~ '' }} + {%- endif %} + {%- if param_fields.description is defined %} + {{- '\n' ~ (param_fields.description | trim) ~ '' }} + {%- endif %} + {%- if param_fields.enum is defined %} + {{- '\n' ~ (param_fields.enum | tojson | safe) ~ '' }} + {%- endif %} + {%- set handled_keys = ['name', 'type', 'description', 'enum'] %} + {{- render_extra_keys(param_fields, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {% set handled_keys = ['type', 'properties', 'required'] %} + {{- render_extra_keys(tool.parameters, handled_keys) }} + {%- if tool.parameters is defined and tool.parameters.required is defined %} + {{- '\n' ~ (tool.parameters.required | tojson | safe) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- set handled_keys = ['type', 'name', 'description', 'parameters'] %} + {{- render_extra_keys(tool, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {{- "\n" }} + + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} +{%- endif %} + + +{%- if system_message is defined %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- '<|im_end|>\n' }} + {%- endif %} +{%- endif %} + +{%- for message in loop_messages %} + {%- if message.role == "assistant" %} + {# Add reasoning content in to content field for unified processing below. #} + {%- if message.reasoning_content is defined and message.reasoning_content is string and message.reasoning_content | trim | length > 0 %} + {%- set content = "\n" ~ message.reasoning_content ~ "\n\n" ~ (message.content | default('', true)) %} + {%- else %} + {%- set content = message.content | default('', true) %} + {%- if content is string -%} + {# Allow downstream logic to to take care of broken thought, only handle coherent reasoning here. #} + {%- if '' not in content and '' not in content -%} + {%- set content = "" ~ content -%} + {%- endif -%} + {%- else -%} + {%- set content = content -%} + {%- endif -%} + {%- endif %} + {%- if message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 %} + {# Assistant message has tool calls. #} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {%- set include_content = not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {%- if content is string and content | trim | length > 0 %} + {%- if include_content %} + {{- (content | trim) ~ '\n' -}} + {%- else %} + {%- set c = (content | string) %} + {%- if '' in c %} + {# Keep only content after the last closing think. Also generation prompt causes this. #} + {%- set c = c.split('')[-1] %} + {%- elif '' in c %} + {# If was opened but never closed, drop the trailing think segment #} + {%- set c = c.split('')[0] %} + {%- endif %} + {%- set c = "" ~ c | trim %} + {%- if c | length > 0 %} + {{- c ~ '\n' -}} + {%- endif %} + {%- endif %} + {%- else %} + {{- "" -}} + {%- endif %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n\n' -}} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' -}} + {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %} + {{- args_value ~ '\n\n' -}} + {%- endfor %} + {%- endif %} + {{- '\n\n' -}} + {%- endfor %} + {{- '<|im_end|>\n' }} + {%- endgeneration %} + {%- else %} + {# Assistant message doesn't have tool calls. #} + {%- if not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {{- (content | default('', true) | string | trim) ~ '<|im_end|>\n' }} + {%- endgeneration %} + {%- else %} + {%- set c = (content | default('', true) | string) %} + {%- if '' in c and '' in c %} + {%- set c = "" ~ c.split('')[-1] %} + {%- endif %} + {%- set c = c | trim %} + {%- if c | length > 0 %} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {{- c ~ '<|im_end|>\n' }} + {%- endgeneration %} + {%- else %} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {{- '<|im_end|>\n' }} + {%- endgeneration %} + {%- endif %} + {%- endif %} + {%- endif %} + {%- elif message.role == "user" or message.role == "system" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- set content = message.content | string %} + {{- content }} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user\n' }} + {%- endif %} + {{- '\n' }} + {{- message.content }} + {{- '\n\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>\n' }} + {%- endif %} +{%- endfor %} + +{%- if add_generation_prompt %} + {%- if enable_thinking %} + {{- '<|im_start|>assistant\n\n' }} + {%- else %} + {{- '<|im_start|>assistant\n' }} + {%- endif %} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_super.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_super.jinja new file mode 100644 index 0000000000000000000000000000000000000000..71935c3a25edcdde07a0b7c4bec26f68bbce73a4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_super.jinja @@ -0,0 +1,209 @@ +{% macro render_extra_keys(json_dict, handled_keys) %} + {%- if json_dict is mapping %} + {%- for json_key in json_dict if json_key not in handled_keys %} + {%- if json_dict[json_key] is mapping or (json_dict[json_key] is sequence and json_dict[json_key] is not string) %} + {{- '\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | tojson | safe) ~ '' }} + {%- else %} + {{-'\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | string) ~ '' }} + {%- endif %} + {%- endfor %} + {%- endif %} +{% endmacro %} +{%- set enable_thinking = enable_thinking if enable_thinking is defined else True %} +{%- set low_effort = low_effort if low_effort is defined else False %} +{%- set truncate_history_thinking = truncate_history_thinking if truncate_history_thinking is defined else True %} + +{%- set ns = namespace(last_user_idx = -1) %} +{%- set loop_messages = messages %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} + +{%- if messages[0]["role"] == "system" %} + {%- set system_message = messages[0]["content"] %} + {%- set loop_messages = messages[1:] %} +{%- else %} + {%- set system_message = "" %} + {%- set loop_messages = messages %} +{%- endif %} +{%- if not tools is defined %} + {%- set tools = [] %} +{%- endif %} +{# Recompute last_user_idx relative to loop_messages after handling system #} +{%- set ns = namespace(last_user_idx = -1) %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} +{%- if system_message is defined %} + {{- "<|im_start|>system\n" + system_message }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- "<|im_start|>system\n" }} + {%- endif %} +{%- endif %} +{%- if tools is iterable and tools | length > 0 %} + {%- if system_message is defined and system_message | length > 0 %} + {{- "\n\n" }} + {%- endif %} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {{- "" }} + {%- for tool in tools %} + {%- if tool.function is defined %} + {%- set tool = tool.function %} + {%- endif %} + {{- "\n\n" ~ tool.name ~ "" }} + {%- if tool.description is defined %} + {{- '\n' ~ (tool.description | trim) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- if tool.parameters is defined and tool.parameters is mapping and tool.parameters.properties is defined and tool.parameters.properties is mapping %} + {%- for param_name, param_fields in tool.parameters.properties|items %} + {{- '\n' }} + {{- '\n' ~ param_name ~ '' }} + {%- if param_fields.type is defined %} + {{- '\n' ~ (param_fields.type | string) ~ '' }} + {%- endif %} + {%- if param_fields.description is defined %} + {{- '\n' ~ (param_fields.description | trim) ~ '' }} + {%- endif %} + {%- if param_fields.enum is defined %} + {{- '\n' ~ (param_fields.enum | tojson | safe) ~ '' }} + {%- endif %} + {%- set handled_keys = ['name', 'type', 'description', 'enum'] %} + {{- render_extra_keys(param_fields, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {% set handled_keys = ['type', 'properties', 'required'] %} + {{- render_extra_keys(tool.parameters, handled_keys) }} + {%- if tool.parameters is defined and tool.parameters.required is defined %} + {{- '\n' ~ (tool.parameters.required | tojson | safe) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- set handled_keys = ['type', 'name', 'description', 'parameters'] %} + {{- render_extra_keys(tool, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {{- "\n" }} + + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} +{%- endif %} + + +{%- if system_message is defined %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- '<|im_end|>\n' }} + {%- endif %} +{%- endif %} + +{%- for message in loop_messages %} + {%- if message.role == "assistant" %} + {# Add reasoning content in to content field for unified processing below. #} + {%- if message.reasoning_content is defined and message.reasoning_content is string and message.reasoning_content | trim | length > 0 %} + {%- set content = "\n" ~ message.reasoning_content ~ "\n\n" ~ (message.content | default('', true)) %} + {%- else %} + {%- set content = message.content | default('', true) %} + {%- if content is string -%} + {# Allow downstream logic to to take care of broken thought, only handle coherent reasoning here. #} + {%- if '' not in content and '' not in content -%} + {%- set content = "" ~ content -%} + {%- endif -%} + {%- else -%} + {%- set content = content -%} + {%- endif -%} + {%- endif %} + {%- if message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 %} + {# Assistant message has tool calls. #} + {{- '<|im_start|>assistant\n' }} + {%- set include_content = not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {%- if content is string and content | trim | length > 0 %} + {%- if include_content %} + {{- (content | trim) ~ '\n' -}} + {%- else %} + {%- set c = (content | string) %} + {%- if '' in c %} + {# Keep only content after the last closing think. Also generation prompt causes this. #} + {%- set c = c.split('')[-1] %} + {%- elif '' in c %} + {# If was opened but never closed, drop the trailing think segment #} + {%- set c = c.split('')[0] %} + {%- endif %} + {%- set c = "" ~ c | trim %} + {%- if c | length > 0 %} + {{- c ~ '\n' -}} + {%- endif %} + {%- endif %} + {%- else %} + {{- "" -}} + {%- endif %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n\n' -}} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' -}} + {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %} + {{- args_value ~ '\n\n' -}} + {%- endfor %} + {%- endif %} + {{- '\n\n' -}} + {%- endfor %} + {{- '<|im_end|>\n' }} + {%- else %} + {# Assistant message doesn't have tool calls. #} + {%- if not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {{- '<|im_start|>assistant\n' ~ (content | default('', true) | string | trim) ~ '<|im_end|>\n' }} + {%- else %} + {%- set c = (content | default('', true) | string) %} + {%- if '' in c and '' in c %} + {%- set c = "" ~ c.split('')[-1] %} + {%- endif %} + {%- set c = c | trim %} + {%- if c | length > 0 %} + {{- '<|im_start|>assistant\n' ~ c ~ '<|im_end|>\n' }} + {%- else %} + {{- '<|im_start|>assistant\n<|im_end|>\n' }} + {%- endif %} + {%- endif %} + {%- endif %} + {%- elif message.role == "user" or message.role == "system" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- set content = message.content | string %} + {%- if message.role == "user" and loop.index0 == ns.last_user_idx and low_effort %} + {{- content + '\n\n{reasoning effort: low}' }} + {%- else %} + {{- content }} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user\n' }} + {%- endif %} + {{- '\n' }} + {{- message.content }} + {{- '\n\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>\n' }} + {%- endif %} +{%- endfor %} + +{%- if add_generation_prompt %} + {%- if enable_thinking %} + {{- '<|im_start|>assistant\n\n' }} + {%- else %} + {{- '<|im_start|>assistant\n' }} + {%- endif %} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_super_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_super_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..bcd170998dc60b864b7f9d35b31c7664cf35a546 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_super_training.jinja @@ -0,0 +1,226 @@ +{#- Training variant of the Nemotron Super chat template (see nemotron_3_super.jinja for the original). + The original is already prefix-preserving, so the only modification is adding + {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. All other rendering (including the + `truncate_history_thinking` and `low_effort` logic) is identical to the original. +-#} +{% macro render_extra_keys(json_dict, handled_keys) %} + {%- if json_dict is mapping %} + {%- for json_key in json_dict if json_key not in handled_keys %} + {%- if json_dict[json_key] is mapping or (json_dict[json_key] is sequence and json_dict[json_key] is not string) %} + {{- '\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | tojson | safe) ~ '' }} + {%- else %} + {{-'\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | string) ~ '' }} + {%- endif %} + {%- endfor %} + {%- endif %} +{% endmacro %} +{%- set enable_thinking = enable_thinking if enable_thinking is defined else True %} +{%- set truncate_history_thinking = truncate_history_thinking if truncate_history_thinking is defined else True %} +{%- set low_effort = low_effort if low_effort is defined else False %} + +{%- set ns = namespace(last_user_idx = -1) %} +{%- set loop_messages = messages %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} + +{%- if messages[0]["role"] == "system" %} + {%- set system_message = messages[0]["content"] %} + {%- set loop_messages = messages[1:] %} +{%- else %} + {%- set system_message = "" %} + {%- set loop_messages = messages %} +{%- endif %} +{%- if not tools is defined %} + {%- set tools = [] %} +{%- endif %} +{# Recompute last_user_idx relative to loop_messages after handling system #} +{%- set ns = namespace(last_user_idx = -1) %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} +{%- if system_message is defined %} + {{- "<|im_start|>system\n" + system_message }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- "<|im_start|>system\n" }} + {%- endif %} +{%- endif %} +{%- if tools is iterable and tools | length > 0 %} + {%- if system_message is defined and system_message | length > 0 %} + {{- "\n\n" }} + {%- endif %} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {{- "" }} + {%- for tool in tools %} + {%- if tool.function is defined %} + {%- set tool = tool.function %} + {%- endif %} + {{- "\n\n" ~ tool.name ~ "" }} + {%- if tool.description is defined %} + {{- '\n' ~ (tool.description | trim) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- if tool.parameters is defined and tool.parameters is mapping and tool.parameters.properties is defined and tool.parameters.properties is mapping %} + {%- for param_name, param_fields in tool.parameters.properties|items %} + {{- '\n' }} + {{- '\n' ~ param_name ~ '' }} + {%- if param_fields.type is defined %} + {{- '\n' ~ (param_fields.type | string) ~ '' }} + {%- endif %} + {%- if param_fields.description is defined %} + {{- '\n' ~ (param_fields.description | trim) ~ '' }} + {%- endif %} + {%- if param_fields.enum is defined %} + {{- '\n' ~ (param_fields.enum | tojson | safe) ~ '' }} + {%- endif %} + {%- set handled_keys = ['name', 'type', 'description', 'enum'] %} + {{- render_extra_keys(param_fields, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {% set handled_keys = ['type', 'properties', 'required'] %} + {{- render_extra_keys(tool.parameters, handled_keys) }} + {%- if tool.parameters is defined and tool.parameters.required is defined %} + {{- '\n' ~ (tool.parameters.required | tojson | safe) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- set handled_keys = ['type', 'name', 'description', 'parameters'] %} + {{- render_extra_keys(tool, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {{- "\n" }} + + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} +{%- endif %} + + +{%- if system_message is defined %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- '<|im_end|>\n' }} + {%- endif %} +{%- endif %} + +{%- for message in loop_messages %} + {%- if message.role == "assistant" %} + {# Add reasoning content in to content field for unified processing below. #} + {%- if message.reasoning_content is defined and message.reasoning_content is string and message.reasoning_content | trim | length > 0 %} + {%- set content = "\n" ~ message.reasoning_content ~ "\n\n" ~ (message.content | default('', true)) %} + {%- else %} + {%- set content = message.content | default('', true) %} + {%- if content is string -%} + {# Allow downstream logic to to take care of broken thought, only handle coherent reasoning here. #} + {%- if '' not in content and '' not in content -%} + {%- set content = "" ~ content -%} + {%- endif -%} + {%- else -%} + {%- set content = content -%} + {%- endif -%} + {%- endif %} + {%- if message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 %} + {# Assistant message has tool calls. #} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {%- set include_content = not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {%- if content is string and content | trim | length > 0 %} + {%- if include_content %} + {{- (content | trim) ~ '\n' -}} + {%- else %} + {%- set c = (content | string) %} + {%- if '' in c %} + {# Keep only content after the last closing think. Also generation prompt causes this. #} + {%- set c = c.split('')[-1] %} + {%- elif '' in c %} + {# If was opened but never closed, drop the trailing think segment #} + {%- set c = c.split('')[0] %} + {%- endif %} + {%- set c = "" ~ c | trim %} + {%- if c | length > 0 %} + {{- c ~ '\n' -}} + {%- endif %} + {%- endif %} + {%- else %} + {{- "" -}} + {%- endif %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n\n' -}} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' -}} + {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %} + {{- args_value ~ '\n\n' -}} + {%- endfor %} + {%- endif %} + {{- '\n\n' -}} + {%- endfor %} + {{- '<|im_end|>\n' }} + {%- endgeneration %} + {%- else %} + {# Assistant message doesn't have tool calls. #} + {%- if not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {{- (content | default('', true) | string | trim) ~ '<|im_end|>\n' }} + {%- endgeneration %} + {%- else %} + {%- set c = (content | default('', true) | string) %} + {%- if '' in c and '' in c %} + {%- set c = "" ~ c.split('')[-1] %} + {%- endif %} + {%- set c = c | trim %} + {%- if c | length > 0 %} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {{- c ~ '<|im_end|>\n' }} + {%- endgeneration %} + {%- else %} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {{- '<|im_end|>\n' }} + {%- endgeneration %} + {%- endif %} + {%- endif %} + {%- endif %} + {%- elif message.role == "user" or message.role == "system" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- set content = message.content | string %} + {%- if message.role == "user" and loop.index0 == ns.last_user_idx and low_effort %} + {{- content + '\n\n{reasoning effort: low}' }} + {%- else %} + {{- content }} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user\n' }} + {%- endif %} + {{- '\n' }} + {{- message.content }} + {{- '\n\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>\n' }} + {%- endif %} +{%- endfor %} + +{%- if add_generation_prompt %} + {%- if enable_thinking %} + {{- '<|im_start|>assistant\n\n' }} + {%- else %} + {{- '<|im_start|>assistant\n' }} + {%- endif %} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_ultra.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_ultra.jinja new file mode 100644 index 0000000000000000000000000000000000000000..7afbeb759a6786de17cde07485f9c2db387fd94d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_ultra.jinja @@ -0,0 +1,195 @@ +{% macro render_extra_keys(json_dict, handled_keys) %} + {%- if json_dict is mapping %} + {%- for json_key in json_dict if json_key not in handled_keys %} + {%- if json_dict[json_key] is mapping or (json_dict[json_key] is sequence and json_dict[json_key] is not string) %} + {{- '\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | tojson | safe) ~ '' }} + {%- else %} + {{-'\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | string) ~ '' }} + {%- endif %} + {%- endfor %} + {%- endif %} +{% endmacro %} +{%- set enable_thinking = enable_thinking if enable_thinking is defined else True %} +{%- set medium_effort = medium_effort if medium_effort is defined else False %} +{%- set truncate_history_thinking = truncate_history_thinking if truncate_history_thinking is defined else True %} +{%- set ns = namespace(last_user_idx = -1) %} +{%- set loop_messages = messages %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} +{%- if messages[0]["role"] == "system" %} + {%- set system_message = messages[0]["content"] %} + {%- set loop_messages = messages[1:] %} +{%- else %} + {%- set system_message = "" %} + {%- set loop_messages = messages %} +{%- endif %} +{%- if not tools is defined %} + {%- set tools = [] %} +{%- endif %} +{%- set ns = namespace(last_user_idx = -1) %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} +{%- if system_message is defined %} + {{- "<|im_start|>system\n" + system_message }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- "<|im_start|>system\n" }} + {%- endif %} +{%- endif %} +{%- if tools is iterable and tools | length > 0 %} + {%- if system_message is defined and system_message | length > 0 %} + {{- "\n\n" }} + {%- endif %} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {{- "" }} + {%- for tool in tools %} + {%- if tool.function is defined %} + {%- set tool = tool.function %} + {%- endif %} + {{- "\n\n" ~ tool.name ~ "" }} + {%- if tool.description is defined %} + {{- '\n' ~ (tool.description | trim) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- if tool.parameters is defined and tool.parameters is mapping and tool.parameters.properties is defined and tool.parameters.properties is mapping %} + {%- for param_name, param_fields in tool.parameters.properties|items %} + {{- '\n' }} + {{- '\n' ~ param_name ~ '' }} + {%- if param_fields.type is defined %} + {{- '\n' ~ (param_fields.type | string) ~ '' }} + {%- endif %} + {%- if param_fields.description is defined %} + {{- '\n' ~ (param_fields.description | trim) ~ '' }} + {%- endif %} + {%- if param_fields.enum is defined %} + {{- '\n' ~ (param_fields.enum | tojson | safe) ~ '' }} + {%- endif %} + {%- set handled_keys = ['name', 'type', 'description', 'enum'] %} + {{- render_extra_keys(param_fields, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {% set handled_keys = ['type', 'properties', 'required'] %} + {{- render_extra_keys(tool.parameters, handled_keys) }} + {%- if tool.parameters is defined and tool.parameters.required is defined %} + {{- '\n' ~ (tool.parameters.required | tojson | safe) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- set handled_keys = ['type', 'name', 'description', 'parameters'] %} + {{- render_extra_keys(tool, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {{- "\n" }} + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} +{%- endif %} +{%- if system_message is defined %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- for message in loop_messages %} + {%- if message.role == "assistant" %} + {%- if message.reasoning_content is defined and message.reasoning_content is string and message.reasoning_content | trim | length > 0 %} + {%- set content = "\n" ~ message.reasoning_content ~ "" ~ (message.content | default('', true)) %} + {%- else %} + {%- set content = message.content | default('', true) %} + {%- if content is string -%} + {%- if '' not in content and '' not in content -%} + {%- set content = "" ~ content -%} + {%- endif -%} + {%- else -%} + {%- set content = content -%} + {%- endif -%} + {%- endif %} + {%- if message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 %} + {{- '<|im_start|>assistant\n' }} + {%- set include_content = not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {%- if content is string and content | trim | length > 0 %} + {%- if include_content %} + {{- (content | trim) ~ '\n' -}} + {%- else %} + {%- set c = (content | string) %} + {%- if '' in c %} + {%- set c = c.split('')[-1] %} + {%- elif '' in c %} + {%- set c = c.split('')[0] %} + {%- endif %} + {%- set c = "" ~ c %} + {%- if c | length > 0 %} + {{- c ~ '\n' -}} + {%- endif %} + {%- endif %} + {%- else %} + {{- "" -}} + {%- endif %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n\n' -}} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' -}} + {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %} + {{- args_value ~ '\n\n' -}} + {%- endfor %} + {%- endif %} + {{- '\n\n' -}} + {%- endfor %} + {{- '<|im_end|>\n' }} + {%- else %} + {%- if not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {{- '<|im_start|>assistant\n' ~ (content | default('', true) | string | trim) ~ '<|im_end|>\n' }} + {%- else %} + {%- set c = (content | default('', true) | string) %} + {%- if '' in c and '' in c %} + {%- set c = "" ~ c.split('')[-1] %} + {%- endif %} + {%- set c = c | trim %} + {%- if c | length > 0 %} + {{- '<|im_start|>assistant\n' ~ c ~ '<|im_end|>\n' }} + {%- else %} + {{- '<|im_start|>assistant\n<|im_end|>\n' }} + {%- endif %} + {%- endif %} + {%- endif %} + {%- elif message.role == "user" or message.role == "system" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- set content = message.content | string %} + {%- if message.role == "user" and loop.index0 == ns.last_user_idx and medium_effort %} + {{- content + '\n\n{reasoning effort: efficient}' }} + {%- else %} + {{- content }} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user\n' }} + {%- endif %} + {{- '\n' }} + {{- message.content }} + {{- '\n\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>\n' }} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {%- if enable_thinking %} + {{- '<|im_start|>assistant\n\n' }} + {%- else %} + {{- '<|im_start|>assistant\n' }} + {%- endif %} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_ultra_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_ultra_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..12a52d22e4c38c67a6a98b5b396e134ad3de94f8 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/nemotron_3_ultra_training.jinja @@ -0,0 +1,212 @@ +{#- Training variant of the Nemotron Ultra chat template (see nemotron_3_ultra.jinja for the original). + The original is already prefix-preserving, so the only modification is adding + {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. All other rendering (including the + `truncate_history_thinking` and `medium_effort` logic) is identical to the original. +-#} +{% macro render_extra_keys(json_dict, handled_keys) %} + {%- if json_dict is mapping %} + {%- for json_key in json_dict if json_key not in handled_keys %} + {%- if json_dict[json_key] is mapping or (json_dict[json_key] is sequence and json_dict[json_key] is not string) %} + {{- '\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | tojson | safe) ~ '' }} + {%- else %} + {{-'\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | string) ~ '' }} + {%- endif %} + {%- endfor %} + {%- endif %} +{% endmacro %} +{%- set enable_thinking = enable_thinking if enable_thinking is defined else True %} +{%- set medium_effort = medium_effort if medium_effort is defined else False %} +{%- set truncate_history_thinking = truncate_history_thinking if truncate_history_thinking is defined else True %} +{%- set ns = namespace(last_user_idx = -1) %} +{%- set loop_messages = messages %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} +{%- if messages[0]["role"] == "system" %} + {%- set system_message = messages[0]["content"] %} + {%- set loop_messages = messages[1:] %} +{%- else %} + {%- set system_message = "" %} + {%- set loop_messages = messages %} +{%- endif %} +{%- if not tools is defined %} + {%- set tools = [] %} +{%- endif %} +{%- set ns = namespace(last_user_idx = -1) %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} +{%- if system_message is defined %} + {{- "<|im_start|>system\n" + system_message }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- "<|im_start|>system\n" }} + {%- endif %} +{%- endif %} +{%- if tools is iterable and tools | length > 0 %} + {%- if system_message is defined and system_message | length > 0 %} + {{- "\n\n" }} + {%- endif %} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {{- "" }} + {%- for tool in tools %} + {%- if tool.function is defined %} + {%- set tool = tool.function %} + {%- endif %} + {{- "\n\n" ~ tool.name ~ "" }} + {%- if tool.description is defined %} + {{- '\n' ~ (tool.description | trim) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- if tool.parameters is defined and tool.parameters is mapping and tool.parameters.properties is defined and tool.parameters.properties is mapping %} + {%- for param_name, param_fields in tool.parameters.properties|items %} + {{- '\n' }} + {{- '\n' ~ param_name ~ '' }} + {%- if param_fields.type is defined %} + {{- '\n' ~ (param_fields.type | string) ~ '' }} + {%- endif %} + {%- if param_fields.description is defined %} + {{- '\n' ~ (param_fields.description | trim) ~ '' }} + {%- endif %} + {%- if param_fields.enum is defined %} + {{- '\n' ~ (param_fields.enum | tojson | safe) ~ '' }} + {%- endif %} + {%- set handled_keys = ['name', 'type', 'description', 'enum'] %} + {{- render_extra_keys(param_fields, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {% set handled_keys = ['type', 'properties', 'required'] %} + {{- render_extra_keys(tool.parameters, handled_keys) }} + {%- if tool.parameters is defined and tool.parameters.required is defined %} + {{- '\n' ~ (tool.parameters.required | tojson | safe) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- set handled_keys = ['type', 'name', 'description', 'parameters'] %} + {{- render_extra_keys(tool, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {{- "\n" }} + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} +{%- endif %} +{%- if system_message is defined %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- for message in loop_messages %} + {%- if message.role == "assistant" %} + {%- if message.reasoning_content is defined and message.reasoning_content is string and message.reasoning_content | trim | length > 0 %} + {%- set content = "\n" ~ message.reasoning_content ~ "" ~ (message.content | default('', true)) %} + {%- else %} + {%- set content = message.content | default('', true) %} + {%- if content is string -%} + {%- if '' not in content and '' not in content -%} + {%- set content = "" ~ content -%} + {%- endif -%} + {%- else -%} + {%- set content = content -%} + {%- endif -%} + {%- endif %} + {%- if message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 %} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {%- set include_content = not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {%- if content is string and content | trim | length > 0 %} + {%- if include_content %} + {{- (content | trim) ~ '\n' -}} + {%- else %} + {%- set c = (content | string) %} + {%- if '' in c %} + {%- set c = c.split('')[-1] %} + {%- elif '' in c %} + {%- set c = c.split('')[0] %} + {%- endif %} + {%- set c = "" ~ c %} + {%- if c | length > 0 %} + {{- c ~ '\n' -}} + {%- endif %} + {%- endif %} + {%- else %} + {{- "" -}} + {%- endif %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n\n' -}} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' -}} + {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %} + {{- args_value ~ '\n\n' -}} + {%- endfor %} + {%- endif %} + {{- '\n\n' -}} + {%- endfor %} + {{- '<|im_end|>\n' }} + {%- endgeneration %} + {%- else %} + {%- if not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {{- (content | default('', true) | string | trim) ~ '<|im_end|>\n' }} + {%- endgeneration %} + {%- else %} + {%- set c = (content | default('', true) | string) %} + {%- if '' in c and '' in c %} + {%- set c = "" ~ c.split('')[-1] %} + {%- endif %} + {%- set c = c | trim %} + {%- if c | length > 0 %} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {{- c ~ '<|im_end|>\n' }} + {%- endgeneration %} + {%- else %} + {{- '<|im_start|>assistant\n' }} + {%- generation %} + {{- '<|im_end|>\n' }} + {%- endgeneration %} + {%- endif %} + {%- endif %} + {%- endif %} + {%- elif message.role == "user" or message.role == "system" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- set content = message.content | string %} + {%- if message.role == "user" and loop.index0 == ns.last_user_idx and medium_effort %} + {{- content + '\n\n{reasoning effort: efficient}' }} + {%- else %} + {{- content }} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user\n' }} + {%- endif %} + {{- '\n' }} + {{- message.content }} + {{- '\n\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>\n' }} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {%- if enable_thinking %} + {{- '<|im_start|>assistant\n\n' }} + {%- else %} + {{- '<|im_start|>assistant\n' }} + {%- endif %} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3.jinja new file mode 100644 index 0000000000000000000000000000000000000000..ddb5006baa8ee6aa317c5d84827e6993469c2073 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3.jinja @@ -0,0 +1,8 @@ +{% for message in messages %}{% if message['role'] == 'system' %}{{'<|system|> +' + message['content'] + '<|end|> +'}}{% elif message['role'] == 'user' %}{{'<|user|> +' + message['content'] + '<|end|> +'}}{% elif message['role'] == 'assistant' %}{{'<|assistant|> +' + message['content'] + '<|end|> +'}}{% endif %}{% endfor %}{% if add_generation_prompt %}{{ '<|assistant|> +' }}{% else %}{{ eos_token }}{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3_5.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3_5.jinja new file mode 100644 index 0000000000000000000000000000000000000000..d1533d1526b2e42fccd99477a7274dc20b7a189b --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3_5.jinja @@ -0,0 +1,8 @@ +{% for message in messages %}{% if message['role'] == 'system' and message['content'] %}{{'<|system|> +' + message['content'] + '<|end|> +'}}{% elif message['role'] == 'user' %}{{'<|user|> +' + message['content'] + '<|end|> +'}}{% elif message['role'] == 'assistant' %}{{'<|assistant|> +' + message['content'] + '<|end|> +'}}{% endif %}{% endfor %}{% if add_generation_prompt %}{{ '<|assistant|> +' }}{% else %}{{ eos_token }}{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3_5_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3_5_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..61d15d77936bc8ebbf965f4478185e9b4233caad --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3_5_training.jinja @@ -0,0 +1,26 @@ +{#- Training variant of the Phi-3.5 chat template (see phi3_5.jinja for the original). + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{%- for message in messages %} + {%- if message['role'] == 'system' and message['content'] %} + {{- '<|system|>\n' + message['content'] + '<|end|>\n' }} + {%- elif message['role'] == 'user' %} + {{- '<|user|>\n' + message['content'] + '<|end|>\n'}} + {%- elif message['role'] == 'assistant' %} + {{- '<|assistant|>\n' }} + {%- generation %} + {{- message['content'] + '<|end|>\n' }} + {%- endgeneration %} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|assistant|>\n'}} +{%- elif messages[-1]['role'] == 'assistant' %} + {%- generation %} + {{- eos_token }} + {%- endgeneration %} +{%- else %} + {{- eos_token }} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..1536d152f7de385ed29917e463bb0aba66977eb3 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/phi3_training.jinja @@ -0,0 +1,26 @@ +{#- Training variant of the Phi-3 chat template (see phi3.jinja for the original). + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{%- for message in messages %} + {%- if message['role'] == 'system' %} + {{- '<|system|>\n' + message['content'] + '<|end|>\n' }} + {%- elif message['role'] == 'user' %} + {{- '<|user|>\n' + message['content'] + '<|end|>\n' }} + {%- elif message['role'] == 'assistant' %} + {{- '<|assistant|>\n' }} + {%- generation %} + {{- message['content'] + '<|end|>\n' }} + {%- endgeneration %} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|assistant|>\n' }} +{%- elif messages[-1]['role'] == 'assistant' %} + {%- generation %} + {{- eos_token }} + {%- endgeneration %} +{%- else %} + {{- eos_token }} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5.jinja new file mode 100644 index 0000000000000000000000000000000000000000..bdf7919a96cfe43d50914a007b9c0877bd0ec27e --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5.jinja @@ -0,0 +1,54 @@ +{%- if tools %} + {{- '<|im_start|>system\n' }} + {%- if messages[0]['role'] == 'system' %} + {{- messages[0]['content'] }} + {%- else %} + {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }} + {%- endif %} + {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within XML tags:\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n\n\nFor each function call, return a json object with function name and arguments within XML tags:\n\n{\"name\": , \"arguments\": }\n<|im_end|>\n" }} +{%- else %} + {%- if messages[0]['role'] == 'system' %} + {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }} + {%- else %} + {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- for message in messages %} + {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %} + {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {{- '<|im_start|>' + message.role }} + {%- if message.content %} + {{- '\n' + message.content }} + {%- endif %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n\n{"name": "' }} + {{- tool_call.name }} + {{- '", "arguments": ' }} + {{- tool_call.arguments | tojson }} + {{- '}\n' }} + {%- endfor %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- message.content }} + {{- '\n' }} + {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..fd7258ece606cb8b6b59a3fb28904282f6004ac4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5_training.jinja @@ -0,0 +1,65 @@ +{#- Training variant of the Qwen2.5 chat template (see qwen2_5.jinja for the original). + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{%- if tools %} + {{- '<|im_start|>system\n' }} + {%- if messages[0]['role'] == 'system' %} + {{- messages[0]['content'] }} + {%- else %} + {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }} + {%- endif %} + {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within XML tags:\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n\n\nFor each function call, return a json object with function name and arguments within XML tags:\n\n{\"name\": , \"arguments\": }\n<|im_end|>\n" }} +{%- else %} + {%- if messages[0]['role'] == 'system' %} + {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }} + {%- else %} + {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- for message in messages %} + {%- if (message.role == "user") or (message.role == "system" and not loop.first) %} + {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {{- '<|im_start|>assistant' }} + {%- generation %} + {%- if not message.tool_calls %} + {{- '\n' + message.content + '<|im_end|>\n' }} + {%- else %} + {%- if message.content %} + {{- '\n' + message.content }} + {%- endif %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n\n{"name": "' }} + {{- tool_call.name }} + {{- '", "arguments": ' }} + {{- tool_call.arguments | tojson }} + {{- '}\n' }} + {%- endfor %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endgeneration %} + {%- elif message.role == "tool" %} + {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- message.content }} + {{- '\n' }} + {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5_vl.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5_vl.jinja new file mode 100644 index 0000000000000000000000000000000000000000..6c226632394ae7474b0d4b13e15793eac2e21ee9 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5_vl.jinja @@ -0,0 +1,7 @@ +{% set image_count = namespace(value=0) %}{% set video_count = namespace(value=0) %}{% for message in messages %}{% if loop.first and message['role'] != 'system' %}<|im_start|>system +You are a helpful assistant.<|im_end|> +{% endif %}<|im_start|>{{ message['role'] }} +{% if message['content'] is string %}{{ message['content'] }}<|im_end|> +{% else %}{% for content in message['content'] %}{% if content['type'] == 'image' or 'image' in content or 'image_url' in content %}{% set image_count.value = image_count.value + 1 %}{% if add_vision_id %}Picture {{ image_count.value }}: {% endif %}<|vision_start|><|image_pad|><|vision_end|>{% elif content['type'] == 'video' or 'video' in content %}{% set video_count.value = video_count.value + 1 %}{% if add_vision_id %}Video {{ video_count.value }}: {% endif %}<|vision_start|><|video_pad|><|vision_end|>{% elif 'text' in content %}{{ content['text'] }}{% endif %}{% endfor %}<|im_end|> +{% endif %}{% endfor %}{% if add_generation_prompt %}<|im_start|>assistant +{% endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5_vl_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5_vl_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..46e34469a34f03fa8c12b7535307cc189997d14b --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen2_5_vl_training.jinja @@ -0,0 +1,63 @@ +{#- Training variant of the Qwen 2.5 VL chat template (see qwen2_5_vl.jinja for the original). + Also used for Qwen 2 VL, which ships a byte-identical chat template. + Modifications vs the original: + - Split the assistant message into its own branch so the {% generation %} / {% endgeneration %} + markers wrap the assistant content (everything after the '<|im_start|>assistant\n' prompt + cue, up to and including the trailing '<|im_end|>\n'). This enables assistant-only loss + masking in SFT training. +-#} +{%- set image_count = namespace(value=0) %} +{%- set video_count = namespace(value=0) %} +{%- for message in messages %} + {%- if loop.first and message['role'] != 'system' %} + {{- '<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n' }} + {%- endif %} + {%- if message['role'] == 'assistant' %} + {{- '<|im_start|>assistant\n' }} + {%- generation -%} + {%- if message['content'] is string %} + {{- message['content'] }} + {{- '<|im_end|>\n' }} + {%- else %} + {%- for content in message['content'] %} + {%- if content['type'] == 'image' or 'image' in content or 'image_url' in content %} + {%- set image_count.value = image_count.value + 1 %} + {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%} + <|vision_start|><|image_pad|><|vision_end|> + {%- elif content['type'] == 'video' or 'video' in content %} + {%- set video_count.value = video_count.value + 1 %} + {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%} + <|vision_start|><|video_pad|><|vision_end|> + {%- elif 'text' in content %} + {{- content['text'] }} + {%- endif %} + {%- endfor %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endgeneration -%} + {%- else %} + {{- '<|im_start|>' + message['role'] + '\n' }} + {%- if message['content'] is string %} + {{- message['content'] }} + {{- '<|im_end|>\n' }} + {%- else %} + {%- for content in message['content'] %} + {%- if content['type'] == 'image' or 'image' in content or 'image_url' in content %} + {%- set image_count.value = image_count.value + 1 %} + {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%} + <|vision_start|><|image_pad|><|vision_end|> + {%- elif content['type'] == 'video' or 'video' in content %} + {%- set video_count.value = video_count.value + 1 %} + {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%} + <|vision_start|><|video_pad|><|vision_end|> + {%- elif 'text' in content %} + {{- content['text'] }} + {%- endif %} + {%- endfor %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3.jinja new file mode 100644 index 0000000000000000000000000000000000000000..01be9b307daa2d425f7c168c9fb145a286e0afb4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3.jinja @@ -0,0 +1,89 @@ +{%- if tools %} + {{- '<|im_start|>system\n' }} + {%- if messages[0].role == 'system' %} + {{- messages[0].content + '\n\n' }} + {%- endif %} + {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within XML tags:\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n\n\nFor each function call, return a json object with function name and arguments within XML tags:\n\n{\"name\": , \"arguments\": }\n<|im_end|>\n" }} +{%- else %} + {%- if messages[0].role == 'system' %} + {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %} +{%- for message in messages[::-1] %} + {%- set index = (messages|length - 1) - loop.index0 %} + {%- if ns.multi_step_tool and message.role == "user" and message.content is string and not(message.content.startswith('') and message.content.endswith('')) %} + {%- set ns.multi_step_tool = false %} + {%- set ns.last_query_index = index %} + {%- endif %} +{%- endfor %} +{%- for message in messages %} + {%- if message.content is string %} + {%- set content = message.content %} + {%- else %} + {%- set content = '' %} + {%- endif %} + {%- if (message.role == "user") or (message.role == "system" and not loop.first) %} + {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {%- set reasoning_content = '' %} + {%- if message.reasoning_content is string %} + {%- set reasoning_content = message.reasoning_content %} + {%- else %} + {%- if '' in content %} + {%- set reasoning_content = content.split('')[0].rstrip('\n').split('')[-1].lstrip('\n') %} + {%- set content = content.split('')[-1].lstrip('\n') %} + {%- endif %} + {%- endif %} + {%- if loop.index0 > ns.last_query_index %} + {%- if loop.last or (not loop.last and reasoning_content) %} + {{- '<|im_start|>' + message.role + '\n\n' + reasoning_content.strip('\n') + '\n\n\n' + content.lstrip('\n') }} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + content }} + {%- endif %} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + content }} + {%- endif %} + {%- if message.tool_calls %} + {%- for tool_call in message.tool_calls %} + {%- if (loop.first and content) or (not loop.first) %} + {{- '\n' }} + {%- endif %} + {%- if tool_call.function %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n{"name": "' }} + {{- tool_call.name }} + {{- '", "arguments": ' }} + {%- if tool_call.arguments is string %} + {{- tool_call.arguments }} + {%- else %} + {{- tool_call.arguments | tojson }} + {%- endif %} + {{- '}\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- content }} + {{- '\n' }} + {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- if enable_thinking is defined and enable_thinking is false %} + {{- '\n\n\n\n' }} + {%- endif %} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_nothink.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_nothink.jinja new file mode 100644 index 0000000000000000000000000000000000000000..0ef09f214eaa6d9bca297988afc1454b5827b2c7 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_nothink.jinja @@ -0,0 +1,154 @@ +{%- set image_count = namespace(value=0) %} +{%- set video_count = namespace(value=0) %} +{%- macro render_content(content, do_vision_count, is_system_content=false) %} + {%- if content is string %} + {{- content }} + {%- elif content is iterable and content is not mapping %} + {%- for item in content %} + {%- if 'image' in item or 'image_url' in item or item.type == 'image' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain images.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set image_count.value = image_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Picture ' ~ image_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|image_pad|><|vision_end|>' }} + {%- elif 'video' in item or item.type == 'video' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain videos.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set video_count.value = video_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Video ' ~ video_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|video_pad|><|vision_end|>' }} + {%- elif 'text' in item %} + {{- item.text }} + {%- else %} + {{- raise_exception('Unexpected item type in content.') }} + {%- endif %} + {%- endfor %} + {%- elif content is none or content is undefined %} + {{- '' }} + {%- else %} + {{- raise_exception('Unexpected content type.') }} + {%- endif %} +{%- endmacro %} +{%- if not messages %} + {{- raise_exception('No messages provided.') }} +{%- endif %} +{%- if tools and tools is iterable and tools is not mapping %} + {{- '<|im_start|>system\n' }} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n" }} + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {%- if content %} + {{- '\n\n' + content }} + {%- endif %} + {%- endif %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %} +{%- for message in messages[::-1] %} + {%- set index = (messages|length - 1) - loop.index0 %} + {%- if ns.multi_step_tool and message.role == "user" %} + {%- set content = render_content(message.content, false)|trim %} + {%- if not(content.startswith('') and content.endswith('')) %} + {%- set ns.multi_step_tool = false %} + {%- set ns.last_query_index = index %} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if ns.multi_step_tool %} + {{- raise_exception('No user query found in messages.') }} +{%- endif %} +{%- for message in messages %} + {%- set content = render_content(message.content, true)|trim %} + {%- if message.role == "system" %} + {%- if not loop.first %} + {{- raise_exception('System message must be at the beginning.') }} + {%- endif %} + {%- elif message.role == "user" %} + {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {%- set reasoning_content = '' %} + {%- if message.reasoning_content is string %} + {%- set reasoning_content = message.reasoning_content %} + {%- else %} + {%- if '' in content %} + {%- set reasoning_content = content.split('')[0].rstrip('\n').split('')[-1].lstrip('\n') %} + {%- set content = content.split('')[-1].lstrip('\n') %} + {%- endif %} + {%- endif %} + {%- set reasoning_content = reasoning_content|trim %} + {%- if loop.index0 > ns.last_query_index %} + {{- '<|im_start|>' + message.role + '\n\n' + reasoning_content + '\n\n\n' + content }} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + content }} + {%- endif %} + {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {%- if loop.first %} + {%- if content|trim %} + {{- '\n\n\n\n' }} + {%- else %} + {{- '\n\n' }} + {%- endif %} + {%- else %} + {{- '\n\n\n' }} + {%- endif %} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' }} + {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %} + {{- args_value }} + {{- '\n\n' }} + {%- endfor %} + {%- endif %} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- content }} + {{- '\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- raise_exception('Unexpected message role.') }} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- if enable_thinking is defined and enable_thinking is true %} + {{- '\n' }} + {%- else %} + {{- '\n\n\n\n' }} + {%- endif %} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_nothink_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_nothink_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..a5bde154d92c83eb794470601ac82a1b22b5b938 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_nothink_training.jinja @@ -0,0 +1,162 @@ +{#- Training variant of the Qwen3.5 chat template, NoThink flavor (see qwen3_5_nothink.jinja for the original). + Modifications vs the original: + - {%- if '' in content %} → {%- if '' in content and '' in content %} + Always check for both tags to avoid edge cases where the model generates only one tag. + - Removed the loop.index0 > ns.last_query_index conditional; always include thinking block. + This makes the template prefix-preserving for the [user, assistant] → [user, assistant, tool] transition. + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{%- set image_count = namespace(value=0) %} +{%- set video_count = namespace(value=0) %} +{%- macro render_content(content, do_vision_count, is_system_content=false) %} + {%- if content is string %} + {{- content }} + {%- elif content is iterable and content is not mapping %} + {%- for item in content %} + {%- if 'image' in item or 'image_url' in item or item.type == 'image' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain images.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set image_count.value = image_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Picture ' ~ image_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|image_pad|><|vision_end|>' }} + {%- elif 'video' in item or item.type == 'video' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain videos.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set video_count.value = video_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Video ' ~ video_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|video_pad|><|vision_end|>' }} + {%- elif 'text' in item %} + {{- item.text }} + {%- else %} + {{- raise_exception('Unexpected item type in content.') }} + {%- endif %} + {%- endfor %} + {%- elif content is none or content is undefined %} + {{- '' }} + {%- else %} + {{- raise_exception('Unexpected content type.') }} + {%- endif %} +{%- endmacro %} +{%- if not messages %} + {{- raise_exception('No messages provided.') }} +{%- endif %} +{%- if tools and tools is iterable and tools is not mapping %} + {{- '<|im_start|>system\n' }} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n" }} + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {%- if content %} + {{- '\n\n' + content }} + {%- endif %} + {%- endif %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %} +{%- for message in messages[::-1] %} + {%- set index = (messages|length - 1) - loop.index0 %} + {%- if ns.multi_step_tool and message.role == "user" %} + {%- set content = render_content(message.content, false)|trim %} + {%- if not(content.startswith('') and content.endswith('')) %} + {%- set ns.multi_step_tool = false %} + {%- set ns.last_query_index = index %} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if ns.multi_step_tool %} + {{- raise_exception('No user query found in messages.') }} +{%- endif %} +{%- for message in messages %} + {%- set content = render_content(message.content, true)|trim %} + {%- if message.role == "system" %} + {%- if not loop.first %} + {{- raise_exception('System message must be at the beginning.') }} + {%- endif %} + {%- elif message.role == "user" %} + {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {%- set reasoning_content = '' %} + {%- if message.reasoning_content is string %} + {%- set reasoning_content = message.reasoning_content %} + {%- else %} + {%- if '' in content and '' in content %} + {%- set reasoning_content = content.split('')[0].rstrip('\n').split('')[-1].lstrip('\n') %} + {%- set content = content.split('')[-1].lstrip('\n') %} + {%- endif %} + {%- endif %} + {%- set reasoning_content = reasoning_content|trim %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- generation %} + {{- '\n' + reasoning_content + '\n\n\n' + content }} + {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {%- if loop.first %} + {%- if content|trim %} + {{- '\n\n\n\n' }} + {%- else %} + {{- '\n\n' }} + {%- endif %} + {%- else %} + {{- '\n\n\n' }} + {%- endif %} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' }} + {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %} + {{- args_value }} + {{- '\n\n' }} + {%- endfor %} + {%- endif %} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- endgeneration %} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- content }} + {{- '\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- raise_exception('Unexpected message role.') }} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- if enable_thinking is defined and enable_thinking is true %} + {{- '\n' }} + {%- else %} + {{- '\n\n\n\n' }} + {%- endif %} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_think.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_think.jinja new file mode 100644 index 0000000000000000000000000000000000000000..a585dec894e63da457d9440ec6aa7caa16d20860 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_think.jinja @@ -0,0 +1,154 @@ +{%- set image_count = namespace(value=0) %} +{%- set video_count = namespace(value=0) %} +{%- macro render_content(content, do_vision_count, is_system_content=false) %} + {%- if content is string %} + {{- content }} + {%- elif content is iterable and content is not mapping %} + {%- for item in content %} + {%- if 'image' in item or 'image_url' in item or item.type == 'image' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain images.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set image_count.value = image_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Picture ' ~ image_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|image_pad|><|vision_end|>' }} + {%- elif 'video' in item or item.type == 'video' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain videos.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set video_count.value = video_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Video ' ~ video_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|video_pad|><|vision_end|>' }} + {%- elif 'text' in item %} + {{- item.text }} + {%- else %} + {{- raise_exception('Unexpected item type in content.') }} + {%- endif %} + {%- endfor %} + {%- elif content is none or content is undefined %} + {{- '' }} + {%- else %} + {{- raise_exception('Unexpected content type.') }} + {%- endif %} +{%- endmacro %} +{%- if not messages %} + {{- raise_exception('No messages provided.') }} +{%- endif %} +{%- if tools and tools is iterable and tools is not mapping %} + {{- '<|im_start|>system\n' }} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n" }} + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {%- if content %} + {{- '\n\n' + content }} + {%- endif %} + {%- endif %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %} +{%- for message in messages[::-1] %} + {%- set index = (messages|length - 1) - loop.index0 %} + {%- if ns.multi_step_tool and message.role == "user" %} + {%- set content = render_content(message.content, false)|trim %} + {%- if not(content.startswith('') and content.endswith('')) %} + {%- set ns.multi_step_tool = false %} + {%- set ns.last_query_index = index %} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if ns.multi_step_tool %} + {{- raise_exception('No user query found in messages.') }} +{%- endif %} +{%- for message in messages %} + {%- set content = render_content(message.content, true)|trim %} + {%- if message.role == "system" %} + {%- if not loop.first %} + {{- raise_exception('System message must be at the beginning.') }} + {%- endif %} + {%- elif message.role == "user" %} + {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {%- set reasoning_content = '' %} + {%- if message.reasoning_content is string %} + {%- set reasoning_content = message.reasoning_content %} + {%- else %} + {%- if '' in content %} + {%- set reasoning_content = content.split('')[0].rstrip('\n').split('')[-1].lstrip('\n') %} + {%- set content = content.split('')[-1].lstrip('\n') %} + {%- endif %} + {%- endif %} + {%- set reasoning_content = reasoning_content|trim %} + {%- if loop.index0 > ns.last_query_index %} + {{- '<|im_start|>' + message.role + '\n\n' + reasoning_content + '\n\n\n' + content }} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + content }} + {%- endif %} + {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {%- if loop.first %} + {%- if content|trim %} + {{- '\n\n\n\n' }} + {%- else %} + {{- '\n\n' }} + {%- endif %} + {%- else %} + {{- '\n\n\n' }} + {%- endif %} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' }} + {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %} + {{- args_value }} + {{- '\n\n' }} + {%- endfor %} + {%- endif %} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- content }} + {{- '\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- raise_exception('Unexpected message role.') }} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- if enable_thinking is defined and enable_thinking is false %} + {{- '\n\n\n\n' }} + {%- else %} + {{- '\n' }} + {%- endif %} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_think_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_think_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..fb4b811d6ae3c583b7e7144ace7789f8c07ca10b --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_5_think_training.jinja @@ -0,0 +1,162 @@ +{#- Training variant of the Qwen3.5 chat template, Think flavor (see qwen3_5_think.jinja for the original). + Modifications vs the original: + - {%- if '' in content %} → {%- if '' in content and '' in content %} + Always check for both tags to avoid edge cases where the model generates only one tag. + - Removed the loop.index0 > ns.last_query_index conditional; always include thinking block. + This makes the template prefix-preserving for the [user, assistant] → [user, assistant, tool] transition. + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{%- set image_count = namespace(value=0) %} +{%- set video_count = namespace(value=0) %} +{%- macro render_content(content, do_vision_count, is_system_content=false) %} + {%- if content is string %} + {{- content }} + {%- elif content is iterable and content is not mapping %} + {%- for item in content %} + {%- if 'image' in item or 'image_url' in item or item.type == 'image' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain images.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set image_count.value = image_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Picture ' ~ image_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|image_pad|><|vision_end|>' }} + {%- elif 'video' in item or item.type == 'video' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain videos.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set video_count.value = video_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Video ' ~ video_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|video_pad|><|vision_end|>' }} + {%- elif 'text' in item %} + {{- item.text }} + {%- else %} + {{- raise_exception('Unexpected item type in content.') }} + {%- endif %} + {%- endfor %} + {%- elif content is none or content is undefined %} + {{- '' }} + {%- else %} + {{- raise_exception('Unexpected content type.') }} + {%- endif %} +{%- endmacro %} +{%- if not messages %} + {{- raise_exception('No messages provided.') }} +{%- endif %} +{%- if tools and tools is iterable and tools is not mapping %} + {{- '<|im_start|>system\n' }} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n" }} + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {%- if content %} + {{- '\n\n' + content }} + {%- endif %} + {%- endif %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %} +{%- for message in messages[::-1] %} + {%- set index = (messages|length - 1) - loop.index0 %} + {%- if ns.multi_step_tool and message.role == "user" %} + {%- set content = render_content(message.content, false)|trim %} + {%- if not(content.startswith('') and content.endswith('')) %} + {%- set ns.multi_step_tool = false %} + {%- set ns.last_query_index = index %} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if ns.multi_step_tool %} + {{- raise_exception('No user query found in messages.') }} +{%- endif %} +{%- for message in messages %} + {%- set content = render_content(message.content, true)|trim %} + {%- if message.role == "system" %} + {%- if not loop.first %} + {{- raise_exception('System message must be at the beginning.') }} + {%- endif %} + {%- elif message.role == "user" %} + {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {%- set reasoning_content = '' %} + {%- if message.reasoning_content is string %} + {%- set reasoning_content = message.reasoning_content %} + {%- else %} + {%- if '' in content and '' in content %} + {%- set reasoning_content = content.split('')[0].rstrip('\n').split('')[-1].lstrip('\n') %} + {%- set content = content.split('')[-1].lstrip('\n') %} + {%- endif %} + {%- endif %} + {%- set reasoning_content = reasoning_content|trim %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- generation %} + {{- '\n' + reasoning_content + '\n\n\n' + content }} + {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {%- if loop.first %} + {%- if content|trim %} + {{- '\n\n\n\n' }} + {%- else %} + {{- '\n\n' }} + {%- endif %} + {%- else %} + {{- '\n\n\n' }} + {%- endif %} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' }} + {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %} + {{- args_value }} + {{- '\n\n' }} + {%- endfor %} + {%- endif %} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- endgeneration %} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- content }} + {{- '\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- raise_exception('Unexpected message role.') }} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- if enable_thinking is defined and enable_thinking is false %} + {{- '\n\n\n\n' }} + {%- else %} + {{- '\n' }} + {%- endif %} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_6.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_6.jinja new file mode 100644 index 0000000000000000000000000000000000000000..a8755d827c0a7b614c246c4060dfd58ab352a8ff --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_6.jinja @@ -0,0 +1,154 @@ +{%- set image_count = namespace(value=0) %} +{%- set video_count = namespace(value=0) %} +{%- macro render_content(content, do_vision_count, is_system_content=false) %} + {%- if content is string %} + {{- content }} + {%- elif content is iterable and content is not mapping %} + {%- for item in content %} + {%- if 'image' in item or 'image_url' in item or item.type == 'image' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain images.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set image_count.value = image_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Picture ' ~ image_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|image_pad|><|vision_end|>' }} + {%- elif 'video' in item or item.type == 'video' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain videos.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set video_count.value = video_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Video ' ~ video_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|video_pad|><|vision_end|>' }} + {%- elif 'text' in item %} + {{- item.text }} + {%- else %} + {{- raise_exception('Unexpected item type in content.') }} + {%- endif %} + {%- endfor %} + {%- elif content is none or content is undefined %} + {{- '' }} + {%- else %} + {{- raise_exception('Unexpected content type.') }} + {%- endif %} +{%- endmacro %} +{%- if not messages %} + {{- raise_exception('No messages provided.') }} +{%- endif %} +{%- if tools and tools is iterable and tools is not mapping %} + {{- '<|im_start|>system\n' }} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n" }} + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {%- if content %} + {{- '\n\n' + content }} + {%- endif %} + {%- endif %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %} +{%- for message in messages[::-1] %} + {%- set index = (messages|length - 1) - loop.index0 %} + {%- if ns.multi_step_tool and message.role == "user" %} + {%- set content = render_content(message.content, false)|trim %} + {%- if not(content.startswith('') and content.endswith('')) %} + {%- set ns.multi_step_tool = false %} + {%- set ns.last_query_index = index %} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if ns.multi_step_tool %} + {{- raise_exception('No user query found in messages.') }} +{%- endif %} +{%- for message in messages %} + {%- set content = render_content(message.content, true)|trim %} + {%- if message.role == "system" %} + {%- if not loop.first %} + {{- raise_exception('System message must be at the beginning.') }} + {%- endif %} + {%- elif message.role == "user" %} + {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {%- set reasoning_content = '' %} + {%- if message.reasoning_content is string %} + {%- set reasoning_content = message.reasoning_content %} + {%- else %} + {%- if '' in content %} + {%- set reasoning_content = content.split('')[0].rstrip('\n').split('')[-1].lstrip('\n') %} + {%- set content = content.split('')[-1].lstrip('\n') %} + {%- endif %} + {%- endif %} + {%- set reasoning_content = reasoning_content|trim %} + {%- if (preserve_thinking is defined and preserve_thinking is true) or (loop.index0 > ns.last_query_index) %} + {{- '<|im_start|>' + message.role + '\n\n' + reasoning_content + '\n\n\n' + content }} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + content }} + {%- endif %} + {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {%- if loop.first %} + {%- if content|trim %} + {{- '\n\n\n\n' }} + {%- else %} + {{- '\n\n' }} + {%- endif %} + {%- else %} + {{- '\n\n\n' }} + {%- endif %} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' }} + {%- set args_value = args_value | string if args_value is string else args_value | tojson | safe %} + {{- args_value }} + {{- '\n\n' }} + {%- endfor %} + {%- endif %} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- content }} + {{- '\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- raise_exception('Unexpected message role.') }} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- if enable_thinking is defined and enable_thinking is false %} + {{- '\n\n\n\n' }} + {%- else %} + {{- '\n' }} + {%- endif %} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_6_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_6_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..e4e705768d7d62e8149f7c28da77c93b57f6d041 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_6_training.jinja @@ -0,0 +1,162 @@ +{#- Training variant of the Qwen3.6 chat template (see qwen3_6.jinja for the original). + Modifications vs the original: + - {%- if '' in content %} → {%- if '' in content and '' in content %} + Always check for both tags to avoid edge cases where the model generates only one tag. + - Removed the loop.index0 > ns.last_query_index conditional; always include thinking block. + This makes the template prefix-preserving for the [user, assistant] → [user, assistant, tool] transition. + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{%- set image_count = namespace(value=0) %} +{%- set video_count = namespace(value=0) %} +{%- macro render_content(content, do_vision_count, is_system_content=false) %} + {%- if content is string %} + {{- content }} + {%- elif content is iterable and content is not mapping %} + {%- for item in content %} + {%- if 'image' in item or 'image_url' in item or item.type == 'image' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain images.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set image_count.value = image_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Picture ' ~ image_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|image_pad|><|vision_end|>' }} + {%- elif 'video' in item or item.type == 'video' %} + {%- if is_system_content %} + {{- raise_exception('System message cannot contain videos.') }} + {%- endif %} + {%- if do_vision_count %} + {%- set video_count.value = video_count.value + 1 %} + {%- endif %} + {%- if add_vision_id %} + {{- 'Video ' ~ video_count.value ~ ': ' }} + {%- endif %} + {{- '<|vision_start|><|video_pad|><|vision_end|>' }} + {%- elif 'text' in item %} + {{- item.text }} + {%- else %} + {{- raise_exception('Unexpected item type in content.') }} + {%- endif %} + {%- endfor %} + {%- elif content is none or content is undefined %} + {{- '' }} + {%- else %} + {{- raise_exception('Unexpected content type.') }} + {%- endif %} +{%- endmacro %} +{%- if not messages %} + {{- raise_exception('No messages provided.') }} +{%- endif %} +{%- if tools and tools is iterable and tools is not mapping %} + {{- '<|im_start|>system\n' }} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n" }} + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {%- if content %} + {{- '\n\n' + content }} + {%- endif %} + {%- endif %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if messages[0].role == 'system' %} + {%- set content = render_content(messages[0].content, false, true)|trim %} + {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %} +{%- for message in messages[::-1] %} + {%- set index = (messages|length - 1) - loop.index0 %} + {%- if ns.multi_step_tool and message.role == "user" %} + {%- set content = render_content(message.content, false)|trim %} + {%- if not(content.startswith('') and content.endswith('')) %} + {%- set ns.multi_step_tool = false %} + {%- set ns.last_query_index = index %} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if ns.multi_step_tool %} + {{- raise_exception('No user query found in messages.') }} +{%- endif %} +{%- for message in messages %} + {%- set content = render_content(message.content, true)|trim %} + {%- if message.role == "system" %} + {%- if not loop.first %} + {{- raise_exception('System message must be at the beginning.') }} + {%- endif %} + {%- elif message.role == "user" %} + {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {%- set reasoning_content = '' %} + {%- if message.reasoning_content is string %} + {%- set reasoning_content = message.reasoning_content %} + {%- else %} + {%- if '' in content and '' in content %} + {%- set reasoning_content = content.split('')[0].rstrip('\n').split('')[-1].lstrip('\n') %} + {%- set content = content.split('')[-1].lstrip('\n') %} + {%- endif %} + {%- endif %} + {%- set reasoning_content = reasoning_content|trim %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- generation %} + {{- '\n' + reasoning_content + '\n\n\n' + content }} + {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {%- if loop.first %} + {%- if content|trim %} + {{- '\n\n\n\n' }} + {%- else %} + {{- '\n\n' }} + {%- endif %} + {%- else %} + {{- '\n\n\n' }} + {%- endif %} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' }} + {%- set args_value = args_value | string if args_value is string else args_value | tojson | safe %} + {{- args_value }} + {{- '\n\n' }} + {%- endfor %} + {%- endif %} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- endgeneration %} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- content }} + {{- '\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- raise_exception('Unexpected message role.') }} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- if enable_thinking is defined and enable_thinking is false %} + {{- '\n\n\n\n' }} + {%- else %} + {{- '\n' }} + {%- endif %} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_instruct_2507.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_instruct_2507.jinja new file mode 100644 index 0000000000000000000000000000000000000000..70adff8a08fb31e0636f618564838d4bf3c05286 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_instruct_2507.jinja @@ -0,0 +1,61 @@ +{%- if tools %} + {{- '<|im_start|>system\n' }} + {%- if messages[0].role == 'system' %} + {{- messages[0].content + '\n\n' }} + {%- endif %} + {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within XML tags:\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n\n\nFor each function call, return a json object with function name and arguments within XML tags:\n\n{\"name\": , \"arguments\": }\n<|im_end|>\n" }} +{%- else %} + {%- if messages[0].role == 'system' %} + {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- for message in messages %} + {%- if message.content is string %} + {%- set content = message.content %} + {%- else %} + {%- set content = '' %} + {%- endif %} + {%- if (message.role == "user") or (message.role == "system" and not loop.first) %} + {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {{- '<|im_start|>' + message.role + '\n' + content }} + {%- if message.tool_calls %} + {%- for tool_call in message.tool_calls %} + {%- if (loop.first and content) or (not loop.first) %} + {{- '\n' }} + {%- endif %} + {%- if tool_call.function %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n{"name": "' }} + {{- tool_call.name }} + {{- '", "arguments": ' }} + {%- if tool_call.arguments is string %} + {{- tool_call.arguments }} + {%- else %} + {{- tool_call.arguments | tojson }} + {%- endif %} + {{- '}\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- content }} + {{- '\n' }} + {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_instruct_2507_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_instruct_2507_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..2e30797390d4983e6e2fcbce9827f56d5ee364ae --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_instruct_2507_training.jinja @@ -0,0 +1,71 @@ +{#- Training variant of the Qwen3-Instruct-2507 chat template (see qwen3_instruct_2507.jinja for the original). + This is for models like Qwen3-4B-Instruct-2507 that ship without the reasoning_content / + multi_step_tool / enable_thinking logic present in later Qwen3 revisions. + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{%- if tools %} + {{- '<|im_start|>system\n' }} + {%- if messages[0].role == 'system' %} + {{- messages[0].content + '\n\n' }} + {%- endif %} + {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within XML tags:\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n\n\nFor each function call, return a json object with function name and arguments within XML tags:\n\n{\"name\": , \"arguments\": }\n<|im_end|>\n" }} +{%- else %} + {%- if messages[0].role == 'system' %} + {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- for message in messages %} + {%- if message.content is string %} + {%- set content = message.content %} + {%- else %} + {%- set content = '' %} + {%- endif %} + {%- if (message.role == "user") or (message.role == "system" and not loop.first) %} + {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- generation %} + {{- content }} + {%- if message.tool_calls %} + {%- for tool_call in message.tool_calls %} + {%- if (loop.first and content) or (not loop.first) %} + {{- '\n' }} + {%- endif %} + {%- if tool_call.function %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n{"name": "' }} + {{- tool_call.name }} + {{- '", "arguments": ' }} + {%- if tool_call.arguments is string %} + {{- tool_call.arguments }} + {%- else %} + {{- tool_call.arguments | tojson }} + {%- endif %} + {{- '}\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- endgeneration %} + {%- elif message.role == "tool" %} + {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- content }} + {{- '\n' }} + {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..decc48dc6b6fecb761d045d4a318b92c1c489d0b --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_training.jinja @@ -0,0 +1,93 @@ +{#- Training variant of the Qwen3 chat template (see qwen3.jinja for the original). + Modifications vs the original: + - {%- if '' in content %} → {%- if '' in content and '' in content %} + Always check for both tags to avoid edge cases where the model generates only one tag. + - Removed the loop.index0 > ns.last_query_index conditional; always include thinking block. + This makes the template prefix-preserving for the [user, assistant] → [user, assistant, tool] transition. + - Added {% generation %} / {% endgeneration %} around assistant message output to support + assistant-only loss masking in SFT training. +-#} +{%- if tools %} + {{- '<|im_start|>system\n' }} + {%- if messages[0].role == 'system' %} + {{- messages[0].content + '\n\n' }} + {%- endif %} + {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within XML tags:\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n\n\nFor each function call, return a json object with function name and arguments within XML tags:\n\n{\"name\": , \"arguments\": }\n<|im_end|>\n" }} +{%- else %} + {%- if messages[0].role == 'system' %} + {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %} +{%- for message in messages[::-1] %} + {%- set index = (messages|length - 1) - loop.index0 %} + {%- if ns.multi_step_tool and message.role == "user" and message.content is string and not(message.content.startswith('') and message.content.endswith('')) %} + {%- set ns.multi_step_tool = false %} + {%- set ns.last_query_index = index %} + {%- endif %} +{%- endfor %} +{%- for message in messages %} + {%- if message.content is string %} + {%- set content = message.content %} + {%- else %} + {%- set content = '' %} + {%- endif %} + {%- if (message.role == "user") or (message.role == "system" and not loop.first) %} + {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }} + {%- elif message.role == "assistant" %} + {%- set reasoning_content = '' %} + {%- if message.reasoning_content is string %} + {%- set reasoning_content = message.reasoning_content %} + {%- else %} + {%- if '' in content and '' in content %} + {%- set reasoning_content = content.split('')[0].rstrip('\n').split('')[-1].lstrip('\n') %} + {%- set content = content.split('')[-1].lstrip('\n') %} + {%- endif %} + {%- endif %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- generation %} + {{- '\n' + reasoning_content.strip('\n') + '\n\n\n' + content.lstrip('\n') }} + {%- if message.tool_calls %} + {%- for tool_call in message.tool_calls %} + {%- if (loop.first and content) or (not loop.first) %} + {{- '\n' }} + {%- endif %} + {%- if tool_call.function %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n{"name": "' }} + {{- tool_call.name }} + {{- '", "arguments": ' }} + {%- if tool_call.arguments is string %} + {{- tool_call.arguments }} + {%- else %} + {{- tool_call.arguments | tojson }} + {%- endif %} + {{- '}\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- endgeneration %} + {%- elif message.role == "tool" %} + {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {{- content }} + {{- '\n' }} + {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} + {%- if enable_thinking is defined and enable_thinking is false %} + {{- '\n\n\n\n' }} + {%- endif %} +{%- endif %} \ No newline at end of file diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_vl.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_vl.jinja new file mode 100644 index 0000000000000000000000000000000000000000..124386803f142761528f710e77ae483f5f8c4fc4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_vl.jinja @@ -0,0 +1,120 @@ +{%- if tools %} + {{- '<|im_start|>system\n' }} + {%- if messages[0].role == 'system' %} + {%- if messages[0].content is string %} + {{- messages[0].content }} + {%- else %} + {%- for content in messages[0].content %} + {%- if 'text' in content %} + {{- content.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {{- '\n\n' }} + {%- endif %} + {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within XML tags:\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n\n\nFor each function call, return a json object with function name and arguments within XML tags:\n\n{\"name\": , \"arguments\": }\n<|im_end|>\n" }} +{%- else %} + {%- if messages[0].role == 'system' %} + {{- '<|im_start|>system\n' }} + {%- if messages[0].content is string %} + {{- messages[0].content }} + {%- else %} + {%- for content in messages[0].content %} + {%- if 'text' in content %} + {{- content.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- set image_count = namespace(value=0) %} +{%- set video_count = namespace(value=0) %} +{%- for message in messages %} + {%- if message.role == "user" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- if message.content is string %} + {{- message.content }} + {%- else %} + {%- for content in message.content %} + {%- if content.type == 'image' or 'image' in content or 'image_url' in content %} + {%- set image_count.value = image_count.value + 1 %} + {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%} + <|vision_start|><|image_pad|><|vision_end|> + {%- elif content.type == 'video' or 'video' in content %} + {%- set video_count.value = video_count.value + 1 %} + {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%} + <|vision_start|><|video_pad|><|vision_end|> + {%- elif 'text' in content %} + {{- content.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "assistant" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- if message.content is string %} + {{- message.content }} + {%- else %} + {%- for content_item in message.content %} + {%- if 'text' in content_item %} + {{- content_item.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {%- if message.tool_calls %} + {%- for tool_call in message.tool_calls %} + {%- if (loop.first and message.content) or (not loop.first) %} + {{- '\n' }} + {%- endif %} + {%- if tool_call.function %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n{"name": "' }} + {{- tool_call.name }} + {{- '", "arguments": ' }} + {%- if tool_call.arguments is string %} + {{- tool_call.arguments }} + {%- else %} + {{- tool_call.arguments | tojson }} + {%- endif %} + {{- '}\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {%- if message.content is string %} + {{- message.content }} + {%- else %} + {%- for content in message.content %} + {%- if content.type == 'image' or 'image' in content or 'image_url' in content %} + {%- set image_count.value = image_count.value + 1 %} + {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%} + <|vision_start|><|image_pad|><|vision_end|> + {%- elif content.type == 'video' or 'video' in content %} + {%- set video_count.value = video_count.value + 1 %} + {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%} + <|vision_start|><|video_pad|><|vision_end|> + {%- elif 'text' in content %} + {{- content.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {{- '\n' }} + {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_vl_training.jinja b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_vl_training.jinja new file mode 100644 index 0000000000000000000000000000000000000000..137a64a1722352220eee524909ef631a37066541 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/chat_templates/qwen3_vl_training.jinja @@ -0,0 +1,127 @@ +{#- Training variant of the Qwen 3 VL chat template (see qwen3_vl.jinja for the original). + Modifications vs the original: + - Added {% generation %} / {% endgeneration %} around assistant message content to + support assistant-only loss masking in SFT training. +-#} +{%- if tools %} + {{- '<|im_start|>system\n' }} + {%- if messages[0].role == 'system' %} + {%- if messages[0].content is string %} + {{- messages[0].content }} + {%- else %} + {%- for content in messages[0].content %} + {%- if 'text' in content %} + {{- content.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {{- '\n\n' }} + {%- endif %} + {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within XML tags:\n" }} + {%- for tool in tools %} + {{- "\n" }} + {{- tool | tojson }} + {%- endfor %} + {{- "\n\n\nFor each function call, return a json object with function name and arguments within XML tags:\n\n{\"name\": , \"arguments\": }\n<|im_end|>\n" }} +{%- else %} + {%- if messages[0].role == 'system' %} + {{- '<|im_start|>system\n' }} + {%- if messages[0].content is string %} + {{- messages[0].content }} + {%- else %} + {%- for content in messages[0].content %} + {%- if 'text' in content %} + {{- content.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- endif %} +{%- endif %} +{%- set image_count = namespace(value=0) %} +{%- set video_count = namespace(value=0) %} +{%- for message in messages %} + {%- if message.role == "user" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- if message.content is string %} + {{- message.content }} + {%- else %} + {%- for content in message.content %} + {%- if content.type == 'image' or 'image' in content or 'image_url' in content %} + {%- set image_count.value = image_count.value + 1 %} + {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%} + <|vision_start|><|image_pad|><|vision_end|> + {%- elif content.type == 'video' or 'video' in content %} + {%- set video_count.value = video_count.value + 1 %} + {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%} + <|vision_start|><|video_pad|><|vision_end|> + {%- elif 'text' in content %} + {{- content.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "assistant" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- generation -%} + {%- if message.content is string %} + {{- message.content }} + {%- else %} + {%- for content_item in message.content %} + {%- if 'text' in content_item %} + {{- content_item.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {%- if message.tool_calls %} + {%- for tool_call in message.tool_calls %} + {%- if (loop.first and message.content) or (not loop.first) %} + {{- '\n' }} + {%- endif %} + {%- if tool_call.function %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n{"name": "' }} + {{- tool_call.name }} + {{- '", "arguments": ' }} + {%- if tool_call.arguments is string %} + {{- tool_call.arguments }} + {%- else %} + {{- tool_call.arguments | tojson }} + {%- endif %} + {{- '}\n' }} + {%- endfor %} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- endgeneration -%} + {%- elif message.role == "tool" %} + {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %} + {{- '<|im_start|>user' }} + {%- endif %} + {{- '\n\n' }} + {%- if message.content is string %} + {{- message.content }} + {%- else %} + {%- for content in message.content %} + {%- if content.type == 'image' or 'image' in content or 'image_url' in content %} + {%- set image_count.value = image_count.value + 1 %} + {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%} + <|vision_start|><|image_pad|><|vision_end|> + {%- elif content.type == 'video' or 'video' in content %} + {%- set video_count.value = video_count.value + 1 %} + {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%} + <|vision_start|><|video_pad|><|vision_end|> + {%- elif 'text' in content %} + {{- content.text }} + {%- endif %} + {%- endfor %} + {%- endif %} + {{- '\n' }} + {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- endif %} +{%- endfor %} +{%- if add_generation_prompt %} + {{- '<|im_start|>assistant\n' }} +{%- endif %} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6a1721cba48803210a91d0280eb9ccd35214d74f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/__init__.py @@ -0,0 +1,18 @@ +# Copyright 2020-2026 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. + +from .main import main + + +__all__ = ["main"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/accelerate_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/accelerate_config.py new file mode 100644 index 0000000000000000000000000000000000000000..d775fca787f7618a2785d1294beec2c152962e90 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/accelerate_config.py @@ -0,0 +1,47 @@ +# Copyright 2020-2026 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 importlib.resources as resources +from pathlib import Path + + +def resolve_accelerate_config_argument(launch_args: list[str]) -> list[str]: + """ + Resolve `--accelerate_config` from CLI arguments into `accelerate --config_file`. + + The function supports either a filesystem path or a predefined config name shipped in `trl/accelerate_configs` + (without the `.yaml` suffix). + """ + if "--accelerate_config" not in launch_args: + return launch_args + + config_index = launch_args.index("--accelerate_config") + if config_index + 1 >= len(launch_args): + raise ValueError("Expected a value after `--accelerate_config`.") + + config_name = launch_args[config_index + 1] + if Path(config_name).is_file(): + accelerate_config_path = config_name + else: + candidate = resources.files("trl.accelerate_configs").joinpath(f"{config_name}.yaml") + if not candidate.exists(): + raise ValueError( + f"Accelerate config {config_name} is neither a file nor a valid config in the `trl` package. " + "Please provide a valid config name or a path to a config file." + ) + accelerate_config_path = candidate + + # Remove '--accelerate_config '. + launch_args = launch_args[:config_index] + launch_args[config_index + 2 :] + return ["--config_file", str(accelerate_config_path)] + launch_args diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/accelerate_launcher.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/accelerate_launcher.py new file mode 100644 index 0000000000000000000000000000000000000000..eceebe1ffe8d49d6cfa4a3bdc5d3037b5dfd9da3 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/accelerate_launcher.py @@ -0,0 +1,47 @@ +# Copyright 2020-2026 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 importlib.resources as resources +from collections.abc import Callable +from typing import Any + +from accelerate.commands.launch import launch_command, launch_command_parser + + +def launch_training_script( + script_name: str, + launch_args: list[str], + training_script_args: list[str], + *, + launch_command_fn: Callable[[Any], None] = launch_command, + launch_parser_fn: Callable[[], Any] = launch_command_parser, +) -> None: + """ + Launch a TRL training script through `accelerate launch`. + + Parameters: + script_name (`str`): + Script filename in `trl/scripts`, e.g. `"dpo.py"`. + launch_args (`list[str]`): + Arguments consumed by `accelerate launch`. + training_script_args (`list[str]`): + Arguments forwarded to the training script. + launch_command_fn (`Callable[[Any], None]`, *optional*): + Function used to execute accelerate launch. + launch_parser_fn (`Callable[[], Any]`, *optional*): + Factory creating the accelerate launch parser. + """ + training_script = resources.files("trl.scripts").joinpath(script_name) + accelerate_args = launch_parser_fn().parse_args(launch_args + [str(training_script)] + training_script_args) + launch_command_fn(accelerate_args) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4bafa3ba61879096285ddeca6b48d7fe3292ffeb --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/__init__.py @@ -0,0 +1,37 @@ +# Copyright 2020-2026 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. + +from .base import Command +from .env import EnvCommand +from .skills import SkillsCommand +from .training import TrainingCommand +from .vllm_serve import VllmServeCommand + + +def get_commands() -> list[Command]: + """Return all registered top-level TRL CLI commands.""" + return [ + TrainingCommand("dpo"), + EnvCommand(), + TrainingCommand("grpo"), + TrainingCommand("kto"), + TrainingCommand("reward"), + TrainingCommand("rloo"), + TrainingCommand("sft"), + SkillsCommand(), + VllmServeCommand(), + ] + + +__all__ = ["Command", "get_commands"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/base.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/base.py new file mode 100644 index 0000000000000000000000000000000000000000..0000b558f26418077c3946519f54dcd1195029cc --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/base.py @@ -0,0 +1,62 @@ +# Copyright 2020-2026 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. + +from abc import ABC, abstractmethod +from argparse import Namespace +from dataclasses import dataclass + + +@dataclass(slots=True) +class CommandContext: + """Context shared by CLI commands during execution.""" + + argv: list[str] + + def argv_after(self, token: str) -> list[str]: + """ + Return CLI tokens after the first occurrence of `token`. + + Parameters: + token (`str`): + Subcommand name as it appears in `argv`. + """ + try: + index = self.argv.index(token) + except ValueError: + return [] + return self.argv[index + 1 :] + + +class Command(ABC): + """ + Base command definition for the TRL CLI. + + Parameters: + name (`str`): + Subcommand name exposed by the CLI. + help_text (`str`): + Short description displayed in help output. + """ + + def __init__(self, name: str, help_text: str): + self.name = name + self.help_text = help_text + + @abstractmethod + def register(self, subparsers) -> None: + """Register this command parser in the subparser collection.""" + + @abstractmethod + def run(self, args: Namespace, context: CommandContext) -> int: + """Execute the command.""" diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/env.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/env.py new file mode 100644 index 0000000000000000000000000000000000000000..28498ba15cb0ca1998b2f4b937c6393b7fbd1536 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/env.py @@ -0,0 +1,33 @@ +# Copyright 2020-2026 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. + +from argparse import Namespace + +from .base import Command, CommandContext + + +class EnvCommand(Command): + """CLI command that prints TRL environment information.""" + + def __init__(self): + super().__init__(name="env", help_text="Print the environment information") + + def register(self, subparsers) -> None: + subparsers.add_parser(self.name, help=self.help_text) + + def run(self, args: Namespace, context: CommandContext) -> int: + from ...scripts.env import print_env + + print_env() + return 0 diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/skills.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/skills.py new file mode 100644 index 0000000000000000000000000000000000000000..737bf4747276a348042e25f3826e6ad6e3bfa96c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/skills.py @@ -0,0 +1,42 @@ +# Copyright 2020-2026 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. + +from argparse import Namespace + +from ...skills.cli import add_skills_subcommands +from .base import Command, CommandContext + + +class SkillsCommand(Command): + """CLI command that manages TRL agent skills.""" + + def __init__(self): + super().__init__(name="skills", help_text="Manage TRL agent skills") + self._skills_parser = None + + def register(self, subparsers) -> None: + self._skills_parser = subparsers.add_parser(self.name, help=self.help_text) + skills_subparsers = self._skills_parser.add_subparsers(dest="skills_command", help="Skills commands") + add_skills_subcommands(skills_subparsers) + + def run(self, args: Namespace, context: CommandContext) -> int: + if getattr(args, "skills_command", None): + if hasattr(args, "func"): + return args.func(args) + print("Error: Unknown skills command") + return 1 + + if self._skills_parser is not None: + self._skills_parser.print_help() + return 0 diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/training.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/training.py new file mode 100644 index 0000000000000000000000000000000000000000..64f52c73b7ec998d42d420d53890184bd5a40428 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/training.py @@ -0,0 +1,72 @@ +# Copyright 2020-2026 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 importlib +from argparse import Namespace + +from .base import Command, CommandContext + + +def _subtract_subsequence(lst: list[str], subseq: list[str]) -> list[str]: + """Return lst with the ordered subsequence subseq removed.""" + sub_iter = iter(subseq) + current = next(sub_iter, None) + result = [] + for item in lst: + if current is not None and item == current: + current = next(sub_iter, None) + else: + result.append(item) + return result + + +class TrainingCommand(Command): + """ + Generic CLI command that launches a training script with accelerate. + + The script `trl/scripts/.py` must expose a `make_parser()` function. + + Parameters: + name (`str`): + CLI subcommand name (e.g. `"dpo"`). + """ + + def __init__(self, name: str): + super().__init__(name=name, help_text=f"Run the {name} training script") + + def register(self, subparsers) -> None: + subparsers.add_parser(self.name, help=self.help_text, add_help=False) + + def run(self, args: Namespace, context: CommandContext) -> int: + from ..accelerate_config import resolve_accelerate_config_argument + from ..accelerate_launcher import launch_training_script + + module = importlib.import_module(f"...scripts.{self.name}", package=__package__) + all_args = context.argv_after(self.name) + parser = module.make_parser(prog=f"trl {self.name}") + + # Handles -h (exits). Returns config_remaining and cli_remaining separately. + # cli_remaining is an ordered subsequence of all_args; config_remaining is not. + *_, config_remaining, cli_remaining = parser.parse_args_and_config( + all_args, return_remaining_strings=True, separate_remaining_strings=True + ) + launch_args = resolve_accelerate_config_argument(config_remaining + cli_remaining) + training_script_args = _subtract_subsequence(all_args, cli_remaining) + + launch_training_script( + script_name=f"{self.name}.py", + launch_args=launch_args, + training_script_args=training_script_args, + ) + return 0 diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/vllm_serve.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/vllm_serve.py new file mode 100644 index 0000000000000000000000000000000000000000..cc1cea21a5c1fcb8f52d8c2ce46a820e8702be03 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/commands/vllm_serve.py @@ -0,0 +1,36 @@ +# Copyright 2020-2026 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. + +from argparse import Namespace + +from .base import Command, CommandContext + + +class VllmServeCommand(Command): + """CLI command for serving TRL models with vLLM.""" + + def __init__(self): + super().__init__(name="vllm-serve", help_text="Serve a model with vLLM") + + def register(self, subparsers) -> None: + subparsers.add_parser(self.name, help=self.help_text, add_help=False) + + def run(self, args: Namespace, context: CommandContext) -> int: + from ...scripts.vllm_serve import main as vllm_serve_main + from ...scripts.vllm_serve import make_parser as make_vllm_serve_parser + + parser = make_vllm_serve_parser(prog="trl vllm-serve") + (script_args,) = parser.parse_args_and_config(args=context.argv_after(self.name)) + vllm_serve_main(script_args) + return 0 diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/main.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/main.py new file mode 100644 index 0000000000000000000000000000000000000000..cea99a16d9a6ce250dbc242389cd4ea21f7f75f2 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/cli/main.py @@ -0,0 +1,51 @@ +# Copyright 2020-2026 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 sys +from argparse import ArgumentParser + +from .commands import get_commands +from .commands.base import Command, CommandContext + + +def _build_parser(commands: list[Command]) -> ArgumentParser: + parser = ArgumentParser(prog="trl", allow_abbrev=False) + subparsers = parser.add_subparsers(help="available commands", dest="command") + + for command in commands: + command.register(subparsers) + + return parser + + +def main(argv: list[str] | None = None) -> int: + """Run the TRL CLI.""" + commands = get_commands() + commands_by_name = {command.name: command for command in commands} + parser = _build_parser(commands) + argv = list(sys.argv[1:] if argv is None else argv) + + args, _ = parser.parse_known_args(argv) + command_name = getattr(args, "command", None) + if command_name is None: + parser.print_help() + return 0 + + command = commands_by_name[command_name] + context = CommandContext(argv=argv) + return command.run(args, context) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/data_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d27c582106dfabcb3d515ebad5f1c01125084974 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/data_utils.py @@ -0,0 +1,977 @@ +# Copyright 2020-2026 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 copy +from collections import defaultdict, deque +from collections.abc import Callable, Sequence +from itertools import takewhile +from typing import Any, Literal, TypeVar + +import numpy as np +import pyarrow as pa +import pyarrow.compute as pc +import pyarrow.types +from datasets import Dataset, DatasetDict, IterableDataset, IterableDatasetDict +from transformers import PreTrainedTokenizerBase, ProcessorMixin + + +DatasetType = TypeVar("DatasetType", Dataset, DatasetDict) +IterableDatasetType = TypeVar("IterableDatasetType", IterableDataset, IterableDatasetDict) + + +def prepare_multimodal_messages(messages: list[dict[str, Any]], images: list | None = None) -> list[dict[str, Any]]: + # docstyle-ignore # because is not parsable in the code block + """ + Convert messages into a structured multimodal format and inject the provided images into the message contents. + + Args: + messages (`list[dict[str, Any]]`): + Messages with `"role"`, `"content"` (or `"tool_calls"`). Content may be a raw string before transformation. + List of messages with a `"role"` key (`"system"`, `"user"`, `"assistant"`, or `"tool"`) and a `"content"` key containing + either a string or a list of structured blocks if already prepared. Optionally, the `"content"` might + be `None` or not provided in favour of `"tool_calls"` in the `"assistant"` turns if applicable. + images (`list`, *optional*): + List of image objects to insert in the messages. + + Returns: + `list[dict[str, Any]]`: A new list of messages where every `"content"` value is a list of structured + content blocks, and all `"image"` placeholders are populated with the corresponding image objects. If the + assistant turns contains `"tool_calls"`, then the `"content"` might be empty. + + Notes: + - When the input `messages` isn't already in the structured format, (i.e., all `"content"` values are strings), + the function transforms them into the structured format by wrapping text in `{"type": "text", "text": ...}` + and inserting `{"type": "image"}` placeholders for the images *before* the first user message. + If the number of placeholders does not match the number of provided images, an error is raised. + - Existing image blocks that already include an `"image"` payload are preserved as-is. Only unfilled image + placeholders are counted and populated from `images`. + + Example: + ```python + # Input + [ + {"role": "user", "content": "What's in this image?"}, + {"role": "assistant", "content": "It looks like a cat."}, + ] + + # Output, one image provided + [ + {"role": "user", "content": [{"type": "image", "image": }, {"type": "text", "text": "What's in this image?"}]}, + {"role": "assistant", "content": [{"type": "text", "text": "It looks like a cat."}]}, + ] + ``` + """ + images = images or [] + + # First, convert all messages to the structured format if needed, and insert image placeholders if needed. + # Build new message dicts only when transforming string content to avoid modifying the originals. + new_messages = [] + images_included = False + for message in messages: + if message["role"] == "user": + if isinstance(message["content"], str) and not images_included: + image_entries = [{"type": "image"} for _ in range(len(images))] + message = {**message, "content": [*image_entries, {"type": "text", "text": message["content"]}]} + images_included = True + elif isinstance(message["content"], str): + message = {**message, "content": [{"type": "text", "text": message["content"]}]} + elif message["role"] in {"assistant", "system", "tool"}: + if isinstance(message.get("content"), str): + message = {**message, "content": [{"type": "text", "text": message["content"]}]} + else: + raise ValueError( + f"Invalid role in message: {message['role']}. Expected 'system', 'user', 'assistant', or 'tool'." + ) + new_messages.append(message) + + # Then, check that the number of image placeholders matches the number of images provided + num_placeholders = sum( + sum(1 for part in message["content"] if part["type"] == "image" and "image" not in part) + for message in new_messages + if message.get("content") and message["role"] != "tool" + ) + if num_placeholders != len(images): + raise ValueError( + f"Number of images provided ({len(images)}) does not match number of image placeholders ({num_placeholders})." + ) + + # Then, fill in the actual images in the placeholders + if images: + img_idx = 0 + for i, message in enumerate(new_messages): + if not message.get("content") or message["role"] == "tool": + continue + new_content = [] + for part in message["content"]: + if part["type"] == "image" and "image" not in part: + new_content.append({**part, "image": images[img_idx]}) + img_idx += 1 + else: + new_content.append(part) + new_messages[i] = {**message, "content": new_content} + + return new_messages + + +def prepare_multimodal_messages_vllm(messages: list[dict[str, Any]]) -> list[dict[str, Any]]: + # docstyle-ignore # because is not parsable in the code block + """ + Convert structured multimodal messages into a format compatible with vLLM. Replaces `"type": "image"` blocks with + `"type": "image_pil"` blocks, and `"image": Image` with `"image_pil": Image`. + + Args: + messages (`list[dict[str, Any]]`): + Messages with `"role"` and `"content"`. Content is expected to be a list of structured blocks. + + Returns: + `list[dict[str, Any]]`: + A deep-copied list of messages compatible with vLLM's expected input format. + + Example: + ```python + # Input + [{"role": "user", "content": [{"type": "image", "image": }, {"type": "text", "text": "What's in this image?"}]}] + + # Output + [{"role": "user", "content": [{"type": "image_pil", "image_pil": }, {"type": "text", "text": "What's in this image?"}]}] + ``` + """ + messages = copy.deepcopy(messages) # avoid modifying the original messages + for message in messages: + if isinstance(message["content"], list): + for part in message["content"]: + if part["type"] == "image": + part["type"] = "image_pil" # vLLM expects 'image_pil' key for images + part["image_pil"] = part.pop("image") + return messages + + +def is_conversational(example: dict[str, Any]) -> bool: + r""" + Check if the example is in a conversational format. + + Args: + example (`dict[str, Any]`): + A single data entry of a dataset. The example can have different keys depending on the dataset type. + + Returns: + `bool`: + `True` if the data is in a conversational format, `False` otherwise. + + Examples: + + ```python + >>> example = {"prompt": [{"role": "user", "content": "What color is the sky?"}]} + >>> is_conversational(example) + True + + >>> example = {"prompt": "The sky is"} + >>> is_conversational(example) + False + ``` + """ + supported_keys = ["prompt", "chosen", "rejected", "completion", "messages"] + example_keys = {key for key in example.keys() if key in supported_keys} + + # It must have one of the supported keys + if example_keys: + key = example_keys.pop() # take the first supported key + maybe_messages = example[key] + # It must be a list of messages + if isinstance(maybe_messages, list): + maybe_message = maybe_messages[0] + # Each message must a list of dictionaries with keys "role" and "content" + if isinstance(maybe_message, dict) and "role" in maybe_message: + return True + + return False + + +def apply_chat_template( + example: dict[str, list[dict[str, str]]], + processing_class: PreTrainedTokenizerBase | ProcessorMixin, + tools: list[dict | Callable] | None = None, + **template_kwargs, +) -> dict[str, str]: + r""" + Apply a chat template to a conversational example along with the schema for a list of functions in `tools`. + + For more details, see [`maybe_apply_chat_template`]. + """ + tools = tools or None # `or None`: Llama bug: it renders tool boilerplate for tools=[] + # Check that the example has the correct keys + supported_keys = ["prompt", "chosen", "rejected", "completion", "messages", "label"] + example_keys = {key for key in example.keys() if key in supported_keys} + if example_keys not in [ + {"messages"}, # language modeling + {"prompt"}, # prompt-only + {"prompt", "completion"}, # prompt-completion + {"prompt", "chosen", "rejected"}, # preference + {"chosen", "rejected"}, # preference with implicit prompt + {"prompt", "completion", "label"}, # unpaired preference + ]: + raise KeyError(f"Invalid keys in the example: {example_keys}") + + # Apply the chat template to the whole conversation + if "messages" in example: + messages = processing_class.apply_chat_template( + example["messages"], + tools=tools, + tokenize=False, + **example.get("chat_template_kwargs", {}), + **template_kwargs, + ) + + # Apply the chat template to the prompt, adding the generation prompt + if "prompt" in example: + last_role = example["prompt"][-1]["role"] + if last_role in ["user", "tool"]: + add_generation_prompt = True + continue_final_message = False + elif last_role == "assistant": + add_generation_prompt = False + continue_final_message = True + else: + raise ValueError(f"Invalid role in the last message: {last_role}") + prompt = processing_class.apply_chat_template( + example["prompt"], + tools=tools, + continue_final_message=continue_final_message, + tokenize=False, + add_generation_prompt=add_generation_prompt, + **example.get("chat_template_kwargs", {}), + **template_kwargs, + ) + + # Apply the chat template to the entire prompt + completion + if "prompt" in example: # explicit prompt and prompt-completion case + if "chosen" in example: + prompt_chosen = processing_class.apply_chat_template( + example["prompt"] + example["chosen"], + tools=tools, + tokenize=False, + **example.get("chat_template_kwargs", {}), + **template_kwargs, + ) + # DeepSeek-R1 inserts a token when using `add_generation_prompt`, which can cause discrepancies + # between the prompt alone and the combined prompt+completion. To ensure consistency, we extract the + # common prefix between the two. In most cases, this is a no-op. + prompt = "".join(x for x, _ in takewhile(lambda x: x[0] == x[1], zip(prompt, prompt_chosen, strict=False))) + + chosen = prompt_chosen[len(prompt) :] + if "rejected" in example and "prompt" in example: # explicit prompt + prompt_rejected = processing_class.apply_chat_template( + example["prompt"] + example["rejected"], + tools=tools, + tokenize=False, + **example.get("chat_template_kwargs", {}), + **template_kwargs, + ) + # Handle DeepSeek-R1 token, see the above comment for details + prompt = "".join( + x for x, _ in takewhile(lambda x: x[0] == x[1], zip(prompt, prompt_rejected, strict=False)) + ) + rejected = prompt_rejected[len(prompt) :] + if "completion" in example: + prompt_completion = processing_class.apply_chat_template( + example["prompt"] + example["completion"], + tools=tools, + tokenize=False, + **example.get("chat_template_kwargs", {}), + **template_kwargs, + ) + # Handle DeepSeek-R1 token, see the above comment for details + prompt = "".join( + x for x, _ in takewhile(lambda x: x[0] == x[1], zip(prompt, prompt_completion, strict=False)) + ) + completion = prompt_completion[len(prompt) :] + else: # implicit prompt case + if "chosen" in example: + chosen = processing_class.apply_chat_template( + example["chosen"], + tools=tools, + tokenize=False, + **example.get("chat_template_kwargs", {}), + **template_kwargs, + ) + if "rejected" in example: + rejected = processing_class.apply_chat_template( + example["rejected"], + tools=tools, + tokenize=False, + **example.get("chat_template_kwargs", {}), + **template_kwargs, + ) + + # Extract the completion by removing the prompt part from the prompt-completion string + output = {} + if "messages" in example: + output["text"] = messages + if "prompt" in example: + output["prompt"] = prompt + if "chosen" in example: + output["chosen"] = chosen + if "rejected" in example: + output["rejected"] = rejected + if "completion" in example: + output["completion"] = completion + if "label" in example: + output["label"] = example["label"] + + return output + + +def maybe_apply_chat_template( + example: dict[str, list[dict[str, str]]], + processing_class: PreTrainedTokenizerBase | ProcessorMixin, + tools: list[dict | Callable] | None = None, + **template_kwargs: Any, +) -> dict[str, str]: + r""" + If the example is in a conversational format, apply a chat template to it. + + Args: + example (`dict[str, list[dict[str, str]]`): + Dictionary representing a single data entry of a conversational dataset. Each data entry can have different + keys depending on the dataset type. The supported dataset types are: + + - Language modeling dataset: `"messages"`. + - Prompt-only dataset: `"prompt"`. + - Prompt-completion dataset: `"prompt"` and `"completion"`. + - Preference dataset: `"prompt"`, `"chosen"`, and `"rejected"`. + - Preference dataset with implicit prompt: `"chosen"` and `"rejected"`. + - Unpaired preference dataset: `"prompt"`, `"completion"`, and `"label"`. + + For keys `"messages"`, `"prompt"`, `"chosen"`, `"rejected"`, and `"completion"`, the values are lists of + messages, where each message is a dictionary with keys `"role"` and `"content"`. Additionally, the example + may contain a `"chat_template_kwargs"` key, which is a dictionary of additional keyword arguments to pass + to the chat template renderer. + processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`]): + Tokenizer to apply the chat template with. + tools (`list[dict | Callable]`, *optional*): + A list of tools (callable functions) that will be accessible to the model. If the template does not support + function calling, this argument will have no effect. + **template_kwargs (`Any`, *optional*): + Additional kwargs to pass to the template renderer. Will be accessible by the chat template. + + Returns: + `dict[str, str]`: + Formatted example with the chat template applied. + + Notes: + - This function does not alter the keys, except for Language modeling dataset, where `"messages"` is replaced + by `"text"`. + + - In case of prompt-only data, if the last role is `"user"`, the generation prompt is added to the prompt. + Else, if the last role is `"assistant"`, the final message is continued. + + Example: + + ```python + >>> from transformers import AutoTokenizer + + >>> tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-3-mini-128k-instruct") + >>> example = { + ... "prompt": [{"role": "user", "content": "What color is the sky?"}], + ... "completion": [{"role": "assistant", "content": "It is blue."}], + ... } + >>> apply_chat_template(example, tokenizer) + {'prompt': '<|user|>\nWhat color is the sky?<|end|>\n<|assistant|>\n', 'completion': 'It is blue.<|end|>\n'} + ``` + """ + if is_conversational(example): + return apply_chat_template(example, processing_class, tools, **template_kwargs) + else: + return example + + +def _unpair_row(batch: dict[str, list[Any]]) -> dict[str, list[Any]]: + batch_size = len(batch["chosen"]) + new_batch = { + "completion": batch["chosen"] + batch["rejected"], + "label": [True] * batch_size + [False] * batch_size, + } + if "prompt" in batch: + new_batch["prompt"] = batch["prompt"] + batch["prompt"] + return new_batch + + +def unpair_preference_dataset( + dataset: DatasetType | IterableDatasetType, **map_kwargs +) -> DatasetType | IterableDatasetType: + # docstyle-ignore + """ + Unpair a preference dataset. + + The output contains only `"prompt"`, `"completion"`, and `"label"`; all other columns are dropped. + + Args: + dataset ([`~datasets.Dataset`] or [`~datasets.DatasetDict`] or [`~datasets.IterableDataset`] or [`~datasets.IterableDatasetDict`]): + Preference dataset to unpair. The dataset must have columns `"chosen"`, `"rejected"` and optionally + `"prompt"`. + **map_kwargs (`dict`, *optional*): + Additional keyword arguments to pass to the dataset's map method when unpairing preferences. + + Returns: + [`~datasets.Dataset`] or [`~datasets.DatasetDict`] or [`~datasets.IterableDataset`] or [`~datasets.IterableDatasetDict`]: + The unpaired preference dataset. + + Example: + + ```python + >>> from datasets import Dataset + + >>> dataset_dict = { + ... "prompt": ["The sky is", "The sun is"], + ... "chosen": [" blue.", "in the sky."], + ... "rejected": [" green.", " in the sea."], + ... } + >>> dataset = Dataset.from_dict(dataset_dict) + >>> dataset = unpair_preference_dataset(dataset) + >>> dataset + Dataset({ + features: ['prompt', 'completion', 'label'], + num_rows: 4 + }) + + >>> dataset[0] + {'prompt': 'The sky is', 'completion': ' blue.', 'label': True} + ``` + """ + if isinstance(dataset, DatasetDict): + column_names = next(iter(dataset.values())).column_names + elif isinstance(dataset, Dataset): + column_names = dataset.column_names + else: # IterableDataset + column_names = dataset.column_names or list(next(iter(dataset)).keys()) + return dataset.map(_unpair_row, batched=True, remove_columns=column_names, **map_kwargs) + + +def maybe_unpair_preference_dataset( + dataset: DatasetType, num_proc: int | None = None, desc: str | None = None +) -> DatasetType: + r""" + Unpair a preference dataset if it is paired. + + Args: + dataset ([`~datasets.Dataset`] or [`~datasets.DatasetDict`]): + Preference dataset to unpair. The dataset must have columns `"chosen"`, `"rejected"` and optionally + `"prompt"`. + num_proc (`int`, *optional*): + Number of processes to use for processing the dataset. + desc (`str`, *optional*): + Meaningful description to be displayed alongside with the progress bar while mapping examples. + + Returns: + [`~datasets.Dataset`] or [`~datasets.DatasetDict`]: The unpaired preference dataset if it was paired, otherwise + the original dataset. + + Example: + + ```python + >>> from datasets import Dataset + + >>> dataset_dict = { + ... "prompt": ["The sky is", "The sun is"], + ... "chosen": [" blue.", "in the sky."], + ... "rejected": [" green.", " in the sea."], + ... } + >>> dataset = Dataset.from_dict(dataset_dict) + >>> dataset = unpair_preference_dataset(dataset) + >>> dataset + Dataset({ + features: ['prompt', 'completion', 'label'], + num_rows: 4 + }) + + >>> dataset[0] + {'prompt': 'The sky is', 'completion': ' blue.', 'label': True} + ``` + """ + if isinstance(dataset, DatasetDict): + column_names = dataset[list(dataset.keys())[0]].column_names + else: + column_names = dataset.column_names + if "chosen" in column_names and "rejected" in column_names: + return unpair_preference_dataset(dataset, num_proc=num_proc, desc=desc) + else: + return dataset + + +def extract_prompt(example: dict[str, Sequence]) -> dict[str, Sequence]: + r""" + Extracts the shared prompt from a preference data example, where the prompt is implicit within both the chosen and + rejected completions. + + The function identifies the longest common sequence (prefix) of conversation turns between the "chosen" and + "rejected" completions and extracts this as the prompt. It then removes this prompt from the respective "chosen" + and "rejected" completions. + + Args: + example (`dict[str, list]`): + A dictionary representing a single data entry in the preference dataset. It must contain the keys + `"chosen"` and `"rejected"`, where each value is either conversational or standard (`str`). + + Returns: + `dict[str, list]`: A dictionary containing: + - `"prompt"`: The longest common prefix between the "chosen" and "rejected" completions. + - `"chosen"`: The remainder of the "chosen" completion, with the prompt removed. + - `"rejected"`: The remainder of the "rejected" completion, with the prompt removed. + + Examples: + + ```python + >>> example = { + ... "chosen": [ + ... {"role": "user", "content": "What color is the sky?"}, + ... {"role": "assistant", "content": "It is blue."}, + ... ], + ... "rejected": [ + ... {"role": "user", "content": "What color is the sky?"}, + ... {"role": "assistant", "content": "It is green."}, + ... ], + ... } + >>> extract_prompt(example) + {'prompt': [{'role': 'user', 'content': 'What color is the sky?'}], + 'chosen': [{'role': 'assistant', 'content': 'It is blue.'}], + 'rejected': [{'role': 'assistant', 'content': 'It is green.'}]} + ``` + + Or, with the `map` method of [`~datasets.Dataset`]: + + ```python + >>> from trl import extract_prompt + >>> from datasets import Dataset + + >>> dataset_dict = { + ... "chosen": [ + ... [ + ... {"role": "user", "content": "What color is the sky?"}, + ... {"role": "assistant", "content": "It is blue."}, + ... ], + ... [ + ... {"role": "user", "content": "Where is the sun?"}, + ... {"role": "assistant", "content": "In the sky."}, + ... ], + ... ], + ... "rejected": [ + ... [ + ... {"role": "user", "content": "What color is the sky?"}, + ... {"role": "assistant", "content": "It is green."}, + ... ], + ... [ + ... {"role": "user", "content": "Where is the sun?"}, + ... {"role": "assistant", "content": "In the sea."}, + ... ], + ... ], + ... } + >>> dataset = Dataset.from_dict(dataset_dict) + >>> dataset = dataset.map(extract_prompt) + >>> dataset[0] + {'prompt': [{'role': 'user', 'content': 'What color is the sky?'}], + 'chosen': [{'role': 'assistant', 'content': 'It is blue.'}], + 'rejected': [{'role': 'assistant', 'content': 'It is green.'}]} + ``` + """ + for idx in range(min(len(example["chosen"]), len(example["rejected"]))): + if example["chosen"][idx] != example["rejected"][idx]: + if example["chosen"][idx - 1] == " ": # remove space before the prompt + idx -= 1 + break + return { + "prompt": example["chosen"][:idx], + "chosen": example["chosen"][idx:], + "rejected": example["rejected"][idx:], + } + + +def maybe_extract_prompt(example: dict[str, list]) -> dict[str, list]: + r""" + Extracts the shared prompt from a preference data example, where the prompt is implicit within both the chosen and + rejected completions. + + If the example already contains a `"prompt"` key, the function returns the example as is. For more details, see + [`extract_prompt`]. + ``` + """ + # Some dataset add a `"prompt"` column, even though the prompt is implicit and included in the "chosen" and + # "rejected" completions. E.g.: + # {"prompt": "What color is the sky?", + # "chosen": [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is blue."}], + # "rejected": [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is green."}]} + # That's why we check if the prompt is also conversational before deciding not to extract it. + if "chosen" not in example or "rejected" not in example: # not a preference example + return example + if "prompt" in example: + # Both conversational or both non-conversational + chosen_conv = is_conversational({"chosen": example["chosen"]}) + prompt_conv = is_conversational({"prompt": example["prompt"]}) + if (chosen_conv and prompt_conv) or (not chosen_conv and not prompt_conv): + return example + return extract_prompt({"chosen": example["chosen"], "rejected": example["rejected"]}) + + +def _get_dataset_format(dataset: DatasetType) -> dict[str, Any]: + if isinstance(dataset, (DatasetDict, IterableDatasetDict)): + dataset = dataset[next(iter(dataset))] + if isinstance(dataset, Dataset): + format = dataset.format + else: + format_type = dataset._formatting.format_type if dataset._formatting is not None else None + format = {"type": format_type} + format.update(format.pop("format_kwargs", {})) + return format + + +def _check_if_columns_can_be_packed(columns: list[pa.Array]): + first_column_offsets = None + for idx, column in enumerate(columns): + if not (pyarrow.types.is_list(column.type) or pyarrow.types.is_large_list(column.type)): + raise TypeError("Packing requires all columns to be lists of lists.") + + if idx == 0: + first_column_offsets = column.offsets + elif not first_column_offsets.equals(column.offsets): + raise ValueError("All columns must have values of the same length.") + + +class _SegmentTree: + """ + A segment tree data structure that, when initialized as `_SegmentTree(maxval)`, efficiently finds the next larger + value for a given input within the range [1, maxval]. + + See [Fewer Truncations Improve Language Modeling](https://huggingface.co/papers/2404.10830) for more details. + """ + + def __init__(self, maxval: int): + self.maxval = maxval + # For non-power-of-2 values, we need to round up to the next power of 2 for the tree size + self.tree_size = 1 << (maxval - 1).bit_length() + self.tree = [0] * (2 * self.tree_size) + + def add(self, val): + assert 0 < val <= self.maxval + i = self.tree_size + val - 1 + self.tree[i] = val + while i > 1: + i >>= 1 + left, right = self.tree[i << 1], self.tree[(i << 1) + 1] + # Compare the values using if-else otherwise repeated calls to `builtins.max` become the bottleneck + self.tree[i] = left if left >= right else right + + def remove(self, val): + assert 0 < val <= self.maxval + i = self.tree_size + val - 1 + self.tree[i] = 0 + while i > 1: + i >>= 1 + left, right = self.tree[i << 1], self.tree[(i << 1) + 1] + # Compare the values using if-else otherwise repeated calls to `builtins.max` become the bottleneck + self.tree[i] = left if left >= right else right + + def search(self, val): + assert 0 < val <= self.maxval + i = 1 + while i < self.tree_size: + if self.tree[i << 1] >= val: + i = i << 1 + else: + i = (i << 1) + 1 + return self.tree[i] + + +def _pack_bfd( + examples: pa.Table, seq_length: int, on_seq_length_overflow: Literal["truncate", "split"] = "truncate" +) -> pa.Table: + """Pack sequences in a pyarrow Table using Best Fit Decreasing strategy.""" + columns = [column.chunks[0] for column in examples.combine_chunks().columns] + _check_if_columns_can_be_packed(columns) + assert len(columns) > 0 + + lengths = pc.list_value_length(columns[0]) + + # Filter out empty sequences + non_empty_mask = pc.greater(lengths, 0) + columns = [pc.filter(column, non_empty_mask) for column in columns] + lengths = pc.filter(lengths, non_empty_mask) + + if on_seq_length_overflow == "truncate": + columns = [pc.list_slice(column, 0, seq_length) for column in columns] + elif on_seq_length_overflow == "split": + lengths = lengths.to_numpy() + # Split the sequences longer than `seq_length` into chunks (of length `seq_length` or less) while respecting sequence boundaries + num_fragments = np.ceil(lengths / seq_length).astype(int) + offsets = np.arange(np.sum(num_fragments) + 1, dtype=columns[0].offsets.type.to_pandas_dtype()) * seq_length + # "Left-shift" the offsets to account for the last fragment of each original sequence possibly being shorter than `seq_length` + diff = np.zeros_like(offsets) + diff[np.cumsum(num_fragments)] = -lengths % seq_length + diff = np.cumsum(diff) + offsets -= diff + columns = [ + type(column).from_arrays(offsets.astype(column.offsets.type.to_pandas_dtype()), column.values) + for column in columns + ] + else: + raise ValueError(f"Invalid `on_seq_length_overflow`: {on_seq_length_overflow}. Use 'truncate' or 'split'.") + + examples = pa.Table.from_arrays(columns, names=examples.column_names) + lengths = pc.list_value_length(columns[0]) + examples = examples.append_column("seq_lengths", lengths) # Allows us to later construct `position_ids` + ids = np.arange(len(examples)) + lengths = pc.make_struct(lengths, ids) + lengths = lengths.sort("descending", by=0) + + # Greedy BFD binning using a segment tree to quickly find best-fit remaining space. + segment_tree = _SegmentTree(seq_length) + segment_tree.add(seq_length) # the max, `seq_length` bin is always available + space_to_bin = defaultdict(deque) + + # Bin is represented as a dict (of example ids and sum of their lengths) to allow in-place updates + bins: list[dict] = [] + for length, idx in zip(lengths.field(0).to_numpy(), lengths.field(1).to_numpy(), strict=True): + space = segment_tree.search(length) + + if space < seq_length: + # Use existing bin with exactly this amount of space + bin = space_to_bin[space].popleft() + else: + # Create a new bin + bin = {"ids": [], "length": 0} + bins.append(bin) + + bin["ids"].append(idx) + bin["length"] += length + if space < seq_length and not space_to_bin[space]: + segment_tree.remove(space) + + space = space - length + space_to_bin[space].append(bin) + if space > 0: + segment_tree.add(space) + + examples = pc.take(examples, [id_ for bin in bins for id_ in bin["ids"]]) + offsets = np.cumsum([0] + [bin["length"] for bin in bins]) + + assert all( + column.num_chunks == 1 for column in examples.columns + ) # `pc.take` returns a ChunkedArray with a single chunk + + lengths = examples["seq_lengths"].chunks[0] + examples = examples.drop_columns("seq_lengths") + lengths = pa.ListArray.from_arrays(np.cumsum([0] + [len(bin["ids"]) for bin in bins], dtype=np.int32), lengths) + + columns = [] + for column in examples.columns: + column = column.chunks[0] + assert pa.types.is_list(column.type) or pa.types.is_large_list(column.type) + dtype = column.offsets.type.to_pandas_dtype() + column = type(column).from_arrays(offsets.astype(dtype), column.values) + columns.append(column) + return pa.Table.from_arrays(columns + [lengths], names=examples.column_names + ["seq_lengths"]) + + +def _pack_wrapped(examples: pa.Table, seq_length: int) -> pa.Table: + """Pack sequences in a pyarrow Table using a wrapped strategy.""" + columns = [column.chunks[0] for column in examples.combine_chunks().columns] + _check_if_columns_can_be_packed(columns) + offsets, values = columns[0].offsets, columns[0].values + values = values[offsets[0].as_py() : offsets[-1].as_py()] + num_elements = len(values) + offsets = np.arange(0, num_elements, seq_length, dtype=columns[0].offsets.type.to_pandas_dtype()) + offsets = np.concatenate((offsets, [num_elements])) + columns = [ + type(column).from_arrays(offsets.astype(column.offsets.type.to_pandas_dtype()), column.values) + for column in columns + ] + return pa.Table.from_arrays(columns, names=examples.column_names) + + +def pack_dataset( + dataset: DatasetType, + seq_length: int, + strategy: str = "bfd", + map_kwargs: dict[str, Any] | None = None, +) -> DatasetType: + r""" + Pack sequences in a dataset into chunks of size `seq_length`. + + Args: + dataset ([`~datasets.Dataset`] or [`~datasets.DatasetDict`]): + Dataset to pack + seq_length (`int`): + Target sequence length to pack to. + strategy (`str`, *optional*, defaults to `"bfd"`): + Packing strategy to use. Can be either: + + - `"bfd"` (Best Fit Decreasing): Preserves sequence boundaries and truncates sequences that exceed + `seq_length`, discarding overflow tokens. Ideal for SFT and conversational datasets where maintaining + conversation structure is important. + - `"bfd_split"`: Similar to `"bfd"` but splits overflow sequences for packing into other examples. Prevents + token loss for pre-training or long documents, but may break conversation structure in SFT datasets. + - `"wrapped"`: Faster but more aggressive. Ignores sequence boundaries and will cut sequences in the middle + to completely fill each packed sequence with data. + map_kwargs (`dict`, *optional*): + Additional keyword arguments to pass to the dataset's map method when packing examples. + + Returns: + [`~datasets.Dataset`] or [`~datasets.DatasetDict`]: The dataset with packed sequences. The number of examples + may decrease as sequences are combined. + + Example: + ```python + >>> from datasets import Dataset + >>> from trl import pack_dataset + + >>> examples = { + ... "input_ids": [[1, 2, 3, 4, 5], [6, 7], [8, 9, 10], [11]], + ... "attention_mask": [[1, 1, 1, 0, 0], [1, 0], [1, 1, 0], [1]], + ... } + >>> dataset = Dataset.from_dict(examples) + >>> # Default "bfd" strategy (SFT-friendly): truncates long sequences + >>> packed_dataset = pack_dataset(dataset, seq_length=4, strategy="bfd") + >>> packed_dataset[:] + {'input_ids': [[1, 2, 3, 4], [8, 9, 10, 11], [6, 7]], + 'attention_mask': [[1, 1, 1, 0], [1, 1, 0, 1], [1, 0]], + 'seq_lengths': [[4], [3, 1], [2]]} + + >>> # "bfd_split" strategy: preserves all tokens + >>> packed_dataset = pack_dataset(dataset, seq_length=4, strategy="bfd_split") + >>> packed_dataset[:] + {'input_ids': [[1, 2, 3, 4], [8, 9, 10, 5], [6, 7, 11]], + 'attention_mask': [[1, 1, 1, 0], [1, 1, 0, 0], [1, 0, 1]], + 'seq_lengths': [[4], [3, 1], [2, 1]]} + ``` + """ + if map_kwargs is None: + map_kwargs = {} + + valid_strategies = ("bfd", "bfd_split", "wrapped") + if strategy not in valid_strategies: + raise ValueError(f"Invalid packing strategy '{strategy}', must be one of {valid_strategies}.") + format = _get_dataset_format(dataset) + dataset = dataset.with_format("arrow") + if strategy == "bfd": + dataset = dataset.map( + _pack_bfd, + batched=True, + fn_kwargs={"seq_length": seq_length, "on_seq_length_overflow": "truncate"}, + **map_kwargs, + ) + elif strategy == "bfd_split": + dataset = dataset.map( + _pack_bfd, + batched=True, + fn_kwargs={"seq_length": seq_length, "on_seq_length_overflow": "split"}, + **map_kwargs, + ) + elif strategy == "wrapped": + dataset = dataset.map(_pack_wrapped, batched=True, fn_kwargs={"seq_length": seq_length}, **map_kwargs) + else: + raise ValueError(f"Invalid packing strategy: '{strategy}', must be one of {valid_strategies}.") + + if strategy in {"bfd", "bfd_split"} and "columns" in format: + format["columns"] = format["columns"] + ["seq_lengths"] + + dataset = dataset.with_format(**format) + return dataset + + +def is_conversational_from_value(example: dict[str, Any]) -> bool: + r""" + Check if the example is in a conversational format (from/value). Note that this format isn't recommended. Prefer + the ChatML format (role/content) + + Args: + example (`dict[str, Any]`): + A single data entry of a dataset. The example can have different keys depending on the dataset type. + + Returns: + `bool`: + `True` if the data is in a conversational Chatformat, `False` otherwise. + + Examples: + + ```python + >>> example = {"conversations": [{"from": "user", "value": "What color is the sky?"}]} + >>> is_conversational_from_value(example) + True + + >>> example = {"conversations": [{"role": "user", "content": "What color is the sky?"}]} + >>> is_conversational_from_value(example) + False + + >>> example = {"conversations": "The sky is"} + >>> is_conversational_from_value(example) + False + ``` + """ + maybe_messages = example.get("conversations") + # It must be a list of messages + if isinstance(maybe_messages, list): + maybe_message = maybe_messages[0] + # Each message must a list of dictionaries with keys "from" and "value" + if isinstance(maybe_message, dict) and "from" in maybe_message and "value" in maybe_message: + return True + + return False + + +def maybe_convert_to_chatml(example: dict[str, list]) -> dict[str, list]: + """ + Convert a conversational dataset with fields `from` and `value` to ChatML format. + + This function modifies conversational data to align with OpenAI's ChatML format: + - Replaces the key `"from"` with `"role"` in message dictionaries. + - Replaces the key `"value"` with `"content"` in message dictionaries. + - Renames `"conversations"` to `"messages"` for consistency with ChatML. + + Args: + example (`dict[str, list]`): + A single data entry containing a list of messages. + + Returns: + `dict[str, list]`: + Example reformatted to ChatML style. + + Example: + ```python + >>> from trl import maybe_convert_to_chatml + + >>> example = { + ... "conversations": [ + ... {"from": "user", "value": "What color is the sky?"}, + ... {"from": "assistant", "value": "It is blue."}, + ... ] + ... } + >>> maybe_convert_to_chatml(example) + {'messages': [{'role': 'user', 'content': 'What color is the sky?'}, + {'role': 'assistant', 'content': 'It is blue.'}]} + ``` + """ + # List of possible keys containing message lists + for key in ["prompt", "completion", "chosen", "rejected", "messages", "conversations"]: + if key in example and isinstance(example[key], list): + messages = example[key] + for message in messages: + if isinstance(message, dict): + if "from" in message: + message["role"] = message.pop("from") + if "value" in message: + message["content"] = message.pop("value") + + # Rename "conversations" to "messages" + if "conversations" in example: + example["messages"] = example.pop("conversations") + + return example diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/distributed.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/distributed.py new file mode 100644 index 0000000000000000000000000000000000000000..d5d03be37e1457488ba7b15d926cfb9400adc96c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/distributed.py @@ -0,0 +1,91 @@ +# Copyright 2020-2026 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. + +"""Distributed training backend abstraction.""" + +from contextlib import contextmanager + + +class DistributedBackend: + """Abstracts distributed backend specifics (DeepSpeed ZeRO, FSDP) behind a uniform API. + + Detects the active backend once at construction from ``accelerator.state``, then provides context managers that are + no-ops on backends where the operation is not needed. + + Args: + accelerator ([`~accelerate.Accelerator`]): + The accelerator instance managing the distributed state. + + Example: + + ```python + >>> dist = DistributedBackend(accelerator) + >>> with dist.gather_params(list(model.parameters())): + ... model.merge_adapter() + >>> with dist.summon_full_params(model, recurse=False): + ... outputs = model.generate(inputs) + ``` + """ + + def __init__(self, accelerator): + ds_plugin = accelerator.state.deepspeed_plugin + fsdp_plugin = getattr(accelerator.state, "fsdp_plugin", None) + self.zero_stage = ds_plugin.zero_stage if ds_plugin else 0 + self.fsdp_version = getattr(fsdp_plugin, "fsdp_version", None) if fsdp_plugin else None + + @property + def is_zero3(self) -> bool: + """Whether DeepSpeed ZeRO Stage 3 is active.""" + return self.zero_stage == 3 + + @property + def is_fsdp(self) -> bool: + """Whether FSDP (any version) is active.""" + return self.fsdp_version is not None + + @contextmanager + def gather_params(self, params): + """Gather sharded parameters under DeepSpeed ZeRO-3; no-op otherwise. + + Args: + params (iterable of `torch.nn.Parameter`): + Parameters to gather. + """ + if self.is_zero3: + import deepspeed + + with deepspeed.zero.GatheredParameters(params): + yield + else: + yield + + @contextmanager + def summon_full_params(self, module, **kwargs): + """Materialize full FSDP v1 parameters; no-op for FSDP v2 or non-FSDP backends. + + FSDP v2 parameters are always accessible and require no explicit materialization. + + Args: + module (`torch.nn.Module`): + The FSDP-wrapped module. + **kwargs: + Forwarded to ``FSDP.summon_full_params`` (e.g. ``recurse``, ``writeback``). + """ + if self.fsdp_version == 1: + from torch.distributed.fsdp import FullyShardedDataParallel as FSDP + + with FSDP.summon_full_params(module, **kwargs): + yield + else: + yield diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..041a38542a6fbaba81fbdb3d278e737109c95f83 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/__init__.py @@ -0,0 +1,36 @@ +# Copyright 2020-2026 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. + +""" +Experimental submodule for TRL. + +This submodule contains unstable or incubating features. Anything here may change (or be removed) in any release +without deprecation. Use at your own risk. + +To silence this notice set environment variable TRL_EXPERIMENTAL_SILENCE=1. +""" + +import os +import warnings + +from ..import_utils import TRLExperimentalWarning + + +if not os.environ.get("TRL_EXPERIMENTAL_SILENCE"): + warnings.warn( + "You are importing from 'trl.experimental'. APIs here are unstable and may change or be removed without " + "notice. Silence this warning by setting environment variable TRL_EXPERIMENTAL_SILENCE=1.", + TRLExperimentalWarning, + stacklevel=2, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/a2po/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/a2po/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fa3d8b8fbbff1633f7cd5414dd7f2362e302a09a --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/a2po/__init__.py @@ -0,0 +1,16 @@ +# Copyright 2020-2026 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. + +from .a2po_config import A2POConfig +from .a2po_trainer import A2POTrainer diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/a2po/a2po_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/a2po/a2po_config.py new file mode 100644 index 0000000000000000000000000000000000000000..9f4137da675fb85aa5280f683fb2360ead92180b --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/a2po/a2po_config.py @@ -0,0 +1,156 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field + +from trl.trainer.base_config import _BaseConfig + + +@dataclass +class A2POConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`A2POTrainer`]. + + This class includes only the parameters that are specific to A2PO training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + Parameters: + > Parameters that control the model and reference model + + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model` + argument of the [`A2POTrainer`] is provided as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and [`~transformers.AutoTokenizer.from_pretrained`]. + + > Parameters that control the data preprocessing + + remove_unused_columns (`bool`, *optional*, defaults to `False`): + Whether to only keep the column `"prompt"` in the dataset. If you use a custom reward function that + requires any column other than `"prompts"` and `"completions"`, you should keep this to `False`. + + > Parameters that control generation + + max_prompt_length (`int` or `None`, *optional*, defaults to `512`): + Maximum length of the prompt. If the prompt is longer than this, it is left-truncated. + max_completion_length (`int` or `None`, *optional*, defaults to `256`): + Maximum length of the generated completion. + temperature (`float`, *optional*, defaults to `1.0`): + Sampling temperature, used in both Stage 1 and Stage 2 generation. + top_p (`float`, *optional*, defaults to `1.0`): + Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to + `1.0` to consider all tokens. + top_k (`int` or `None`, *optional*): + Number of highest-probability vocabulary tokens to keep. If `None`, top-k filtering is disabled. + + > Parameters that control Stage 1 (offline optimal value estimation) + + num_value_samples (`int`, *optional*, defaults to `8`): + Number of samples drawn from the reference policy per prompt to estimate `V*`. + beta1 (`float`, *optional*, defaults to `0.5`): + KL temperature used to estimate `V*` in Stage 1. + filter_all_incorrect (`bool`, *optional*, defaults to `True`): + Whether to drop prompts for which all reference samples are incorrect. + + > Parameters that control Stage 2 (on-policy regression) + + beta2 (`float`, *optional*, defaults to `1e-3`): + KL temperature used in the Stage 2 regression target. + reward_weights (`list[float]`, *optional*): + Weights for each reward function. Must match the number of reward functions. If `None`, all rewards are + weighted equally with weight `1.0`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"] + + # Parameters that control the model and reference model + model_init_kwargs: dict | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument of " + "the `A2POTrainer` is provided as a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoTokenizer.from_pretrained`." + }, + ) + + # Parameters that control the data preprocessing + remove_unused_columns: bool = field( + default=False, + metadata={ + "help": "Whether to only keep the column 'prompt' in the dataset. If you use a custom reward function " + "that requires any column other than 'prompts' and 'completions', you should keep this to `False`." + }, + ) + + # Parameters that control generation + max_prompt_length: int | None = field( + default=512, + metadata={"help": "Maximum length of the prompt. If the prompt is longer than this, it is left-truncated."}, + ) + max_completion_length: int | None = field( + default=256, metadata={"help": "Maximum length of the generated completion."} + ) + temperature: float = field( + default=1.0, + metadata={"help": "Sampling temperature, used in both Stage 1 and Stage 2 generation."}, + ) + top_p: float = field( + default=1.0, + metadata={ + "help": "Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. " + "Set to `1.0` to consider all tokens." + }, + ) + top_k: int | None = field( + default=None, + metadata={ + "help": "Number of highest-probability vocabulary tokens to keep. If `None`, top-k filtering is disabled." + }, + ) + + # Parameters that control Stage 1 (offline optimal value estimation) + num_value_samples: int = field( + default=8, + metadata={"help": "Number of samples drawn from the reference policy per prompt to estimate `V*`."}, + ) + beta1: float = field( + default=0.5, + metadata={"help": "KL temperature used to estimate `V*` in Stage 1."}, + ) + filter_all_incorrect: bool = field( + default=True, + metadata={"help": "Whether to drop prompts for which all reference samples are incorrect."}, + ) + + # Parameters that control Stage 2 (on-policy regression) + beta2: float = field( + default=1e-3, + metadata={"help": "KL temperature used in the Stage 2 regression target."}, + ) + reward_weights: list[float] | None = field( + default=None, + metadata={ + "help": "Weights for each reward function. Must match the number of reward functions. If `None`, all " + "rewards are weighted equally with weight `1.0`." + }, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/a2po/a2po_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/a2po/a2po_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..2fad6ed25ba8af0c1062fa0df3248ad164bd9dd4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/a2po/a2po_trainer.py @@ -0,0 +1,375 @@ +# Copyright 2020-2026 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 textwrap +from collections import defaultdict +from collections.abc import Callable + +import torch +from accelerate.logging import get_logger +from accelerate.utils import gather_object +from torch.utils.data import DataLoader +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + GenerationConfig, + PreTrainedModel, + PreTrainedTokenizerBase, +) + +from ...data_utils import maybe_apply_chat_template +from ...models import create_reference_model, unwrap_model_for_generation +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import selective_log_softmax +from .a2po_config import A2POConfig + + +logger = get_logger(__name__) + +# A reward function is a callable that returns a list of floats (the rewards). The callable receives prompts, +# completions, and additional columns from the dataset. To ensure forward compatibility, it should accept **kwargs. +RewardFunc = Callable[..., list[float]] + + +class A2POTrainer(_BaseTrainer): + # docstyle-ignore + """ + Trainer for the A*-PO (Optimal Advantage Regression) method, introduced in [Accelerating RL for LLM Reasoning with + Optimal Advantage Regression](https://huggingface.co/papers/2505.20686). + + A*-PO runs in two stages: + + 1. **Offline value estimation.** Before training, `num_value_samples` completions are sampled from the reference + policy for every training prompt and scored with `reward_funcs`. The optimal value is estimated as + `V*(x) = beta1 * log(mean_i exp(r(x, y_i) / beta1))` and cached per prompt. + 2. **On-policy regression.** During training, a single completion is generated per prompt from the current policy. + The loss is the squared error between the implicit reward `beta2 * log(pi(y|x) / pi_ref(y|x))` and the optimal + advantage estimate `r(x, y) - V*(x)`. + + Args: + model (`PreTrainedModel` or `str`): + Model to be trained, or a model identifier (string) passed to + [`~transformers.AutoModelForCausalLM.from_pretrained`]. + reward_funcs (`Callable` or `list[Callable]`): + Reward function(s). Each takes `prompts` and `completions` (plus dataset columns as keyword arguments) and + returns a list of float rewards. When multiple are provided, their weighted sum (see + [`A2POConfig.reward_weights`]) is the scalar reward `r`, which A*-PO assumes to be binary (in `{0, 1}`). + args ([`A2POConfig`], *optional*): + Configuration for this trainer. If `None`, a default configuration is used. + train_dataset ([`~datasets.Dataset`], *optional*): + Training dataset. Must contain a `"prompt"` column. + eval_dataset ([`~datasets.Dataset`], *optional*): + Evaluation dataset. + processing_class ([`~transformers.PreTrainedTokenizerBase`], *optional*): + Processing class used to process the data. If `None`, it is loaded from the model's name with + [`~transformers.AutoTokenizer.from_pretrained`]. + callbacks (`list[~transformers.TrainerCallback]`, *optional*): + List of callbacks to customize the training loop. + optimizers (`tuple[~torch.optim.Optimizer, ~torch.optim.lr_scheduler.LambdaLR]`, *optional*, defaults to `(None, None)`): + Tuple containing the optimizer and the learning rate scheduler. + """ + + _tag_names = ["trl", "a2po"] + _name = "A2PO" + _paper = { + "title": "Accelerating RL for LLM Reasoning with Optimal Advantage Regression", + "id": "2505.20686", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @article{brantley2025accelerating, + title = {{Accelerating RL for LLM Reasoning with Optimal Advantage Regression}}, + author = {Kiant\'e Brantley and Mingyu Chen and Zhaolin Gao and Jason D. Lee and Wen Sun and Wenhao Zhan and Xuezhou Zhang}, + year = 2025, + eprint = {arXiv:2505.20686}, + }"""), + } + + def __init__( + self, + model: PreTrainedModel | str, + reward_funcs: RewardFunc | list[RewardFunc], + args: A2POConfig | None = None, + train_dataset=None, + eval_dataset=None, + processing_class: PreTrainedTokenizerBase | None = None, + callbacks=None, + optimizers=(None, None), + ): + # Args + if args is None: + args = A2POConfig(f"{model if isinstance(model, str) else model.config._name_or_path}-A2PO") + + # Models + if isinstance(model, str): + model_init_kwargs = args.model_init_kwargs or {} + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + model = AutoModelForCausalLM.from_pretrained(model, **model_init_kwargs) + model_id = model.config._name_or_path + + # Some models (e.g. SmolVLM/Idefics3) don't support the `logits_to_keep` argument and error out if we pass it. + # Inspect the forward method so Stage 2 can pass the argument only when it is supported. + self.model_kwarg_keys = inspect.signature(model.forward).parameters.keys() + + # Reference model: a frozen copy of the initial policy. Stage 1 samples from it and Stage 2 regularizes to it. + self.ref_model = create_reference_model(model) + + # Processing class + if processing_class is None: + processing_class = AutoTokenizer.from_pretrained( + model_id, padding_side="left", trust_remote_code=args.trust_remote_code + ) + + # Reward functions + if not isinstance(reward_funcs, list): + reward_funcs = [reward_funcs] + self.reward_funcs = reward_funcs + if args.reward_weights is None: + self.reward_weights = torch.ones(len(reward_funcs), dtype=torch.float32) + else: + self.reward_weights = torch.tensor(args.reward_weights, dtype=torch.float32) + + # Generation: N samples per prompt in Stage 1, a single sample in Stage 2 + self.value_generation_config = GenerationConfig( + max_new_tokens=args.max_completion_length, + do_sample=True, + temperature=args.temperature, + top_p=args.top_p, + top_k=args.top_k, + num_return_sequences=args.num_value_samples, + pad_token_id=processing_class.pad_token_id, + ) + self.generation_config = GenerationConfig( + max_new_tokens=args.max_completion_length, + do_sample=True, + temperature=args.temperature, + top_p=args.top_p, + top_k=args.top_k, + num_return_sequences=1, + pad_token_id=processing_class.pad_token_id, + ) + + # Optimal values V*(x), keyed by prompt text. Populated lazily by Stage 1 at the start of training. + self._optimal_values: dict[str, float] | None = None + + # Metrics + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + + # The data collator returns the list of features untouched; generation happens in `_prepare_inputs`. + def data_collator(features): + return features + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + callbacks=callbacks, + optimizers=optimizers, + ) + + self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True) + + def _calculate_rewards(self, prompts, completions, **reward_kwargs): + device = self.accelerator.device + rewards_per_func = torch.zeros(len(prompts), len(self.reward_funcs), device=device) + for i, reward_func in enumerate(self.reward_funcs): + output = reward_func(prompts=prompts, completions=completions, **reward_kwargs) + rewards_per_func[:, i] = torch.tensor(output, dtype=torch.float32, device=device) + # A*-PO assumes the (weighted) total reward is binary in {0, 1}. + return (rewards_per_func * self.reward_weights.to(device)).sum(dim=1) + + def _get_sequence_logps(self, model, input_ids, attention_mask, logits_to_keep): + model_inputs = {"input_ids": input_ids, "attention_mask": attention_mask} + # Only pass `logits_to_keep` when the model supports it (some models and VLMs don't). + if "logits_to_keep" in self.model_kwarg_keys: + # We add 1 to `logits_to_keep` because the last logits of the sequence is later excluded + model_inputs["logits_to_keep"] = logits_to_keep + 1 + logits = model(**model_inputs).logits + logits = logits[:, :-1, :] # the last logit predicts beyond the sequence + # Only keep the last logits_to_keep. For models that support logits_to_keep, this is a no-op. + logits = logits[:, -logits_to_keep:, :] + completion_ids = input_ids[:, -logits_to_keep:] + per_token_logps = selective_log_softmax(logits, completion_ids) + completion_mask = attention_mask[:, -logits_to_keep:] + return (per_token_logps * completion_mask).sum(dim=1) + + # Stage 1: offline optimal value estimation + def _estimate_optimal_values(self): + beta1 = self.args.beta1 + n = self.args.num_value_samples + optimal_values = {} + all_incorrect = set() + + # Stage 2 looks up V* for every prompt it scores, including eval prompts, so estimate over both datasets. + datasets = [self.train_dataset] if self.eval_dataset is None else [self.train_dataset, self.eval_dataset] + for dataset in datasets: + dataloader = self.accelerator.prepare( + DataLoader(dataset, batch_size=self.args.per_device_train_batch_size, collate_fn=list) + ) + for batch in dataloader: + prompts = [example["prompt"] for example in batch] + prompts_text = [ + maybe_apply_chat_template(example, self.processing_class)["prompt"] for example in batch + ] + + # Sample N completions per prompt from the reference policy + inputs = self.processing_class( + prompts_text, + return_tensors="pt", + padding=True, + truncation=True, + max_length=self.args.max_prompt_length, + add_special_tokens=False, + ).to(self.accelerator.device) + with unwrap_model_for_generation(self.ref_model, self.accelerator) as ref_model: + completion_ids = ref_model.generate(**inputs, generation_config=self.value_generation_config) + + prompt_length = inputs["input_ids"].size(1) + completions_text = self.processing_class.batch_decode( + completion_ids[:, prompt_length:], skip_special_tokens=True + ) + + # Each prompt is repeated N times by `num_return_sequences`. Forward any extra dataset columns (e.g. + # "solution") to the reward functions, repeated to align with the N samples per prompt. + keys = [key for key in batch[0] if key not in ["prompt", "completion"]] + reward_kwargs = {key: [example[key] for example in batch for _ in range(n)] for key in keys} + repeated_prompts = [p for p in prompts for _ in range(n)] + rewards = self._calculate_rewards(repeated_prompts, completions_text, **reward_kwargs) + rewards = rewards.view(len(prompts), n) + + # V*(x) = beta1 * log(mean_i exp(r_i / beta1)), computed stably + v_star = beta1 * (torch.logsumexp(rewards / beta1, dim=1) - math.log(n)) + + for j, prompt_text in enumerate(prompts_text): + optimal_values[prompt_text] = v_star[j].item() + if rewards[j].sum() == 0: + all_incorrect.add(prompt_text) + + # Each rank estimates V* for its shard of prompts; share them so any rank can score any prompt. + # `gather_object` concatenates the per-rank lists, so pass flat lists and rebuild on every rank. + self._optimal_values = dict(gather_object(list(optimal_values.items()))) + all_incorrect = set(gather_object(list(all_incorrect))) + + # Drop training prompts whose reference samples all scored zero (no learning signal). Eval prompts are kept + # so evaluation can still look up their V*. + if self.args.filter_all_incorrect: + self.train_dataset = self.train_dataset.filter( + lambda example: maybe_apply_chat_template(example, self.processing_class)["prompt"] + not in all_incorrect + ) + logger.info(f"Stage 1 complete: estimated V* for {len(self._optimal_values)} prompts.") + + # Stage 2: on-policy regression + def _prepare_inputs(self, inputs): + # Estimate V* on first use, e.g. when `evaluate()` is called without a preceding `train()`. + if self._optimal_values is None: + self._estimate_optimal_values() + mode = "train" if self.model.training else "eval" + device = self.accelerator.device + prompts = [example["prompt"] for example in inputs] + prompts_text = [maybe_apply_chat_template(example, self.processing_class)["prompt"] for example in inputs] + + # One on-policy completion per prompt + prompt_inputs = self.processing_class( + prompts_text, + return_tensors="pt", + padding=True, + truncation=True, + max_length=self.args.max_prompt_length, + add_special_tokens=False, + ).to(device) + with unwrap_model_for_generation(self.model, self.accelerator) as unwrapped_model: + prompt_completion_ids = unwrapped_model.generate(**prompt_inputs, generation_config=self.generation_config) + prompt_length = prompt_inputs["input_ids"].size(1) + completion_ids = prompt_completion_ids[:, prompt_length:] + completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + + # Scalar (binary) reward and cached optimal value. Forward extra dataset columns to the reward functions. + keys = [key for key in inputs[0] if key not in ["prompt", "completion"]] + reward_kwargs = {key: [example[key] for example in inputs] for key in keys} + rewards = self._calculate_rewards(prompts, completions_text, **reward_kwargs) + v_star = torch.tensor([self._optimal_values[p] for p in prompts_text], dtype=torch.float32, device=device) + + # Attention mask: the tokenizer's prompt mask followed by the completion mask. The completion mask is 1 up to + # and including the first EOS and 0 afterwards, so the terminal EOS stays in the log-prob sum (a plain + # `!= pad_token_id` mask would drop it when `pad_token == eos_token`). + is_eos = completion_ids == self.processing_class.eos_token_id + eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device) + eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)] + sequence_indices = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1) + completion_mask = (sequence_indices <= eos_idx.unsqueeze(1)).int() + attention_mask = torch.cat([prompt_inputs["attention_mask"], completion_mask], dim=1) + logits_to_keep = completion_ids.size(1) + + with torch.no_grad(): + ref_logps = self._get_sequence_logps(self.ref_model, prompt_completion_ids, attention_mask, logits_to_keep) + + self._metrics[mode]["reward"].append(rewards.mean().item()) + self._metrics[mode]["v_star"].append(v_star.mean().item()) + + return { + "input_ids": prompt_completion_ids, + "attention_mask": attention_mask, + "logits_to_keep": logits_to_keep, + "ref_logps": ref_logps, + "rewards": rewards, + "v_star": v_star, + } + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + mode = "train" if self.model.training else "eval" + + policy_logps = self._get_sequence_logps( + model, inputs["input_ids"], inputs["attention_mask"], inputs["logits_to_keep"] + ) + + # Implicit reward beta2 * log(pi / pi_ref), regressed onto the optimal advantage r - V* + implicit_reward = self.args.beta2 * (policy_logps - inputs["ref_logps"]) + target = inputs["rewards"] - inputs["v_star"] + loss = ((implicit_reward - target) ** 2).mean() + + self._metrics[mode]["implicit_reward"].append(implicit_reward.mean().item()) + self._metrics[mode]["advantage"].append(target.mean().item()) + return loss + + def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys: list[str] | None = None): + inputs = self._prepare_inputs(inputs) + with torch.no_grad(): + with self.compute_loss_context_manager(): + loss = self.compute_loss(model, inputs) + loss = loss.mean().detach() + return loss, None, None + + def train(self, *args, **kwargs): + if self._optimal_values is None: + logger.info("Running Stage 1: offline optimal value estimation...") + self._estimate_optimal_values() + return super().train(*args, **kwargs) + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} + + # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs` + # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + + logs = {**logs, **metrics} + super().log(logs, start_time) + self._metrics[mode].clear() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3fc30c059a76572f449ca53f59aeff47bd789cf5 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/__init__.py @@ -0,0 +1,16 @@ +# Copyright 2020-2026 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. + +from .async_grpo_config import AsyncGRPOConfig +from .async_grpo_trainer import AsyncGRPOTrainer diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/async_grpo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/async_grpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..cf09fbe1c803a5589bcf71de6889867dfbf22378 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/async_grpo_config.py @@ -0,0 +1,268 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Any + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class AsyncGRPOConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`AsyncGRPOTrainer`]. + + This class includes only the parameters that are specific to asynchronous GRPO training. For a full list of + training arguments, please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values + in this class may differ from those in [`~transformers.TrainingArguments`]. + + Parameters: + > Parameters that control the model + + model_init_kwargs (`dict[str, Any]` or `str`, *optional*): + Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when instantiating the + model from a path. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and [`~transformers.AutoTokenizer.from_pretrained`]. + router_aux_loss_coef (`float`, *optional*, defaults to `0.001`): + Coefficient of the load-balancing auxiliary loss. Only has an effect when training a Mixture-of-Experts + (MoE) model; for other models it does nothing. The auxiliary loss is added to the training loss with this + weight. Set to `0.0` to disable it. + + > Parameters that control generation + + num_generations (`int`, *optional*, defaults to `8`): + Number of generations per prompt to sample. + max_completion_length (`int`, *optional*, defaults to `2048`): + Maximum number of tokens to generate per completion. + temperature (`float`, *optional*, defaults to `1.0`): + Temperature for sampling. The higher the temperature, the more random the completions. + chat_template_kwargs (`dict[str, Any]`, *optional*): + Additional keyword arguments to pass to the `apply_chat_template` function when generating completions. + max_tool_calling_iterations (`int`, *optional*): + Maximum number of tool-calling turns when training an agent. If `None`, there is no limit and generation + stops when the model generates a response turn with no tool calls or when the total response length reaches + `max_completion_length`. + + > Parameters that control the vLLM server + + vllm_server_base_url (`str`, *optional*, defaults to `"http://localhost:8000"`): + Base URL of the vLLM server used for generation (e.g., `"http://localhost:8000"`). + vllm_server_timeout (`float`, *optional*, defaults to `240.0`): + Total timeout duration in seconds to wait for the vLLM server to be ready. + request_timeout (`int`, *optional*, defaults to `600`): + Timeout in seconds for individual HTTP requests to the vLLM server. + + > Parameters that control the training + + epsilon (`float`, *optional*, defaults to `0.2`): + Epsilon value for clipping. + epsilon_high (`float`, *optional*): + Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the lower-bound + specified in argument `epsilon`. Paper [DAPO](https://huggingface.co/papers/2503.14476) recommends `0.28`. + + > Parameters that control the async rollout pipeline + + max_inflight_tasks (`int`, *optional*, defaults to `-1`): + Maximum number of concurrent generation tasks sent to the vLLM server. Defaults to `-1` (auto), which + sets it to `max_staleness * per_device_train_batch_size * gradient_accumulation_steps * num_processes`. + If using tool-use environments, you may want to set this manually based on how many parallel environments + you can run. + max_staleness (`int`, *optional*, defaults to `4`): + Maximum number of weight update steps a rollout sample can lag behind the current model version before + being discarded. + queue_maxsize (`int`, *optional*, defaults to `1024`): + Maximum number of rollout samples to buffer in the rollout queue. + weight_sync_steps (`int`, *optional*, defaults to `1`): + Number of training steps between weight synchronizations to the vLLM server. + heartbeat_stale_after_s (`float`, *optional*, defaults to `300.0`): + Seconds since the rollout worker's last heartbeat after which the trainer treats it as + hung and aborts. + + > Parameters that control the logging + + log_completions (`bool`, *optional*, defaults to `False`): + Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. + num_completions_to_print (`int`, *optional*): + Number of completions to print with `rich`. If `None`, all completions are logged. + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `1` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `1e-6` instead of `5e-5`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"] + + # Parameters that control the model + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when instantiating " + "the model from a path." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoTokenizer.from_pretrained`." + }, + ) + router_aux_loss_coef: float = field( + default=0.001, + metadata={ + "help": "Coefficient of the load-balancing auxiliary loss. Only has an effect when training a " + "Mixture-of-Experts (MoE) model; for other models it does nothing. The auxiliary loss is added to the " + "training loss with this weight. Set to `0.0` to disable it." + }, + ) + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=1e-6, + metadata={"help": "The initial learning rate for AdamW."}, + ) + logging_steps: float = field( + default=1, + metadata={ + "help": "Log every X update steps. Should be an integer or a float in range `[0,1)`. If smaller than 1, " + "will be interpreted as ratio of total training steps." + }, + ) + + # Parameters that control generation + num_generations: int = field( + default=8, + metadata={"help": "Number of generations per prompt to sample."}, + ) + max_completion_length: int = field( + default=2048, + metadata={"help": "Maximum number of tokens to generate per completion."}, + ) + temperature: float = field( + default=1.0, + metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."}, + ) + chat_template_kwargs: dict | None = field( + default=None, + metadata={ + "help": "Additional keyword arguments to pass to the `apply_chat_template` function when generating " + "completions." + }, + ) + max_tool_calling_iterations: int | None = field( + default=None, + metadata={ + "help": "Maximum number of tool-calling turns when training an agent. If `None`, there is no limit and " + "generation stops when the model generates a response turn with no tool calls or when the total response " + "length reaches `max_completion_length`." + }, + ) + + # Parameters that control the vLLM server + vllm_server_base_url: str = field( + default="http://localhost:8000", + metadata={"help": "Base URL of the vLLM server used for generation (e.g., 'http://localhost:8000')."}, + ) + vllm_server_timeout: float = field( + default=240.0, + metadata={ + "help": "Total timeout duration in seconds to wait for the vLLM server to be ready. If the server is not " + "up after the timeout, a `TimeoutError` is raised." + }, + ) + request_timeout: int = field( + default=600, + metadata={"help": "Timeout in seconds for individual HTTP requests to the vLLM server."}, + ) + + # Parameters that control the training + epsilon: float = field( + default=0.2, + metadata={"help": "Epsilon value for clipping."}, + ) + epsilon_high: float | None = field( + default=None, + metadata={ + "help": "Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the " + "lower-bound specified in argument `epsilon`. Paper DAPO recommends `0.28`." + }, + ) + + # Parameters that control the async rollout pipeline + max_inflight_tasks: int = field( + default=-1, + metadata={ + "help": "Maximum number of concurrent generation tasks sent to the vLLM server. Defaults to -1 (auto), " + "which sets it to `max_staleness * per_device_train_batch_size * gradient_accumulation_steps * " + "num_processes`. Generating more samples than this is wasteful since they will be discarded as stale " + "before the trainer can consume them. If using tool-use environments, you may want to set this manually " + "based on how many parallel environments you can run." + }, + ) + max_staleness: int = field( + default=4, + metadata={ + "help": "Maximum number of weight update steps a rollout sample can lag behind the current model version " + "before being discarded." + }, + ) + queue_maxsize: int = field( + default=1024, + metadata={"help": "Maximum number of rollout samples to buffer in the rollout queue."}, + ) + weight_sync_steps: int = field( + default=1, + metadata={"help": "Number of training steps between weight synchronizations to the vLLM server."}, + ) + heartbeat_stale_after_s: float = field( + default=300.0, + metadata={ + "help": "Seconds since the rollout worker's last heartbeat after which the trainer treats it as hung " + "and aborts." + }, + ) + + # Parameters that control the logging + log_completions: bool = field( + default=False, + metadata={ + "help": "Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. If `rich` is " + "installed, it prints the sample. If `wandb` logging is enabled, it logs it to `wandb`." + }, + ) + num_completions_to_print: int | None = field( + default=None, + metadata={"help": "Number of completions to print with `rich`. If `None`, all completions are logged."}, + ) + + def __post_init__(self): + super().__post_init__() + + # Accelerator config: required for the async IterableDataset-backed dataloader to work correctly. + # split_batches=True and dispatch_batches=True ensure that the main process drives the dataloader + # and batches are broadcast to other processes rather than each process pulling independently. + if not hasattr(self, "accelerator_config") or self.accelerator_config is None: + self.accelerator_config = {"split_batches": True, "dispatch_batches": True} + elif isinstance(self.accelerator_config, dict): + self.accelerator_config["split_batches"] = True + self.accelerator_config["dispatch_batches"] = True + else: + self.accelerator_config.split_batches = True + self.accelerator_config.dispatch_batches = True diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/async_grpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/async_grpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..5c07ef3edd840ce05813a6926d7596f8382724d6 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/async_grpo_trainer.py @@ -0,0 +1,780 @@ +# Copyright 2020-2026 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 math +import queue +import textwrap +import time +from collections import defaultdict +from collections.abc import Callable +from dataclasses import dataclass +from typing import Any, Protocol + +import torch +from accelerate.logging import get_logger +from datasets import Dataset, IterableDataset +from torch.distributed._tensor import DTensor +from torch.utils.data import DataLoader +from transformers import AutoModelForCausalLM, AutoTokenizer, PreTrainedTokenizerBase, TrainerCallback +from transformers.data.data_collator import DataCollatorMixin + +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import pad, patch_chunked_lm_head +from .async_grpo_config import AsyncGRPOConfig +from .async_rollout_worker import AsyncRolloutWorker +from .weight_transfer import WeightTransferClient + + +logger = get_logger(__name__) + +# A reward function is a callable that returns a list of floats (the rewards). The callable receives prompts, +# completions, and additional arguments from the trainer (refer to the trainer's source for details). To ensure forward +# compatibility, it should accept **kwargs. +RewardFunc = Callable[..., list[float]] + + +class _SupportsReset(Protocol): + def reset(self, **kwargs) -> str | None: ... + + +EnvironmentFactory = Callable[[], _SupportsReset] + + +class RolloutWorkerProtocol(Protocol): + """Interface a rollout worker must implement to be passed as `rollout_worker` to [`AsyncGRPOTrainer`]. + + The default [`AsyncRolloutWorker`] spawns a CUDA-free child process and scores completions with the trainer's + `reward_funcs`. Implement this protocol to plug in a custom rollout/scoring backend instead — for example, one that + runs reward models on their own GPUs. + + Attributes: + rollout_buffer (`queue.Queue`): + Queue the trainer drains; the worker pushes scored `RolloutSample`s onto it. + """ + + rollout_buffer: queue.Queue + + def start(self) -> None: + """Begin producing rollouts. Called once on train begin, after the initial weight sync.""" + ... + + def stop(self) -> None: + """Stop the worker and release its resources. Called on train end.""" + ... + + def update_model_version(self, version: int) -> None: + """Tell the worker which policy version is now live, so it can tag or discard stale samples.""" + ... + + def check_health(self, stale_after_s: float) -> None: + """Raise if the worker has crashed or stopped producing within `stale_after_s` seconds.""" + ... + + +class StepIntervalCallback(TrainerCallback): + """ + A callback that calls a function every N optimization steps. + """ + + def __init__(self, fn, every_n_steps: int): + self.fn = fn + self.every_n_steps = every_n_steps + + def on_step_end(self, _args, state, _control, **_kwargs): + if state.global_step % self.every_n_steps == 0: + self.fn() + + +class _InitialWeightSyncCallback(TrainerCallback): + """Idempotent: NCCL group setup + cold weight sync to vLLM on train begin.""" + + def __init__(self, trainer: "AsyncGRPOTrainer"): + self._trainer = trainer + self._fired = False + + def on_train_begin(self, _args, _state, _control, **_kwargs): + if self._fired: + return + self._fired = True + if self._trainer.accelerator.is_main_process and self._trainer.weight_transfer is not None: + self._trainer.weight_transfer.init_weight_transfer() + self._trainer._sync_weight() + + +class _StartRolloutWorkerCallback(TrainerCallback): + """Idempotent: starts the rollout worker. Must be registered AFTER `_InitialWeightSyncCallback`.""" + + def __init__(self, trainer: "AsyncGRPOTrainer"): + self._trainer = trainer + self._fired = False + + def on_train_begin(self, _args, _state, _control, **_kwargs): + if self._fired: + return + self._fired = True + if self._trainer.accelerator.is_main_process and self._trainer.rollout_worker is not None: + self._trainer.rollout_worker.start() + + +class RolloutQueueDataset(torch.utils.data.IterableDataset): + def __init__( + self, + rollout_queue, + model_version_fn, + check_health_fn, + stale_after_s, + max_staleness=3, + poll_interval_s=5.0, + ): + self.queue = rollout_queue + self.model_version_fn = model_version_fn + self.check_health_fn = check_health_fn + self.stale_after_s = stale_after_s + self.max_staleness = max_staleness + self.poll_interval_s = poll_interval_s + + def __iter__(self): + while True: + t0 = time.time() + if self.queue.qsize() == 0: + logger.info("queue empty, waiting for rollout samples...") + try: + sample = self.queue.get(timeout=self.poll_interval_s) + except queue.Empty: + # Returning here would broadcast None through accelerate's dispatch loop. + self.check_health_fn(self.stale_after_s) + continue + queue_wait_time_s = time.time() - t0 + if queue_wait_time_s > 1.0: + logger.info(f"waited {queue_wait_time_s:.1f}s for sample (qsize={self.queue.qsize()})") + + staleness = self.model_version_fn() - sample.model_version + if staleness > self.max_staleness: + logger.info(f"dropping stale sample (staleness={staleness}, max={self.max_staleness})") + continue # drop stale, pull next + + yield { + "input_ids": sample.input_ids, + "completion_mask": sample.completion_mask, + "old_log_probs": sample.old_log_probs, + "advantage": sample.advantage, + "metrics": {**sample.metrics, "queue_wait_time_s": queue_wait_time_s}, + } + + +class _EmptyIterableDataset(torch.utils.data.IterableDataset): + """Placeholder for non-rank-0 processes. Never actually iterated.""" + + def __iter__(self): + return iter([]) + + +@dataclass +class DataCollatorForRollout(DataCollatorMixin): + """ + Padding-free collator for rollout samples. Splits the global batch into `num_processes` groups (one per rank) and + concatenates each group's samples into a single packed row, with `position_ids` resetting per sequence and + advantages expanded per-token. Rows are padded only to the longest group, so the batch stays rectangular for + `DataLoaderDispatcher` to scatter row `i` -> rank `i`; this inter-rank padding is stripped per-rank in + `compute_loss`. + + Args: + pad_token_id (`int`): + Token id used to pad `input_ids`. + num_processes (`int`, *optional*, defaults to `1`): + Number of ranks; the global batch is packed into this many rows. + """ + + pad_token_id: int + num_processes: int = 1 + return_tensors: str = "pt" + + def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]: + groups = [examples[i :: self.num_processes] for i in range(self.num_processes)] + + input_ids, attention_mask, completion_mask, old_log_probs, position_ids, advantages = [], [], [], [], [], [] + for group in groups: + seq_lengths = [len(example["input_ids"]) for example in group] + ids = [token for example in group for token in example["input_ids"]] + input_ids.append(torch.tensor(ids, dtype=torch.long)) + attention_mask.append(torch.ones(len(ids), dtype=torch.long)) + completion_mask.append( + torch.tensor([m for example in group for m in example["completion_mask"]], dtype=torch.long) + ) + old_log_probs.append( + torch.tensor([lp for example in group for lp in example["old_log_probs"]], dtype=torch.float32) + ) + position_ids.append(torch.cat([torch.arange(n) for n in seq_lengths])) + advantages.append( + torch.cat( + [torch.full((n,), example["advantage"]) for example, n in zip(group, seq_lengths, strict=False)] + ) + ) + + input_ids = pad(input_ids, padding_value=self.pad_token_id) + attention_mask = pad(attention_mask, padding_value=0) + completion_mask = pad(completion_mask, padding_value=0) + old_log_probs = pad(old_log_probs, padding_value=0.0) + position_ids = pad(position_ids, padding_value=0) + advantages = pad(advantages, padding_value=0.0) + + # Total valid completion tokens across all samples in the full batch. + # Repeated per rank so that DataLoaderDispatcher (dispatch_batches=True) slices correctly on dim=0 + global_n_tokens = sum(sum(example["completion_mask"]) for example in examples) + global_n_tokens = torch.full((self.num_processes,), float(global_n_tokens), dtype=torch.float32) + + # Per-sample metrics grouped per rank, as a dict of 2D tensors (one row per rank) so that Accelerate's + # recursive broadcast (dispatch_batches=True) can scatter them — it traverses nested dicts of tensors but + # chokes on plain Python floats. Rows are padded with NaN so padded slots are ignored by the nan-aware + # aggregation in `compute_loss`. + metrics_list = [example["metrics"] for example in examples] + metrics = ( + { + key: pad( + [ + torch.tensor([example["metrics"].get(key, 0.0) for example in group], dtype=torch.float32) + for group in groups + ], + padding_value=float("nan"), + ) + for key in metrics_list[0] + } + if metrics_list and metrics_list[0] + else {} + ) + + return { + "input_ids": input_ids, + "attention_mask": attention_mask, + "completion_mask": completion_mask, + "old_log_probs": old_log_probs, + "position_ids": position_ids, + "advantages": advantages, + "global_n_tokens": global_n_tokens, + "metrics": metrics, + } + + +class AsyncGRPOTrainer(_BaseTrainer): + """ + Trainer for the Group Relative Policy Optimization (GRPO) method. This algorithm was initially proposed in the + paper [DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language + Models](https://huggingface.co/papers/2402.03300). This trainer is the asynchronous version of GRPO, where + generation is offloaded to an external vLLM server that runs asynchronously alongside training, decoupling rollout + from the gradient update loop. + + Example: + + ```python + from trl.experimental.async_grpo import AsyncGRPOTrainer + from trl.rewards import accuracy_reward + from datasets import load_dataset + + dataset = load_dataset("trl-lib/DeepMath-103K", split="train") + + trainer = AsyncGRPOTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", + reward_funcs=accuracy_reward, + train_dataset=dataset, + ) + trainer.train() + ``` + + Args: + model (`str`): + Model to be trained. Must be a string, being the *model id* of a pretrained model hosted inside a model + repo on huggingface.co, or a path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using [`~transformers.AutoModelForCausalLM.from_pretrained`]. The model name is also used to identify the + model on the vLLM server used for generation. + reward_funcs (`RewardFunc | list[RewardFunc]`): + Reward functions to be used for computing the rewards. To compute the rewards, we call all the reward + functions with the prompts and completions and sum the rewards. Can be either: + + - A single reward function: The function is provided with the prompts and the generated completions, plus + any additional columns in the dataset. It should return a list of rewards. Reward functions can be either + synchronous or asynchronous and can also return `None` when the reward is not applicable to those + samples. This is useful for multi-task training where different reward functions apply to different types + of samples. When a reward function returns `None` for a sample, that reward function is excluded from the + reward calculation for that sample. For more details, see [Using a custom reward + function](#using-a-custom-reward-function). + - A list of reward functions, where each item is a reward function as described above. Rewards from all + functions are summed. + + Unlike [`GRPOTrainer`], rewards are computed in a spawned child process, so each reward function (along + with `tools` and `environment_factory`) must be picklable: use a module-level function, + `functools.partial`, or a callable class instance — lambdas and closures will fail at startup. The child + process also runs with `CUDA_VISIBLE_DEVICES=""`, so a GPU-backed reward model runs on CPU (slow), not the + trainer's GPU. + args ([`AsyncGRPOConfig`], *optional*): + Configuration for this trainer. If `None`, a default configuration is used. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + Dataset to use for training. It must include a column `"prompt"`. Any additional columns in the dataset are + ignored. The format of the samples can be either: + + - [Standard](dataset_formats#standard): Each sample contains plain text. + - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role + and content). + processing_class ([`~transformers.PreTrainedTokenizerBase`], *optional*): + Processing class used to process the data. The padding side must be set to `"left"`. If `None`, the + processing class is loaded from the model's name with [`~transformers.AutoTokenizer.from_pretrained`]. A + padding token, `tokenizer.pad_token`, must be set. If the processing class has not set a padding token, + `tokenizer.eos_token` will be used as the default. + callbacks (list of [`~transformers.TrainerCallback`], *optional*): + List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed + in [here](https://huggingface.co/docs/transformers/main_classes/callback). + + If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`] + method. + optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`): + A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your + model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`. + tools (list of `Callable`, *optional*): + A list of callable tool functions (sync or async) that the model can invoke during generation. Each tool + should be a standard Python function with properly type-hinted arguments and return values, and a + Google-style docstring describing its purpose, arguments, and return value. For more details, see: + https://huggingface.co/docs/transformers/en/chat_extras#passing-tools. The model uses the function's name, + type hints, and docstring to determine how to call it. Ensure that the model's chat template supports tool + use and that it has been fine-tuned for tool calling. + environment_factory (`EnvironmentFactory`, *optional*): + A callable that creates and returns an environment instance. The environment class should define methods + that can be invoked as tools during generation. Each method should comply with the same requirements as the + `tools` described above. If `environment_factory` is provided, an instance of the environment is created + for each generation in the batch, allowing for parallel and independent interactions. The environment must + also implement a callable `reset` method that can be used to reset state between generations. The `reset` + method should return either `None` or a string: when it returns a string, that string is appended to the + last user message before generation. This feature is experimental and may change or be removed at any time + without prior notice. + rollout_worker (`RolloutWorkerProtocol`, *optional*): + Custom rollout worker implementing [`RolloutWorkerProtocol`]. If `None`, a default [`AsyncRolloutWorker`] + is created, which spawns a CUDA-free child process and scores completions with the trainer's + `reward_funcs`. Pass a custom worker to plug in a different rollout/scoring backend instead — for example, + one that runs reward models on their own GPUs. + """ + + _tag_names = ["trl", "async-grpo"] + _name = "AsyncGRPO" + _paper = { + "title": "DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models", + "id": "2402.03300", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @article{shao2024deepseekmath, + title = {{DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models}}, + author = {Zhihong Shao and Peiyi Wang and Qihao Zhu and Runxin Xu and Junxiao Song and Mingchuan Zhang and Y. K. Li and Y. Wu and Daya Guo}, + year = 2024, + eprint = {arXiv:2402.03300}, + }"""), + } + + def __init__( + self, + model: str, + reward_funcs: RewardFunc | list[RewardFunc], + args: AsyncGRPOConfig | None = None, + train_dataset: Dataset | IterableDataset | None = None, + processing_class: PreTrainedTokenizerBase | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + tools: list[Callable] | None = None, + environment_factory: EnvironmentFactory | None = None, + rollout_worker: RolloutWorkerProtocol | None = None, + ): + self.args = args or AsyncGRPOConfig() + + # Training arguments + self.epsilon_low = self.args.epsilon + self.epsilon_high = self.args.epsilon_high if self.args.epsilon_high is not None else self.args.epsilon + self.temperature = self.args.temperature + + # Model + model_name = model + model_init_kwargs = self.args.model_init_kwargs or {} + model_init_kwargs.setdefault("trust_remote_code", self.args.trust_remote_code) + # FlashAttention is required: training runs in padding-free mode, where sequences are concatenated into a + # single row and `cu_seq_lens` are derived from `position_ids` resets. SDPA/eager can't handle this. + model = AutoModelForCausalLM.from_pretrained( + model_name, + device_map=None, + dtype=torch.float32, + attn_implementation="kernels-community/flash-attn3", + **model_init_kwargs, + ) + + if self.args.use_liger_kernel: + raise NotImplementedError("`use_liger_kernel` is not supported yet.") + + # MoE load-balancing auxiliary loss, applied to Mixture-of-Experts models (no effect otherwise) + text_config = model.config.get_text_config() + is_moe = getattr(text_config, "output_router_logits", None) is not None + self.aux_loss_enabled = is_moe and self.args.router_aux_loss_coef != 0.0 + self.router_aux_loss_coef = self.args.router_aux_loss_coef + + patch_chunked_lm_head( + model, chunk_size=8192, temperature=self.temperature, output_router_logits=self.aux_loss_enabled + ) + + # Processing class + if processing_class is None: + processing_class = AutoTokenizer.from_pretrained(model_name, trust_remote_code=self.args.trust_remote_code) + if processing_class.pad_token is None: + processing_class.pad_token = processing_class.eos_token + + # Reward functions + if not isinstance(reward_funcs, list): + reward_funcs = [reward_funcs] + + # Initialize the Trainer + super().__init__( + model=model, + args=self.args, + train_dataset=train_dataset, + processing_class=processing_class, + callbacks=callbacks, + optimizers=optimizers, + compute_loss_func="non-None value to disable scaling", + ) + # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the + # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set + # self.model_accepts_loss_kwargs to False to enable scaling. + self.model_accepts_loss_kwargs = False + + # Infer max_steps from dataset size when not explicitly set. This must happen after super().__init__() + # so that self.accelerator.num_processes is available for the correct calculation. + samples_per_step = ( + self.args.per_device_train_batch_size + * self.args.gradient_accumulation_steps + * self.accelerator.num_processes + ) + if self.args.max_steps <= 0 and train_dataset is not None and hasattr(train_dataset, "__len__"): + samples_per_epoch = len(train_dataset) * self.args.num_generations + self.args.max_steps = int(self.args.num_train_epochs * samples_per_epoch / samples_per_step) + + # Infer max_inflight_tasks when not explicitly set. Generating more samples than the trainer can consume + # before they become stale is wasteful. The useful upper bound is max_staleness * samples_per_step. + if self.args.max_inflight_tasks < 0: + self.args.max_inflight_tasks = self.args.max_staleness * samples_per_step + logger.info( + f"max_inflight_tasks set to {self.args.max_inflight_tasks} " + f"(max_staleness={self.args.max_staleness} × samples_per_step={samples_per_step})" + ) + + # Initialize the metrics + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + self._train_tokens_start_time = None + self.model_version = 0 + # Create worker and queue on rank 0 + if self.accelerator.is_main_process: + if self.train_dataset is None: + raise ValueError("train_dataset is required for AsyncGRPOTrainer") + + if rollout_worker is not None: + # Use the injected worker (e.g. a stub in tests). The queue is owned by the worker. + # Weight transfer is also expected to be wired by the test fixture (or left as None + # if the stub doesn't sync to a real vLLM). + self.rollout_worker = rollout_worker + self.weight_transfer = None + else: + # Collect weight metadata once — names/dtypes/shapes are fixed for the lifetime of training. + # DTensor.shape returns the global shape without triggering any all-gather. + weight_names, weight_dtype_names, weight_shapes = [], [], [] + for name, param in model.named_parameters(): + # DDP/FSDP1 wrapping, avoids vllm module not exist error + name = name.removeprefix("module.") + weight_names.append(name) + weight_dtype_names.append(str(param.dtype).split(".")[-1]) + weight_shapes.append(list(param.shape)) + self.weight_transfer = WeightTransferClient( + vllm_server_url=self.args.vllm_server_base_url, + server_timeout=self.args.vllm_server_timeout, + weight_update_info={ + "names": weight_names, + "dtype_names": weight_dtype_names, + "shapes": weight_shapes, + "packed": True, + }, + ) + self.rollout_worker = AsyncRolloutWorker( + model_name=model_name, + dataset=train_dataset, + reward_funcs=reward_funcs, + processing_class=processing_class, + tools=tools, + environment_factory=environment_factory, + num_generations=self.args.num_generations, + max_inflight_tasks=self.args.max_inflight_tasks, + queue_maxsize=self.args.queue_maxsize, + vllm_server_url=self.args.vllm_server_base_url, + max_tokens=self.args.max_completion_length, + temperature=self.args.temperature, + request_timeout=self.args.request_timeout, + chat_template_kwargs=self.args.chat_template_kwargs, + max_tool_calling_iterations=self.args.max_tool_calling_iterations, + log_completions=self.args.log_completions, + num_completions_to_print=self.args.num_completions_to_print, + ) + # TODO(@aminediro): decide if this is returned by the worker or common API that is passed to the worker later. + self.rollout_queue = self.rollout_worker.rollout_buffer + else: + self.rollout_queue = None + self.rollout_worker = None + self.weight_transfer = None + + # Add callbacks. Registration order matters: weight sync first, then worker start. + self.add_callback(_InitialWeightSyncCallback(self)) + self.add_callback(_StartRolloutWorkerCallback(self)) + self.add_callback(StepIntervalCallback(self._sync_weight, self.args.weight_sync_steps)) + + def get_train_dataloader(self) -> DataLoader: + if self.accelerator.is_main_process: + dataset = RolloutQueueDataset( + rollout_queue=self.rollout_queue, + model_version_fn=lambda: self.model_version, + check_health_fn=self.rollout_worker.check_health, + stale_after_s=self.args.heartbeat_stale_after_s, + max_staleness=self.args.max_staleness, + ) + else: + dataset = _EmptyIterableDataset() + + return self.accelerator.prepare( + DataLoader( + dataset, + batch_size=self.args.per_device_train_batch_size * self.accelerator.num_processes, + collate_fn=DataCollatorForRollout(self.processing_class.pad_token_id, self.accelerator.num_processes), + num_workers=0, + # NOTE(@aminediro): + # dispatch_batches = True for DataLoader whose underlying dataset is an IterableDataset + # dataloader prepared by the Accelerator is only iterated through on the main process a + ) + ) + + def _set_signature_columns_if_needed(self): + # If `self.args.remove_unused_columns` is True, non-signature columns are removed. + # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids" + # and "attention_mask"). In AsyncGRPOTrainer, we need additional columns ("completion_mask", "old_log_probs", + # "advantages", "global_n_tokens") to compute the loss, hence the override. + if self._signature_columns is None: + self._signature_columns = [ + "input_ids", + "attention_mask", + "completion_mask", + "old_log_probs", + "position_ids", + "advantages", + "global_n_tokens", + "metrics", + ] + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + # Padding-free: the collator already packed this rank's samples into a single row (real tokens concatenated, + # `position_ids` resetting per sequence, advantages expanded per-token), then padded the row to the longest + # rank's length so DataLoaderDispatcher could scatter rectangular rows. Strip that trailing inter-rank padding + # here. + mask_bool = inputs["attention_mask"].bool() + input_ids = inputs["input_ids"][mask_bool].unsqueeze(0) + completion_mask = inputs["completion_mask"][mask_bool].unsqueeze(0) + old_log_probs = inputs["old_log_probs"][mask_bool].unsqueeze(0) + position_ids = inputs["position_ids"][mask_bool].unsqueeze(0) + advantages = inputs["advantages"][mask_bool].unsqueeze(0) + + forward_start = time.time() + outputs = model( + input_ids=input_ids, + position_ids=position_ids, + labels=input_ids, + completion_mask=completion_mask, + use_cache=False, + ) + log_probs, entropy = outputs["log_probs"], outputs["entropy"] + self._last_forward_time_s = time.time() - forward_start + + completion_mask = completion_mask[:, 1:] + old_log_probs = old_log_probs[:, 1:] + advantages = advantages[:, 1:] + log_ratio = log_probs - old_log_probs + coef_1 = torch.exp(log_ratio) + coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high) + per_token_loss1 = coef_1 * advantages + per_token_loss2 = coef_2 * advantages + per_token_loss = -torch.min(per_token_loss1, per_token_loss2) + + # DDP/FSDP averages gradients across ranks (world_size). + # To get correct per-token normalization we scale by 1/tokens_per_rank + # = world_size / global_n_tokens, so after DDP averaging the effective + loss = (per_token_loss * completion_mask).sum() + global_n_tokens = inputs["global_n_tokens"][0] + world_size = self.accelerator.num_processes + tokens_per_rank = (global_n_tokens / world_size).clamp(min=1.0) + loss = loss / tokens_per_rank.to(torch.float32) + # For DAPO, we would scale like this instead: + # loss = loss / max(per_token_loss.size(0), 1) + loss = loss / self.current_gradient_accumulation_steps + + # The policy loss above is scaled for gradient accumulation (HF auto-scaling is off here), so scale aux too + if self.aux_loss_enabled: + aux_loss = outputs["aux_loss"] + loss = loss + self.router_aux_loss_coef * aux_loss / self.current_gradient_accumulation_steps + + with torch.no_grad(): + valid_mask = completion_mask > 0 + local_count = valid_mask.sum().float() + + local_ratio_sum = ( + coef_1[valid_mask].sum() if valid_mask.any() else torch.zeros((), device=completion_mask.device) + ) + # Approx KL: http://joschu.net/blog/kl-approx.html + local_kl_sum = ( + ((coef_1[valid_mask] - 1) - log_ratio[valid_mask]).sum() + if valid_mask.any() + else torch.zeros((), device=completion_mask.device) + ) + + local_entropy_sum = ( + entropy[valid_mask].sum() if valid_mask.any() else torch.zeros((), device=completion_mask.device) + ) + + clipped = (coef_1 < 1 - self.epsilon_low) | (coef_1 > 1 + self.epsilon_high) + local_clip_sum = ( + clipped[valid_mask].float().sum() + if valid_mask.any() + else torch.zeros((), device=completion_mask.device) + ) + + # Batch all-reduce: [ratio_sum, kl_sum, entropy_sum, clip_sum, count] + stats = torch.stack([local_ratio_sum, local_kl_sum, local_entropy_sum, local_clip_sum, local_count]) + stats = self.accelerator.reduce(stats, reduction="sum") + global_ratio_sum, global_kl_sum, global_entropy_sum, global_clip_sum, global_count = stats.unbind(0) + self._metrics["train"]["ratio"].append((global_ratio_sum / global_count).item()) + self._metrics["train"]["kl"].append((global_kl_sum / global_count).item()) + self._metrics["train"]["entropy"].append((global_entropy_sum / global_count).item()) + self._metrics["train"]["clip_ratio"].append((global_clip_sum / global_count).item()) + + if self.aux_loss_enabled: + gathered_aux = self.accelerator.reduce(aux_loss.detach().to(torch.float32), reduction="sum") + self._metrics["train"]["aux_loss"].append((gathered_aux / world_size).item()) + + # Logging metrics from the rollout worker (reward, reward_std, etc.). + # inputs["metrics"] is a dict keyed by metric name; each value is this rank's row of per-sample values, + # NaN-padded (the nan-aware aggregation below ignores both padding and unscorable samples). + sample_metrics = inputs["metrics"] # dict[str, Tensor(shape=[1, n_samples_local])] + keys = list(sample_metrics.keys()) + device = completion_mask.device + n_samples = (position_ids == 0).sum().to(torch.float32) + if keys: + # nan-aware per key: unscorable samples carry NaN, so a plain .sum() would poison the whole metric. + local_sums = torch.stack([torch.nansum(sample_metrics[k].to(device)) for k in keys]) + local_counts = torch.stack( + [(~torch.isnan(sample_metrics[k].to(device))).sum().to(torch.float32) for k in keys] + ) + stats = torch.cat([local_sums, local_counts]) + stats = self.accelerator.reduce(stats, reduction="sum") + n = len(keys) + global_sums, global_counts = stats[:n], stats[n:] + for k, global_sum, global_count in zip(keys, global_sums, global_counts, strict=True): + metric = (global_sum / global_count).item() if global_count > 0 else float("nan") + self._metrics["train"][k].append(metric) + + length_stats = torch.stack([completion_mask.sum().float(), n_samples]) + length_stats = self.accelerator.reduce(length_stats, reduction="sum") + self._metrics["train"]["completions/mean_length"].append((length_stats[0] / length_stats[1]).item()) + + # Training throughput: completion tokens consumed by this training step per second. + now = time.time() + if self._train_tokens_start_time is not None: + train_elapsed = now - self._train_tokens_start_time + if train_elapsed > 0: + self._metrics["train"]["training_tok/s"].append(global_n_tokens.item() / train_elapsed) + self._train_tokens_start_time = now + + self._metrics["train"]["forward_time_s"].append(self._last_forward_time_s) + # NOTE: in dynamic mbs setup, we would need to agg across DP ranks. + self._metrics["train"]["train_seq_len"].append(float(position_ids.max() + 1)) + return loss + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + # Average the metrics + metrics = {} + for key, val in self._metrics[mode].items(): + # Filter out NaN values before averaging. A reward function that returns None for all samples + # in a batch produces NaN for that batch's metric. With logging_steps > 1, a naive sum()/len() + # would let a single NaN contaminate valid data from other batches. Only return None when no + # valid values remain (e.g. JSON loggers crash on float NaN). + valid = [v for v in val if not math.isnan(v)] + metrics[key] = sum(valid) / len(valid) if valid else None + + # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs` + # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() + + def _streaming_iter(self): + # Iterate parameters one at a time. For FSDP2 (DTensor), full_tensor() all-gathers just this parameter across + # FSDP ranks, then frees it once the generator advances — avoiding materializing the full model in memory. + device = self.accelerator.device + for name, param in self.model.named_parameters(): + name = name.removeprefix("module.") # DDP/FSDP1 wrapping + full = param.full_tensor() if isinstance(param, DTensor) else param.detach() + if full.device != device: + full = full.to(device) + yield name, full + + def _sync_weight(self): + t0 = time.time() + logger.info("Weight sync: pausing vLLM...") + if self.accelerator.is_main_process and self.weight_transfer: + self.weight_transfer.pause() + t_pause = time.time() + logger.info(f"Weight sync: pause took {t_pause - t0:.1f}s, waiting for all ranks...") + + self.accelerator.wait_for_everyone() + t_barrier = time.time() + + logger.info(f"Weight sync: transferring weights... (barrier took {t_barrier - t_pause:.1f}s)") + if self.accelerator.is_main_process and self.weight_transfer: + self.weight_transfer.send_weights(self._streaming_iter()) + else: + # Non-rank-0 processes must still participate in full_tensor() collectives for FSDP2. + for _ in self._streaming_iter(): + pass + t_transfer = time.time() + + self.accelerator.wait_for_everyone() + + logger.info(f"Weight sync: resuming vLLM... (transfer took {t_transfer - t_barrier:.1f}s)") + if self.accelerator.is_main_process: + if self.weight_transfer: + self.weight_transfer.resume() + self.model_version += 1 + if self.rollout_worker: + self.rollout_worker.update_model_version(self.model_version) + weight_sync_time_s = time.time() - t0 + self._metrics["train"]["weight_sync_time_s"].append(weight_sync_time_s) + logger.info(f"Weight sync: done. Total {weight_sync_time_s:.1f}s") + + def _inner_training_loop(self, *args, **kwargs): + try: + return super()._inner_training_loop(*args, **kwargs) + finally: + if self.accelerator.is_main_process: + if self.rollout_worker: + self.rollout_worker.stop() + if self.weight_transfer: + self.weight_transfer.destroy() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/async_rollout_worker.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/async_rollout_worker.py new file mode 100644 index 0000000000000000000000000000000000000000..43f1ec341f33c76ad64ba361461c8151c8ce8090 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/async_rollout_worker.py @@ -0,0 +1,829 @@ +# Copyright 2020-2026 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 asyncio +import inspect +import multiprocessing as mp +import os +import pickle +import queue +import threading +import time +import traceback +from collections.abc import Awaitable, Callable, Iterator +from dataclasses import dataclass +from multiprocessing.queues import Queue as MPQueue +from multiprocessing.sharedctypes import Synchronized as MPValue +from multiprocessing.synchronize import Event as MPEvent +from typing import Any, TypeAlias + +import aiohttp +import numpy as np +from accelerate.logging import get_logger +from datasets import Dataset +from transformers import PreTrainedTokenizerBase + +from ...chat_template_utils import ( + add_response_schema, + get_training_chat_template, + is_chat_template_prefix_preserving, + parse_response, +) +from ...import_utils import is_vllm_available +from ...trainer.utils import print_prompt_completions_sample + + +logger = get_logger(__name__) + +Messages: TypeAlias = list[dict[str, str]] + +_RETRYABLE_HTTP_ERRORS = (aiohttp.ClientError, asyncio.TimeoutError, TimeoutError, ConnectionResetError) + + +async def _retry_on_http_error(coro_factory: Callable[[], Awaitable], *, label: str, max_attempts: int = 1): + """Retry an aiohttp coroutine on transport errors with bounded exponential backoff.""" + for attempt in range(max_attempts): + try: + return await coro_factory() + except _RETRYABLE_HTTP_ERRORS as e: + if attempt >= max_attempts - 1: + raise + sleep = min(2 ** min(attempt, 4), 16) + logger.warning(f"{label} failed ({type(e).__name__}: {e}); retry {attempt + 1}/{max_attempts} in {sleep}s") + await asyncio.sleep(sleep) + + +@dataclass(slots=True) +class RolloutGroup: + prompt: Messages + prompt_ids: list[int] + reward_kwargs: dict[str, list[Any]] + completions: list[Messages] + completions_ids: list[list[int]] + completions_logprobs: list[list[float]] + tool_mask: list[list[int]] + tool_call_counts: list[int] + tool_failure_counts: list[int] + model_version: int + queued_at: float = 0.0 + + +@dataclass(slots=True) +class RolloutSample: + prompt: Messages + completion: Messages + input_ids: list[int] + completion_mask: list[int] + old_log_probs: list[float] + advantage: float + model_version: int + metrics: dict[str, float] + + +# Env vars the child must drop so accelerate's `PartialState()` initialises in +# single-process mode instead of trying to join the parent's process group. +_CHILD_ENV_TO_STRIP = ( + "RANK", + "WORLD_SIZE", + "LOCAL_RANK", + "LOCAL_WORLD_SIZE", + "MASTER_ADDR", + "MASTER_PORT", + "GROUP_RANK", + "ROLE_RANK", + "ROLE_WORLD_SIZE", + "TORCHELASTIC_RUN_ID", + "TORCHELASTIC_RESTART_COUNT", + "TORCHELASTIC_MAX_RESTARTS", + "TORCH_FR_DUMP_TEMP_FILE", + "NCCL_DEBUG_FILE", +) + + +def _scrub_child_env() -> None: + # The child has no business touching CUDA; any library that imports torch + # and lazily probes devices would race the parent's allocator. + os.environ["CUDA_VISIBLE_DEVICES"] = "" + for k in _CHILD_ENV_TO_STRIP: + os.environ.pop(k, None) + + +def _spawn_stop_watcher(rollout_loop: "_AsyncRolloutLoop", stop_event: MPEvent) -> None: + # Daemon thread that translates the parent's mp.Event into the child's + # asyncio.Event so _run_loops breaks out of its gather. + def _watch(): + stop_event.wait() + try: + rollout_loop._loop.call_soon_threadsafe(rollout_loop._stop_event.set) + except RuntimeError: + # Loop already closed (run() returned before stop fired). Nothing to do. + pass + + threading.Thread(target=_watch, daemon=True, name="grpo-mp-stop-watcher").start() + + +def _child_main( + loop_kwargs: dict[str, Any], + samples_queue: MPQueue, + model_version_value: MPValue, + stop_event: MPEvent, + child_ready_event: MPEvent, + heartbeat_value: MPValue, + failed_event: MPEvent, + exception_info_queue: MPQueue, +) -> None: + _scrub_child_env() + # `accelerate.logging.get_logger` requires `PartialState()` to have been called. + from accelerate.state import PartialState + + PartialState() + + rollout_loop = _AsyncRolloutLoop( + **loop_kwargs, + rollout_buffer=samples_queue, + model_version_value=model_version_value, + heartbeat_value=heartbeat_value, + failed_event=failed_event, + exception_info_queue=exception_info_queue, + ) + child_ready_event.set() + _spawn_stop_watcher(rollout_loop, stop_event) + try: + rollout_loop.run() + except Exception: + traceback.print_exc() + raise + + +class _AsyncRolloutLoop: + """Asyncio generate and score loops. Lives entirely inside the spawned child process. + + Owns the tokenizer, dataset iterator, reward funcs, environments, and the asyncio event loop. Talks to vLLM via + `/v1/completions`. Pushes scored `RolloutSample`s into the shared `mp.Queue` (`rollout_buffer`); reads the bumped + policy version from the shared `mp.Value` (`model_version_value`). + """ + + def __init__( + self, + *, + model_name: str, + dataset: Dataset, + reward_funcs: list[Callable[..., list[float]]], + processing_class: PreTrainedTokenizerBase, + rollout_buffer: MPQueue, + model_version_value: MPValue, + heartbeat_value: MPValue, + failed_event: MPEvent, + exception_info_queue: MPQueue, + tools: list[Callable] | None = None, + environment_factory: Callable[[], object] | None = None, + num_generations: int = 8, + max_inflight_tasks: int = 128, + queue_maxsize: int = 0, + vllm_server_url: str = "http://localhost:8000", + max_tokens: int = 32, + temperature: float = 1.0, + request_timeout: int = 120, + chat_template_kwargs: dict[str, Any] | None = None, + max_tool_calling_iterations: int | None = None, + log_completions: bool = False, + num_completions_to_print: int | None = None, + ): + self.model_name = model_name + self.dataset = dataset + self._dataset_iter = iter(dataset) + self.reward_funcs = reward_funcs + self.reward_func_names = [f.__name__ for f in reward_funcs] + self.tokenizer = add_response_schema(processing_class) + self.rollout_buffer = rollout_buffer # shared mp.Queue + self._model_version_value = model_version_value # shared mp.Value + self._heartbeat_value = heartbeat_value # shared mp.Value('d'); wall-clock seconds + self._failed_event = failed_event # shared mp.Event + self._exception_info_queue = exception_info_queue # shared mp.Queue(maxsize=1) + + self.num_generations = num_generations + self.max_inflight_tasks = max_inflight_tasks + self.queue_maxsize = queue_maxsize + self.max_tokens = max_tokens + self.temperature = temperature + self.request_timeout = request_timeout + self.chat_template_kwargs = chat_template_kwargs or {} + self.max_tool_calling_iterations = max_tool_calling_iterations + self.log_completions = log_completions + self.num_completions_to_print = num_completions_to_print + self.vllm_server_url = vllm_server_url.rstrip("/") + + self.environments = None + environment_methods = [[] for _ in range(max_inflight_tasks)] + if environment_factory is not None: + self.environments = [environment_factory() for _ in range(max_inflight_tasks)] + for i, environment in enumerate(self.environments): + has_reset = False + for name, member in inspect.getmembers(environment, predicate=inspect.ismethod): + if name == "reset": + has_reset = True + elif not name.startswith("_"): + environment_methods[i].append(member) + if not has_reset: + raise ValueError( + "Each environment instance returned by `environment_factory` must define `reset`." + ) + + base_tools = tools or [] + self._sync_tool_dicts = [{} for _ in range(max_inflight_tasks)] + for i in range(max_inflight_tasks): + for tool in base_tools + (environment_methods[i] if self.environments is not None else []): + if inspect.iscoroutinefunction(tool): + raise ValueError("Asynchronous tools are not supported yet.") + self._sync_tool_dicts[i][tool.__name__] = tool + self.tools = base_tools + (environment_methods[0] if self.environments is not None else []) + + # The chat template must be prefix-preserving in multi-turn training; if the tokenizer's + # template isn't, swap in a training-safe one. + if self.tools and not is_chat_template_prefix_preserving(self.tokenizer): + self.chat_template = get_training_chat_template(self.tokenizer) + else: + self.chat_template = None + + self._groups_to_score: asyncio.Queue[RolloutGroup | None] = asyncio.Queue(maxsize=16) + self._total_completion_tokens = 0 + self._total_groups_scored = 0 + self._generation_start_time: float | None = None + self.session: aiohttp.ClientSession | None = None + + self._loop = asyncio.new_event_loop() + self._stop_event = asyncio.Event() + + @property + def model_version(self) -> int: + return int(self._model_version_value.value) + + def run(self) -> None: + asyncio.set_event_loop(self._loop) + try: + self._loop.run_until_complete(self._run_loops(stop_event=self._stop_event)) + except BaseException as e: + # Push pickle-safe exception info to the parent before setting _failed_event, so a + # reader that sees the event is guaranteed to also see the info on the queue. + info = (type(e).__name__, str(e), traceback.format_exc()) + try: + self._exception_info_queue.put_nowait(info) + except Exception: + pass # queue full (parent hasn't drained a prior failure), best-effort put + self._failed_event.set() + logger.exception(f"Worker process failed: {e}") + raise + finally: + self._loop.close() + + async def _run_loops(self, stop_event: asyncio.Event) -> None: + async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(limit=self.max_inflight_tasks)) as session: + self.session = session + logger.info( + f"vllm worker started: num_generations={self.num_generations}, " + f"max_inflight_tasks={self.max_inflight_tasks}" + ) + await asyncio.gather( + asyncio.create_task(self._generate_loop(stop_event=stop_event)), + asyncio.create_task(self._score_loop(stop_event=stop_event)), + ) + + async def _generate_loop(self, stop_event: asyncio.Event) -> None: + pending_groups: dict[int, RolloutGroup] = {} + pending_completed: dict[int, int] = {} + inflight_tasks: dict[asyncio.Task, tuple[int, int]] = {} + free_slots = set(range(self.max_inflight_tasks)) + work_iter = self._repeat_iterator() + + self._generation_start_time = time.monotonic() + try: + while True: + # Wall-clock for cross-process comparison; parent uses time.time() in check_health. + self._heartbeat_value.value = time.time() + while free_slots and not stop_event.is_set(): + group_id, row = next(work_iter) + if group_id not in pending_groups: + prompt = row["prompt"] + prompt_ids = self.tokenizer.apply_chat_template( + prompt, + return_dict=False, + add_generation_prompt=True, + tools=self.tools or None, # `or None`: Llama bug: renders tool boilerplate for tools=[] + chat_template=self.chat_template, + **self.chat_template_kwargs, + ) + reward_kwargs = { + key: [row[key]] * self.num_generations + for key in row + if key not in {"prompt", "completion", "completion_ids"} + } + pending_groups[group_id] = RolloutGroup( + prompt=prompt, + prompt_ids=prompt_ids, + reward_kwargs=reward_kwargs, + completions=[], + completions_ids=[], + completions_logprobs=[], + tool_mask=[], + tool_call_counts=[], + tool_failure_counts=[], + model_version=self.model_version, + ) + pending_completed[group_id] = 0 + + slot = free_slots.pop() + if self.environments is not None: + self.environments[slot].reset(**row) + + task = asyncio.create_task( + self._generate_one(pending_groups[group_id].prompt, tool_dict=self._sync_tool_dicts[slot]) + ) + inflight_tasks[task] = (group_id, slot) + + if not inflight_tasks: + if stop_event.is_set(): + return + await asyncio.sleep(0.01) + continue + + done, _ = await asyncio.wait(inflight_tasks, return_when=asyncio.FIRST_COMPLETED, timeout=0.1) + if not done: + continue + + for task in done: + group_id, slot = inflight_tasks.pop(task) + free_slots.add(slot) + if task.exception() is not None: + raise task.exception() + + ( + completion, + completion_ids, + completion_logprobs, + tool_mask, + tool_call_count, + tool_failure_count, + ) = task.result() + group = pending_groups[group_id] + group.completions.append(completion) + group.completions_ids.append(completion_ids) + group.completions_logprobs.append(completion_logprobs) + group.tool_mask.append(tool_mask) + group.tool_call_counts.append(tool_call_count) + group.tool_failure_counts.append(tool_failure_count) + self._total_completion_tokens += sum(tool_mask) + pending_completed[group_id] += 1 + + if pending_completed[group_id] == self.num_generations: + group.queued_at = time.monotonic() + while True: + try: + self._groups_to_score.put_nowait(group) + break + except asyncio.QueueFull: + if stop_event.is_set(): + return + await asyncio.sleep(0.1) + del pending_groups[group_id] + del pending_completed[group_id] + finally: + for task in inflight_tasks: + task.cancel() + if inflight_tasks: + await asyncio.gather(*inflight_tasks, return_exceptions=True) + try: + self._groups_to_score.put_nowait(None) + except asyncio.QueueFull: + pass + + async def _score_loop(self, stop_event: asyncio.Event) -> None: + while not stop_event.is_set(): + self._heartbeat_value.value = time.time() + t_wait = time.monotonic() + try: + group = await asyncio.wait_for(self._groups_to_score.get(), timeout=0.5) + except asyncio.TimeoutError: + continue + if group is None: + return + score_queue_wait = time.monotonic() - t_wait + wait_scoring = time.monotonic() - group.queued_at + + if score_queue_wait > 0.5: + logger.info(f"[score] waited {score_queue_wait:.1f}s for a group to score") + + t0 = time.monotonic() + samples = await self._score_group(group) + scoring_time = time.monotonic() - t0 + logger.info( + f"[score] scored {len(samples)} samples in {scoring_time:.2f}s, " + f"buffer_qsize={self.rollout_buffer.qsize()}" + ) + + self._compute_rollout_metrics(samples, scoring_time, wait_scoring) + + if self.log_completions and samples: + print_prompt_completions_sample( + prompts=[s.prompt for s in samples], + completions=[s.completion for s in samples], + rewards={"reward": [s.metrics["reward"] for s in samples]}, + advantages=[s.advantage for s in samples], + step=self._total_groups_scored, + num_samples=self.num_completions_to_print, + ) + self._total_groups_scored += 1 + + for sample in samples: + while True: + try: + self.rollout_buffer.put_nowait(sample) + break + except queue.Full: + if stop_event.is_set(): + return + logger.info( + f"[score] rollout buffer full (maxsize={self.queue_maxsize}), " + "waiting for trainer to consume..." + ) + await asyncio.sleep(0.1) + + def _compute_rollout_metrics(self, samples: list[RolloutSample], scoring_time: float, wait_scoring: float) -> None: + assert self._generation_start_time is not None + elapsed = time.monotonic() - self._generation_start_time + generation_tok_per_sec = self._total_completion_tokens / elapsed if elapsed > 0 else 0.0 + for sample in samples: + sample.metrics["generation_tok_per_s"] = generation_tok_per_sec + sample.metrics["scoring_time_ms"] = scoring_time * 1000 + sample.metrics["wait_scoring_ms"] = wait_scoring * 1000 + sample.metrics["buffer_qsize"] = self.rollout_buffer.qsize() + + def _repeat_iterator(self) -> Iterator[tuple[int, dict[str, Any]]]: + group_id = 0 + while True: + try: + row = next(self._dataset_iter) + except StopIteration: + self._dataset_iter = iter(self.dataset) + row = next(self._dataset_iter) + for _ in range(self.num_generations): + yield group_id, row + group_id += 1 + + async def _generate_one( + self, prompt: Messages, tool_dict: dict[str, Callable] + ) -> tuple[list[dict[str, str]], list[int], list[float], list[int], int, int]: + completion, completion_ids, completion_logprobs, tool_mask = [], [], [], [] + tool_call_count = 0 + tool_failure_count = 0 + iteration_num = 0 + max_iterations = self.max_tool_calling_iterations + prompt_ids = self.tokenizer.apply_chat_template( + prompt, + return_dict=False, + add_generation_prompt=True, + tools=self.tools or None, + chat_template=self.chat_template, + **self.chat_template_kwargs, + ) + while True: + turn_ids, turn_logprobs = await self._generate_one_turn(prompt_ids) + assistant_message = parse_response(self.tokenizer, turn_ids) + completion.append(assistant_message) + completion_ids.extend(turn_ids) + completion_logprobs.extend(turn_logprobs) + tool_mask.extend([1] * len(turn_ids)) + tool_calls = assistant_message.get("tool_calls") + if tool_calls is None or (max_iterations is not None and iteration_num >= max_iterations): + return completion, completion_ids, completion_logprobs, tool_mask, tool_call_count, tool_failure_count + + tool_messages, n_calls, n_failures = self._execute_tool_calls(tool_calls, tool_dict) + tool_call_count += n_calls + tool_failure_count += n_failures + completion.extend(tool_messages) + suffix_ids = self._get_tool_suffix_ids(tool_messages) + completion_ids.extend(suffix_ids) + completion_logprobs.extend([0.0] * len(suffix_ids)) + tool_mask.extend([0] * len(suffix_ids)) + prompt_ids = prompt_ids + turn_ids + suffix_ids + iteration_num += 1 + + def _get_tool_suffix_ids(self, tool_messages: list[dict[str, Any]]) -> list[int]: + # Use the real tool name: some templates (e.g. GPT-OSS) derive the tool response header from + # the assistant's tool call name. + dummy_tool_calls = [{"type": "function", "function": {"name": tool_messages[0]["name"], "arguments": {}}}] + dummy_messages = [ + {"role": "user", "content": "dummy"}, + # `content: ""` is required: VLM processors crash on tokenize=True without it + # (KeyError in processing_utils.py, see huggingface/transformers#45290). + {"role": "assistant", "content": "", "tool_calls": dummy_tool_calls}, + ] + prefix_ids = self.tokenizer.apply_chat_template( + dummy_messages, + add_generation_prompt=False, + tokenize=True, + chat_template=self.chat_template, + return_dict=False, + **self.chat_template_kwargs, + ) + full_ids = self.tokenizer.apply_chat_template( + dummy_messages + tool_messages, + add_generation_prompt=True, + tokenize=True, + chat_template=self.chat_template, + return_dict=False, + **self.chat_template_kwargs, + ) + # Some chat templates (Qwen3/Qwen3.5) render "...<|im_end|>\n" after assistant/tool blocks. + # Align the slicing boundary to EOS, not EOS + newline. + eos_positions = [i for i, tok_id in enumerate(prefix_ids) if tok_id == self.tokenizer.eos_token_id] + if eos_positions: + prefix_ids = prefix_ids[: eos_positions[-1] + 1] + if full_ids[: len(prefix_ids)] != prefix_ids: + raise ValueError("Unexpected tokenization: the EOS-trimmed prefix IDs are not a prefix of the full IDs.") + return full_ids[len(prefix_ids) :] + + def _execute_tool_calls( + self, tool_calls: list[dict[str, Any]], tool_dict: dict[str, Callable] + ) -> tuple[list[dict[str, str]], int, int]: + tool_messages = [] + n_calls = 0 + n_failures = 0 + for tool_call in tool_calls: + n_calls += 1 + function = tool_call["function"] + name = function["name"] + try: + arguments = function.get("arguments", {}) + result = tool_dict[name](**arguments) + except Exception as error: + n_failures += 1 + result = {"error": str(error)} + tool_messages.append({"role": "tool", "name": name, "content": str(result)}) + return tool_messages, n_calls, n_failures + + async def _generate_one_turn(self, prompt_ids: list[int]) -> tuple[list[int], list[float]]: + payload = { + "model": self.model_name, + "prompt": prompt_ids, + "max_tokens": self.max_tokens, + "temperature": self.temperature, + "n": 1, + "return_token_ids": True, + "logprobs": 0, + } + output = await _retry_on_http_error( + lambda: self._post("/v1/completions", payload, self.request_timeout), + max_attempts=30, + label="vllm /v1/completions", + ) + choice = output["choices"][0] + return choice["token_ids"], choice["logprobs"]["token_logprobs"] + + async def _score_group(self, group: RolloutGroup) -> list[RolloutSample]: + kwargs = dict( + completions=group.completions, + prompt=group.prompt, + prompts=[group.prompt] * len(group.completions), + completion_ids=group.completions_ids, + **group.reward_kwargs, + ) + all_rewards = await asyncio.gather( + *[ + reward_func(**kwargs) + if inspect.iscoroutinefunction(reward_func) + else asyncio.to_thread(reward_func, **kwargs) + for reward_func in self.reward_funcs + ] + ) + + # Reward funcs may return None per-sample (unparseable gold). Convert to NaN. A completion + # for which every func returned None is unscorable: nansum would give 0 and the row would + # pull the policy away from actually-correct answers. + # Mark such rows NaN, then compute advantage on the scorable subset only. + all_rewards = [[r if r is not None else float("nan") for r in row] for row in all_rewards] + arr = np.array(all_rewards, dtype=float) + all_nan_mask = np.all(np.isnan(arr), axis=0) + rewards = np.nansum(arr, axis=0) + rewards[all_nan_mask] = np.nan + + scored_mask = ~np.isnan(rewards) + # NOTE: for NaN reward we set advantage to 0 ! + advantages = np.zeros_like(rewards) + if scored_mask.any(): + scored = rewards[scored_mask] + advantages[scored_mask] = (scored - scored.mean()) / (scored.std() + 1e-8) + reward_mean = float(scored.mean()) + reward_std = float(scored.std()) + else: + reward_mean = reward_std = float("nan") + logger.info(f"Rollout metrics: reward_mean={reward_mean:.4f}, reward_std={reward_std:.4f}") + + total_calls = sum(group.tool_call_counts) + tool_metrics = ( + [ + { + "tools/call_frequency": float(n_calls), + "tools/failure_frequency": (n_failures / n_calls) if n_calls > 0 else 0.0, + } + for n_calls, n_failures in zip(group.tool_call_counts, group.tool_failure_counts, strict=True) + ] + if total_calls > 0 + else [{}] * len(group.completions) + ) + + per_func_rewards = np.array(all_rewards, dtype=float) + return [ + RolloutSample( + prompt=group.prompt, + completion=completion, + input_ids=group.prompt_ids + completion_ids, + completion_mask=[0] * len(group.prompt_ids) + tool_mask, + old_log_probs=[0.0] * len(group.prompt_ids) + logprobs, + advantage=advantage, + model_version=group.model_version, + metrics={ + "reward": float(reward), + "reward_std": reward_std, + **{ + f"rewards/{name}": float(func_reward) + for name, func_reward in zip(self.reward_func_names, per_func_rewards[:, i], strict=True) + }, + **tm, + }, + ) + for i, (completion, completion_ids, logprobs, tool_mask, advantage, reward, tm) in enumerate( + zip( + group.completions, + group.completions_ids, + group.completions_logprobs, + group.tool_mask, + advantages, + rewards, + tool_metrics, + strict=True, + ) + ) + ] + + async def _post(self, path: str, payload: dict, timeout: float, max_retries: int = 3) -> dict: + client_timeout = aiohttp.ClientTimeout(total=timeout) + + async def _do_post(): + async with self.session.post( + f"{self.vllm_server_url}{path}", json=payload, timeout=client_timeout + ) as response: + response.raise_for_status() + content = await response.json() + return content if content else {} + + return await _retry_on_http_error(_do_post, label=f"POST {path}", max_attempts=max_retries) + + +class AsyncRolloutWorker: + """Parent-side controller: spawns a child process running `_AsyncRolloutLoop`. + + The trainer holds this object on rank 0. The child does the actual rollout work; this class only manages lifecycle + (start/stop) and exposes the shared `mp.Queue` (`rollout_buffer`) and `mp.Value` (`model_version`) the trainer + reads/writes. + + Constructor kwargs are forwarded as-is to `_AsyncRolloutLoop` when the child spawns; only `queue_maxsize` and + `child_ready_timeout` are consumed here. Because the child is spawned, every forwarded kwarg is pickled: + `reward_funcs`, `tools`, and `environment_factory` (and anything they close over) must be picklable — module-level + functions, `functools.partial`, or callable instances, never lambdas or closures. `start()` validates this up front + and raises a `TypeError` otherwise. The child also runs with `CUDA_VISIBLE_DEVICES=""`, so GPU reward models + execute on CPU. + """ + + def __init__( + self, + *, + queue_maxsize: int = 0, + child_ready_timeout: int = 300, + **loop_kwargs: Any, + ): + if not is_vllm_available(min_version="0.17.1"): + raise ImportError( + "vLLM >= 0.17.1 is required to use AsyncRolloutWorker. Install it with: pip install 'vllm>=0.17.1'" + ) + ctx = mp.get_context("spawn") + self._mp_ctx = ctx + self.rollout_buffer = ctx.Queue(maxsize=queue_maxsize) + self._model_version_value = ctx.Value("i", 0) + self._stop_event_mp = ctx.Event() + self._child_ready_event = ctx.Event() + # Liveness state shared with the child. Wall-clock seconds because monotonic() is per-process. + self._heartbeat_value = ctx.Value("d", 0.0) + self._failed_event = ctx.Event() + self._exception_info_queue = ctx.Queue(maxsize=1) + # Forwarded verbatim to _AsyncRolloutLoop in the child. queue_maxsize is also + # forwarded — the child reads it for "rollout buffer full" log lines. + loop_kwargs["queue_maxsize"] = queue_maxsize + self._loop_kwargs = loop_kwargs + self._child_ready_timeout = child_ready_timeout + self._process: mp.Process | None = None + + @property + def model_version(self) -> int: + return int(self._model_version_value.value) + + @model_version.setter + def model_version(self, value: int) -> None: + # NOTE(@aminediro) Read/write ops like += are not atomic with mp.Value + with self._model_version_value.get_lock(): + self._model_version_value.value = int(value) + + def update_model_version(self, model_version: int) -> None: + self.model_version = model_version + + def start(self) -> None: + if self._process is not None: + logger.warning("AsyncRolloutWorker.start() called but child process is already running; ignoring.") + return + # Reset so spawn-import latency (~tens of seconds) doesn't immediately trip check_health. + self._heartbeat_value.value = time.time() + try: + pickle.dumps(self._loop_kwargs) + except (pickle.PicklingError, AttributeError, TypeError) as e: + # fails fast with an actionable message instead of an opaque traceback + raise TypeError( + "AsyncRolloutWorker forwards reward_funcs / tools / environment_factory to a spawned " + "child process, so they must be picklable. Lambdas and closures are not: use a " + "module-level function, functools.partial, or a callable class instance instead." + ) from e + self._process = self._mp_ctx.Process( + target=_child_main, + args=( + self._loop_kwargs, + self.rollout_buffer, + self._model_version_value, + self._stop_event_mp, + self._child_ready_event, + self._heartbeat_value, + self._failed_event, + self._exception_info_queue, + ), + name="grpo-rollout-worker-child", + daemon=True, + ) + self._process.start() + logger.info( + f"AsyncRolloutWorker spawned child pid={self._process.pid}; " + f"waiting up to {self._child_ready_timeout}s for the ready signal" + ) + # spawn re-imports torch+transformers+trl+vllm in the child — slow on cold launch. Poll + # liveness so an early crash surfaces immediately instead of after the full timeout. + deadline = time.monotonic() + self._child_ready_timeout + while not self._child_ready_event.wait(timeout=1.0): + if not self._process.is_alive(): + exit_code = self._process.exitcode + self._process = None + raise RuntimeError( + f"AsyncRolloutWorker child exited during init (exitcode={exit_code}). " + "Check the child's stderr for the traceback." + ) + if time.monotonic() >= deadline: + raise RuntimeError( + f"AsyncRolloutWorker child did not signal ready within {self._child_ready_timeout}s." + ) + logger.info("AsyncRolloutWorker child is ready") + + def check_health(self, stale_after_s: float) -> None: + """Raise if the child crashed or hasn't ticked the heartbeat within `stale_after_s`.""" + if self._failed_event.is_set(): + try: + type_name, msg, tb = self._exception_info_queue.get_nowait() + cause = RuntimeError(f"{type_name}: {msg}\n{tb}") + except queue.Empty: + cause = None + raise RuntimeError("Rollout worker child has failed; see chained exception.") from cause + age = time.time() - self._heartbeat_value.value + if age > stale_after_s: + raise RuntimeError(f"Rollout worker heartbeat stale: {age:.0f}s > {stale_after_s:.0f}s; child is hung.") + + def stop(self) -> None: + if self._process is None: + return + logger.info("Stopping AsyncRolloutWorker child process...") + self._stop_event_mp.set() + # If start() raised before Process.start() returned (e.g. pickle failure during spawn), + # _popen is None and .join() would assert — skip cleanly. + if self._process._popen is not None: + self._process.join(timeout=15) + if self._process.is_alive(): + logger.warning("Child did not exit within 15s; terminating.") + self._process.terminate() + self._process.join(timeout=5) + if self._process.is_alive(): + self._process.kill() + self._process = None diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/weight_transfer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/weight_transfer.py new file mode 100644 index 0000000000000000000000000000000000000000..1662cf7a32bb3976cca60d236760200665577518 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/async_grpo/weight_transfer.py @@ -0,0 +1,143 @@ +# Copyright 2020-2026 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 threading +import time + +import requests +from accelerate.logging import get_logger + +from ...import_utils import is_vllm_available + + +if is_vllm_available(min_version="0.22.0"): + from vllm.distributed.weight_transfer.nccl_engine import NCCLTrainerSendWeightsArgs, NCCLWeightTransferEngine + from vllm.utils.network_utils import get_ip, get_open_port + + +logger = get_logger(__name__) + + +class WeightTransferClient: + def __init__( + self, + vllm_server_url: str, + weight_update_info: dict, + server_timeout: float = 240.0, + init_weight_transfer_timeout: int = 1800, + ): + if not is_vllm_available(min_version="0.22.0"): + raise ImportError( + "vLLM >= 0.22.0 is required to use WeightTransferClient. Install it with: pip install 'vllm>=0.22.0'" + ) + self.vllm_server_url = vllm_server_url.rstrip("/") + self.server_timeout = server_timeout + self.init_weight_transfer_timeout = init_weight_transfer_timeout + self._weight_update_info = weight_update_info + self.model_update_group = None + + def _wait_for_server_ready_sync(self, timeout_s: float | None = None, poll_interval_s: float = 2.0) -> None: + timeout_s = timeout_s if timeout_s is not None else self.server_timeout + logger.info(f"Waiting for vLLM server at {self.vllm_server_url} ...") + start = time.time() + while True: + elapsed = time.time() - start + try: + response = requests.get(f"{self.vllm_server_url}/health", timeout=5) + if response.status_code == 200: + logger.info(f"vLLM server ready after {elapsed:.1f}s") + return + except (requests.ConnectionError, requests.Timeout, OSError): + pass + if elapsed >= timeout_s: + raise TimeoutError( + f"Timed out after {timeout_s:.0f}s waiting for vLLM server at {self.vllm_server_url}. " + "Make sure the vLLM server is running and reachable. If the server needs more time to load " + "the model, increase `vllm_server_timeout` in your AsyncGRPOConfig." + ) + if int(elapsed) % 10 < poll_interval_s: + logger.info(f"Still waiting for vLLM server... ({elapsed:.0f}s)") + time.sleep(poll_interval_s) + + def init_weight_transfer(self) -> None: + self._wait_for_server_ready_sync() + response = requests.get(f"{self.vllm_server_url}/get_world_size") + inference_world_size = response.json()["world_size"] + world_size = inference_world_size + 1 + master_address = get_ip() + master_port = get_open_port() + init_info = { + "master_address": master_address, + "master_port": master_port, + "rank_offset": 1, + "world_size": world_size, + } + t_init = threading.Thread( + target=requests.post, + args=(f"{self.vllm_server_url}/init_weight_transfer_engine",), + kwargs={"json": {"init_info": init_info}, "timeout": self.init_weight_transfer_timeout}, + ) + t_init.start() + self.model_update_group = NCCLWeightTransferEngine.trainer_init( + { + "master_address": master_address, + "master_port": master_port, + "world_size": world_size, + } + ) + t_init.join() + logger.info("Initialised weight-transfer NCCL group with vLLM") + + def send_weights(self, iterator) -> None: + if self.model_update_group is None: + return + t0 = time.time() + # Prepare the workers for the reload; must complete before any weights are sent. + requests.post( + f"{self.vllm_server_url}/start_weight_update", + json={"is_checkpoint_format": True}, + timeout=1800, + ) + # The /update_weights POST drives the workers' blocking NCCL recv, so it runs on a thread + # concurrently with the trainer-side broadcast. + t_update = threading.Thread( + target=requests.post, + args=(f"{self.vllm_server_url}/update_weights",), + kwargs={"json": {"update_info": self._weight_update_info}, "timeout": 1800}, + ) + t_update.start() + NCCLWeightTransferEngine.trainer_send_weights( + iterator=iterator, + trainer_args=NCCLTrainerSendWeightsArgs(group=self.model_update_group, packed=True), + ) + t_update.join() + requests.post(f"{self.vllm_server_url}/finish_weight_update", timeout=1800) + logger.debug(f"[weight_sync] send_weights took {time.time() - t0:.1f}s") + + def pause(self) -> None: + t0 = time.time() + requests.post(f"{self.vllm_server_url}/pause", params={"mode": "keep"}) + logger.debug(f"[weight_sync] pause HTTP took {time.time() - t0:.1f}s") + + def resume(self) -> None: + t0 = time.time() + requests.post(f"{self.vllm_server_url}/resume") + logger.debug(f"[weight_sync] resume HTTP took {time.time() - t0:.1f}s") + + def destroy(self) -> None: + if self.model_update_group is None: + return + self.model_update_group.group.store = None + self.model_update_group.group.socket = None + self.model_update_group = None diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bco/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bco/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3a6871ca60e002b21ac74a69e4113ded3391f622 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bco/__init__.py @@ -0,0 +1,16 @@ +# Copyright 2020-2026 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. + +from .bco_config import BCOConfig +from .bco_trainer import BCOTrainer diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bco/bco_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bco/bco_config.py new file mode 100644 index 0000000000000000000000000000000000000000..d804f73938c75c3a8f6ba7eac3611febcc1d5bfd --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bco/bco_config.py @@ -0,0 +1,164 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Any + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class BCOConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`experimental.bco.BCOTrainer`]. + + This class includes only the parameters that are specific to BCO training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + 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: + max_length (`int` or `None`, *optional*, defaults to `1024`): + Maximum length of the sequences (prompt + completion) in the batch. This argument is required if you want + to use the default data collator. + max_completion_length (`int`, *optional*): + Maximum length of the completion. This argument is required if you want to use the default data collator + and your model is an encoder-decoder. + beta (`float`, *optional*, defaults to `0.1`): + Parameter controlling the deviation from the reference model. Higher β means less deviation from the + reference model. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model and reference model. + generate_during_eval (`bool`, *optional*, defaults to `False`): + If `True`, generates and logs completions from both the model and the reference model to W&B or Comet + during evaluation. + is_encoder_decoder (`bool`, *optional*): + 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. + precompute_ref_log_probs (`bool`, *optional*, defaults to `False`): + Whether to precompute reference model log probabilities for training and evaluation datasets. This is + useful when training without the reference model to reduce the total GPU memory needed. + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the model and + reference model from strings. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] for both the model and reference model. + dataset_num_proc (`int`, *optional*): + Number of processes to use for processing the dataset. + prompt_sample_size (`int`, *optional*, defaults to `1024`): + Number of prompts that are fed to density ratio classifier. + min_density_ratio (`float`, *optional*, defaults to `0.5`): + Minimum value of the density ratio. The estimated density ratio is clamped to this value. + max_density_ratio (`float`, *optional*, defaults to `10.0`): + Maximum value of the density ratio. The estimated density ratio is clamped to this value. + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `5e-7` instead of `5e-5`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=5e-7, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + max_length: int | None = field( + default=1024, + metadata={ + "help": "Maximum length of the sequences (prompt + completion) in the batch. " + "This argument is required if you want to use the default data collator." + }, + ) + max_completion_length: int | None = field( + default=None, + metadata={ + "help": "Maximum length of the completion. This argument is required if you want to use the " + "default data collator and your model is an encoder-decoder." + }, + ) + beta: float = field( + default=0.1, + metadata={ + "help": "Parameter controlling the deviation from the reference model. " + "Higher β means less deviation from the reference model." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the model and reference model."}, + ) + generate_during_eval: bool = field( + default=False, + metadata={ + "help": "If `True`, generates and logs completions from both the model and the reference model " + "to W&B during evaluation." + }, + ) + is_encoder_decoder: bool | None = field( + default=None, + metadata={ + "help": "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." + }, + ) + precompute_ref_log_probs: bool = field( + default=False, + metadata={ + "help": "Whether to precompute reference model log probabilities for training and evaluation datasets. " + "This is useful when training without the reference model to reduce the total GPU memory " + "needed." + }, + ) + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the " + "model from a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models that ship custom Python code from the Hub. Forwarded to " + "`AutoModelForCausalLM.from_pretrained` for both the model and reference model." + }, + ) + dataset_num_proc: int | None = field( + default=None, + metadata={"help": "Number of processes to use for processing the dataset."}, + ) + prompt_sample_size: int = field( + default=1024, + metadata={"help": "Number of prompts that are fed to density ratio classifier."}, + ) + min_density_ratio: float = field( + default=0.5, + metadata={"help": "Minimum value of the density ratio. The estimated density ratio is clamped to this value."}, + ) + max_density_ratio: float = field( + default=10.0, + metadata={"help": "Maximum value of the density ratio. The estimated density ratio is clamped to this value."}, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bco/bco_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bco/bco_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..ab252ae58584ecf52064d0ca28dad128e939faf0 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bco/bco_trainer.py @@ -0,0 +1,1557 @@ +# Copyright 2020-2026 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 dataclasses +import inspect +import json +import os +import random +import textwrap +from collections import defaultdict +from collections.abc import Callable +from contextlib import contextmanager, nullcontext +from dataclasses import dataclass +from operator import itemgetter +from pathlib import Path +from typing import Any, Literal + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +import torch.nn.functional as F +import transformers +from accelerate import Accelerator, PartialState, logging +from accelerate.utils import is_peft_model, tqdm +from datasets import Dataset +from packaging.version import Version +from torch import autocast +from torch.utils.data import DataLoader, SequentialSampler +from transformers import ( + AutoModelForCausalLM, + BaseImageProcessor, + DataCollator, + FeatureExtractionMixin, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, + TrainingArguments, + is_comet_available, + is_sklearn_available, + is_wandb_available, +) +from transformers.trainer_utils import EvalLoopOutput, has_length +from transformers.utils import is_peft_available + +from ...data_utils import maybe_apply_chat_template, maybe_extract_prompt, maybe_unpair_preference_dataset +from ...import_utils import is_joblib_available +from ...models.utils import prepare_deepspeed +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import disable_dropout_in_model, log_table_to_comet_experiment, selective_log_softmax +from ..utils import DPODataCollatorWithPadding, create_reference_model, pad_to_length, peft_module_casting_to_bf16 +from .bco_config import BCOConfig + + +if is_peft_available(): + from peft import PeftConfig, get_peft_model, prepare_model_for_kbit_training + +if is_wandb_available(): + import wandb + +if is_sklearn_available(): + from sklearn.linear_model import LogisticRegression + +if is_joblib_available(): + import joblib + +logger = logging.get_logger(__name__) + +RUNNING_NAME = "running.json" +CLF_NAME = "clf.pkl" + + +@torch.no_grad() +def get_global_statistics( + accelerator, xs: torch.Tensor, mask=None, device="cpu" +) -> tuple[torch.Tensor, torch.Tensor, int]: + """ + Computes element-wise mean and variance of the tensor across processes. Reference: + https://github.com/OpenLMLab/MOSS-RLHF/blob/40b91eb2f2b71b16919addede0341d2bef70825d/utils.py#L57C1-L73C75 + """ + xs = xs.to(accelerator.device) + sum_and_count = torch.tensor([xs.sum(), (xs.numel() if mask is None else mask.sum())], device=xs.device) + sum_and_count = accelerator.reduce(sum_and_count) + global_sum, count = sum_and_count + global_mean = global_sum / count + + sum_var = torch.sum(((xs - global_mean) ** 2).mul(1 if mask is None else mask)) + sum_var = accelerator.reduce(sum_var) + global_var = sum_var / count + + return global_mean.to(device), global_var.to(device), count.item() + + +@dataclass +class RunningMoments: + """ + Calculates the running mean and standard deviation of a data stream. Reference: + https://github.com/OpenLMLab/MOSS-RLHF/blob/40b91eb2f2b71b16919addede0341d2bef70825d/utils.py#L75 + """ + + accelerator: Accelerator + mean: float = 0 + std: float = 1 + var: float = 1 + count: float = 1e-24 + + @torch.no_grad() + def update(self, xs: torch.Tensor) -> tuple[float, float]: + """ + Updates running moments from batch's moments computed across ranks + """ + if self.accelerator.use_distributed: + xs_mean, xs_var, xs_count = get_global_statistics(self.accelerator, xs) + else: + xs_count = xs.numel() + xs_var, xs_mean = torch.var_mean(xs, unbiased=False) + xs_mean, xs_var = xs_mean.float(), xs_var.float() + + delta = xs_mean - self.mean + tot_count = self.count + xs_count + + new_sum = xs_var * xs_count + # correct old_sum deviation accounting for the new mean + old_sum = self.var * self.count + delta**2 * self.count * xs_count / tot_count + tot_sum = old_sum + new_sum + + self.mean += (delta * xs_count / tot_count).item() + new_var = tot_sum / tot_count + self.std = (new_var * tot_count / (tot_count - 1)).float().sqrt().item() + self.var = new_var.item() + self.count = tot_count + + return xs_mean.item(), (xs_var * xs_count / (xs_count - 1)).float().sqrt().item() + + def save_to_json(self, json_path: str): + """Save the content of this instance in JSON format inside `json_path`.""" + # save everything except accelerator + if self.accelerator.is_main_process: + save_dict = dataclasses.asdict(self, dict_factory=lambda x: {k: v for (k, v) in x if k != "accelerator"}) + json_string = json.dumps(save_dict, indent=2, sort_keys=True) + "\n" + with open(json_path, "w", encoding="utf-8") as f: + f.write(json_string) + + @classmethod + def load_from_json(cls, accelerator: Accelerator, json_path: str): + """Create an instance from the content of `json_path`.""" + # load everything except accelerator + with open(json_path, encoding="utf-8") as f: + text = f.read() + return cls(accelerator=accelerator, **json.loads(text)) + + +def _tokenize( + batch: dict[str, list[Any]], + tokenizer: PreTrainedTokenizerBase, + embedding_tokenizer: PreTrainedTokenizerBase | None = None, +) -> dict[str, list[Any]]: + """Tokenize a batch from a BCO specific dataset.""" + prompt_tokenized = tokenizer(batch["prompt"], add_special_tokens=False) + prompt_input_ids = prompt_tokenized["input_ids"] + prompt_attention_mask = prompt_tokenized["attention_mask"] + prompt_and_completion = [ + prompt + completion for prompt, completion in zip(batch["prompt"], batch["completion"], strict=True) + ] + full_tokenized = tokenizer(prompt_and_completion, add_special_tokens=False) + full_input_ids = full_tokenized["input_ids"] + full_attention_mask = full_tokenized["attention_mask"] + + answer_input_ids = [f[len(p) :] for f, p in zip(full_input_ids, prompt_input_ids, strict=True)] + answer_attention_mask = [f[len(p) :] for f, p in zip(full_attention_mask, prompt_attention_mask, strict=True)] + + # Concat tokens to form `enc(a) + enc(a + b)[len(enc(a)):]` + full_concat_input_ids = [np.concatenate([p, a]) for p, a in zip(prompt_input_ids, answer_input_ids, strict=True)] + # Prepare input tokens for token by token comparison + full_input_ids = [np.array(f) for f in full_input_ids] + for full, concat in zip(full_input_ids, full_concat_input_ids, strict=True): + if len(full) != len(concat): + raise ValueError( + "The elements in 'full_input_ids' and 'full_concat_input_ids' must have the same pairwise length." + ) + + # On some tokenizers, like Llama-2 tokenizer, there are occasions where tokens + # can be merged together when tokenizing prompt+answer. This could result + # on the last token from the prompt being different when tokenized on its own + # vs when done as prompt+answer. + response_token_ids_start_idx = [len(p) for p in prompt_input_ids] + + # If tokenized prompt is different than both prompt+answer, then it means the + # last token has changed due to merging. + for idx, (p, f, r) in enumerate(zip(prompt_input_ids, full_input_ids, response_token_ids_start_idx, strict=True)): + if not np.array_equal(p, f[:r]): + response_token_ids_start_idx[idx] -= 1 + + prompt_input_ids = [f[:r] for f, r in zip(full_input_ids, response_token_ids_start_idx, strict=True)] + prompt_attention_mask = [f[:r] for f, r in zip(full_attention_mask, response_token_ids_start_idx, strict=True)] + + for p, m in zip(prompt_input_ids, prompt_attention_mask, strict=True): + if len(p) != len(m): + raise ValueError("Prompt input ids and attention mask should have the same length.") + + answer_input_ids = [f[r:] for f, r in zip(full_input_ids, response_token_ids_start_idx, strict=True)] + answer_attention_mask = [f[r:] for f, r in zip(full_attention_mask, response_token_ids_start_idx, strict=True)] + + output = dict( + prompt_input_ids=prompt_input_ids, + prompt_attention_mask=prompt_attention_mask, + answer_input_ids=answer_input_ids, + answer_attention_mask=answer_attention_mask, + ) + + if embedding_tokenizer is not None: + embedding_tokenized = embedding_tokenizer(batch["prompt"], add_special_tokens=False) + + output.update( + { + "embedding_input_ids": embedding_tokenized["input_ids"], + "embedding_attention_mask": embedding_tokenized["attention_mask"], + } + ) + + return output + + +def _process_tokens(example: dict[str, Any], model: "PreTrainedModel" = None, **kwargs) -> dict: + """Process tokens of a BCO specific dataset. + + At this stage, we don't convert to PyTorch tensors yet; we just handle the truncation in case the prompt + + completion responses is/are too long. First we truncate the prompt; if we're still too long, we truncate the + completion. + + We also create the labels for the completion responses, which are of length equal to the sum of the length of the + prompt and the completion response, with `-100` for the prompt tokens. + """ + prompt = example["prompt"] + completion = example["completion"] + + batch = { + f"{kwargs['prefix']}prompt": prompt, + f"{kwargs['prefix']}completion": completion, + f"{kwargs['prefix']}label": example["label"], + } + + if not kwargs["is_encoder_decoder"]: + # Check issues below for more details + # 1. https://github.com/huggingface/trl/issues/907 + # 2. https://github.com/EleutherAI/lm-evaluation-harness/pull/531#issuecomment-1595586257 + # 3. https://github.com/LianjiaTech/BELLE/issues/337 + + if not isinstance(prompt, str): + raise ValueError(f"prompt should be an str but got {type(prompt)}") + + if not isinstance(completion, str): + raise ValueError(f"completion should be an str but got {type(completion)}") + + # keys of format prompt_* refers to just the prompt and answer_* refers to just the answer + all_tokens = { + "prompt_input_ids": example["prompt_input_ids"], + "prompt_attention_mask": example["prompt_attention_mask"], + "answer_input_ids": example["answer_input_ids"], + "answer_attention_mask": example["answer_attention_mask"], + } + + # calculate max length by checking if BOS/EOS is already there + max_length = kwargs["max_length"] + bos_token_id = kwargs["tokenizer"].bos_token_id + eos_token_id = kwargs["tokenizer"].eos_token_id + if bos_token_id != all_tokens["prompt_input_ids"][0]: + max_length -= 1 + if eos_token_id != all_tokens["answer_input_ids"][-1]: + max_length -= 1 + + # if combined sequence is too long (> max_length - 1 for BOS token - 1 for EOS), truncate the response + if len(all_tokens["prompt_input_ids"]) + len(all_tokens["answer_input_ids"]) > max_length: + for k in ["answer_input_ids", "answer_attention_mask"]: + all_tokens[k] = all_tokens[k][: max_length - len(all_tokens["prompt_input_ids"])] + + # all input_ids and attention mask as is. We then check if we need to add BOS/EOS tokens + batch[f"{kwargs['prefix']}prompt_input_ids"] = all_tokens["prompt_input_ids"] + batch[f"{kwargs['prefix']}prompt_attention_mask"] = all_tokens["prompt_attention_mask"] + batch[f"{kwargs['prefix']}completion_input_ids"] = ( + all_tokens["prompt_input_ids"] + all_tokens["answer_input_ids"] + ) + batch[f"{kwargs['prefix']}completion_attention_mask"] = ( + all_tokens["prompt_attention_mask"] + all_tokens["answer_attention_mask"] + ) + + # add BOS, which affects both prompt and the full completion + if bos_token_id is not None: + if len(all_tokens["prompt_input_ids"]) == 0 or bos_token_id != all_tokens["prompt_input_ids"][0]: + batch[f"{kwargs['prefix']}prompt_input_ids"] = [bos_token_id] + batch[ + f"{kwargs['prefix']}prompt_input_ids" + ] + batch[f"{kwargs['prefix']}prompt_attention_mask"] = [1] + batch[ + f"{kwargs['prefix']}prompt_attention_mask" + ] + batch[f"{kwargs['prefix']}completion_input_ids"] = [bos_token_id] + batch[ + f"{kwargs['prefix']}completion_input_ids" + ] + batch[f"{kwargs['prefix']}completion_attention_mask"] = [1] + batch[ + f"{kwargs['prefix']}completion_attention_mask" + ] + # add EOS, which affects only the full completion + if len(all_tokens["answer_input_ids"]) == 0 or eos_token_id != all_tokens["answer_input_ids"][-1]: + batch[f"{kwargs['prefix']}completion_input_ids"] = batch[f"{kwargs['prefix']}completion_input_ids"] + [ + eos_token_id + ] + batch[f"{kwargs['prefix']}completion_attention_mask"] = batch[ + f"{kwargs['prefix']}completion_attention_mask" + ] + [1] + + batch[f"{kwargs['prefix']}completion_labels"] = batch[f"{kwargs['prefix']}completion_input_ids"][:] + batch[f"{kwargs['prefix']}completion_labels"][: len(batch[f"{kwargs['prefix']}prompt_input_ids"])] = [ + -100 + ] * len(batch[f"{kwargs['prefix']}prompt_input_ids"]) + else: + completion_tokens = kwargs["tokenizer"]( + completion, truncation=True, max_length=kwargs["max_completion_length"], add_special_tokens=True + ) + prompt_tokens = kwargs["tokenizer"](prompt, add_special_tokens=True) + + batch[f"{kwargs['prefix']}prompt_input_ids"] = prompt_tokens["input_ids"] + batch[f"{kwargs['prefix']}prompt_attention_mask"] = prompt_tokens["attention_mask"] + + batch[f"{kwargs['prefix']}completion_labels"] = completion_tokens["input_ids"] + batch[f"{kwargs['prefix']}completion_attention_mask"] = completion_tokens["attention_mask"] + if model is not None and hasattr(model, "prepare_decoder_input_ids_from_labels"): + batch[f"{kwargs['prefix']}completion_decoder_input_ids"] = model.prepare_decoder_input_ids_from_labels( + labels=torch.tensor(batch["completion_labels"]) + ) + + return batch + + +class BCOTrainer(_BaseTrainer): + r""" + Initialize BCOTrainer from [BCO](https://huggingface.co/papers/2404.04656) paper. + + Args: + model ([`~transformers.PreTrainedModel`]): + The model to train, preferably an [`~transformers.AutoModelForSequenceClassification`]. + ref_model ([`~transformers.PreTrainedModel`]): + Hugging Face transformer model with a casual language modelling head. Used for implicit reward computation + and loss. If no reference model is provided, the trainer will create a reference model with the same + architecture as the model to be optimized. + args ([`experimental.bco.BCOConfig`]): + The arguments to use for training. + train_dataset ([`~datasets.Dataset`]): + The dataset to use for training. + eval_dataset ([`~datasets.Dataset`]): + The dataset to use for evaluation. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. If provided, will be used to automatically process the inputs + for the model, and it will be saved along the model to make it easier to rerun an interrupted training or + reuse the fine-tuned model. + data_collator ([`~transformers.DataCollator`], *optional*): + The data collator to use for training. If None is specified, the default data collator + ([`experimental.utils.DPODataCollatorWithPadding`]) will be used which will pad the sequences to the + maximum length of the sequences in the batch, given a dataset of paired sequences. + model_init (`Callable[[], transformers.PreTrainedModel]`): + The model initializer to use for training. If None is specified, the default model initializer will be + used. + callbacks (`list[transformers.TrainerCallback]`): + The callbacks to use for training. + optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): + The optimizer and scheduler to use for training. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`): + The function to use to preprocess the logits before computing the metrics. + peft_config ([`~peft.PeftConfig`], *optional*): + The PEFT configuration to use for training. If you pass a PEFT configuration, the model will be wrapped in + a PEFT model. + compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*): + The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to + metric values. + model_adapter_name (`str`, defaults to `None`): + Name of the train target PEFT adapter, when using LoRA with multiple adapters. + ref_adapter_name (`str`, defaults to `None`): + Name of the reference PEFT adapter, when using LoRA with multiple adapters. + embedding_func (`Callable`, *optional*): + Function to compute prompt embeddings, used to train the underlying distribution matching (UDM) classifier + when the desirable and undesirable datasets have divergent prompt distributions. Requires the scikit-learn + and joblib libraries. + embedding_tokenizer ([`~transformers.PreTrainedTokenizerBase`], *optional*): + Tokenizer used to prepare prompts for `embedding_func`. + """ + + _tag_names = ["trl", "bco"] + _name = "BCO" + _paper = { + "title": "Binary Classifier Optimization for Large Language Model Alignment", + "id": "2404.04656", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @article{jung2024binary, + title = {{Binary Classifier Optimization for Large Language Model Alignment}}, + author = {Seungjae Jung and Gunsoo Han and Daniel Wontae Nam and Kyoung{-}Woon On}, + year = 2024, + eprint = {arXiv:2404.04656} + }"""), + } + + def __init__( + self, + model: PreTrainedModel | nn.Module | str = None, + ref_model: PreTrainedModel | nn.Module | str | None = None, + args: BCOConfig = None, + train_dataset: Dataset | None = None, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + processing_class: PreTrainedTokenizerBase + | BaseImageProcessor + | FeatureExtractionMixin + | ProcessorMixin + | None = None, + data_collator: DataCollator | None = None, + model_init: Callable[[], PreTrainedModel] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + peft_config: "PeftConfig | None" = None, + compute_metrics: Callable[[EvalLoopOutput], dict] | None = None, + model_adapter_name: str | None = None, + ref_adapter_name: str | None = None, + embedding_func: Callable | None = None, + embedding_tokenizer: PreTrainedTokenizerBase | None = None, + ): + if embedding_func is not None and not (is_sklearn_available() and is_joblib_available()): + raise ImportError( + "BCOTrainer with UDM requires the scikit-learn and joblib libraries. Please install it with `pip install scikit-learn joblib`." + ) + + if type(args) is TrainingArguments: + raise ValueError("Please use `BCOConfig` instead `TrainingArguments`.") + + if train_dataset is None: + raise ValueError("`train_dataset` is required") + + if not isinstance(model, str) and model is not None and ref_model is model: + raise ValueError( + "`model` and `ref_model` cannot be the same object. If you want `ref_model` to be the " + "same as `model`, you must mass a copy of it, or `None` if you use peft." + ) + + if args.model_init_kwargs is None: + model_init_kwargs = {} + elif not isinstance(model, str): + raise ValueError("You passed model_kwargs to the BCOTrainer. But your model is already instantiated.") + else: + model_init_kwargs = args.model_init_kwargs + dtype = model_init_kwargs.get("dtype", "auto") + if dtype is not None: + # Convert to `torch.dtype` if an str is passed + if isinstance(dtype, str) and dtype != "auto": + dtype = getattr(torch, dtype) + if dtype != "auto" and not isinstance(dtype, torch.dtype): + raise ValueError( + f"Invalid `dtype` passed to the BCOConfig. Expected a string with either `torch.dtype` or 'auto', but got {dtype}." + ) + model_init_kwargs["dtype"] = dtype + model_init_kwargs["device_map"] = model_init_kwargs.get("device_map", "auto") + + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + + if isinstance(model, str): + model = AutoModelForCausalLM.from_pretrained(model, **model_init_kwargs) + + if isinstance(ref_model, str): + ref_model = AutoModelForCausalLM.from_pretrained(ref_model, **model_init_kwargs) + + # PEFT + # Initialize this variable to False. This helps tracking the case when `peft_module_casting_to_bf16` + # has been called in order to properly call autocast if needed. + self._peft_has_been_casted_to_bf16 = False + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first " + "merge and unload the existing adapter, save the resulting base model, and then pass that base " + "model along with the new `peft_config` to the trainer." + ) + + if getattr(model, "is_loaded_in_8bit", False) or getattr(model, "is_loaded_in_4bit", False): + _support_gc_kwargs = hasattr( + args, "gradient_checkpointing_kwargs" + ) and "gradient_checkpointing_kwargs" in list( + inspect.signature(prepare_model_for_kbit_training).parameters + ) + + prepare_model_kwargs = {"use_gradient_checkpointing": args.gradient_checkpointing} + + if _support_gc_kwargs: + prepare_model_kwargs["gradient_checkpointing_kwargs"] = args.gradient_checkpointing_kwargs + + model = prepare_model_for_kbit_training(model, **prepare_model_kwargs) + elif args.gradient_checkpointing: + # For backward compatibility with older versions of transformers + if hasattr(model, "enable_input_require_grads"): + model.enable_input_require_grads() + else: + + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + # get peft model with the given config + model = get_peft_model(model, peft_config) + if args.bf16 and getattr(model, "is_loaded_in_4bit", False): + peft_module_casting_to_bf16(model) + # If args.bf16 we need to explicitly call `generate` with torch amp autocast context manager + self._peft_has_been_casted_to_bf16 = True + + # For models that use gradient_checkpointing, we need to attach a hook that enables input + # to explicitly have `requires_grad=True`, otherwise training will either silently + # fail or completely fail. + elif args.gradient_checkpointing: + # For backward compatibility with older versions of transformers + if hasattr(model, "enable_input_require_grads"): + model.enable_input_require_grads() + else: + + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + if args.generate_during_eval and not (is_wandb_available() or is_comet_available()): + raise ValueError( + "`generate_during_eval=True` requires Weights and Biases or Comet to be installed." + " Please install `wandb` or `comet-ml` to resolve." + ) + + if model is not None: + self.is_encoder_decoder = model.config.is_encoder_decoder + elif args.is_encoder_decoder is None: + raise ValueError("When no model is provided, you need to pass the parameter is_encoder_decoder.") + else: + self.is_encoder_decoder = args.is_encoder_decoder + + self.model_adapter_name = model_adapter_name + self.ref_adapter_name = ref_adapter_name + + if ref_model: + self.ref_model = ref_model + elif is_peft_model(model) or args.precompute_ref_log_probs: + # The `model` with adapters turned off will be used as the reference model + self.ref_model = None + else: + self.ref_model = create_reference_model(model) + + if processing_class is None: + raise ValueError( + "max_length or a processing_class must be specified when using the default DPODataCollatorWithPadding" + ) + if args.max_length is None: + logger.warning( + "When using DPODataCollatorWithPadding, you should set `max_length` in the `BCOConfig`. " + "It will be set to `512` by default, but you should do it yourself in the future.", + ) + max_length = 512 + if args.max_length is not None: + max_length = args.max_length + + max_completion_length = None + if args.max_completion_length is None and self.is_encoder_decoder: + logger.warning( + "When using DPODataCollatorWithPadding with an encoder decoder architecture, you should set `max_completion_length` in the BCOTrainer's init" + " it will be set to `128` by default, but you should do it yourself in the future.", + ) + max_completion_length = 128 + if args.max_completion_length is not None and self.is_encoder_decoder: + max_completion_length = args.max_completion_length + + if data_collator is None: + data_collator = DPODataCollatorWithPadding( + pad_token_id=processing_class.pad_token_id, + is_encoder_decoder=self.is_encoder_decoder, + ) + + if args.remove_unused_columns: + args.remove_unused_columns = False + # warn users + logger.warning( + "When using DPODataCollatorWithPadding, you should set `remove_unused_columns=False` in your BCOConfig" + " we have set it for you, but you should do it yourself in the future.", + ) + + self.use_dpo_data_collator = True + else: + self.use_dpo_data_collator = False + + # Disable dropout in the model and reference model + if args.disable_dropout: + disable_dropout_in_model(model) + if self.ref_model is not None: + disable_dropout_in_model(self.ref_model) + + self.max_length = max_length + self.generate_during_eval = args.generate_during_eval + self.max_completion_length = max_completion_length + self.precompute_ref_log_probs = args.precompute_ref_log_probs + + # Since ref_logs are precomputed on the first call to get_train/eval_dataloader + # keep track of first called to avoid computation of future calls + self._precomputed_train_ref_log_probs = False + self._precomputed_eval_ref_log_probs = False + + # metric + self._stored_metrics = defaultdict(lambda: defaultdict(list)) + + # BCO parameter + self.beta = args.beta + self.aux_loss_enabled = getattr(model.config, "output_router_logits", False) + self.aux_loss_coef = getattr(model.config, "router_aux_loss_coef", 0.0) + if self.aux_loss_enabled and self.aux_loss_coef == 0.0: + logger.warning( + "You set `output_router_logits` to `True` in the model config, but `router_aux_loss_coef` is set to " + "`0.0`, meaning the auxiliary loss will not be used. Either set `router_aux_loss_coef` to a value " + "greater than `0.0`, or set `output_router_logits` to `False` if you don't want to use the auxiliary " + "loss.", + ) + + # Underlying Distribution Matching argument + self.embedding_func = embedding_func + self.embedding_tokenizer = embedding_tokenizer + + with PartialState().main_process_first(): + # Extract the prompt if needed + train_dataset = train_dataset.map( + maybe_extract_prompt, num_proc=args.dataset_num_proc, desc="Extracting prompt from train dataset" + ) + # Unpair the dataset if needed + train_dataset = maybe_unpair_preference_dataset( + train_dataset, args.dataset_num_proc, desc="Unpairing train dataset" + ) + # Apply the chat template if needed + train_dataset = train_dataset.map( + maybe_apply_chat_template, + fn_kwargs={"processing_class": processing_class}, + num_proc=args.dataset_num_proc, + ) + if eval_dataset is not None: + # Extract the prompt if needed + eval_dataset = eval_dataset.map( + maybe_extract_prompt, num_proc=args.dataset_num_proc, desc="Extracting prompt from eval dataset" + ) + # Unpair the dataset if needed + eval_dataset = maybe_unpair_preference_dataset( + eval_dataset, args.dataset_num_proc, desc="Unpairing eval dataset" + ) + eval_dataset = eval_dataset.map( + maybe_apply_chat_template, + fn_kwargs={"processing_class": processing_class}, + num_proc=args.dataset_num_proc, + ) + + # Tokenize and prepare the training datasets + train_dataset = train_dataset.map( + _tokenize, + batched=True, + fn_kwargs={"tokenizer": processing_class, "embedding_tokenizer": self.embedding_tokenizer}, + num_proc=args.dataset_num_proc, + desc="Tokenizing train dataset", + ) + + # Prepare the datasets + fn_kwargs = { + "prefix": "", + "is_encoder_decoder": self.is_encoder_decoder, + "tokenizer": processing_class, + "max_length": self.max_length, + "max_completion_length": self.max_completion_length, + } + train_dataset = train_dataset.map( + _process_tokens, + fn_kwargs=fn_kwargs, + num_proc=args.dataset_num_proc, + desc="Processing tokenized train dataset", + ) + + if eval_dataset is not None: + # Tokenize + eval_dataset = eval_dataset.map( + _tokenize, + fn_kwargs={"tokenizer": processing_class, "embedding_tokenizer": self.embedding_tokenizer}, + batched=True, + num_proc=args.dataset_num_proc, + desc="Tokenizing eval dataset", + ) + + # Process + fn_kwargs = { + "prefix": "", + "is_encoder_decoder": self.is_encoder_decoder, + "tokenizer": processing_class, + "max_length": self.max_length, + "max_completion_length": self.max_completion_length, + } + eval_dataset = eval_dataset.map( + _process_tokens, + fn_kwargs=fn_kwargs, + num_proc=args.dataset_num_proc, + desc="Processing tokenized eval dataset", + ) + + desirable = train_dataset.filter( + lambda x: x["label"], num_proc=args.dataset_num_proc, desc="Filtering desirable examples" + ) + undesirable = train_dataset.filter( + lambda x: not x["label"], num_proc=args.dataset_num_proc, desc="Filtering undesirable examples" + ) + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + model_init=model_init, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the + # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set + # self.model_accepts_loss_kwargs to False to enable scaling. + self.model_accepts_loss_kwargs = False + + # Add tags for models that have been loaded with the correct transformers version + if hasattr(self.model, "add_model_tags"): + self.model.add_model_tags(self._tag_names) + + if not hasattr(self, "accelerator"): + raise AttributeError( + "Your `Trainer` does not have an `accelerator` object. Consider upgrading `transformers`." + ) + + # Deepspeed Zero-3 does not support precompute_ref_log_probs + if self.is_deepspeed_enabled: + if self.accelerator.state.deepspeed_plugin.zero_stage == 3 and self.precompute_ref_log_probs: + raise ValueError( + "You cannot use `precompute_ref_log_probs=True` with Deepspeed ZeRO-3. Please set `precompute_ref_log_probs=False`." + ) + + if self.ref_model is None: + if not (is_peft_model(model) or self.precompute_ref_log_probs): + raise ValueError( + "No reference model and model is not a Peft model. Try setting `precompute_ref_log_probs=True`" + ) + else: + if self.is_deepspeed_enabled: + self.ref_model = prepare_deepspeed(self.ref_model, self.accelerator) + else: + self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True) + + self.running = RunningMoments(accelerator=self.accelerator) + + if self.embedding_func is None or args.resume_from_checkpoint: + return + + chosen_embeddings = self._get_sample_prompt_embeddings(desirable, sample_size=self.args.prompt_sample_size) + rejected_embeddings = self._get_sample_prompt_embeddings(undesirable, sample_size=self.args.prompt_sample_size) + + embeddings = torch.cat((chosen_embeddings, rejected_embeddings), dim=0) + labels = torch.cat( + (torch.ones_like(chosen_embeddings[:, 0]), torch.zeros_like(rejected_embeddings[:, 0])), dim=0 + ) + + self.clf = LogisticRegression(class_weight="balanced").fit( + embeddings.cpu().float().numpy(), labels.cpu().numpy() + ) + chosen_mean = self.clf.score( + chosen_embeddings.cpu().float().numpy(), torch.ones_like(chosen_embeddings[:, 0]).cpu().numpy() + ) + rejected_mean = self.clf.score( + rejected_embeddings.cpu().float().numpy(), torch.zeros_like(rejected_embeddings[:, 0]).cpu().numpy() + ) + logger.info(f"UDM classifier training scores: chosen: {chosen_mean}, rejected: {rejected_mean}") + + @property + def match_underlying_distribution(self): + return self.embedding_func is not None and self.embedding_tokenizer is not None + + def _get_chosen_prob(self, prompt_embeddings: torch.FloatTensor) -> torch.FloatTensor: + """ + Calculates the probability if the given prompt embedding is from desirable dataset. This function calculates + the probability in the process and ensemble across processes. + """ + dtype = prompt_embeddings.dtype + device = prompt_embeddings.device + rank = self.accelerator.process_index + + padded_prompt_embeddings = self.accelerator.pad_across_processes( + prompt_embeddings, pad_index=self.embedding_tokenizer.pad_token_id + ) + sample_size = padded_prompt_embeddings.shape[0] + nonzero = padded_prompt_embeddings.mean(dim=1) != self.embedding_tokenizer.pad_token_id + prompt_embeddings = self.accelerator.gather(padded_prompt_embeddings) + + # cannot predict for all empty values + if prompt_embeddings.shape[0] == 0: + return torch.tensor([], device=device, dtype=dtype) + + prob = self.clf.predict_proba(prompt_embeddings.cpu().float().numpy())[:, 1] + prob = torch.as_tensor(prob, dtype=dtype, device=device) + prob = self.accelerator.reduce(prob, reduction="mean") + + prob = prob[sample_size * rank : sample_size * (rank + 1)] + prob = prob[nonzero] + + return prob + + def _vectorize_prompt(self, input_ids: torch.LongTensor, attention_mask: torch.LongTensor) -> torch.FloatTensor: + """ + Replaces processing_class.pad_token_id to embedding_tokenizer.pad_token_id and applies self.embedding_func + """ + input_ids = torch.where( + input_ids == self.processing_class.pad_token_id, + self.embedding_tokenizer.pad_token_id, + input_ids, + ) + + with torch.no_grad(): + embeddings = self.embedding_func( + input_ids=input_ids, + attention_mask=attention_mask, + ) + + return embeddings + + def _get_prompt_embeddings( + self, batch: dict[str, list | torch.LongTensor] + ) -> tuple[torch.FloatTensor, torch.FloatTensor]: + """Extract embeddings from frozen embedding model""" + + if not self.match_underlying_distribution: + return None, None + + embeddings = self._vectorize_prompt( + input_ids=batch["embedding_input_ids"], + attention_mask=batch["embedding_attention_mask"], + ) + + labels = torch.tensor(batch["label"], dtype=torch.bool, device=embeddings.device) + chosen_idx = torch.where(labels)[0] + rejected_idx = torch.where(~labels)[0] + + chosen_embeddings = embeddings[chosen_idx, ...] + rejected_embeddings = embeddings[rejected_idx, ...] + + return (chosen_embeddings, rejected_embeddings) + + def _get_sample_prompt_embeddings(self, dataset: Dataset, sample_size: int = 512) -> torch.FloatTensor: + """ + Sample instances from dataset and get prompt embeddings. Used for density ratio classifier training. + """ + n_samples = min(len(dataset), sample_size) + rand_indices = np.random.choice(len(dataset), size=(n_samples,)) + + embedding_dataset = dataset.select(rand_indices) + + dataloader_params = { + "batch_size": self.args.per_device_train_batch_size, + "collate_fn": self.data_collator, + "num_workers": self.args.dataloader_num_workers, + "pin_memory": self.args.dataloader_pin_memory, + "shuffle": False, + } + + # prepare dataloader + data_loader = self.accelerator.prepare(DataLoader(embedding_dataset, **dataloader_params)) + + with torch.no_grad(): + all_embeddings = torch.empty(0) + for padded_batch in tqdm(iterable=data_loader, desc="Building sample prompt embeddings"): + embeddings = self._vectorize_prompt( + input_ids=padded_batch["embedding_input_ids"], + attention_mask=padded_batch["embedding_attention_mask"], + ) + embeddings = self.accelerator.gather_for_metrics(embeddings) + all_embeddings = torch.cat((all_embeddings, embeddings.cpu())) + + return all_embeddings + + def _save_optimizer_and_scheduler(self, output_dir): + output_dir = output_dir if output_dir is not None else self.args.output_dir + super()._save_optimizer_and_scheduler(output_dir) + + if self.accelerator.is_main_process: + # When saving optimizer and scheduler to checkpoint, save also the running delta object. + self.running.save_to_json(os.path.join(output_dir, RUNNING_NAME)) + + if self.match_underlying_distribution: + joblib.dump(self.clf, os.path.join(output_dir, CLF_NAME), compress=True) + + def _load_optimizer_and_scheduler(self, checkpoint): + if checkpoint is None: + logger.warning_once(f"Missing Checkpoint {checkpoint}") + return + + super()._load_optimizer_and_scheduler(checkpoint) + + # when loading optimizer and scheduler from checkpoint, also load the running delta object. + running_file = os.path.join(checkpoint, RUNNING_NAME) + if os.path.isfile(running_file): + self.running = RunningMoments.load_from_json(self.accelerator, running_file) + + if self.match_underlying_distribution: + clf_file = os.path.join(checkpoint, CLF_NAME) + if os.path.isfile(clf_file): + self.clf = joblib.load(clf_file) + + @contextmanager + def null_ref_context(self): + """Context manager for handling null reference model (that is, peft adapter manipulation).""" + with ( + self.accelerator.unwrap_model(self.model).disable_adapter() + if is_peft_model(self.model) and not self.ref_adapter_name + else nullcontext() + ): + if self.ref_adapter_name: + self.model.set_adapter(self.ref_adapter_name) + yield + if self.ref_adapter_name: + self.model.set_adapter(self.model_adapter_name or "default") + + def get_train_dataloader(self) -> DataLoader: + """ + Returns the training [`~torch.utils.data.DataLoader`]. + + Subclass of transformers.src.transformers.trainer.get_train_dataloader to precompute `ref_log_probs`. + """ + + if self.precompute_ref_log_probs and not self._precomputed_train_ref_log_probs: + dataloader_params = { + "batch_size": self.args.per_device_train_batch_size, + "collate_fn": self.data_collator, + "num_workers": self.args.dataloader_num_workers, + "pin_memory": self.args.dataloader_pin_memory, + "shuffle": False, + } + + # prepare dataloader + data_loader = self.accelerator.prepare(DataLoader(self.train_dataset, **dataloader_params)) + reference_completion_logps = [] + + for padded_batch in tqdm(iterable=data_loader, desc="Train dataset reference log probs"): + reference_completion_logp = self.compute_reference_log_probs(padded_batch) + + reference_completion_logp = self.accelerator.gather_for_metrics(reference_completion_logp) + reference_completion_logps.append(reference_completion_logp.cpu()) + + self.train_dataset = self.train_dataset.add_column( + name="reference_logps", column=torch.cat(reference_completion_logps).float().numpy() + ) + + self._precomputed_train_ref_log_probs = True + + return super().get_train_dataloader() + + def get_eval_dataloader(self, eval_dataset: Dataset | None = None) -> DataLoader: + """ + Returns the evaluation [`~torch.utils.data.DataLoader`]. + + Subclass of transformers.src.transformers.trainer.get_eval_dataloader to precompute `ref_log_probs`. + + Args: + eval_dataset (`torch.utils.data.Dataset`, *optional*): + If provided, will override `self.eval_dataset`. If it is a [`~datasets.Dataset`], columns not accepted + by the `model.forward()` method are automatically removed. It must implement `__len__`. + """ + if eval_dataset is None and self.eval_dataset is None: + raise ValueError("Trainer: evaluation requires an eval_dataset.") + eval_dataset = eval_dataset if eval_dataset is not None else self.eval_dataset + + if self.precompute_ref_log_probs and not self._precomputed_eval_ref_log_probs: + dataloader_params = { + "batch_size": self.args.per_device_eval_batch_size, + "collate_fn": self.data_collator, + "num_workers": self.args.dataloader_num_workers, + "pin_memory": self.args.dataloader_pin_memory, + "shuffle": False, + } + + # prepare dataloader + data_loader = self.accelerator.prepare(DataLoader(eval_dataset, **dataloader_params)) + + reference_completion_logps = [] + + for padded_batch in tqdm(iterable=data_loader, desc="Eval dataset reference log probs"): + reference_completion_logp = self.compute_reference_log_probs(padded_batch) + + reference_completion_logp = self.accelerator.gather_for_metrics(reference_completion_logp) + reference_completion_logps.append(reference_completion_logp.cpu()) + + eval_dataset = eval_dataset.add_column( + name="reference_logps", column=torch.cat(reference_completion_logps).float().numpy() + ) + + # Save calculated reference_chosen_logps and reference_rejected_logps to the eval_dataset for subsequent runs + if self.eval_dataset is not None: + self.eval_dataset = eval_dataset + self._precomputed_eval_ref_log_probs = True + + return super().get_eval_dataloader(eval_dataset=eval_dataset) + + def compute_reference_log_probs(self, padded_batch: dict) -> dict: + """Computes log probabilities of the reference model for a single padded batch of a BCO specific dataset.""" + with torch.no_grad(): + if self.ref_model is None: + with self.null_ref_context(): + if self.is_encoder_decoder: + completion_logits = self.model( + padded_batch["prompt_input_ids"], + attention_mask=padded_batch["prompt_attention_mask"], + decoder_input_ids=padded_batch.get("completion_decoder_input_ids"), + labels=padded_batch["completion_labels"], + ).logits + + else: + completion_logits = self.model( + padded_batch["completion_input_ids"], + attention_mask=padded_batch["completion_attention_mask"], + ).logits + + else: + if self.is_encoder_decoder: + completion_logits = self.ref_model( + padded_batch["prompt_input_ids"], + attention_mask=padded_batch["prompt_attention_mask"], + decoder_input_ids=padded_batch.get("completion_decoder_input_ids"), + labels=padded_batch["completion_labels"], + ).logits + + else: + completion_logits = self.ref_model( + padded_batch["completion_input_ids"], attention_mask=padded_batch["completion_attention_mask"] + ).logits + + completion_logps = self.get_batch_logps( + completion_logits, + padded_batch["completion_labels"], + average_log_prob=False, + is_encoder_decoder=self.is_encoder_decoder, + ) + + return completion_logps + + @staticmethod + def get_batch_logps( + logits: torch.FloatTensor, + labels: torch.LongTensor, + average_log_prob: bool = False, + is_encoder_decoder: bool = False, + ) -> torch.FloatTensor: + """Compute the log probabilities of the given labels under the given logits. + + Args: + logits: Logits of the model (unnormalized). Shape: (batch_size, sequence_length, vocab_size) + labels: + Labels for which to compute the log probabilities. Label tokens with a value of `-100` are ignored. + Shape: (batch_size, sequence_length) + average_log_prob: + If True, return the average log probability per (non-masked) token. Otherwise, return the sum of the + log probabilities of the (non-masked) tokens. + is_encoder_decoder: + Whether the model is an encoder-decoder model. If True, the labels are not shifted, and the logits are + assumed to already be aligned with the labels. If False, the labels are shifted to the right by one + position, and the logits are assumed to be aligned with the shifted labels. + + Returns: + A tensor of shape (batch_size,) containing the average/sum log probabilities of the given labels under the + given logits. + """ + if logits.shape[:-1] != labels.shape: + raise ValueError("Logits (batch and sequence length dim) and labels must have the same shape.") + + if not is_encoder_decoder: + labels = labels[:, 1:].clone() + logits = logits[:, :-1, :] + else: + # Fixes end-dec RuntimeError + labels = labels.clone() + + loss_mask = labels != -100 + + # dummy token; we'll ignore the losses on these tokens later + labels[labels == -100] = 0 + + per_token_logps = selective_log_softmax(logits, labels) + + if average_log_prob: + return (per_token_logps * loss_mask).sum(-1) / loss_mask.sum(-1) + else: + return (per_token_logps * loss_mask).sum(-1) + + def forward( + self, model: nn.Module, batch: dict[str, list | torch.LongTensor] + ) -> tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]: + model_kwargs = ( + { + "labels": batch["completion_labels"], + "decoder_input_ids": batch.get("completion_decoder_input_ids"), + } + if self.is_encoder_decoder + else {} + ) + if self.aux_loss_enabled: + model_kwargs["output_router_logits"] = True + + outputs = model( + batch["completion_input_ids"], + attention_mask=batch["completion_attention_mask"], + **model_kwargs, + ) + completion_logits = outputs.logits + + completion_logps = self.get_batch_logps( + completion_logits, + batch["completion_labels"], + average_log_prob=False, + is_encoder_decoder=self.is_encoder_decoder, + ) + + if completion_logps.shape[0] != len(batch["label"]): + raise ValueError( + "There is a mismatch between the number of examples in this batch and the number of " + "examples for which an output sequence was predicted." + ) + + chosen_idx = [i for i in range(completion_logps.shape[0]) if batch["label"][i] is True] + rejected_idx = [i for i in range(completion_logps.shape[0]) if batch["label"][i] is False] + + chosen_logps = completion_logps[chosen_idx, ...] + rejected_logps = completion_logps[rejected_idx, ...] + + chosen_logits = completion_logits[chosen_idx, ...] + rejected_logits = completion_logits[rejected_idx, ...] + + if self.aux_loss_enabled: + return (chosen_logps, rejected_logps, chosen_logits, rejected_logits, outputs.aux_loss) + else: + return (chosen_logps, rejected_logps, chosen_logits, rejected_logits) + + def _get_udm_weight(self, rejected_embeddings: torch.FloatTensor) -> torch.FloatTensor: + prob_desirable = self._get_chosen_prob(rejected_embeddings) + min_ratio = self.args.min_density_ratio + max_ratio = self.args.max_density_ratio + + weight = (prob_desirable / (1 - prob_desirable + 1e-8)).clamp(min=min_ratio, max=max_ratio) + + return weight + + def bco_loss( + self, + policy_chosen_logps: torch.FloatTensor, + policy_rejected_logps: torch.FloatTensor, + reference_chosen_logps: torch.FloatTensor, + reference_rejected_logps: torch.FloatTensor, + chosen_embeddings: torch.FloatTensor | None, + rejected_embeddings: torch.FloatTensor | None, + do_train: bool = True, + ) -> tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]: + """Compute the BCO loss for a batch of policy and reference model log probabilities. + + Args: + policy_chosen_logps: + Log probabilities of the policy model for the chosen responses. Shape: (num(chosen) in batch_size,) + policy_rejected_logps: + Log probabilities of the policy model for the rejected responses. Shape: (num(rejected) in batch_size,) + reference_chosen_logps: + Log probabilities of the reference model for the chosen responses. Shape: (num(chosen) in batch_size,) + reference_rejected_logps: + Log probabilities of the reference model for the rejected responses. Shape: (num(rejected) in + batch_size,) + chosen_embeddings: embeddings of desirable prompts + rejected_embeddings: embeddings of undesirable prompts + do_train: whether to update the running delta value. Default is True. + + Returns: + A tuple of four tensors: (losses, chosen_rewards, rejected_rewards, delta). The losses tensor contains the + BCO loss for each example in the batch. The chosen_rewards and rejected_rewards tensors contain the rewards + for the chosen and rejected responses, respectively. The delta value contains the moving average of all + implicit rewards. + """ + + chosen_logratios = policy_chosen_logps - reference_chosen_logps + chosen_rewards = self.beta * chosen_logratios + + rejected_logratios = policy_rejected_logps - reference_rejected_logps + rejected_rewards = self.beta * rejected_logratios + + if do_train: + self.running.update(torch.cat((chosen_rewards, rejected_rewards), 0).detach()) + delta = torch.as_tensor(self.running.mean, device=chosen_rewards.device) + + chosen_losses = -F.logsigmoid(chosen_rewards - delta) + rejected_losses = -F.logsigmoid(-(rejected_rewards - delta)) + + if self.match_underlying_distribution: + chosen_weight = torch.ones_like(chosen_losses) + rejected_weight = self._get_udm_weight(rejected_embeddings) + + losses = torch.cat((chosen_weight * chosen_losses, rejected_weight * rejected_losses), dim=0) + else: + losses = torch.cat((chosen_losses, rejected_losses), dim=0) + + return losses, chosen_rewards, rejected_rewards, delta + + def get_batch_loss_metrics( + self, + model, + batch: dict[str, list | torch.LongTensor], + do_train: bool = True, + ): + """Compute the BCO loss and other metrics for the given batch of inputs for train or test.""" + metrics = {} + batch = {k: (v.to(self.accelerator.device) if isinstance(v, torch.Tensor) else v) for k, v in batch.items()} + + forward_output = self.forward(model, batch) + ( + policy_chosen_logps, + policy_rejected_logps, + policy_chosen_logits, + policy_rejected_logits, + ) = forward_output[:4] + if self.aux_loss_enabled: + aux_loss = forward_output[4] + + # if reference_logps in batch use them, otherwise use the reference model + if "reference_logps" in batch: + chosen_idx = [i for i in range(batch["reference_logps"].shape[0]) if batch["label"][i] is True] + rejected_idx = [i for i in range(batch["reference_logps"].shape[0]) if batch["label"][i] is False] + + reference_chosen_logps = batch["reference_logps"][chosen_idx, ...] + reference_rejected_logps = batch["reference_logps"][rejected_idx, ...] + else: + with torch.no_grad(): + if self.ref_model is None: + with self.null_ref_context(): + ( + reference_chosen_logps, + reference_rejected_logps, + _, + _, + ) = self.forward(self.model, batch)[:4] + else: + ( + reference_chosen_logps, + reference_rejected_logps, + _, + _, + ) = self.forward(self.ref_model, batch)[:4] + + chosen_embeddings, rejected_embeddings = self._get_prompt_embeddings(batch) + + losses, chosen_rewards, rejected_rewards, delta = self.bco_loss( + policy_chosen_logps, + policy_rejected_logps, + reference_chosen_logps, + reference_rejected_logps, + chosen_embeddings, + rejected_embeddings, + do_train=do_train, + ) + metrics["delta"] = self.accelerator.gather_for_metrics(delta).mean().item() + + num_chosen = torch.Tensor([len(chosen_rewards)]).to(self.accelerator.device) + num_rejected = torch.Tensor([len(rejected_rewards)]).to(self.accelerator.device) + + all_num_chosen = self.accelerator.gather_for_metrics(num_chosen).sum().item() + all_num_rejected = self.accelerator.gather_for_metrics(num_rejected).sum().item() + + if all_num_chosen > 0: + metrics["rewards/chosen_sum"] = ( + self.accelerator.gather_for_metrics(chosen_rewards.nansum()).nansum().item() + ) + metrics["logps/chosen_sum"] = ( + self.accelerator.gather_for_metrics(policy_chosen_logps.nansum()).nansum().item() + ) + metrics["logits/chosen_sum"] = ( + self.accelerator.gather_for_metrics(policy_chosen_logits.nansum()).nansum().item() + ) + metrics["count/chosen"] = all_num_chosen + + if all_num_rejected > 0: + metrics["rewards/rejected_sum"] = ( + self.accelerator.gather_for_metrics(rejected_rewards.nansum()).nansum().item() + ) + metrics["logps/rejected_sum"] = ( + self.accelerator.gather_for_metrics(policy_rejected_logps.nansum()).nansum().item() + ) + metrics["logits/rejected_sum"] = ( + self.accelerator.gather_for_metrics(policy_rejected_logits.nansum()).nansum().item() + ) + metrics["count/rejected"] = all_num_rejected + + loss = losses.nanmean() + if self.aux_loss_enabled: + loss += self.aux_loss_coef * aux_loss + + return loss, metrics + + def compute_loss( + self, + model: PreTrainedModel | nn.Module, + inputs: dict[str, torch.Tensor | Any], + return_outputs=False, + num_items_in_batch=None, + ) -> torch.Tensor | tuple[torch.Tensor, dict[str, torch.Tensor]]: + compute_loss_context_manager = ( + autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext() + ) + + with compute_loss_context_manager: + loss, metrics = self.get_batch_loss_metrics(model, inputs) + + # Make sure to move the loss to the device the original accumulating loss is at back in the `Trainer` class: + loss = loss.to(self.args.device) + # force log the metrics + if self.accelerator.is_main_process: + self.store_metrics(metrics, train_eval="train") + + if return_outputs: + return (loss, metrics) + return loss + + def store_metrics(self, metrics: dict[str, float], train_eval: Literal["train", "eval"] = "train") -> None: + for key, value in metrics.items(): + self._stored_metrics[train_eval][key].append(value) + + def _get_train_sampler(self, dataset: Dataset | None = None) -> torch.utils.data.Sampler | None: + if dataset is None: + dataset = self.train_dataset + if dataset is None or not has_length(dataset): + return None + return SequentialSampler(dataset) + + def generate_from_model_and_ref(self, model, batch: dict[str, torch.LongTensor]) -> tuple[str, str]: + """Generate samples from the model and reference model for the given batch of inputs.""" + + # If one uses `generate_during_eval` with peft + bf16, we need to explicitly call generate with + # the torch amp context manager as some hidden states are silently casted to full precision. + generate_context_manager = ( + autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext() + ) + with generate_context_manager: + policy_output = model.generate( + input_ids=batch["prompt_input_ids"], + attention_mask=batch["prompt_attention_mask"], + max_length=self.max_length, + do_sample=True, + pad_token_id=self.processing_class.pad_token_id, + ) + + # if reference_output in batch use that otherwise use the reference model + if "reference_output" in batch: + reference_output = batch["reference_output"] + else: + if self.ref_model is None: + with self.null_ref_context(): + reference_output = self.model.generate( + input_ids=batch["prompt_input_ids"], + attention_mask=batch["prompt_attention_mask"], + max_length=self.max_length, + do_sample=True, + pad_token_id=self.processing_class.pad_token_id, + ) + else: + reference_output = self.ref_model.generate( + input_ids=batch["prompt_input_ids"], + attention_mask=batch["prompt_attention_mask"], + max_length=self.max_length, + do_sample=True, + pad_token_id=self.processing_class.pad_token_id, + ) + + policy_output = pad_to_length(policy_output, self.max_length, self.processing_class.pad_token_id) + policy_output_decoded = self.processing_class.batch_decode(policy_output, skip_special_tokens=True) + + reference_output = pad_to_length(reference_output, self.max_length, self.processing_class.pad_token_id) + reference_output_decoded = self.processing_class.batch_decode(reference_output, skip_special_tokens=True) + + return policy_output_decoded, reference_output_decoded + + def prediction_step( + self, + model: PreTrainedModel | nn.Module, + inputs: dict[str, torch.Tensor | Any], + prediction_loss_only: bool, + ignore_keys: list[str] | None = None, + ): + if ignore_keys is None: + if hasattr(model, "config"): + ignore_keys = getattr(model.config, "keys_to_ignore_at_inference", []) + else: + ignore_keys = [] + + prediction_context_manager = ( + autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext() + ) + with torch.no_grad(), prediction_context_manager: + loss, metrics = self.get_batch_loss_metrics(model, inputs, do_train=False) + + # force log the metrics + if self.accelerator.is_main_process: + self.store_metrics(metrics, train_eval="eval") + + if prediction_loss_only: + return (loss.detach(), None, None) + + # logits for the chosen and rejected samples from model + logits_dict = {} + if "logits/chosen_sum" in metrics: + logits_dict["eval_logits/chosen"] = metrics["logits/chosen_sum"] + if "logits/rejected_sum" in metrics: + logits_dict["eval_logits/rejected"] = metrics["logits/rejected_sum"] + logits = [v for k, v in logits_dict.items() if k not in ignore_keys] + logits = torch.tensor(logits, device=self.accelerator.device) + labels = torch.zeros(logits.shape[0], device=self.accelerator.device) + + return (loss.detach(), logits, labels) + + def evaluation_loop( + self, + dataloader: DataLoader, + description: str, + prediction_loss_only: bool | None = None, + ignore_keys: list[str] | None = None, + metric_key_prefix: str = "eval", + ) -> EvalLoopOutput: + """ + Overriding built-in evaluation loop to store metrics for each batch. Prediction/evaluation loop, shared by + `Trainer.evaluate()` and `Trainer.predict()`. + + Works both with or without labels. + """ + + # Sample and save to game log if requested (for one batch to save time) + if self.generate_during_eval: + # Generate random indices within the range of the total number of samples + num_samples = len(dataloader.dataset) + random_indices = random.sample(range(num_samples), k=self.args.eval_batch_size) + + # Use dataloader.dataset.select to get the random batch without iterating over the DataLoader + random_batch_dataset = dataloader.dataset.select(random_indices) + random_batch = self.data_collator(random_batch_dataset) + random_batch = self._prepare_inputs(random_batch) + + target_labels = torch.tensor(random_batch["label"], dtype=torch.bool, device=self.accelerator.device) + target_indices = torch.where(~target_labels)[0] + target_batch = { + "prompt_input_ids": random_batch["prompt_input_ids"][target_indices], + "prompt_attention_mask": random_batch["prompt_attention_mask"][target_indices], + "prompt": itemgetter(*target_indices)(random_batch["prompt"]), + } + policy_output_decoded, ref_output_decoded = self.generate_from_model_and_ref(self.model, target_batch) + + table = pd.DataFrame( + columns=["Prompt", "Policy", "Ref Model"], + data=[ + [prompt, pol[len(prompt) :], ref[len(prompt) :]] + for prompt, pol, ref in zip( + target_batch["prompt"], policy_output_decoded, ref_output_decoded, strict=True + ) + ], + ) + if "wandb" in self.args.report_to: + wandb.log({"game_log": wandb.Table(data=table)}) + + if "comet_ml" in self.args.report_to: + log_table_to_comet_experiment( + name="game_log.csv", + table=table, + ) + + # Base evaluation + initial_output = super().evaluation_loop( + dataloader, description, prediction_loss_only, ignore_keys, metric_key_prefix + ) + + return initial_output + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + """ + Log `logs` on the various objects watching training, including stored metrics. + + Args: + logs (`dict[str, float]`): + The values to log. + start_time (`float`, *optional*): + Start time of the training. + """ + # logs either has 'loss' or 'eval_loss' + train_eval = "train" if "loss" in logs else "eval" + # train metrics should have no prefix, eval should have 'eval_' + prefix = "eval_" if train_eval == "eval" else "" + # accumulate average metrics from sums and lengths + for split in ["chosen", "rejected"]: + if f"count/{split}" in self._stored_metrics[train_eval]: + count_sum = torch.Tensor(self._stored_metrics[train_eval][f"count/{split}"]).sum().item() + for metric in ["rewards", "logps", "logits"]: + logs[f"{prefix}{metric}/{split}"] = ( + torch.Tensor(self._stored_metrics[train_eval][f"{metric}/{split}_sum"]).sum().item() + / count_sum + ) + # delete obsolete metric + del self._stored_metrics[train_eval][f"{metric}/{split}_sum"] + del self._stored_metrics[train_eval][f"count/{split}"] + # calculate reward margin + if f"{prefix}rewards/chosen" in logs and f"{prefix}rewards/rejected" in logs: + logs[f"{prefix}rewards/margins"] = logs[f"{prefix}rewards/chosen"] - logs[f"{prefix}rewards/rejected"] + # Add averaged stored metrics to logs + for key, metrics in self._stored_metrics[train_eval].items(): + logs[f"{prefix}{key}"] = torch.Tensor(metrics).mean().item() + del self._stored_metrics[train_eval] + return super().log(logs, start_time) + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bema_for_ref_model/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bema_for_ref_model/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8d7de0bee7977851b77a803f297a91ed6d170e27 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bema_for_ref_model/__init__.py @@ -0,0 +1,16 @@ +# Copyright 2020-2026 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. + +from .callback import BEMACallback +from .dpo_trainer import DPOTrainer diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bema_for_ref_model/callback.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bema_for_ref_model/callback.py new file mode 100644 index 0000000000000000000000000000000000000000..d030be9fb51c428fe82e6391c2ec64a05345d5d5 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bema_for_ref_model/callback.py @@ -0,0 +1,221 @@ +# Copyright 2020-2026 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 logging + +import torch +from transformers import PreTrainedModel, TrainerControl, TrainerState, TrainingArguments +from transformers.trainer_callback import CallbackHandler + +from ...trainer.callbacks import BEMACallback as _BEMACallback + + +# Logger for module-level logging +logger = logging.getLogger(__name__) + + +class CallbackHandlerWithRefModel(CallbackHandler): + """ + A [`~transformers.CallbackHandler`] that supports passing a reference model to callbacks. + """ + + def __init__(self, callbacks, model, ref_model, processing_class, optimizer, lr_scheduler): + super().__init__(callbacks, model, processing_class, optimizer, lr_scheduler) + self.ref_model = ref_model + + # Copied from CallbackHandler.call_event with the addition of `ref_model` to the callback call. + def call_event(self, event, args, state, control, **kwargs): + for callback in self.callbacks: + result = getattr(callback, event)( + args, + state, + control, + model=self.model, + ref_model=self.ref_model, # <- Added ref_model to the callback call + processing_class=self.processing_class, + optimizer=self.optimizer, + lr_scheduler=self.lr_scheduler, + train_dataloader=self.train_dataloader, + eval_dataloader=self.eval_dataloader, + **kwargs, + ) + # A Callback can skip the return of `control` if it doesn't change it. + if result is not None: + control = result + return control + + +class BEMACallback(_BEMACallback): + # docstyle-ignore + r""" + A [`~transformers.TrainerCallback`] that implements [BEMA](https://huggingface.co/papers/2508.00180) + (Bias-Corrected Exponential Moving Average) by [Adam Block](https://huggingface.co/abblock) and [Cyril + Zhang](https://huggingface.co/cyrilzhang). Code from https://github.com/abblock/bema under MIT license. + + BEMA computes model weights that scale like: + + $$ + \theta_t' = \alpha_t \cdot (\theta_t - \theta_0) + \text{EMA}_t + $$ + + where \\( \theta_t \\) is the current model weights, \\( \theta_0 \\) is a snapshot of the model weights at the + first `update_after` step, \\( \text{EMA}_t \\) is the exponential moving average of the model weights, and + \\( \alpha_t \\) is a scaling factor that decays with the number of steps \\( t \\) as + + $$ + \alpha_t = (\rho + \gamma \cdot t)^{-\eta}. + $$ + + The EMA is computed as: + + $$ + \text{EMA}_t = (1 - \beta_t) \cdot \text{EMA}_{t-1} + \beta_t \cdot \theta_t + $$ + + where \\( \beta_t \\) is a decay factor that decays with the number of steps \\( t \\) as + + $$ + \beta_t = (\rho + \gamma \cdot t)^{-\kappa}. + $$ + + Args: + update_freq (`int`, *optional*, defaults to `400`): + Update the BEMA weights every X steps. Denoted this as \\( \phi \\) in the paper. + ema_power (`float`, *optional*, defaults to `0.5`): + Power for the EMA decay factor. Denoted \\( \kappa \\) in the paper. To disable EMA, set this to `0.0`. + bias_power (`float`, *optional*, defaults to `0.2`): + Power for the BEMA scaling factor. Denoted \\( \eta \\) in the paper. To disable BEMA, set this to `0.0`. + lag (`int`, *optional*, defaults to `10`): + Initial offset in the weight decay schedule that controls early-stage smoothness by acting as a virtual + starting age for the updates. Denoted as \\( \rho \\) in the paper. + update_after (`int`, *optional*, defaults to `0`): + Burn-in time before starting to update the BEMA weights. Denoted \\( \tau \\) in the paper. + multiplier (`float`, *optional*, defaults to `1.0`): + Initial value for the EMA decay factor. Denoted as \\( \gamma \\) in the paper. + min_ema_multiplier (`float`, *optional*, defaults to `0.0`): + Minimum value for the EMA decay factor. + device (`str`, *optional*, defaults to `"cpu"`): + Device to use for the BEMA buffers, e.g. `"cpu"` or `"cuda"`. Note that in most cases, this device SHOULD + BE DIFFERENT from the device used for training in order to avoid OOM. + update_ref_model (`bool`, *optional*, defaults to `False`): + Whether to update the reference model with BEMA weights. This creates a lagged, smoothed version of the + main model as the reference model. + ref_model_update_freq (`int`, *optional*, defaults to `400`): + Update the reference model with BEMA weights every this many steps. + ref_model_update_after (`int`, *optional*, defaults to `0`): + Number of steps to wait before starting to update the reference model. + + Example: + + ```python + from trl import BEMACallback + + trainer = Trainer(..., callbacks=[BEMACallback()]) + ``` + """ + + def __init__( + self, + update_freq: int = 400, + ema_power: float = 0.5, + bias_power: float = 0.2, + lag: int = 10, + update_after: int = 0, + multiplier: float = 1.0, + min_ema_multiplier: float = 0.0, + device: str = "cpu", + update_ref_model: bool = False, + ref_model_update_freq: int = 400, + ref_model_update_after: int = 0, + ): + super().__init__( + update_freq, + ema_power, + bias_power, + lag, + update_after, + multiplier, + min_ema_multiplier, + device, + ) + # Reference model update parameters + self.update_ref_model = update_ref_model + self.ref_model_update_freq = ref_model_update_freq + self.ref_model_update_after = ref_model_update_after + + @torch.no_grad() + def on_step_end( + self, args: TrainingArguments, state: TrainerState, control: TrainerControl, model: PreTrainedModel, **kwargs + ): + super().on_step_end(args, state, control, model, **kwargs) + + step = state.global_step + # Update reference model if enabled + if ( + self.update_ref_model + and step >= self.ref_model_update_after + and (step - self.ref_model_update_after) % self.ref_model_update_freq == 0 + ): + if "ref_model" not in kwargs: + raise ValueError("'ref_model' not found in kwargs.") + + ref_model = kwargs["ref_model"] + + # Get the current BEMA state dict + bema_state_dict = self.running_model.state_dict() + + # Handle the case where ref_model is None (PEFT case) + if ref_model is None: + # In PEFT case, ref_model is None and we need to update the base model of the main model + main_model = self._unwrap_model(model) + if hasattr(main_model, "get_base_model"): + # This is a PEFT model, update the base model + base_model = main_model.get_base_model() + self._update_model_with_bema_weights(base_model, bema_state_dict, is_peft_base=True) + else: + # Regular model, update directly + self._update_model_with_bema_weights(main_model, bema_state_dict, is_peft_base=False) + else: + # ref_model is provided, unwrap it and update + ref_model = self._unwrap_model(ref_model) + if hasattr(ref_model, "get_base_model"): + # This is a PEFT model, update the base model + base_model = ref_model.get_base_model() + self._update_model_with_bema_weights(base_model, bema_state_dict, is_peft_base=True) + else: + # Regular model, update directly + self._update_model_with_bema_weights(ref_model, bema_state_dict, is_peft_base=False) + + logger.info("BEMACallback: Updated reference model with BEMA weights") + + def _update_model_with_bema_weights(self, model, bema_state_dict, is_peft_base=False): + """Helper method to update a model with BEMA weights, handling PEFT and distributed scenarios.""" + if is_peft_base: + # For PEFT base models, filter out adapter parameters + filtered_state_dict = {} + for key, value in bema_state_dict.items(): + # Skip adapter parameters + if not key.startswith("lora_") and not key.startswith("adapter_"): + # Remove 'base_model.' prefix if it exists + if key.startswith("base_model."): + base_key = key[len("base_model.") :] + else: + base_key = key + filtered_state_dict[base_key] = value + + # Update the base model + model.load_state_dict(filtered_state_dict, strict=False) + else: + # Regular model, update directly + model.load_state_dict(bema_state_dict, strict=False) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bema_for_ref_model/dpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bema_for_ref_model/dpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..8c50a232dc38c236dc64d79d32714b799ceeea8d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/bema_for_ref_model/dpo_trainer.py @@ -0,0 +1,30 @@ +# Copyright 2020-2026 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. + +from ...trainer.dpo_trainer import DPOTrainer as _DPOTrainer +from .callback import CallbackHandlerWithRefModel + + +class DPOTrainer(_DPOTrainer): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + # Replace with a new one that calls the events with the reference model + self.callback_handler = CallbackHandlerWithRefModel( + self.callback_handler.callbacks, + self.model, + self.ref_model, + self.processing_class, + self.optimizer, + self.lr_scheduler, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/cpo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/cpo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..57e151f53f63b9af52f3b7ba9355e1b3e223fc93 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/cpo/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .cpo_config import CPOConfig +from .cpo_trainer import CPOTrainer + + +__all__ = ["CPOConfig", "CPOTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/cpo/cpo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/cpo/cpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..61cb88a34fb9d1871f2b9ac9d4ccff7da14ea3a4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/cpo/cpo_config.py @@ -0,0 +1,182 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Any + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class CPOConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`experimental.cpo.CPOTrainer`]. + + This class includes only the parameters that are specific to CPO training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + 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: + max_length (`int` or `None`, *optional*, defaults to `1024`): + Maximum length of the sequences (prompt + completion) in the batch. This argument is required if you want + to use the default data collator. + max_completion_length (`int`, *optional*): + Maximum length of the completion. This argument is required if you want to use the default data collator + and your model is an encoder-decoder. + beta (`float`, *optional*, defaults to `0.1`): + Parameter controlling the deviation from the reference model. Higher β means less deviation from the + reference model. For the IPO loss (`loss_type="ipo"`), β is the regularization parameter denoted by τ in + the [paper](https://huggingface.co/papers/2310.12036). + label_smoothing (`float`, *optional*, defaults to `0.0`): + Label smoothing factor. This argument is required if you want to use the default data collator. + loss_type (`str`, *optional*, defaults to `"sigmoid"`): + Type of loss to use. Possible values are: + + - `"sigmoid"`: sigmoid loss from the original [DPO](https://huggingface.co/papers/2305.18290) paper. + - `"hinge"`: hinge loss on the normalized likelihood from the + [SLiC](https://huggingface.co/papers/2305.10425) paper. + - `"ipo"`: IPO loss from the [IPO](https://huggingface.co/papers/2310.12036) paper. + - `"simpo"`: SimPO loss from the [SimPO](https://huggingface.co/papers/2405.14734) paper. + - `"alphapo"`: AlphaPO loss from the [AlphaPO](https://huggingface.co/papers/2501.03884) paper. This + automatically sets `loss_type="simpo"` and `cpo_alpha=0.0`. + + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model. + cpo_alpha (`float`, *optional*, defaults to `1.0`): + Weight of the BC regularizer in CPO training. + simpo_gamma (`float`, *optional*, defaults to `0.5`): + Target reward margin for the SimPO loss, used only when the `loss_type="simpo"`. + alpha (`float`, *optional*, defaults to `0.0`): + Alpha parameter that controls reward function shape across all loss types. When alpha=0 (default), uses + standard log probability rewards. When `alpha != 0`, applies AlphaPO transformation: `r = (1 - p^(-alpha)) + / alpha` from the [AlphaPO paper](https://huggingface.co/papers/2501.03884). This parameter works with all + loss types. + generate_during_eval (`bool`, *optional*, defaults to `False`): + If `True`, generates and logs completions from the model to W&B or Comet during evaluation. + is_encoder_decoder (`bool`, *optional*): + 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. + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the model from a + string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`]. + dataset_num_proc (`int`, *optional*): + Number of processes to use for processing the dataset. + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `1e-6` instead of `5e-5`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=1e-6, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + max_length: int | None = field( + default=1024, + metadata={"help": "Maximum length of the sequences (prompt + completion) in the batch."}, + ) + max_completion_length: int | None = field( + default=None, + metadata={ + "help": "Maximum length of the completion. This argument is required if you want to use the default data " + "collator and your model is an encoder-decoder." + }, + ) + beta: float = field( + default=0.1, + metadata={ + "help": "Parameter controlling the deviation from the reference model. Higher β means less deviation from " + "the reference model." + }, + ) + label_smoothing: float = field( + default=0.0, + metadata={"help": "Label smoothing factor."}, + ) + loss_type: str = field( + default="sigmoid", + metadata={ + "help": "Type of loss to use.", + "choices": ["sigmoid", "hinge", "ipo", "simpo", "alphapo"], + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the model."}, + ) + cpo_alpha: float = field( + default=1.0, + metadata={"help": "Weight of the BC regularizer in CPO training."}, + ) + simpo_gamma: float = field( + default=0.5, + metadata={"help": "Target reward margin for the SimPO loss, used only when the `loss_type='simpo'`."}, + ) + alpha: float = field( + default=0.0, + metadata={ + "help": "Alpha parameter that controls reward function shape across all loss types. When alpha=0 " + "(default), uses standard log probability rewards. When `alpha != 0`, applies AlphaPO transformation: " + "`r = (1 - p^(-alpha)) / alpha` from the AlphaPO paper. This parameter works with all loss types." + }, + ) + generate_during_eval: bool = field( + default=False, + metadata={"help": "If `True`, generates and logs completions from the model to W&B during evaluation."}, + ) + is_encoder_decoder: bool | None = field( + default=None, + metadata={"help": "Whether the model is an encoder-decoder model."}, + ) + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the model " + "from a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models that ship custom Python code from the Hub. Forwarded to " + "`AutoModelForCausalLM.from_pretrained`." + }, + ) + dataset_num_proc: int | None = field( + default=None, + metadata={"help": "Number of processes to use for processing the dataset."}, + ) + + def __post_init__(self): + # Syntactic sugar for AlphaPO: set loss_type to "simpo" and cpo_alpha to 0.0 + if self.loss_type == "alphapo": + self.loss_type = "simpo" + self.cpo_alpha = 0.0 + + super().__post_init__() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/cpo/cpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/cpo/cpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..73f57ac754703a8e24230b039d3dd2203f2c27b4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/cpo/cpo_trainer.py @@ -0,0 +1,1070 @@ +# Copyright 2020-2026 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 random +import textwrap +from collections import defaultdict +from collections.abc import Callable +from contextlib import nullcontext +from pathlib import Path +from typing import Any, Literal + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +import torch.nn.functional as F +import transformers +from accelerate import PartialState, logging +from accelerate.utils import is_peft_model +from datasets import Dataset +from packaging.version import Version +from torch import autocast +from torch.utils.data import DataLoader +from transformers import ( + AutoModelForCausalLM, + BaseImageProcessor, + DataCollator, + FeatureExtractionMixin, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, + is_comet_available, + is_wandb_available, +) +from transformers.trainer_utils import EvalLoopOutput +from transformers.utils import is_peft_available, is_torch_fx_proxy + +from ...data_utils import maybe_apply_chat_template, maybe_extract_prompt +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import disable_dropout_in_model, log_table_to_comet_experiment, selective_log_softmax +from ..utils import ( + DPODataCollatorWithPadding, + add_bos_token_if_needed, + add_eos_token_if_needed, + pad_to_length, + peft_module_casting_to_bf16, +) +from .cpo_config import CPOConfig + + +if is_peft_available(): + from peft import PeftConfig, get_peft_model, prepare_model_for_kbit_training + + +if is_wandb_available(): + import wandb + + +logger = logging.get_logger(__name__) + + +class CPOTrainer(_BaseTrainer): + r""" + Initialize CPOTrainer. + + Args: + model ([`~transformers.PreTrainedModel`]): + The model to train, preferably an [`~transformers.AutoModelForSequenceClassification`]. + args ([`experimental.cpo.CPOConfig`]): + The CPO config arguments to use for training. + data_collator ([`~transformers.DataCollator`]): + The data collator to use for training. If None is specified, the default data collator + ([`experimental.utils.DPODataCollatorWithPadding`]) will be used which will pad the sequences to the + maximum length of the sequences in the batch, given a dataset of paired sequences. + train_dataset ([`~datasets.Dataset`]): + The dataset to use for training. + eval_dataset ([`~datasets.Dataset`]): + The dataset to use for evaluation. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. If provided, will be used to automatically process the inputs + for the model, and it will be saved along the model to make it easier to rerun an interrupted training or + reuse the fine-tuned model. + model_init (`Callable[[], transformers.PreTrainedModel]`): + The model initializer to use for training. If None is specified, the default model initializer will be + used. + callbacks (`list[transformers.TrainerCallback]`): + The callbacks to use for training. + optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): + The optimizer and scheduler to use for training. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`): + The function to use to preprocess the logits before computing the metrics. + peft_config ([`~peft.PeftConfig`], *optional*): + The PEFT configuration to use for training. If you pass a PEFT configuration, the model will be wrapped in + a PEFT model. + compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*): + The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to + metric values. + """ + + _tag_names = ["trl", "cpo"] + _name = "CPO" + _paper = { + "title": "Contrastive Preference Optimization: Pushing the Boundaries of LLM Performance in Machine Translation", + "id": "2401.08417", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @inproceedings{xu2024contrastive, + title = {{Contrastive Preference Optimization: Pushing the Boundaries of LLM Performance in Machine Translation}}, + author = {Haoran Xu and Amr Sharaf and Yunmo Chen and Weiting Tan and Lingfeng Shen and Benjamin Van Durme and Kenton Murray and Young Jin Kim}, + year = 2024, + booktitle = {Forty-first International Conference on Machine Learning, {ICML} 2024, Vienna, Austria, July 21-27, 2024}, + publisher = {OpenReview.net}, + url = {https://openreview.net/forum?id=51iwkioZpn} + }"""), + } + + def __init__( + self, + model: PreTrainedModel | nn.Module | str | None = None, + args: CPOConfig | None = None, + data_collator: DataCollator | None = None, + train_dataset: Dataset | None = None, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + processing_class: PreTrainedTokenizerBase + | BaseImageProcessor + | FeatureExtractionMixin + | ProcessorMixin + | None = None, + model_init: Callable[[], PreTrainedModel] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + peft_config: "PeftConfig | None" = None, + compute_metrics: Callable[[EvalLoopOutput], dict] | None = None, + ): + if train_dataset is None: + raise ValueError("`train_dataset` is required") + + if args.model_init_kwargs is None: + model_init_kwargs = {} + elif not isinstance(model, str): + raise ValueError("You passed model_kwargs to the CPOTrainer. But your model is already instantiated.") + else: + model_init_kwargs = args.model_init_kwargs + dtype = model_init_kwargs.get("dtype", "auto") + if dtype is not None: + # Convert to `torch.dtype` if an str is passed + if isinstance(dtype, str) and dtype != "auto": + dtype = getattr(torch, dtype) + if dtype != "auto" and not isinstance(dtype, torch.dtype): + raise ValueError( + f"Invalid `dtype` passed to the CPOConfig. Expected a string with either `torch.dtype` or 'auto', but got {dtype}." + ) + model_init_kwargs["dtype"] = dtype + model_init_kwargs["device_map"] = model_init_kwargs.get("device_map", "auto") + + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + + if isinstance(model, str): + model = AutoModelForCausalLM.from_pretrained(model, **model_init_kwargs) + + # PEFT + # Initialize this variable to False. This helps tracking the case when `peft_module_casting_to_bf16` + # has been called in order to properly call autocast if needed. + self._peft_has_been_casted_to_bf16 = False + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first " + "merge and unload the existing adapter, save the resulting base model, and then pass that base " + "model along with the new `peft_config` to the trainer." + ) + + if getattr(model, "is_loaded_in_8bit", False) or getattr(model, "is_loaded_in_4bit", False): + _support_gc_kwargs = hasattr( + args, "gradient_checkpointing_kwargs" + ) and "gradient_checkpointing_kwargs" in list( + inspect.signature(prepare_model_for_kbit_training).parameters + ) + + prepare_model_kwargs = {"use_gradient_checkpointing": args.gradient_checkpointing} + + if _support_gc_kwargs: + prepare_model_kwargs["gradient_checkpointing_kwargs"] = args.gradient_checkpointing_kwargs + + model = prepare_model_for_kbit_training(model, **prepare_model_kwargs) + elif args.gradient_checkpointing: + # For backward compatibility with older versions of transformers + if hasattr(model, "enable_input_require_grads"): + model.enable_input_require_grads() + else: + + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + # get peft model with the given config + model = get_peft_model(model, peft_config) + if args.bf16 and getattr(model, "is_loaded_in_4bit", False): + peft_module_casting_to_bf16(model) + # If args.bf16 we need to explicitly call `generate` with torch amp autocast context manager + self._peft_has_been_casted_to_bf16 = True + + # For models that use gradient_checkpointing, we need to attach a hook that enables input + # to explicitly have `requires_grad=True`, otherwise training will either silently + # fail or completely fail. + elif args.gradient_checkpointing: + # For backward compatibility with older versions of transformers + if hasattr(model, "enable_input_require_grads"): + model.enable_input_require_grads() + else: + + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + if args.generate_during_eval and not (is_wandb_available() or is_comet_available()): + raise ValueError( + "`generate_during_eval=True` requires Weights and Biases or Comet to be installed." + " Please install `wandb` or `comet-ml` to resolve." + ) + + if model is not None: + self.is_encoder_decoder = model.config.is_encoder_decoder + elif args.is_encoder_decoder is None: + raise ValueError("When no model is provided, you need to pass the parameter is_encoder_decoder.") + else: + self.is_encoder_decoder = args.is_encoder_decoder + + if self.is_encoder_decoder: + self.decoder_start_token_id = model.config.decoder_start_token_id + self.pad_token_id = model.config.pad_token_id + + if processing_class is None: + raise ValueError("processing_class must be specified to tokenize a CPO dataset.") + if args.max_length is None: + logger.warning( + "`max_length` is not set in the CPOConfig's init" + " it will default to `512` by default, but you should do it yourself in the future.", + ) + max_length = 512 + else: + max_length = args.max_length + + if args.max_completion_length is None and self.is_encoder_decoder: + logger.warning( + "When using an encoder decoder architecture, you should set `max_completion_length` in the CPOConfig's init" + " it will default to `128` by default, but you should do it yourself in the future.", + ) + max_completion_length = 128 + else: + max_completion_length = args.max_completion_length + + if data_collator is None: + data_collator = DPODataCollatorWithPadding( + pad_token_id=processing_class.pad_token_id, + is_encoder_decoder=self.is_encoder_decoder, + ) + + if args.remove_unused_columns: + args.remove_unused_columns = False + # warn users + logger.warning( + "When using DPODataCollatorWithPadding, you should set `remove_unused_columns=False` in your TrainingArguments" + " we have set it for you, but you should do it yourself in the future.", + ) + + self.use_dpo_data_collator = True + else: + self.use_dpo_data_collator = False + + # Disable dropout in the model + if args.disable_dropout: + disable_dropout_in_model(model) + + self.max_length = max_length + self.generate_during_eval = args.generate_during_eval + self.max_completion_length = max_completion_length + self.processing_class = processing_class + + if processing_class.pad_token is None: + processing_class.pad_token = processing_class.eos_token + self.pad_token_id = processing_class.pad_token_id + + if args.loss_type in ["hinge", "ipo"] and args.label_smoothing > 0: + logger.warning( + f"You are using the {args.loss_type} loss type that does not support label smoothing. The " + "`label_smoothing` parameter will be ignored. Set `label_smoothing` to `0.0` to remove this warning.", + ) + if args.loss_type == "kto_pair": + raise ValueError("Support for kto_pair has been removed in CPOTrainer. Please use KTOTrainer.") + + self.beta = args.beta + self.label_smoothing = args.label_smoothing + self.loss_type = args.loss_type + self.cpo_alpha = args.cpo_alpha + self.aux_loss_enabled = getattr(model.config, "output_router_logits", False) + self.aux_loss_coef = getattr(model.config, "router_aux_loss_coef", 0.0) + if self.aux_loss_enabled and self.aux_loss_coef == 0.0: + logger.warning( + "You set `output_router_logits` to `True` in the model config, but `router_aux_loss_coef` is set to " + "`0.0`, meaning the auxiliary loss will not be used. Either set `router_aux_loss_coef` to a value " + "greater than `0.0`, or set `output_router_logits` to `False` if you don't want to use the auxiliary " + "loss.", + ) + + if args.loss_type == "simpo": + self.simpo_gamma = args.simpo_gamma + + # AlphaPO parameter for reward shaping + self.alpha = args.alpha + + self._stored_metrics = defaultdict(lambda: defaultdict(list)) + + # Compute that only on the main process for faster data processing. + # see: https://github.com/huggingface/trl/pull/1255 + with PartialState().main_process_first(): + # Extract the prompt if needed, and apply the chat template if needed + train_dataset = train_dataset.map(maybe_extract_prompt, num_proc=args.dataset_num_proc) + train_dataset = train_dataset.map( + maybe_apply_chat_template, + fn_kwargs={"processing_class": processing_class}, + num_proc=args.dataset_num_proc, + ) + if eval_dataset is not None: + eval_dataset = eval_dataset.map(maybe_extract_prompt, num_proc=args.dataset_num_proc) + eval_dataset = eval_dataset.map( + maybe_apply_chat_template, + fn_kwargs={"processing_class": processing_class}, + num_proc=args.dataset_num_proc, + ) + + # tokenize the dataset + train_dataset = train_dataset.map(self.tokenize_row, num_proc=args.dataset_num_proc) + if eval_dataset is not None: + eval_dataset = eval_dataset.map(self.tokenize_row, num_proc=args.dataset_num_proc) + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + model_init=model_init, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the + # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set + # self.model_accepts_loss_kwargs to False to enable scaling. + self.model_accepts_loss_kwargs = False + + # Add tags for models that have been loaded with the correct transformers version + if hasattr(self.model, "add_model_tags"): + self.model.add_model_tags(self._tag_names) + + if not hasattr(self, "accelerator"): + raise AttributeError( + "Your `Trainer` does not have an `accelerator` object. Consider upgrading `transformers`." + ) + + def build_tokenized_answer(self, prompt, answer): + """ + Llama tokenizer does satisfy `enc(a + b) = enc(a) + enc(b)`. It does ensure `enc(a + b) = enc(a) + enc(a + + b)[len(enc(a)):]`. Reference: + https://github.com/EleutherAI/lm-evaluation-harness/pull/531#issuecomment-1595586257 + """ + + full_tokenized = self.processing_class(prompt + answer, add_special_tokens=False) + prompt_input_ids = self.processing_class(prompt, add_special_tokens=False)["input_ids"] + + answer_input_ids = full_tokenized["input_ids"][len(prompt_input_ids) :] + answer_attention_mask = full_tokenized["attention_mask"][len(prompt_input_ids) :] + + # Concat tokens to form `enc(a) + enc(a + b)[len(enc(a)):]` + full_concat_input_ids = np.concatenate([prompt_input_ids, answer_input_ids]) + + # Prepare input tokens for token by token comparison + full_input_ids = np.array(full_tokenized["input_ids"]) + + if len(full_input_ids) != len(full_concat_input_ids): + raise ValueError("Prompt input ids and answer input ids should have the same length.") + + # On some tokenizers, like Llama-2 tokenizer, there are occasions where tokens + # can be merged together when tokenizing prompt+answer. This could result + # on the last token from the prompt being different when tokenized on its own + # vs when done as prompt+answer. + response_token_ids_start_idx = len(prompt_input_ids) + + # If tokenized prompt is different than both prompt+answer, then it means the + # last token has changed due to merging. + if prompt_input_ids != full_tokenized["input_ids"][:response_token_ids_start_idx]: + response_token_ids_start_idx -= 1 + + prompt_input_ids = full_tokenized["input_ids"][:response_token_ids_start_idx] + prompt_attention_mask = full_tokenized["attention_mask"][:response_token_ids_start_idx] + + if len(prompt_input_ids) != len(prompt_attention_mask): + raise ValueError("Prompt input ids and attention mask should have the same length.") + + answer_input_ids = full_tokenized["input_ids"][response_token_ids_start_idx:] + answer_attention_mask = full_tokenized["attention_mask"][response_token_ids_start_idx:] + + return dict( + prompt_input_ids=prompt_input_ids, + prompt_attention_mask=prompt_attention_mask, + input_ids=answer_input_ids, + attention_mask=answer_attention_mask, + ) + + def tokenize_row(self, feature, model: PreTrainedModel | nn.Module | None = None) -> dict: + """Tokenize a single row from a CPO specific dataset. + + At this stage, we don't convert to PyTorch tensors yet; we just handle the truncation in case the prompt + + chosen or prompt + rejected responses is/are too long. First we truncate the prompt; if we're still too long, + we truncate the chosen/rejected. + + We also create the labels for the chosen/rejected responses, which are of length equal to the sum of the length + of the prompt and the chosen/rejected response, with `-100` for the prompt tokens. + """ + batch = {} + prompt = feature["prompt"] + chosen = feature["chosen"] + rejected = feature["rejected"] + + if not self.is_encoder_decoder: + # Check issues below for more details + # 1. https://github.com/huggingface/trl/issues/907 + # 2. https://github.com/EleutherAI/lm-evaluation-harness/pull/531#issuecomment-1595586257 + # 3. https://github.com/LianjiaTech/BELLE/issues/337 + + if not isinstance(prompt, str): + raise ValueError(f"prompt should be an str but got {type(prompt)}") + prompt_tokens = self.processing_class(prompt, add_special_tokens=False) + prompt_tokens = {f"prompt_{k}": v for k, v in prompt_tokens.items()} + + if not isinstance(chosen, str): + raise ValueError(f"chosen should be an str but got {type(chosen)}") + chosen_tokens = self.build_tokenized_answer(prompt, chosen) + + if not isinstance(rejected, str): + raise ValueError(f"rejected should be an str but got {type(rejected)}") + rejected_tokens = self.build_tokenized_answer(prompt, rejected) + + # Last prompt token might get merged by tokenizer and + # it should not be included for generation if that happens + prompt_len_input_ids = len(prompt_tokens["prompt_input_ids"]) + + chosen_prompt_len_input_ids = len(chosen_tokens["prompt_input_ids"]) + rejected_prompt_len_input_ids = len(rejected_tokens["prompt_input_ids"]) + prompt_len_input_ids = min(chosen_prompt_len_input_ids, rejected_prompt_len_input_ids) + + for k, v in prompt_tokens.items(): + prompt_tokens[k] = v[:prompt_len_input_ids] + + # Make sure prompts only have one different token at most an + # and length only differs by 1 at most + num_diff_tokens = sum( + a != b + for a, b in zip(chosen_tokens["prompt_input_ids"], rejected_tokens["prompt_input_ids"], strict=False) + ) + num_diff_len = abs(chosen_prompt_len_input_ids - rejected_prompt_len_input_ids) + if num_diff_tokens > 1 or num_diff_len > 1: + raise ValueError( + "Chosen and rejected prompt_input_ids might only differ on the " + "last token due to tokenizer merge ops." + ) + + # add BOS token to head of prompt. Avoid adding if it's already there + prompt_tokens, chosen_tokens, rejected_tokens = add_bos_token_if_needed( + self.processing_class.bos_token_id, + prompt_len_input_ids, + prompt_tokens, + chosen_prompt_len_input_ids, + chosen_tokens, + rejected_prompt_len_input_ids, + rejected_tokens, + ) + + # add EOS token to end of answer. Avoid adding if it's already there + chosen_tokens, rejected_tokens = add_eos_token_if_needed( + self.processing_class.eos_token_id, chosen_tokens, rejected_tokens + ) + + longer_response_length = max(len(chosen_tokens["input_ids"]), len(rejected_tokens["input_ids"])) + + # if combined sequence is too long, truncate the response + for answer_tokens in [chosen_tokens, rejected_tokens]: + if len(answer_tokens["prompt_input_ids"]) + longer_response_length > self.max_length: + for k in ["input_ids", "attention_mask"]: + answer_tokens[k] = answer_tokens[k][: self.max_length - longer_response_length] + + # Create labels + chosen_sequence_tokens = { + k: chosen_tokens[f"prompt_{k}"] + chosen_tokens[k] for k in ["input_ids", "attention_mask"] + } + rejected_sequence_tokens = { + k: rejected_tokens[f"prompt_{k}"] + rejected_tokens[k] for k in ["input_ids", "attention_mask"] + } + chosen_sequence_tokens["labels"] = chosen_sequence_tokens["input_ids"][:] + chosen_sequence_tokens["labels"][: len(chosen_tokens["prompt_input_ids"])] = [-100] * len( + chosen_tokens["prompt_input_ids"] + ) + rejected_sequence_tokens["labels"] = rejected_sequence_tokens["input_ids"][:] + rejected_sequence_tokens["labels"][: len(rejected_tokens["prompt_input_ids"])] = [-100] * len( + rejected_tokens["prompt_input_ids"] + ) + + for k, toks in { + "chosen_": chosen_sequence_tokens, + "rejected_": rejected_sequence_tokens, + "": prompt_tokens, + }.items(): + for type_key, tokens in toks.items(): + if type_key == "token_type_ids": + continue + batch[f"{k}{type_key}"] = tokens + + else: + chosen_tokens = self.processing_class( + chosen, truncation=True, max_length=self.max_completion_length, add_special_tokens=True + ) + rejected_tokens = self.processing_class( + rejected, truncation=True, max_length=self.max_completion_length, add_special_tokens=True + ) + prompt_tokens = self.processing_class(prompt, add_special_tokens=True) + + batch["chosen_labels"] = chosen_tokens["input_ids"] + batch["rejected_labels"] = rejected_tokens["input_ids"] + batch["prompt_input_ids"] = prompt_tokens["input_ids"] + batch["prompt_attention_mask"] = prompt_tokens["attention_mask"] + + if model is not None and hasattr(model, "prepare_decoder_input_ids_from_labels"): + batch["rejected_decoder_input_ids"] = model.prepare_decoder_input_ids_from_labels( + labels=torch.tensor(batch["rejected_labels"]) + ) + batch["chosen_decoder_input_ids"] = model.prepare_decoder_input_ids_from_labels( + labels=torch.tensor(batch["chosen_labels"]) + ) + + return batch + + @staticmethod + def concatenated_inputs( + batch: dict[str, list | torch.LongTensor], + is_encoder_decoder: bool = False, + padding_value: int = 0, + device: torch.device | None = None, + ) -> dict[str, torch.LongTensor]: + """Concatenate the chosen and rejected inputs into a single tensor. + + Args: + batch: + A batch of data. Must contain the keys 'chosen_input_ids' and 'rejected_input_ids', which are tensors + of shape (batch_size, sequence_length). + is_encoder_decoder: + Whether the model is an encoder-decoder model. + padding_value: + The padding value to use for the concatenated inputs_ids. + device: + The device for the concatenated inputs. + + Returns: + A dictionary containing the concatenated inputs under the key 'concatenated_input_ids'. + """ + concatenated_batch = {} + + if is_encoder_decoder: + max_length = max(batch["chosen_labels"].shape[1], batch["rejected_labels"].shape[1]) + else: + max_length = max(batch["chosen_input_ids"].shape[1], batch["rejected_input_ids"].shape[1]) + + for k in batch: + if k.startswith("chosen") and isinstance(batch[k], torch.Tensor): + if "labels" in k or is_encoder_decoder: + pad_value = -100 + elif k.endswith("_input_ids"): + pad_value = padding_value + elif k.endswith("_attention_mask"): + pad_value = 0 + concatenated_key = k.replace("chosen", "concatenated") + concatenated_batch[concatenated_key] = pad_to_length(batch[k], max_length, pad_value=pad_value) + for k in batch: + if k.startswith("rejected") and isinstance(batch[k], torch.Tensor): + if "labels" in k or is_encoder_decoder: + pad_value = -100 + elif k.endswith("_input_ids"): + pad_value = padding_value + elif k.endswith("_attention_mask"): + pad_value = 0 + concatenated_key = k.replace("rejected", "concatenated") + concatenated_batch[concatenated_key] = torch.cat( + ( + concatenated_batch[concatenated_key], + pad_to_length(batch[k], max_length, pad_value=pad_value), + ), + dim=0, + ).to(device=device) + + if is_encoder_decoder: + concatenated_batch["concatenated_input_ids"] = batch["prompt_input_ids"].repeat(2, 1).to(device=device) + concatenated_batch["concatenated_attention_mask"] = ( + batch["prompt_attention_mask"].repeat(2, 1).to(device=device) + ) + + return concatenated_batch + + def cpo_loss( + self, + policy_chosen_logps: torch.FloatTensor, + policy_rejected_logps: torch.FloatTensor, + ) -> tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]: + """Compute the CPO loss for a batch of policy and reference model log probabilities. + + Args: + policy_chosen_logps: + Log probabilities of the policy model for the chosen responses. Shape: (batch_size,) + policy_rejected_logps: + Log probabilities of the policy model for the rejected responses. Shape: (batch_size,) + + Returns: + A tuple of three tensors: (losses, chosen_rewards, rejected_rewards). The losses tensor contains the CPO + loss for each example in the batch. The chosen_rewards and rejected_rewards tensors contain the rewards for + the chosen and rejected responses, respectively. + """ + # Apply AlphaPO reward transformation if alpha != 0 + if self.alpha != 0.0: + # Compute probabilities + chosen_probs = torch.exp(policy_chosen_logps) + rejected_probs = torch.exp(policy_rejected_logps) + + # Apply AlphaPO transformation: r = (1 - p^(-alpha)) / alpha + policy_chosen_rewards = (1 - chosen_probs.pow(-self.alpha)) / self.alpha + policy_rejected_rewards = (1 - rejected_probs.pow(-self.alpha)) / self.alpha + + logits = (policy_chosen_rewards - policy_rejected_rewards).to(self.accelerator.device) + else: + # Standard log probability rewards when alpha = 0 + logits = (policy_chosen_logps - policy_rejected_logps).to(self.accelerator.device) + + # The beta is a temperature parameter for the CPO loss, typically something in the range of 0.1 to 0.5. + # We ignore the reference model as beta -> 0. The label_smoothing parameter encodes our uncertainty about the labels and + # calculates a conservative CPO loss. + + if self.loss_type == "simpo": + gamma_logratios = self.simpo_gamma / self.beta + logits = logits - gamma_logratios + # This reduces to Equation 3 from the CPO paper when label_smoothing -> 0. + losses = ( + -F.logsigmoid(self.beta * logits) * (1 - self.label_smoothing) + - F.logsigmoid(-self.beta * logits) * self.label_smoothing + ) + elif self.loss_type == "sigmoid": + # This reduces to Equation 3 from the CPO paper when label_smoothing -> 0. + losses = ( + -F.logsigmoid(self.beta * logits) * (1 - self.label_smoothing) + - F.logsigmoid(-self.beta * logits) * self.label_smoothing + ) + elif self.loss_type == "hinge": + losses = torch.relu(1 - self.beta * logits) + elif self.loss_type == "ipo": + # eqn (17) of the paper where beta is the regularization parameter for the IPO loss, denoted by tau in the paper. + losses = (logits - 1 / (2 * self.beta)) ** 2 + else: + raise ValueError( + f"Unknown loss type: {self.loss_type}. Should be one of ['sigmoid', 'hinge', 'ipo', 'simpo']" + ) + + # Calculate rewards for logging + if self.alpha != 0.0: + # When using AlphaPO transformation, use the transformed rewards + chosen_rewards = self.beta * policy_chosen_rewards.to(self.accelerator.device).detach() + rejected_rewards = self.beta * policy_rejected_rewards.to(self.accelerator.device).detach() + else: + # Standard log probability rewards + chosen_rewards = self.beta * (policy_chosen_logps.to(self.accelerator.device)).detach() + rejected_rewards = self.beta * (policy_rejected_logps.to(self.accelerator.device)).detach() + + return losses, chosen_rewards, rejected_rewards + + @staticmethod + def get_batch_logps( + logits: torch.FloatTensor, + labels: torch.LongTensor, + average_log_prob: bool = False, + is_encoder_decoder: bool = False, + ) -> torch.FloatTensor: + """Compute the log probabilities of the given labels under the given logits. + + Args: + logits: Logits of the model (unnormalized). Shape: (batch_size, sequence_length, vocab_size) + labels: + Labels for which to compute the log probabilities. Label tokens with a value of `-100` are ignored. + Shape: (batch_size, sequence_length) + average_log_prob: + If True, return the average log probability per (non-masked) token. Otherwise, return the sum of the + log probabilities of the (non-masked) tokens. + is_encoder_decoder: Whether the model is an encoder-decoder model. + + Returns: + A tensor of shape (batch_size,) containing the average/sum log probabilities of the given labels under the + given logits. + """ + if logits.shape[:-1] != labels.shape: + raise ValueError("Logits (batch and sequence length dim) and labels must have the same shape.") + + if not is_encoder_decoder: + labels = labels[:, 1:].clone() + logits = logits[:, :-1, :] + loss_mask = labels != -100 + + # dummy token; we'll ignore the losses on these tokens later + labels[labels == -100] = 0 + + per_token_logps = selective_log_softmax(logits, labels) + + if average_log_prob: + return (per_token_logps * loss_mask).sum(-1) / loss_mask.sum(-1) + else: + return (per_token_logps * loss_mask).sum(-1) + + def concatenated_forward( + self, model: nn.Module, batch: dict[str, list | torch.LongTensor] + ) -> tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]: + """Run the given model on the given batch of inputs, concatenating the chosen and rejected inputs together. + + We do this to avoid doing two forward passes, because it's faster for FSDP. + """ + concatenated_batch = self.concatenated_inputs( + batch, + is_encoder_decoder=self.is_encoder_decoder, + padding_value=self.pad_token_id, + device=self.accelerator.device, + ) + len_chosen = batch["chosen_labels"].shape[0] + + model_kwargs = ( + { + "decoder_input_ids": self._shift_right(concatenated_batch["concatenated_labels"]), + } + if self.is_encoder_decoder + else {} + ) + + if self.aux_loss_enabled: + model_kwargs["output_router_logits"] = True + + outputs = model( + concatenated_batch["concatenated_input_ids"], + attention_mask=concatenated_batch["concatenated_attention_mask"], + use_cache=False, + **model_kwargs, + ) + all_logits = outputs.logits + + def cross_entropy_loss(logits, labels): + if not self.is_encoder_decoder: + # Shift so that tokens < n predict n + logits = logits[..., :-1, :].contiguous() + labels = labels[..., 1:].contiguous() + # Flatten the tokens + loss_fct = nn.CrossEntropyLoss() + logits = logits.view(-1, logits.shape[-1]) + labels = labels.view(-1) + # Enable model parallelism + labels = labels.to(logits.device) + loss = loss_fct(logits, labels) + return loss + + labels = concatenated_batch["concatenated_labels"].clone() + + if self.cpo_alpha == 0: + nll_loss = torch.tensor(0.0).to(self.accelerator.device) + else: + nll_loss = cross_entropy_loss(all_logits[:len_chosen], labels[:len_chosen]) + + all_logps = self.get_batch_logps( + all_logits, + concatenated_batch["concatenated_labels"], + average_log_prob=self.loss_type in ["ipo", "simpo"], + is_encoder_decoder=self.is_encoder_decoder, + ) + + chosen_logps = all_logps[:len_chosen] + rejected_logps = all_logps[len_chosen:] + + chosen_logits = all_logits[:len_chosen] + rejected_logits = all_logits[len_chosen:] + + if self.aux_loss_enabled: + return (chosen_logps, rejected_logps, chosen_logits, rejected_logits, nll_loss, outputs.aux_loss) + + return (chosen_logps, rejected_logps, chosen_logits, rejected_logits, nll_loss) + + def get_batch_loss_metrics( + self, + model, + batch: dict[str, list | torch.LongTensor], + train_eval: Literal["train", "eval"] = "train", + ): + """Compute the CPO loss and other metrics for the given batch of inputs for train or test.""" + metrics = {} + + forward_output = self.concatenated_forward(model, batch) + ( + policy_chosen_logps, + policy_rejected_logps, + policy_chosen_logits, + policy_rejected_logits, + policy_nll_loss, + ) = forward_output[:5] + if self.aux_loss_enabled: + aux_loss = forward_output[5] + + losses, chosen_rewards, rejected_rewards = self.cpo_loss( + policy_chosen_logps, + policy_rejected_logps, + ) + + loss = losses.mean() + self.cpo_alpha * policy_nll_loss + reward_accuracies = (chosen_rewards > rejected_rewards).float() + + prefix = "eval_" if train_eval == "eval" else "" + metrics[f"{prefix}rewards/chosen"] = self.accelerator.gather_for_metrics(chosen_rewards).mean().item() + metrics[f"{prefix}rewards/rejected"] = self.accelerator.gather_for_metrics(rejected_rewards).mean().item() + metrics[f"{prefix}rewards/accuracies"] = self.accelerator.gather_for_metrics(reward_accuracies).mean().item() + metrics[f"{prefix}rewards/margins"] = ( + self.accelerator.gather_for_metrics(chosen_rewards - rejected_rewards).mean().item() + ) + metrics[f"{prefix}logps/rejected"] = ( + self.accelerator.gather_for_metrics(policy_rejected_logps).detach().mean().item() + ) + metrics[f"{prefix}logps/chosen"] = ( + self.accelerator.gather_for_metrics(policy_chosen_logps).detach().mean().item() + ) + metrics[f"{prefix}logits/rejected"] = ( + self.accelerator.gather_for_metrics(policy_rejected_logits.detach().mean()).mean().item() + ) + metrics[f"{prefix}logits/chosen"] = ( + self.accelerator.gather_for_metrics(policy_chosen_logits.detach().mean()).mean().item() + ) + metrics[f"{prefix}nll_loss"] = self.accelerator.gather_for_metrics(policy_nll_loss).detach().mean().item() + + if self.aux_loss_enabled: + loss += self.aux_loss_coef * aux_loss + + return loss, metrics + + def compute_loss( + self, + model: PreTrainedModel | nn.Module, + inputs: dict[str, torch.Tensor | Any], + return_outputs=False, + num_items_in_batch=None, + ) -> torch.Tensor | tuple[torch.Tensor, dict[str, torch.Tensor]]: + compute_loss_context_manager = ( + autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext() + ) + + with compute_loss_context_manager: + loss, metrics = self.get_batch_loss_metrics(model, inputs, train_eval="train") + + # force log the metrics + self.store_metrics(metrics, train_eval="train") + + if return_outputs: + return (loss, metrics) + return loss + + def generate_from_model(self, model, batch: dict[str, torch.LongTensor]) -> str: + """Generate samples from the model and reference model for the given batch of inputs.""" + + # If one uses `generate_during_eval` with peft + bf16, we need to explicitly call generate with + # the torch amp context manager as some hidden states are silently casted to full precision. + generate_context_manager = ( + autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext() + ) + + with generate_context_manager: + policy_output = model.generate( + input_ids=batch["prompt_input_ids"], + attention_mask=batch["prompt_attention_mask"], + max_length=self.max_length, + do_sample=True, + pad_token_id=self.processing_class.pad_token_id, + ) + + policy_output = pad_to_length(policy_output, self.max_length, self.processing_class.pad_token_id) + policy_output_decoded = self.processing_class.batch_decode(policy_output, skip_special_tokens=True) + + return policy_output_decoded + + def prediction_step( + self, + model: PreTrainedModel | nn.Module, + inputs: dict[str, torch.Tensor | Any], + prediction_loss_only: bool, + ignore_keys: list[str] | None = None, + ): + if ignore_keys is None: + if hasattr(model, "config"): + ignore_keys = getattr(model.config, "keys_to_ignore_at_inference", []) + else: + ignore_keys = [] + + prediction_context_manager = ( + autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext() + ) + + with torch.no_grad(), prediction_context_manager: + loss, metrics = self.get_batch_loss_metrics(model, inputs, train_eval="eval") + + # force log the metrics + self.store_metrics(metrics, train_eval="eval") + + if prediction_loss_only: + return (loss.detach(), None, None) + + # logits for the chosen and rejected samples from model + logits_dict = { + "eval_logits/chosen": metrics["eval_logits/chosen"], + "eval_logits/rejected": metrics["eval_logits/rejected"], + } + logits = [v for k, v in logits_dict.items() if k not in ignore_keys] + logits = torch.tensor(logits, device=self.accelerator.device) + labels = torch.zeros(logits.shape[0], device=self.accelerator.device) + + return (loss.detach(), logits, labels) + + def store_metrics(self, metrics: dict[str, float], train_eval: Literal["train", "eval"] = "train") -> None: + for key, value in metrics.items(): + self._stored_metrics[train_eval][key].append(value) + + def evaluation_loop( + self, + dataloader: DataLoader, + description: str, + prediction_loss_only: bool | None = None, + ignore_keys: list[str] | None = None, + metric_key_prefix: str = "eval", + ) -> EvalLoopOutput: + """ + Overriding built-in evaluation loop to store metrics for each batch. Prediction/evaluation loop, shared by + `Trainer.evaluate()` and `Trainer.predict()`. + + Works both with or without labels. + """ + + # Sample and save to game log if requested (for one batch to save time) + if self.generate_during_eval: + # Generate random indices within the range of the total number of samples + num_samples = len(dataloader.dataset) + random_indices = random.sample(range(num_samples), k=self.args.eval_batch_size) + + # Use dataloader.dataset.select to get the random batch without iterating over the DataLoader + random_batch_dataset = dataloader.dataset.select(random_indices) + random_batch = self.data_collator(random_batch_dataset) + random_batch = self._prepare_inputs(random_batch) + + policy_output_decoded = self.generate_from_model(self.model, random_batch) + + table = pd.DataFrame( + columns=["Prompt", "Policy"], + data=[ + [prompt, pol[len(prompt) :]] + for prompt, pol in zip(random_batch["prompt"], policy_output_decoded, strict=True) + ], + ) + if "wandb" in self.args.report_to: + wandb.log({"game_log": wandb.Table(data=table)}) + + if "comet_ml" in self.args.report_to: + log_table_to_comet_experiment( + name="game_log.csv", + table=table, + ) + + # Base evaluation + initial_output = super().evaluation_loop( + dataloader, description, prediction_loss_only, ignore_keys, metric_key_prefix + ) + + return initial_output + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + """ + Log `logs` on the various objects watching training, including stored metrics. + + Args: + logs (`dict[str, float]`): + The values to log. + start_time (`float`, *optional*): + Start time of the training. + """ + # logs either has 'loss' or 'eval_loss' + train_eval = "train" if "loss" in logs else "eval" + # Add averaged stored metrics to logs + for key, metrics in self._stored_metrics[train_eval].items(): + logs[key] = torch.tensor(metrics).mean().item() + del self._stored_metrics[train_eval] + return super().log(logs, start_time) + + def _shift_right(self, input_ids): + if self.decoder_start_token_id is None: + raise ValueError( + "model.config.decoder_start_token_id has to be defined. It is usually set to the pad_token_id." + ) + + # shift inputs to the right + if is_torch_fx_proxy(input_ids): + # Item assignment is not supported natively for proxies. + shifted_input_ids = torch.full(input_ids.shape[:-1] + (1,), self.decoder_start_token_id) + shifted_input_ids = torch.cat([shifted_input_ids, input_ids[..., :-1]], dim=-1) + else: + shifted_input_ids = input_ids.new_zeros(input_ids.shape) + shifted_input_ids[..., 1:] = input_ids[..., :-1].clone() + shifted_input_ids[..., 0] = self.decoder_start_token_id + + if self.pad_token_id is None: + raise ValueError("model.config.pad_token_id has to be defined.") + # replace possible -100 values in labels by `pad_token_id` + shifted_input_ids.masked_fill_(shifted_input_ids == -100, self.pad_token_id) + + return shifted_input_ids + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..894333c1d01c23f82964cd651ee45a7c3d652e65 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .distillation_config import DistillationConfig +from .distillation_trainer import DistillationTrainer + + +__all__ = ["DistillationConfig", "DistillationTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/distillation.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/distillation.py new file mode 100644 index 0000000000000000000000000000000000000000..ad64923f0b1cca01e022d39fc6c74e21cfdb47f8 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/distillation.py @@ -0,0 +1,177 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# "peft", +# "trackio", +# "kernels", +# ] +# /// + +# docstyle-ignore +""" +# Full training (off-policy only, lmbda=0): +``` +python trl/experimental/distillation/distillation.py \ + --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \ + --teacher_model_name_or_path Qwen/Qwen2.5-1.5B-Instruct \ + --dataset_name trl-lib/chatbot_arena_completions \ + --learning_rate 2e-5 \ + --per_device_train_batch_size 4 \ + --gradient_accumulation_steps 8 \ + --lmbda 0.0 \ + --output_dir distilled-model \ + --num_train_epochs 1 +``` + +# Mixed on/off-policy (lmbda=0.5): +``` +python trl/experimental/distillation/distillation.py \ + --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \ + --teacher_model_name_or_path Qwen/Qwen2.5-1.5B-Instruct \ + --dataset_name trl-lib/chatbot_arena_completions \ + --learning_rate 2e-5 \ + --per_device_train_batch_size 4 \ + --gradient_accumulation_steps 8 \ + --lmbda 0.5 \ + --beta 0.5 \ + --output_dir distilled-model \ + --num_train_epochs 1 +``` + +# LoRA: +``` +python trl/experimental/distillation/distillation.py \ + --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \ + --teacher_model_name_or_path Qwen/Qwen2.5-1.5B-Instruct \ + --dataset_name trl-lib/chatbot_arena_completions \ + --learning_rate 2e-4 \ + --per_device_train_batch_size 4 \ + --gradient_accumulation_steps 8 \ + --lmbda 0.0 \ + --output_dir distilled-model \ + --num_train_epochs 1 \ + --use_peft \ + --lora_r 64 \ + --lora_alpha 16 +``` +""" + +import argparse +import os + + +# Enable logging in a Hugging Face Space +os.environ.setdefault("TRACKIO_SPACE_ID", "trl-trackio") + + +def main(script_args, training_args, model_args): + from datasets import load_dataset + from transformers import GenerationConfig + + from trl import ( + LogCompletionsCallback, + get_kbit_device_map, + get_peft_config, + get_quantization_config, + ) + from trl.experimental.distillation import DistillationTrainer + + ################ + # Model init kwargs + ################ + quantization_config = get_quantization_config(model_args) + model_kwargs = dict( + revision=model_args.model_revision, + attn_implementation=model_args.attn_implementation, + dtype=model_args.dtype, + use_cache=False if training_args.gradient_checkpointing else True, + device_map=get_kbit_device_map() if quantization_config is not None else None, + quantization_config=quantization_config, + ) + training_args.model_init_kwargs = model_kwargs + + teacher_model_kwargs = dict( + revision=training_args.teacher_model_revision, + attn_implementation=model_args.attn_implementation, + dtype=model_args.dtype, + use_cache=True, + device_map=get_kbit_device_map() if quantization_config is not None else None, + quantization_config=quantization_config, + ) + if training_args.teacher_model_init_kwargs is not None: + teacher_model_kwargs.update(training_args.teacher_model_init_kwargs) + training_args.teacher_model_init_kwargs = teacher_model_kwargs + + ################ + # Dataset + ################ + dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config) + + ################ + # Training + ################ + eval_dataset = None + if training_args.eval_strategy != "no": + if script_args.dataset_test_split in dataset: + eval_dataset = dataset[script_args.dataset_test_split] + elif "validation" in dataset: + eval_dataset = dataset["validation"] + elif "dev" in dataset: + eval_dataset = dataset["dev"] + + trainer = DistillationTrainer( + model=model_args.model_name_or_path, + teacher_model=training_args.teacher_model_name_or_path, + args=training_args, + train_dataset=dataset[script_args.dataset_train_split], + eval_dataset=eval_dataset, + peft_config=get_peft_config(model_args), + ) + + if training_args.eval_strategy != "no": + generation_config = GenerationConfig( + max_new_tokens=training_args.max_completion_length, do_sample=True, temperature=training_args.temperature + ) + completions_callback = LogCompletionsCallback(trainer, generation_config, num_prompts=8) + trainer.add_callback(completions_callback) + + trainer.train() + + # Save and push to Hub + trainer.save_model(training_args.output_dir) + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name) + + +def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None): + from trl import ModelConfig, ScriptArguments, TrlParser + from trl.experimental.distillation import DistillationConfig + + dataclass_types = (ScriptArguments, DistillationConfig, ModelConfig) + if subparsers is not None: + parser = subparsers.add_parser( + "distillation", help="Run the distillation training script", dataclass_types=dataclass_types + ) + else: + parser = TrlParser(dataclass_types, prog=prog) + return parser + + +if __name__ == "__main__": + parser = make_parser() + script_args, training_args, model_args = parser.parse_args_and_config(fail_with_unknown_args=False) + main(script_args, training_args, model_args) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/distillation_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/distillation_config.py new file mode 100644 index 0000000000000000000000000000000000000000..c70dd4b2d6d32a347590dfb48573fd2acd641407 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/distillation_config.py @@ -0,0 +1,454 @@ +# Copyright 2020-2026 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 warnings +from dataclasses import dataclass, field +from typing import Any + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class DistillationConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`DistillationTrainer`]. + + Extends [`~transformers.TrainingArguments`] with parameters specific to knowledge distillation. This config is + independent of [`SFTConfig`] — all necessary fields are declared here. + + 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: + > Parameters that control the model + + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument of the + trainer is provided as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and + [`~transformers.AutoTokenizer.from_pretrained`], for both the student and teacher. + max_length (`int` or `None`, *optional*, defaults to `1024`): + Maximum total sequence length (prompt + completion) for tokenization and truncation. + + > Parameters that control the distillation + + temperature (`float`, *optional*, defaults to `1.0`): + Temperature for sampling during generation and for computing the distillation loss. Higher values produce + softer probability distributions. + lmbda (`float`, *optional*, defaults to `1.0`): + Probability of using on-policy (student-generated) data for each gradient accumulation slice. A value of + `0.0` means fully off-policy (dataset completions only), `1.0` means fully on-policy. + beta (`float`, *optional*, defaults to `1.0`): + Interpolation coefficient for the Generalized Jensen-Shannon Divergence loss. When `0.0`, the loss is the + forward KL divergence. When `1.0`, the loss is the reverse KL divergence. When `0.5`, it is the standard + JSD. + reverse_kl_top_1_mode (`str`, *optional*, defaults to `"sampled"`): + Selection rule for the reverse-KL top-1 token when `beta > 0` and `loss_top_k == 1`. `"sampled"` uses the + actual completion token in the batch. `"argmax"` uses the student's highest-probability token. This + setting does not affect the forward-KL support, which always uses the teacher's top-1 token. Ignored when + `beta == 0` or `loss_top_k != 1`. + max_completion_length (`int`, *optional*, defaults to `512`): + Maximum number of tokens to generate per completion during on-policy generation. + max_prompt_length (`int` or `None`, *optional*): + Maximum number of tokens for the prompt. If `None`, auto-computed as `max_length - max_completion_length`. + Prompts are truncated according to the tokenizer's `truncation_side` setting. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the student model during training. + + > Parameters that control the teacher model + + teacher_model_name_or_path (`str` or `None`, *optional*): + Model name or path for the teacher model. Used when the teacher is loaded locally. + teacher_model_revision (`str` or `None`, *optional*): + Model revision of the teacher model (e.g., branch name, tag, or commit hash). + teacher_model_init_kwargs (`dict[str, Any]` or `None`, *optional*): + Keyword arguments passed to `AutoModelForCausalLM.from_pretrained` when instantiating the teacher model + from a string. + use_teacher_server (`bool`, *optional*, defaults to `False`): + Whether to use an external vLLM teacher server instead of a local teacher model. + teacher_model_server_url (`str` or `None`, *optional*): + Base URL of a vLLM server hosting the teacher model (e.g., `"http://localhost:8000"`). When set, teacher + logprobs are fetched from the server instead of running a local forward pass when `use_teacher_server=True`. + loss_top_k (`int`, *optional*, defaults to `1`): + Number of top tokens to use when computing the JSD/KL loss. Both student and teacher distributions are + restricted to these K tokens and re-normalized before computing divergence. If 0, the full vocabulary + is used. For local teachers, the general support rule is teacher top-k for forward KL, student top-k for + reverse KL, and the union for mixed JSD. When `beta > 0` and `loss_top_k == 1`, the forward support still + uses the teacher's top-1 token, while the reverse top-1 token is controlled by `reverse_kl_top_1_mode`. + When `use_teacher_server=True`, the pure forward path (`beta=0`) requires this to be positive and uses the + teacher's top-k logprobs for the forward term. When `beta > 0`, server-backed distillation requires + `loss_top_k == 1` and only supports `"sampled"` reverse top-1 tokens. + loss_add_tail (`bool`, *optional*, defaults to `True`): + Whether to append a tail bucket that represents the remaining probability mass outside the selected top-k + support when computing the loss. + + > Parameters that control on-policy generation + + num_generations (`int`, *optional*, defaults to `1`): + Number of completions to generate per prompt during on-policy generation. + generation_batch_size (`int` or `None`, *optional*): + Number of unique prompts per worker per optimizer step. If `None`, computed from + `(per_device_train_batch_size * gradient_accumulation_steps) // num_generations`. + top_p (`float`, *optional*, defaults to `0.95`): + Top-p (nucleus) sampling parameter for on-policy generation. + top_k (`int`, *optional*, defaults to `0`): + Top-k sampling parameter for on-policy generation. `0` disables top-k filtering. + + > Parameters that control vLLM for student generation + + use_vllm (`bool`, *optional*, defaults to `False`): + Whether to use vLLM for generating on-policy completions from the student model. + vllm_mode (`str`, *optional*, defaults to `"colocate"`): + Mode for student vLLM integration. Either `"server"` or `"colocate"`. + vllm_server_base_url (`str` or `None`, *optional*): + Base URL for the student vLLM server. If provided, `vllm_server_host` and `vllm_server_port` are ignored. + vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`): + Host of the student vLLM server. + vllm_server_port (`int`, *optional*, defaults to `8001`): + Port of the student vLLM server. + vllm_server_timeout (`float`, *optional*, defaults to `240.0`): + Timeout for connecting to the student vLLM server. + vllm_group_port (`int`, *optional*, defaults to `51216`): + Port for the vLLM weight-update group (NCCL communicator). + vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.3`): + GPU memory utilization for the colocated student vLLM engine. + vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`): + Tensor parallel size for the colocated student vLLM engine. + vllm_max_model_length (`int` or `None`, *optional*): + Maximum model sequence length for the colocated vLLM engine. + vllm_model_impl (`str`, *optional*, defaults to `"vllm"`): + Model implementation backend for vLLM. Use `"vllm"` or `"transformers"`. + vllm_structured_outputs_regex (`str` or `None`, *optional*): + Regex pattern for vLLM structured outputs. + vllm_sync_frequency (`int`, *optional*, defaults to `1`): + Frequency (in training steps) to synchronize student model weights to the vLLM engine. + vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`): + Enable vLLM sleep mode to offload student weights during the optimizer step. + + > Parameters that control logging + + log_completions (`bool`, *optional*, defaults to `False`): + Whether to log a sample of (prompt, completion) pairs every `log_completions_steps` steps. If `rich` is + installed, it prints the sample. If `wandb` and/or `trackio` logging is enabled, it logs it to `wandb` + and/or `trackio`. + log_completions_steps (`int`, *optional*, defaults to `100`): + Number of steps between logging completions. Only used if `log_completions` is `True`. + num_completions_to_print (`int` or `None`, *optional*): + Number of completions to print. If `None`, all completions are logged. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs", "teacher_model_init_kwargs"] + + # Model + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument " + "of the trainer is provided as a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoTokenizer.from_pretrained`, for both the " + "student and teacher." + }, + ) + max_length: int | None = field( + default=1024, + metadata={"help": "Maximum total sequence length (prompt + completion) for tokenization and truncation."}, + ) + + # Overridden defaults + learning_rate: float = field( + default=1e-6, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + # Distillation core + temperature: float = field( + default=1.0, + metadata={ + "help": "Temperature for sampling and loss computation. Higher values produce softer distributions." + }, + ) + lmbda: float = field( + default=1.0, + metadata={ + "help": "Probability of using on-policy (student-generated) data per gradient accumulation slice. " + "0.0 = fully off-policy, 1.0 = fully on-policy." + }, + ) + beta: float = field( + default=1.0, + metadata={ + "help": "Interpolation coefficient for the Generalized JSD loss. " + "0.0 = forward KL, 0.5 = JSD, 1.0 = reverse KL." + }, + ) + reverse_kl_top_1_mode: str = field( + default="sampled", + metadata={ + "help": "Reverse-KL top-1 token selection when beta > 0 and loss_top_k == 1. " + "Use 'sampled' for the actual completion token or 'argmax' for the student's top-1 token. " + "The forward-KL support always uses the teacher's top-1 token. Ignored when beta == 0 or loss_top_k != 1." + }, + ) + max_completion_length: int = field( + default=512, + metadata={"help": "Maximum number of tokens to generate per completion."}, + ) + max_prompt_length: int | None = field( + default=None, + metadata={ + "help": "Maximum number of tokens for the prompt. If None, auto-computed as " + "max_length - max_completion_length. Prompts are truncated according to the " + "tokenizer's truncation_side setting." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the student model during training."}, + ) + + # Teacher model (local) + teacher_model_name_or_path: str | None = field( + default=None, + metadata={"help": "Model name or path for the teacher model."}, + ) + teacher_model_revision: str | None = field( + default=None, + metadata={"help": "Model revision of the teacher model (e.g., branch name, tag, or commit hash)."}, + ) + teacher_model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained` when instantiating the teacher." + }, + ) + + # Teacher model (external vLLM server) + use_teacher_server: bool = field( + default=False, + metadata={"help": "Whether to use an external vLLM teacher server instead of a local teacher model."}, + ) + teacher_model_server_url: str | None = field( + default=None, + metadata={ + "help": 'Base URL of a vLLM server hosting the teacher model (e.g., "http://localhost:8000"). ' + "Required when use_teacher_server=True." + }, + ) + loss_top_k: int = field( + default=1, + metadata={ + "help": "Number of top tokens to use when computing the JSD/KL loss. " + "Both student and teacher distributions are restricted to these K tokens " + "(selected based on beta: teacher's top-k for forward KL, student's top-k for reverse KL, " + "union of both for JSD) and re-normalized before computing divergence. " + "If 0, the full vocabulary is used (slower but exact). " + "When beta > 0 and loss_top_k == 1, the forward support still uses the teacher's top-1 token, " + "while the reverse top-1 token is controlled by reverse_kl_top_1_mode. " + "When use_teacher_server=True, beta=0 requires loss_top_k > 0 and uses the teacher's top-k " + "logprobs for the forward term. When beta > 0, server-backed distillation requires loss_top_k == 1 " + "and only supports 'sampled' reverse top-1 tokens." + }, + ) + loss_add_tail: bool = field( + default=True, + metadata={ + "help": "Whether to append a tail bucket representing the remaining probability mass outside the selected top-k support." + }, + ) + + # On-policy generation + num_generations: int = field( + default=1, + metadata={"help": "Number of completions to generate per prompt during on-policy generation."}, + ) + generation_batch_size: int | None = field( + default=None, + metadata={ + "help": "Number of unique prompts per worker per optimizer step. " + "If None, computed from (per_device_train_batch_size * gradient_accumulation_steps) // num_generations." + }, + ) + top_p: float = field( + default=0.95, + metadata={"help": "Top-p (nucleus) sampling parameter for on-policy generation."}, + ) + top_k: int = field( + default=0, + metadata={"help": "Top-k sampling parameter for on-policy generation. 0 disables top-k filtering."}, + ) + + # vLLM for student generation + use_vllm: bool = field( + default=False, + metadata={"help": "Whether to use vLLM for generating on-policy completions from the student model."}, + ) + vllm_mode: str = field( + default="colocate", + metadata={"help": 'Mode for student vLLM integration. Either "server" or "colocate".'}, + ) + vllm_server_base_url: str | None = field( + default=None, + metadata={"help": "Base URL for the student vLLM server."}, + ) + vllm_server_host: str = field( + default="0.0.0.0", + metadata={"help": "Host of the student vLLM server."}, + ) + vllm_server_port: int = field( + default=8001, + metadata={"help": "Port of the student vLLM server."}, + ) + vllm_server_timeout: float = field( + default=240.0, + metadata={"help": "Timeout for connecting to the student vLLM server."}, + ) + vllm_group_port: int = field( + default=51216, + metadata={"help": "Port for the vLLM weight-update group (NCCL communicator)."}, + ) + vllm_gpu_memory_utilization: float = field( + default=0.3, + metadata={"help": "GPU memory utilization for the colocated student vLLM engine."}, + ) + vllm_tensor_parallel_size: int = field( + default=1, + metadata={"help": "Tensor parallel size for the colocated student vLLM engine."}, + ) + vllm_max_model_length: int | None = field( + default=None, + metadata={"help": "Maximum model sequence length for the colocated vLLM engine."}, + ) + vllm_model_impl: str = field( + default="vllm", + metadata={"help": 'Model implementation backend for vLLM. Use "vllm" or "transformers".'}, + ) + vllm_structured_outputs_regex: str | None = field( + default=None, + metadata={"help": "Regex pattern for vLLM structured outputs."}, + ) + vllm_sync_frequency: int = field( + default=1, + metadata={"help": "Frequency (in training steps) to synchronize student weights to the vLLM engine."}, + ) + vllm_enable_sleep_mode: bool = field( + default=False, + metadata={"help": "Enable vLLM sleep mode to offload student weights during the optimizer step."}, + ) + + # W&B + + # Logging + log_completions: bool = field( + default=False, + metadata={ + "help": "Whether to log a sample of (prompt, completion) pairs every `log_completions_steps` steps. If `rich` is " + "installed, it prints the sample. If `wandb` and/or `trackio` logging is enabled, it logs it to `wandb` " + "and/or `trackio`." + }, + ) + log_completions_steps: int = field( + default=100, + metadata={"help": "Number of steps between logging completions."}, + ) + num_completions_to_print: int | None = field( + default=None, + metadata={"help": "Number of completions to print. If None, all completions are logged."}, + ) + + def __post_init__(self): + super().__post_init__() + + if self.lmbda < 0.0 or self.lmbda > 1.0: + raise ValueError(f"lmbda must be in [0.0, 1.0], got {self.lmbda}.") + if self.beta < 0.0 or self.beta > 1.0: + raise ValueError(f"beta must be in [0.0, 1.0], got {self.beta}.") + if self.reverse_kl_top_1_mode not in {"sampled", "argmax"}: + raise ValueError("reverse_kl_top_1_mode must be one of: 'sampled', 'argmax'") + + if self.max_length is not None and self.max_completion_length >= self.max_length: + raise ValueError( + f"max_completion_length ({self.max_completion_length}) must be smaller than " + f"max_length ({self.max_length}) to leave room for the prompt." + ) + + if self.max_prompt_length is None and self.max_length is not None: + self.max_prompt_length = self.max_length - self.max_completion_length + + if self.num_generations < 1: + raise ValueError(f"num_generations must be at least 1, got {self.num_generations}.") + + local_sequence_batch_size = self.per_device_train_batch_size * self.gradient_accumulation_steps + if self.generation_batch_size is None: + self.generation_batch_size = local_sequence_batch_size // self.num_generations + if self.generation_batch_size < 1: + raise ValueError(f"generation_batch_size must be at least 1, got {self.generation_batch_size}.") + if self.generation_batch_size * self.num_generations != local_sequence_batch_size: + raise ValueError( + "generation_batch_size * num_generations must equal per_device_train_batch_size * " + f"gradient_accumulation_steps. Got {self.generation_batch_size} * {self.num_generations} != " + f"{self.per_device_train_batch_size} * {self.gradient_accumulation_steps}." + ) + + if self.use_teacher_server and self.use_liger_kernel: + raise ValueError( + "use_liger_kernel=True is not supported with use_teacher_server=True because the Liger loss path " + "requires a local teacher model." + ) + if self.use_teacher_server and ( + self.teacher_model_server_url is None or not self.teacher_model_server_url.strip() + ): + raise ValueError("teacher_model_server_url must be set when use_teacher_server=True.") + + if self.use_teacher_server and self.beta == 0 and self.loss_top_k < 1: + raise ValueError( + f"loss_top_k must be positive when using use_teacher_server=True with beta=0 " + f"(got loss_top_k={self.loss_top_k}). The pure forward server path only has access to the " + f"teacher's top-k logprobs, so it cannot compute the exact full-vocabulary loss when loss_top_k=0." + ) + if self.use_teacher_server and self.reverse_kl_top_1_mode == "argmax": + raise ValueError( + "reverse_kl_top_1_mode='argmax' is not supported with use_teacher_server=True because the server " + "cannot provide teacher logprobs for arbitrary student-selected tokens." + ) + if self.use_teacher_server and self.beta > 0 and self.loss_top_k != 1: + raise ValueError( + f"loss_top_k must be 1 when using use_teacher_server=True with beta>0 " + f"(got loss_top_k={self.loss_top_k}). Mixed forward/reverse distillation with an external teacher " + "is only implemented for top-1 support." + ) + if self.reverse_kl_top_1_mode != "sampled" and (self.beta == 0 or self.loss_top_k != 1): + warnings.warn( + f"reverse_kl_top_1_mode='{self.reverse_kl_top_1_mode}' has no effect when beta={self.beta} " + f"and loss_top_k={self.loss_top_k}. It only applies when beta > 0 and loss_top_k == 1.", + UserWarning, + stacklevel=2, + ) + + if self.num_generations > 1 and self.lmbda < 1.0: + warnings.warn( + f"num_generations={self.num_generations} with lmbda={self.lmbda} means off-policy batches include " + f"{self.num_generations} copies of each sample. Consider lmbda=1.0 when num_generations > 1.", + UserWarning, + stacklevel=2, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/distillation_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/distillation_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..283543b2764d2f7ebe190b78e3c5bd7d93aa6166 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/distillation/distillation_trainer.py @@ -0,0 +1,1748 @@ +# Copyright 2020-2026 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 random +import textwrap +import warnings +from collections import defaultdict +from collections.abc import Callable +from contextlib import nullcontext +from functools import partial +from typing import Any, Optional + +import torch +import torch.distributed as dist +import torch.nn as nn +import torch.nn.functional as F +from accelerate.utils import DistributedType, broadcast_object_list, gather_object +from datasets import Dataset +from torch.utils.data import DataLoader +from transformers import AutoTokenizer, TrainerCallback, is_trackio_available, is_wandb_available +from transformers.data.data_collator import DataCollator +from transformers.feature_extraction_utils import FeatureExtractionMixin +from transformers.generation.configuration_utils import GenerationConfig +from transformers.image_processing_utils import BaseImageProcessor +from transformers.modeling_utils import PreTrainedModel +from transformers.processing_utils import ProcessorMixin +from transformers.tokenization_utils_base import PreTrainedTokenizerBase +from transformers.trainer_utils import EvalPrediction, seed_worker +from transformers.utils import is_liger_kernel_available, is_peft_available, is_rich_available + +from ...extras.profiling import profiling_decorator +from ...generation.vllm_generation import VLLMGeneration +from ...import_utils import is_vllm_available +from ...models import prepare_deepspeed +from ...models.utils import _ForwardRedirection, unwrap_model_for_generation +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import ( + RepeatSampler, + create_model_from_path, + disable_dropout_in_model, + pad, + split_tensor_dict, +) +from .distillation_config import DistillationConfig + + +if is_peft_available(): + from peft import PeftConfig, get_peft_model + +if is_liger_kernel_available(): + from liger_kernel.chunked_loss import LigerFusedLinearJSDLoss + +if is_wandb_available(): + import wandb + +if is_trackio_available(): + import trackio + +if is_rich_available(): + from rich.console import Console + from rich.panel import Panel + from rich.table import Table + from rich.text import Text + + +def _print_completions_sample(prompts: list[str], completions: list[str], step: int, num_samples: int = None) -> None: + """Print a sample of prompt-completion pairs using rich.""" + if not is_rich_available(): + return + + console = Console() + table = Table(show_header=True, header_style="bold white", expand=True) + table.add_column("Prompt", style="bright_yellow") + table.add_column("Completion", style="bright_green") + + if num_samples is not None: + if num_samples >= len(prompts): + num_samples = None + elif num_samples <= 0: + return + + if num_samples is not None: + indices = random.sample(range(len(prompts)), num_samples) + prompts = [prompts[i] for i in indices] + completions = [completions[i] for i in indices] + + for prompt, completion in zip(prompts, completions, strict=True): + table.add_row(Text(prompt), Text(completion)) + table.add_section() + + panel = Panel(table, expand=False, title=f"Step {step}", border_style="bold white") + console.print(panel) + + +def _add_tail_bucket(log_probs, valid_mask): + """Append a (K+1)-th tail element: log(1 - sum(exp(top_k_logps))). + + This creates a proper probability distribution over K+1 elements, preventing trivial zero loss when top_k is small + (especially top_k=1). + """ + log_sum = torch.logsumexp(log_probs, dim=-1, keepdim=True) + log_sum = torch.clamp(log_sum, max=-1e-7) # ensure sum < 1 + tail = torch.log(-torch.expm1(log_sum)) # log(1 - exp(log_sum)) + tail_mask = torch.ones_like(valid_mask[..., :1], dtype=torch.bool) + return torch.cat([log_probs, tail], dim=-1), torch.cat([valid_mask, tail_mask], dim=-1) + + +def _jsd_divergence(student_log_probs, teacher_log_probs, beta, support_mask=None): + """Compute JSD (or forward/reverse KL) from log-probability tensors. + + When *support_mask* is not None, uses manual computation with masked positions zeroed. When None, uses + ``F.kl_div``. + """ + if support_mask is not None: + safe_student = torch.where(support_mask, student_log_probs, torch.zeros_like(student_log_probs)) + safe_teacher = torch.where(support_mask, teacher_log_probs, torch.zeros_like(teacher_log_probs)) + student_probs = torch.where(support_mask, student_log_probs.exp(), torch.zeros_like(student_log_probs)) + teacher_probs = torch.where(support_mask, teacher_log_probs.exp(), torch.zeros_like(teacher_log_probs)) + + if beta == 0: + return torch.nan_to_num(teacher_probs * (safe_teacher - safe_student), nan=0.0) + elif beta == 1: + return torch.nan_to_num(student_probs * (safe_student - safe_teacher), nan=0.0) + else: + beta_t = torch.tensor(beta, dtype=student_log_probs.dtype, device=student_log_probs.device) + tiny = torch.finfo(student_probs.dtype).tiny + mixture_probs = (1 - beta_t) * student_probs + beta_t * teacher_probs + safe_mixture = torch.where( + support_mask, + torch.log(mixture_probs.clamp_min(tiny)), + torch.zeros_like(student_log_probs), + ) + kl_teacher = torch.nan_to_num(teacher_probs * (safe_teacher - safe_mixture), nan=0.0) + kl_student = torch.nan_to_num(student_probs * (safe_student - safe_mixture), nan=0.0) + return beta_t * kl_teacher + (1 - beta_t) * kl_student + else: + if beta == 0: + return F.kl_div(student_log_probs, teacher_log_probs, reduction="none", log_target=True) + elif beta == 1: + return F.kl_div(teacher_log_probs, student_log_probs, reduction="none", log_target=True) + else: + beta_t = torch.tensor(beta, dtype=student_log_probs.dtype, device=student_log_probs.device) + mixture_log_probs = torch.logsumexp( + torch.stack([student_log_probs + torch.log1p(-beta_t), teacher_log_probs + torch.log(beta_t)]), + dim=0, + ) + kl_teacher = F.kl_div(mixture_log_probs, teacher_log_probs, reduction="none", log_target=True) + kl_student = F.kl_div(mixture_log_probs, student_log_probs, reduction="none", log_target=True) + return beta_t * kl_teacher + (1 - beta_t) * kl_student + + +def build_teacher_request_inputs( + input_ids: torch.Tensor, + attention_mask: torch.Tensor, + prompt_attention_mask: torch.Tensor | None = None, + labels: torch.Tensor | None = None, +) -> tuple[list[list[int]], list[int], list[int]]: + """Trim padded batch tensors into per-sample sequences for teacher-server requests.""" + + if input_ids.shape != attention_mask.shape: + raise ValueError( + f"input_ids and attention_mask must have the same shape, got {input_ids.shape} and {attention_mask.shape}." + ) + + input_ids_cpu = input_ids.detach().cpu() + attention_mask_cpu = attention_mask.detach().cpu().bool() + + if prompt_attention_mask is not None: + prompt_lengths = prompt_attention_mask.detach().cpu().sum(dim=1).to(torch.long) + else: + if labels is None: + raise ValueError("labels are required when prompt_attention_mask is not provided.") + if labels.shape != input_ids.shape: + raise ValueError(f"labels must match input_ids shape, got {labels.shape} and {input_ids.shape}.") + full_lengths = attention_mask_cpu.sum(dim=1).to(torch.long) + completion_lengths = (labels.detach().cpu() != -100).sum(dim=1).to(torch.long) + prompt_lengths = full_lengths - completion_lengths + + trimmed_input_ids: list[list[int]] = [] + prompt_lengths_list: list[int] = [] + completion_lengths_list: list[int] = [] + + for row, mask, prompt_length in zip(input_ids_cpu, attention_mask_cpu, prompt_lengths, strict=True): + trimmed_row = row[mask] + prompt_len = int(prompt_length.item()) + if prompt_len < 0 or prompt_len > trimmed_row.numel(): + raise ValueError( + f"Invalid prompt length {prompt_len} for trimmed sequence of length {trimmed_row.numel()}." + ) + trimmed_input_ids.append(trimmed_row.tolist()) + prompt_lengths_list.append(prompt_len) + completion_lengths_list.append(int(trimmed_row.numel()) - prompt_len) + + return trimmed_input_ids, prompt_lengths_list, completion_lengths_list + + +class _DistillationCollator: + """Data collator for the distillation trainer with independent prompt/completion budgets. + + Unlike ``DataCollatorForChatML``, this collator tokenizes prompts and completions separately so that long + completions can never truncate the prompt to empty. It also handles prompt-only data (no assistant completions) for + pure on-policy distillation (``lmbda=1``). + """ + + def __init__( + self, + tokenizer: "PreTrainedTokenizerBase", + max_length: int, + max_prompt_length: int, + messages_key: str = "messages", + ignore_index: int = -100, + ): + self.tokenizer = tokenizer + self.max_length = max_length + self.max_prompt_length = max_prompt_length + self.messages_key = messages_key + self.ignore_index = ignore_index + + if tokenizer.pad_token_id is None: + raise ValueError("The tokenizer does not have a pad token. Please set `pad_token_id` in the tokenizer.") + + def __call__(self, examples: list[dict[str, Any]]) -> dict[str, torch.Tensor]: + all_input_ids: list[list[int]] = [] + all_labels: list[list[int]] = [] + all_prompt_ids: list[list[int]] = [] + + for example in examples: + messages = example[self.messages_key] + + # Split: prompt = everything before the last assistant turn, completion = last assistant turn + has_completion = len(messages) > 1 and messages[-1].get("role") == "assistant" + prompt_messages = messages[:-1] if has_completion else messages + + # Tokenize prompt with its own budget using the tokenizer's truncation side + formatted_prompt = self.tokenizer.apply_chat_template( + prompt_messages, tokenize=False, add_generation_prompt=True + ) + prompt_ids = self.tokenizer( + formatted_prompt, + truncation=True, + max_length=self.max_prompt_length, + padding=False, + add_special_tokens=False, + )["input_ids"] + + if has_completion: + # Tokenize the full message (prompt + completion) without truncation first + formatted_full = self.tokenizer.apply_chat_template( + messages, tokenize=False, add_generation_prompt=False + ) + full_ids = self.tokenizer(formatted_full, truncation=False, padding=False, add_special_tokens=False)[ + "input_ids" + ] + + # Identify completion tokens: everything after the prompt in the full sequence. + # Use the un-truncated prompt length as the split point. + formatted_prompt_ids = self.tokenizer( + formatted_prompt, truncation=False, padding=False, add_special_tokens=False + )["input_ids"] + completion_ids = full_ids[len(formatted_prompt_ids) :] + + # Trim completion so prompt + completion <= max_length + max_comp = self.max_length - len(prompt_ids) + if max_comp > 0 and len(completion_ids) > max_comp: + completion_ids = completion_ids[:max_comp] + elif max_comp <= 0: + completion_ids = [] + + input_ids = prompt_ids + completion_ids + labels = [self.ignore_index] * len(prompt_ids) + list(completion_ids) + else: + # Prompt-only: no completion to train on (on-policy will generate one) + input_ids = list(prompt_ids) + labels = [self.ignore_index] * len(prompt_ids) + + all_input_ids.append(input_ids) + all_labels.append(labels) + all_prompt_ids.append(list(prompt_ids)) + + # Convert to tensors and left-pad + pad_id = self.tokenizer.pad_token_id + input_ids_t = pad( + [torch.tensor(ids, dtype=torch.long) for ids in all_input_ids], + padding_side="left", + padding_value=pad_id, + ) + attention_mask_t = pad( + [torch.ones(len(ids), dtype=torch.long) for ids in all_input_ids], + padding_side="left", + padding_value=0, + ) + labels_t = pad( + [torch.tensor(lab, dtype=torch.long) for lab in all_labels], + padding_side="left", + padding_value=self.ignore_index, + ) + prompts_t = pad( + [torch.tensor(ids, dtype=torch.long) for ids in all_prompt_ids], + padding_side="left", + padding_value=pad_id, + ) + prompt_mask_t = pad( + [torch.ones(len(ids), dtype=torch.long) for ids in all_prompt_ids], + padding_side="left", + padding_value=0, + ) + + return { + "input_ids": input_ids_t, + "attention_mask": attention_mask_t, + "labels": labels_t, + "prompts": prompts_t, + "prompt_attention_mask": prompt_mask_t, + } + + +class _RepeatBatchDataLoader: + """Repeats each collated batch ``repeat_count`` times without re-collation. + + ``RepeatSampler`` with ``repeat_count > 1`` causes the DataLoader to re-collate (re-tokenize) the same examples on + every repeat, which is wasteful. This wrapper instead keeps ``repeat_count=1`` in the sampler and repeats the + already-collated tensor dict, avoiding redundant tokenization. + """ + + def __init__(self, dataloader, repeat_count: int): + self.dataloader = dataloader + self.repeat_count = repeat_count + + def __iter__(self): + for batch in self.dataloader: + for _ in range(self.repeat_count): + yield batch + + def __len__(self): + return len(self.dataloader) * self.repeat_count + + def set_epoch(self, epoch: int): + if hasattr(self.dataloader, "set_epoch"): + self.dataloader.set_epoch(epoch) + + def __getattr__(self, attr): + return getattr(self.dataloader, attr) + + +class DistillationTrainer(_BaseTrainer): + """ + Trainer for knowledge distillation from a teacher model to a student model. + + Supports: + - Generalized JSD loss (forward KL, reverse KL, or interpolated JSD via `beta`) + - On-policy / off-policy mixing via `lmbda` (buffered across gradient accumulation) + - Local teacher model or external teacher via vLLM server + - Student on-policy generation via vLLM or model.generate() + - Liger kernel for memory-efficient fused JSD loss + """ + + _tag_names = ["trl", "distillation"] + _name = "Distillation" + _paper = { + "title": "On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes", + "id": "2306.13649", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @inproceedings{agarwal2024on-policy, + title = {{On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes}}, + author = {Rishabh Agarwal and Nino Vieillard and Yongchao Zhou and Piotr Stanczyk and Sabela Ramos Garea and Matthieu Geist and Olivier Bachem}, + year = 2024, + booktitle = {The Twelfth International Conference on Learning Representations, {ICLR} 2024, Vienna, Austria, May 7-11, 2024}, + publisher = {OpenReview.net}, + url = {https://openreview.net/forum?id=3zKtaqxLhW}, + }"""), + } + + def __init__( + self, + model: PreTrainedModel | nn.Module | str | None = None, + teacher_model: PreTrainedModel | nn.Module | str = None, + args: DistillationConfig | None = None, + data_collator: DataCollator | None = None, # type: ignore + train_dataset: Dataset | None = None, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + processing_class: PreTrainedTokenizerBase + | BaseImageProcessor + | FeatureExtractionMixin + | ProcessorMixin + | None = None, + compute_metrics: Callable[[EvalPrediction], dict] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + peft_config: Optional["PeftConfig"] = None, + ): + if args is None: + args = DistillationConfig(output_dir="tmp_distillation") + + # ── Student model loading ── + model_init_kwargs = args.model_init_kwargs or {} + if isinstance(model_init_kwargs, str): + import json + + model_init_kwargs = json.loads(model_init_kwargs) + teacher_model_init_kwargs = args.teacher_model_init_kwargs or {} + if isinstance(teacher_model_init_kwargs, str): + import json + + teacher_model_init_kwargs = json.loads(teacher_model_init_kwargs) + if isinstance(model, str): + model_name_or_path = model + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + model = create_model_from_path(model, **model_init_kwargs) + else: + model_name_or_path = model.config._name_or_path if model is not None else None + + # ── Processing class (tokenizer) ── + if processing_class is None and model_name_or_path is not None: + processing_class = AutoTokenizer.from_pretrained( + model_name_or_path, trust_remote_code=args.trust_remote_code + ) + if processing_class is not None: + if getattr(processing_class, "pad_token", None) is None: + processing_class.pad_token = processing_class.eos_token + + # ── PEFT ── + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + model = get_peft_model(model, peft_config) + + # ── Data collator ── + if data_collator is None: + data_collator = _DistillationCollator( + tokenizer=processing_class, + max_length=args.max_length, + max_prompt_length=args.max_prompt_length, + ) + + # ── Liger fused JSD loss ── + self.use_liger_loss = False + if args.use_liger_kernel: + self.liger_jsd_loss = LigerFusedLinearJSDLoss( + beta=args.beta, + ignore_index=-100, + temperature=args.temperature, + compiled=False, + weight_hard_loss=0.0, + weight_soft_loss=1.0, + ) + self.use_liger_loss = True + self._forward_redirection = _ForwardRedirection() + + # ── Teacher model setup ── + self.teacher_client = None + self.use_teacher_server = args.use_teacher_server + self.teacher_model_server_url = args.teacher_model_server_url + self._local_teacher_tokenizer_matches_student = True + if self.use_teacher_server: + from ...generation.vllm_client import VLLMClient + + self.teacher_client = VLLMClient(base_url=self.teacher_model_server_url, connection_timeout=60.0) + teacher_model = None + elif teacher_model is not None: + if args.teacher_model_init_kwargs is not None and not isinstance(teacher_model, str): + raise ValueError( + "You passed teacher_model_init_kwargs to the config, but your teacher_model is already " + "instantiated." + ) + + teacher_model_name_or_path = ( + teacher_model + if isinstance(teacher_model, str) + else getattr(getattr(teacher_model, "config", None), "_name_or_path", None) + ) + if teacher_model_name_or_path is None: + raise ValueError( + "DistillationTrainer requires a local teacher model with `config._name_or_path` set so its " + "tokenizer can be validated against the student tokenizer." + ) + + teacher_model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + teacher_tokenizer_kwargs = {} + teacher_revision = teacher_model_init_kwargs.get("revision", args.teacher_model_revision) + if teacher_revision is not None: + teacher_tokenizer_kwargs["revision"] = teacher_revision + teacher_tokenizer_kwargs["trust_remote_code"] = teacher_model_init_kwargs["trust_remote_code"] + teacher_processing_class = AutoTokenizer.from_pretrained( + teacher_model_name_or_path, **teacher_tokenizer_kwargs + ) + if getattr(teacher_processing_class, "pad_token", None) is None: + teacher_processing_class.pad_token = teacher_processing_class.eos_token + self._local_teacher_tokenizer_matches_student = self._local_teacher_tokenizers_match( + processing_class, teacher_processing_class + ) + if not self._local_teacher_tokenizer_matches_student: + warnings.warn( + "DistillationTrainer's built-in local-teacher loss assumes the student and teacher share the " + "same tokenizer. The loaded local teacher tokenizer does not match the student tokenizer, so " + "the teacher weights will be left unchanged for subclass overrides. Direct use of the base " + "DistillationTrainer with this local teacher remains unsupported.", + UserWarning, + stacklevel=2, + ) + + if isinstance(teacher_model, str): + dtype = teacher_model_init_kwargs.get("dtype") + teacher_model_init_kwargs["dtype"] = dtype if dtype in ["auto", None] else getattr(torch, dtype) + + if isinstance(teacher_model, str): + init_kwargs = dict(teacher_model_init_kwargs) + if args.teacher_model_revision is not None: + init_kwargs.setdefault("revision", args.teacher_model_revision) + teacher_model = create_model_from_path(teacher_model, **init_kwargs) + + # Trainer does not need to remove unused columns — the collator handles raw data + args.remove_unused_columns = False + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + # ── Prepare teacher model (after super().__init__ so accelerator is ready) ── + if teacher_model is not None: + if self._local_teacher_tokenizer_matches_student: + teacher_model.resize_token_embeddings(self.model.config.get_text_config().vocab_size) + if self.is_deepspeed_enabled: + self.teacher_model = prepare_deepspeed(teacher_model, self.accelerator) + else: + self.teacher_model = self.accelerator.prepare_model(teacher_model, evaluation_mode=True) + else: + self.teacher_model = None + + if args.disable_dropout: + disable_dropout_in_model(self.model) + + # ── Store config values ── + self.lmbda = args.lmbda + self.beta = args.beta + self.temperature = args.temperature + self.top_p = args.top_p + self.num_generations = args.num_generations + self.reverse_kl_top_1_mode = args.reverse_kl_top_1_mode + self.loss_top_k = args.loss_top_k + self.loss_add_tail = args.loss_add_tail + + # ── Buffer state ── + self._buffered_inputs = None + self._buffered_on_policy_flags = None + self._buffered_text_logs = None + self._buffer_step = 0 + + # ── Loss tracking ── + self._on_policy_loss_total = 0.0 + self._off_policy_loss_total = 0.0 + self._on_policy_step_equiv = 0.0 + self._off_policy_step_equiv = 0.0 + + # ── Generation config ── + generation_kwargs = { + "max_new_tokens": args.max_completion_length, + "temperature": args.temperature, + "top_p": args.top_p, + "do_sample": True, + "top_k": args.top_k, + "pad_token_id": self.processing_class.pad_token_id, + } + self.generation_config = GenerationConfig(**generation_kwargs) + self.generation_kwargs = generation_kwargs + if ( + hasattr(self.model.generation_config, "eos_token_id") + and self.model.generation_config.eos_token_id is not None + ): + self.generation_config.eos_token_id = self.model.generation_config.eos_token_id + + # ── Metrics & Logging ── + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + self._total_train_tokens = 0 + self.log_completions = args.log_completions + self.log_completions_steps = args.log_completions_steps + self.num_completions_to_print = args.num_completions_to_print + + self._textual_logs = { + "prompt": [], + "completion": [], + } + + # ── vLLM for student generation ── + self.use_vllm = args.use_vllm + if self.use_vllm: + if not is_vllm_available(): + raise ImportError( + "vLLM is not available and use_vllm is set to True. Please install vLLM with " + "`pip install vllm` to use it." + ) + self.vllm_generation = VLLMGeneration( + model=self.model, + accelerator=self.accelerator, + processing_class=self.processing_class, + mode=args.vllm_mode, + structured_outputs_regex=args.vllm_structured_outputs_regex, + server_base_url=args.vllm_server_base_url, + server_host=args.vllm_server_host, + server_port=args.vllm_server_port, + group_port=args.vllm_group_port, + server_timeout=args.vllm_server_timeout, + tensor_parallel_size=args.vllm_tensor_parallel_size, + gpu_memory_utilization=args.vllm_gpu_memory_utilization, + max_model_length=args.vllm_max_model_length, + max_num_seqs=args.per_device_train_batch_size * args.gradient_accumulation_steps, + enable_sleep_mode=args.vllm_enable_sleep_mode, + model_impl=args.vllm_model_impl, + temperature=args.temperature, + top_p=args.top_p, + top_k=args.top_k, + max_completion_length=args.max_completion_length, + logprobs=None, + ) + self.vllm_sync_frequency = args.vllm_sync_frequency + self._last_vllm_sync_step = -1 + + @staticmethod + def _local_teacher_tokenizers_match( + student_processing_class: PreTrainedTokenizerBase, + teacher_processing_class: PreTrainedTokenizerBase, + ) -> bool: + """Check whether the student and local teacher tokenizers share the same vocabulary.""" + return student_processing_class.get_vocab() == teacher_processing_class.get_vocab() + + def _raise_if_local_teacher_tokenizer_mismatch(self) -> None: + """Guard the base local-teacher JSD path, while still allowing subclass overrides.""" + if self.teacher_model is not None and not self._local_teacher_tokenizer_matches_student: + raise ValueError( + "DistillationTrainer's built-in local-teacher loss only supports student/teacher pairs that use " + "the same tokenizer. Use a same-tokenizer local teacher, set `use_teacher_server=True`, or " + "override the local teacher loss path in a subclass." + ) + + def _compute_prompt_length(self, inputs: dict[str, torch.Tensor | Any]) -> int: + """Compute the earliest prompt boundary that still includes every completion token in the batch.""" + if inputs.get("labels") is not None: + attention_mask = inputs["attention_mask"] + labels = inputs["labels"] + full_lengths = attention_mask.sum(dim=1) + completion_lengths = (labels != -100).sum(dim=1) + return int((full_lengths - completion_lengths).min().item()) + return inputs["prompts"].shape[1] + + def _get_completion_lengths(self, generated_tokens: torch.Tensor, prompt_width: int) -> torch.Tensor: + """Infer per-sample completion lengths from generated tokens.""" + completion_tokens = generated_tokens[:, prompt_width:] + pad_token_id = self.processing_class.pad_token_id + eos_token_id = self.generation_config.eos_token_id + if eos_token_id is None: + eos_token_ids = set() + elif isinstance(eos_token_id, int): + eos_token_ids = {eos_token_id} + else: + eos_token_ids = set(eos_token_id) + pad_equals_eos = pad_token_id is not None and pad_token_id in eos_token_ids + + completion_lengths = [] + for row in completion_tokens.tolist(): + if pad_equals_eos and eos_token_ids: + completion_length = len(row) + for idx, token_id in enumerate(row): + if token_id in eos_token_ids: + completion_length = idx + 1 + break + elif pad_token_id is not None: + completion_length = len(row) + while completion_length > 0 and row[completion_length - 1] == pad_token_id: + completion_length -= 1 + else: + completion_length = len(row) + completion_lengths.append(completion_length) + + return torch.tensor(completion_lengths, device=generated_tokens.device, dtype=torch.long) + + # ────────────────────────────────────────────────────────────────────── + # Dataset / Dataloader + # ────────────────────────────────────────────────────────────────────── + + def _set_signature_columns_if_needed(self): + super()._set_signature_columns_if_needed() + extra_columns = ["prompts", "prompt_attention_mask", "messages", "chat_template_kwargs", "tools"] + if self._signature_columns is None: + self._signature_columns = extra_columns + else: + for col in extra_columns: + if col not in self._signature_columns: + self._signature_columns.append(col) + + def _get_train_sampler(self, dataset=None): + if dataset is None: + dataset = self.train_dataset + return RepeatSampler( + data_source=dataset, + mini_repeat_count=self.num_generations, + batch_size=self.args.generation_batch_size * self.accelerator.num_processes, + repeat_count=1, + shuffle=True, + seed=self.args.seed, + ) + + def get_train_dataloader(self): + """ + Override to load one generation batch per optimizer window. + + The dataloader yields batches of size `per_device_train_batch_size * gradient_accumulation_steps`. + RepeatSampler ensures each generation batch is repeated `gradient_accumulation_steps` times so the Trainer's + loop iterates the correct number of times. + """ + if self.train_dataset is None: + raise ValueError("Trainer: training requires a train_dataset.") + + train_dataset = self.train_dataset + data_collator = self.data_collator + + dataloader_params = { + "batch_size": self._train_batch_size * self.args.gradient_accumulation_steps, + "collate_fn": data_collator, + "num_workers": self.args.dataloader_num_workers, + "pin_memory": self.args.dataloader_pin_memory, + "persistent_workers": self.args.dataloader_persistent_workers, + } + + if not isinstance(train_dataset, torch.utils.data.IterableDataset): + dataloader_params["sampler"] = self._get_train_sampler() + dataloader_params["drop_last"] = self.args.dataloader_drop_last + dataloader_params["worker_init_fn"] = partial( + seed_worker, + num_workers=self.args.dataloader_num_workers, + rank=self.args.process_index, + ) + if self.args.dataloader_num_workers > 0: + dataloader_params["prefetch_factor"] = self.args.dataloader_prefetch_factor + + base_dataloader = self.accelerator.prepare(DataLoader(train_dataset, **dataloader_params)) + return _RepeatBatchDataLoader(base_dataloader, repeat_count=self.args.gradient_accumulation_steps) + + # ────────────────────────────────────────────────────────────────────── + # Buffering: on/off-policy mixing across gradient accumulation steps + # ────────────────────────────────────────────────────────────────────── + + @profiling_decorator + def _prepare_inputs(self, generation_batch: dict[str, torch.Tensor | Any]) -> dict[str, torch.Tensor | Any]: + if not self.model.training: + return generation_batch + + buffer_steps = self.args.gradient_accumulation_steps + if self._buffer_step % buffer_steps == 0 or self._buffered_inputs is None: + self._fill_buffer(generation_batch, buffer_steps) + + slice_idx = self._buffer_step % buffer_steps + inputs = self._buffered_inputs[slice_idx] + self._buffer_step += 1 + return inputs + + @profiling_decorator + def _fill_buffer(self, generation_batch: dict[str, torch.Tensor | Any], buffer_steps: int): + """Split batch into slices and decide which are on-policy (student-generated) vs off-policy.""" + slices = split_tensor_dict(generation_batch, buffer_steps) + + # Decide on-policy flags (synchronized across processes) + if self.accelerator.is_main_process: + on_policy_flags = [random.random() <= self.lmbda for _ in range(buffer_steps)] + else: + on_policy_flags = [False] * buffer_steps + on_policy_flags = broadcast_object_list(on_policy_flags, from_process=0) + + self._buffered_inputs = [None] * buffer_steps + self._buffered_on_policy_flags = on_policy_flags + self._buffered_text_logs = [None] * buffer_steps + + # Store off-policy slices directly + on_policy_indices = [] + for i, is_on_policy in enumerate(on_policy_flags): + if is_on_policy: + on_policy_indices.append(i) + else: + self._buffered_inputs[i] = slices[i] + + # Generate student completions for on-policy slices + if on_policy_indices: + self._generate_student_completions(slices, on_policy_indices) + + # Gather on-policy text logs once per optimizer step (all processes must participate) + if self.log_completions: + on_policy_prompts = [] + on_policy_completions = [] + for i in on_policy_indices: + if self._buffered_text_logs[i] is not None: + prompts, completions = self._buffered_text_logs[i] + on_policy_prompts.extend(prompts) + on_policy_completions.extend(completions) + self._textual_logs["prompt"].extend(gather_object(on_policy_prompts)) + self._textual_logs["completion"].extend(gather_object(on_policy_completions)) + + @profiling_decorator + def _generate_student_completions(self, slices: list[dict[str, torch.Tensor | Any]], on_policy_indices: list[int]): + """Generate completions from the student model for on-policy training.""" + if not self.use_vllm: + self._generate_with_model(slices, on_policy_indices) + return + + # Collect all prompts across on-policy slices, stripping left-padding so vLLM + # receives only real prompt token IDs (like GRPO trainer). + local_prompts = [] + local_slice_indices = [] + pad_token_id = self.processing_class.pad_token_id + for slice_idx in on_policy_indices: + prompt_mask = slices[slice_idx].get("prompt_attention_mask") + for i, prompt in enumerate(slices[slice_idx]["prompts"]): + if prompt_mask is not None: + prompt = prompt[prompt_mask[i].bool()] + elif pad_token_id is not None: + first_non_pad = (prompt != pad_token_id).nonzero(as_tuple=True)[0] + if len(first_non_pad) > 0: + prompt = prompt[first_non_pad[0] :] + local_prompts.append(prompt) + local_slice_indices.append(slice_idx) + + # Sync student weights to vLLM if needed + if ( + self.state.global_step != self._last_vllm_sync_step + and self.state.global_step % self.vllm_sync_frequency == 0 + ): + self.vllm_generation.sync_weights() + self._last_vllm_sync_step = self.state.global_step + + # Generate completions — pass token IDs directly, no text decoding + prompt_ids_list = [p.tolist() for p in local_prompts] + _, completion_ids, _, _ = self.vllm_generation.generate( + prompts=prompt_ids_list, images=None, num_generations=self.num_generations + ) + + # Process completions into the buffer + self._store_completions_in_buffer( + slices, on_policy_indices, local_slice_indices, local_prompts, completion_ids + ) + + def _generate_with_model(self, slices: list[dict[str, torch.Tensor | Any]], on_policy_indices: list[int]): + """Fallback generation using model.generate() (no vLLM).""" + with unwrap_model_for_generation( + self.model, self.accelerator, generation_kwargs=self.generation_kwargs + ) as unwrapped_model: + for slice_idx in on_policy_indices: + slice_inputs = slices[slice_idx] + generated_outputs = unwrapped_model.generate( + input_ids=slice_inputs["prompts"], + attention_mask=slice_inputs.get("prompt_attention_mask", None), + generation_config=self.generation_config, + return_dict_in_generate=True, + ) + generated_tokens = generated_outputs.sequences + batch_size = generated_tokens.size(0) + device = generated_tokens.device + pad_token_id = self.processing_class.pad_token_id + prompt_width = slice_inputs["prompts"].shape[1] + prompt_mask = slice_inputs.get("prompt_attention_mask") + if prompt_mask is not None: + prompt_token_lengths = prompt_mask.sum(dim=1) + else: + prompt_token_lengths = torch.full((batch_size,), prompt_width, dtype=torch.long, device=device) + completion_lengths = self._get_completion_lengths(generated_tokens, prompt_width) + new_attention_mask, new_labels = self._build_sequence_batch( + generated_tokens, prompt_width, prompt_token_lengths, completion_lengths + ) + + # Decode for logging + prompt_texts = [] + completion_texts = [] + for idx in range(batch_size): + prompt_tokens = slice_inputs["prompts"][idx] + if prompt_mask is not None: + prompt_tokens = prompt_tokens[prompt_mask[idx].bool()] + elif pad_token_id is not None: + prompt_tokens = prompt_tokens[prompt_tokens != pad_token_id] + prompt_texts.append( + self.processing_class.decode(prompt_tokens.tolist(), skip_special_tokens=False) + ) + length = prompt_width + completion_length = int(completion_lengths[idx].item()) + completion_texts.append( + self.processing_class.decode( + generated_tokens[idx, length : length + completion_length].tolist(), + skip_special_tokens=False, + ) + ) + + updated = dict(slice_inputs) + updated["input_ids"] = generated_tokens + updated["attention_mask"] = new_attention_mask + updated["labels"] = new_labels + + self._buffered_inputs[slice_idx] = updated + self._buffered_text_logs[slice_idx] = (prompt_texts, completion_texts) + + def _store_completions_in_buffer( + self, + slices: list[dict[str, torch.Tensor | Any]], + on_policy_indices: list[int], + local_slice_indices: list[int], + local_prompts: list[torch.Tensor], + completion_ids: list, + ): + """Process vLLM completions and store them in the buffer. + + Uses original prompt token IDs directly (no decode/re-encode roundtrip), following the same approach as + GRPOTrainer. + """ + device = self.accelerator.device + pad_token_id = self.processing_class.pad_token_id if self.processing_class.pad_token_id is not None else 0 + max_completion_length = self.generation_config.max_new_tokens + + # Group completions and prompt token IDs by slice + slice_completions = {idx: [] for idx in on_policy_indices} + slice_prompt_ids = {idx: [] for idx in on_policy_indices} + for i, slice_idx in enumerate(local_slice_indices): + slice_completions[slice_idx].append(completion_ids[i]) + slice_prompt_ids[slice_idx].append(local_prompts[i]) + + for slice_idx in on_policy_indices: + slice_inputs = slices[slice_idx] + prompt_id_tensors = slice_prompt_ids[slice_idx] + prompt_width = max(len(p) for p in prompt_id_tensors) + prompt_token_lengths = torch.tensor([len(p) for p in prompt_id_tensors], device=device, dtype=torch.long) + prompt_attention_mask = ( + torch.arange(prompt_width, device=device).unsqueeze(0) + >= (prompt_width - prompt_token_lengths).unsqueeze(1) + ).long() + + # Left-pad prompt token IDs to the longest prompt in this slice + prompt_ids = torch.stack( + [F.pad(p, (prompt_width - len(p), 0), value=pad_token_id) for p in prompt_id_tensors] + ).to(device) + + # Pad/truncate completions (right-pad to max_completion_length) + completion_tensors = [] + completion_ids_for_text = [] + completion_lengths = [] + for comp_ids in slice_completions[slice_idx]: + t = torch.tensor(comp_ids, device=device) + if len(t) > max_completion_length: + t = t[:max_completion_length] + completion_ids_for_text.append(t.tolist()) + completion_lengths.append(len(t)) + if len(t) < max_completion_length: + padding = torch.full((max_completion_length - len(t),), pad_token_id, device=device, dtype=t.dtype) + t = torch.cat([t, padding]) + completion_tensors.append(t) + + completion_ids_padded = torch.stack(completion_tensors) + new_input_ids = torch.cat([prompt_ids, completion_ids_padded], dim=1) + completion_lengths = torch.tensor(completion_lengths, device=device, dtype=torch.long) + new_attention_mask, new_labels = self._build_sequence_batch( + new_input_ids, prompt_width, prompt_token_lengths, completion_lengths + ) + + # Decode for logging only + prompt_texts = self.processing_class.batch_decode( + prompt_id_tensors, skip_special_tokens=False, clean_up_tokenization_spaces=False + ) + completion_texts = self.processing_class.batch_decode( + completion_ids_for_text, skip_special_tokens=False, clean_up_tokenization_spaces=False + ) + + updated = dict(slice_inputs) + updated["input_ids"] = new_input_ids + updated["attention_mask"] = new_attention_mask + updated["labels"] = new_labels + # Update prompts to match the new padding width so prompt_length is consistent + updated["prompts"] = prompt_ids + updated["prompt_attention_mask"] = prompt_attention_mask + + self._buffered_inputs[slice_idx] = updated + self._buffered_text_logs[slice_idx] = (prompt_texts, completion_texts) + + @staticmethod + def _build_sequence_batch( + new_input_ids: torch.Tensor, + prompt_width: int, + prompt_token_lengths: torch.Tensor, + completion_lengths: torch.Tensor, + ) -> tuple[torch.Tensor, torch.Tensor]: + """Build attention mask and labels from prompt/completion lengths.""" + prompt_token_lengths = prompt_token_lengths.to(device=new_input_ids.device, dtype=torch.long) + completion_lengths = completion_lengths.to(device=new_input_ids.device, dtype=torch.long) + positions = torch.arange(new_input_ids.shape[1], device=new_input_ids.device).unsqueeze(0) + prompt_mask = (positions < prompt_width) & (positions >= (prompt_width - prompt_token_lengths).unsqueeze(1)) + completion_mask = (positions >= prompt_width) & (positions < (prompt_width + completion_lengths).unsqueeze(1)) + new_attention_mask = (prompt_mask | completion_mask).long() + + new_labels = torch.full_like(new_input_ids, -100) + new_labels[completion_mask] = new_input_ids[completion_mask] + + return new_attention_mask, new_labels + + # ────────────────────────────────────────────────────────────────────── + # Loss computation + # ────────────────────────────────────────────────────────────────────── + + @staticmethod + def _reduce_divergence_loss(jsd, labels=None, reduction="batchmean", num_items_in_batch=None): + """Reduce a per-token divergence tensor using the trainer's label mask semantics. + + When `num_items_in_batch` is provided (as under gradient accumulation), the divergence is reduced as `sum / + num_items_in_batch`, matching the gradient-accumulation-correct behavior of HF's default cross-entropy. + Otherwise it falls back to the local `reduction` (default `batchmean`). See issue #4719. + """ + mask = None + if labels is not None: + mask = labels != -100 + jsd = jsd[mask] + + if num_items_in_batch is not None: + # Normalize by the global number of valid tokens for gradient-accumulation-correct loss. + jsd_sum = jsd.sum() + if isinstance(num_items_in_batch, torch.Tensor): + num_items_in_batch = num_items_in_batch.to(jsd_sum.device) + return jsd_sum / num_items_in_batch + if reduction == "batchmean": + # clamp_min(1) avoids 0/0 -> nan when a sample has no unmasked positions + # (e.g. completion fully truncated). jsd[mask] is empty -> jsd.sum() == 0, + # so 0/1 == 0 with a valid grad path. + denom = mask.sum().clamp_min(1) if labels is not None else max(jsd.size(0), 1) + return jsd.sum() / denom + elif reduction == "sum": + return jsd.sum() + elif reduction == "mean": + return jsd.mean() + else: + return jsd + + @staticmethod + def generalized_jsd_loss( + student_logits, + teacher_logits, + labels=None, + beta=0.5, + temperature=1.0, + reduction="batchmean", + top_k=0, + add_tail=True, + num_items_in_batch=None, + ): + """ + Compute the generalized Jensen-Shannon Divergence loss for knowledge distillation. + + Args: + student_logits: Tensor of shape (batch_size, sequence_length, vocab_size). + teacher_logits: Tensor of shape (batch_size, sequence_length, vocab_size). + labels: Tensor of shape (batch_size, sequence_length) with -100 for positions to ignore. + beta: Interpolation coefficient. 0.0 = forward KL, 1.0 = reverse KL. + temperature: Softmax temperature. + reduction: 'batchmean', 'sum', 'mean', or 'none'. + top_k: Number of top tokens to restrict the loss to. The support set depends on beta: + beta=0 (forward KL) uses teacher's top-k, beta=1 (reverse KL) uses student's top-k, 0 0 and student_logits.size(-1) > top_k: + neg_inf = torch.full((), float("-inf"), dtype=student_logits.dtype, device=student_logits.device) + student_log_probs_full = F.log_softmax(student_logits, dim=-1) + teacher_log_probs_full = F.log_softmax(teacher_logits, dim=-1) + + if beta == 0: + # Forward KL: teacher-selected support + _, support = teacher_logits.topk(top_k, dim=-1) + support_mask = torch.ones_like(support, dtype=torch.bool) + elif beta == 1: + # Reverse KL: student-selected support + _, support = student_logits.topk(top_k, dim=-1) + support_mask = torch.ones_like(support, dtype=torch.bool) + else: + # JSD: union of both supports (concatenate + deduplicate) + _, student_top = student_logits.topk(top_k, dim=-1) + _, teacher_top = teacher_logits.topk(top_k, dim=-1) + support = torch.cat([teacher_top, student_top], dim=-1) + support_mask = torch.ones(support.shape, dtype=torch.bool, device=support.device) + for i in range(1, support.shape[-1]): + prev_matches = support[..., i : i + 1] == support[..., :i] + prev_valid = support_mask[..., :i] + support_mask[..., i] &= ~(prev_matches & prev_valid).any(dim=-1) + support = torch.where(support_mask, support, torch.zeros_like(support)) + + student_support_logps = student_log_probs_full.gather(-1, support) + teacher_support_logps = teacher_log_probs_full.gather(-1, support) + + # Mask invalid (duplicate) positions with -inf + student_topk_logps = torch.where(support_mask, student_support_logps, neg_inf) + teacher_topk_logps = torch.where(support_mask, teacher_support_logps, neg_inf) + + if add_tail: + # Add tail bucket: append log(1 - sum(exp(top_k_logps))) to preserve + # the remaining probability mass outside the top-k. This prevents trivial + # zero loss when top_k is small (especially top_k=1). + base_support_mask = support_mask + student_log_probs, support_mask = _add_tail_bucket(student_topk_logps, base_support_mask) + teacher_log_probs, _ = _add_tail_bucket(teacher_topk_logps, base_support_mask) + else: + student_log_probs = student_topk_logps - torch.logsumexp(student_topk_logps, dim=-1, keepdim=True) + teacher_log_probs = teacher_topk_logps - torch.logsumexp(teacher_topk_logps, dim=-1, keepdim=True) + else: + student_log_probs = F.log_softmax(student_logits, dim=-1) + teacher_log_probs = F.log_softmax(teacher_logits, dim=-1) + + jsd = _jsd_divergence(student_log_probs, teacher_log_probs, beta, support_mask) + return DistillationTrainer._reduce_divergence_loss( + jsd, labels=labels, reduction=reduction, num_items_in_batch=num_items_in_batch + ) + + def _get_reverse_kl_top_1_tokens( + self, student_scores: torch.Tensor, completion_tokens: torch.Tensor + ) -> torch.Tensor: + """Return the reverse-KL top-1 token IDs for the mixed top-1 loss path. + + Args: + student_scores: Any (B, T, V) tensor whose argmax selects the student's top token + (logits or log-probs — both are order-preserving). + completion_tokens: (B, T) actual token IDs in the completion. + """ + if self.reverse_kl_top_1_mode == "argmax": + return student_scores.argmax(dim=-1) + return completion_tokens + + def _compute_sparse_top_1_divergence_loss( + self, + student_log_probs: torch.Tensor, + teacher_top1_token_ids: torch.Tensor, + teacher_top1_logprobs: torch.Tensor, + reverse_token_ids: torch.Tensor, + reverse_teacher_logprobs: torch.Tensor, + labels: torch.Tensor, + num_items_in_batch=None, + ) -> torch.Tensor: + """Compute exact generalized JSD/KL on top-1 support for the mixed beta>0 path.""" + neg_inf = torch.full((), float("-inf"), dtype=student_log_probs.dtype, device=student_log_probs.device) + + if self.beta == 1: + support = reverse_token_ids.unsqueeze(-1) + support_mask = torch.ones_like(support, dtype=torch.bool) + teacher_support_logprobs = reverse_teacher_logprobs.unsqueeze(-1) + else: + teacher_support = teacher_top1_token_ids.unsqueeze(-1) + reverse_support = reverse_token_ids.unsqueeze(-1) + support = torch.cat([teacher_support, reverse_support], dim=-1) + support_mask = torch.ones_like(support, dtype=torch.bool) + support_mask[..., 1] = support[..., 1] != support[..., 0] + teacher_support_logprobs = torch.stack([teacher_top1_logprobs, reverse_teacher_logprobs], dim=-1) + support = torch.where(support_mask, support, torch.zeros_like(support)) + + student_support_logprobs = student_log_probs.gather(-1, support) + student_support_logprobs = torch.where(support_mask, student_support_logprobs, neg_inf) + teacher_support_logprobs = torch.where(support_mask, teacher_support_logprobs, neg_inf) + + if self.loss_add_tail: + base_support_mask = support_mask + student_sparse_log_probs, support_mask = _add_tail_bucket(student_support_logprobs, base_support_mask) + teacher_sparse_log_probs, _ = _add_tail_bucket(teacher_support_logprobs, base_support_mask) + else: + student_sparse_log_probs = student_support_logprobs - torch.logsumexp( + student_support_logprobs, dim=-1, keepdim=True + ) + teacher_sparse_log_probs = teacher_support_logprobs - torch.logsumexp( + teacher_support_logprobs, dim=-1, keepdim=True + ) + + jsd = _jsd_divergence(student_sparse_log_probs, teacher_sparse_log_probs, self.beta, support_mask) + return self._reduce_divergence_loss( + jsd, labels=labels, reduction="batchmean", num_items_in_batch=num_items_in_batch + ) + + def _compute_local_sparse_top_1_divergence_loss( + self, + student_logits: torch.Tensor, + teacher_logits: torch.Tensor, + completion_tokens: torch.Tensor, + labels: torch.Tensor, + num_items_in_batch=None, + ) -> torch.Tensor: + """Compute the mixed top-1 loss for a local teacher using gathered full-logit probabilities.""" + student_log_probs = F.log_softmax(student_logits / self.temperature, dim=-1) + teacher_log_probs = F.log_softmax(teacher_logits / self.temperature, dim=-1) + + teacher_top1_token_ids = teacher_logits.argmax(dim=-1) + teacher_top1_logprobs = teacher_log_probs.gather(dim=-1, index=teacher_top1_token_ids.unsqueeze(-1)).squeeze( + -1 + ) + reverse_token_ids = self._get_reverse_kl_top_1_tokens(student_logits, completion_tokens) + reverse_teacher_logprobs = teacher_log_probs.gather(dim=-1, index=reverse_token_ids.unsqueeze(-1)).squeeze(-1) + + return self._compute_sparse_top_1_divergence_loss( + student_log_probs=student_log_probs, + teacher_top1_token_ids=teacher_top1_token_ids, + teacher_top1_logprobs=teacher_top1_logprobs, + reverse_token_ids=reverse_token_ids, + reverse_teacher_logprobs=reverse_teacher_logprobs, + labels=labels, + num_items_in_batch=num_items_in_batch, + ) + + def _get_teacher_logits(self, inputs: dict[str, torch.Tensor | Any]) -> torch.Tensor: + """Get teacher logits — dispatches between local model and external server.""" + if self.teacher_model is not None: + self.teacher_model.eval() + with torch.no_grad(): + return self.teacher_model( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + ).logits + elif self.use_teacher_server: + raise NotImplementedError( + "Fetching full teacher logits with use_teacher_server=True is not supported. " + "Server-backed distillation only supports per-token logprobs via " + "`_get_teacher_token_logprobs_from_server`." + ) + else: + raise ValueError("No teacher model or teacher server configured.") + + def _get_teacher_token_logprobs_from_server( + self, + inputs: dict[str, torch.Tensor | Any], + aligned_prompt_length: int, + ) -> dict[str, torch.Tensor]: + """Fetch per-token teacher logprobs from an external vLLM server. + + Returns a dict with: + ``actual_logprobs`` – (batch, completion_length) teacher log-prob for the actual + token at each position (for reverse KL). + ``topk_logprobs`` – (batch, completion_length, K) teacher top-k sorted logprobs + (for forward KL). + ``topk_token_ids`` – (batch, completion_length, K) corresponding token IDs. + """ + import numpy as np + + input_ids = inputs["input_ids"] + batch_size = input_ids.shape[0] + sequences, prompt_lengths, completion_lengths = build_teacher_request_inputs( + input_ids, + inputs["attention_mask"], + prompt_attention_mask=inputs.get("prompt_attention_mask"), + labels=inputs.get("labels"), + ) + + # The pure forward server path can use the requested teacher top-k support. + # When beta > 0, config validation restricts the server-backed path to top-1. + requested_top_k = self.loss_top_k + result = self.teacher_client.get_sequence_logprobs( + sequences=sequences, + prompt_lengths=prompt_lengths, + top_logprobs=requested_top_k, + temperature=self.temperature, + ) + K = requested_top_k + + device = input_ids.device + labels = inputs.get("labels") + if labels is None: + raise ValueError("labels are required to align teacher-server logprobs with the student loss tensors.") + + # The student loss slices tensors in padded-sequence coordinates starting at `aligned_prompt_length`. + # Place each teacher completion into that same coordinate system by locating the first non-masked completion + # token in `labels`. This works for both left-padded off-policy batches and on-policy batches where + # completions are right-padded after a fixed-width prompt block. + completion_offsets = [] + label_mask = labels != -100 + for sample_mask, comp_len in zip(label_mask, completion_lengths, strict=True): + if comp_len == 0: + completion_offsets.append(0) + continue + completion_start = int(torch.nonzero(sample_mask, as_tuple=False)[0].item()) + completion_offsets.append(completion_start - aligned_prompt_length) + + # Size the output tensors to tightly fit the teacher logprobs. Using the full padded + # sequence length would include padding positions with -inf teacher logprobs, producing + # +inf in the forward pass and NaN gradients in the backward pass (0 * inf = NaN). + # Shorter samples in variable-length batches still need the -inf sentinel at the tail; + # downstream loss consumers (_compute_server_sparse_top_1_divergence_loss, + # _compute_server_forward_kl_loss) neutralise those positions before the divergence + # math runs. + completion_length = max( + (offset + len(lps) for offset, lps in zip(completion_offsets, result["logprobs"], strict=True)), + default=0, + ) + + # actual_logprobs: (B, T) — teacher logprob for the actual token + def _actual_to_tensor(key): + arr = np.full((batch_size, completion_length), float("-inf"), dtype=np.float32) + for i, (offset, seq_lps) in enumerate(zip(completion_offsets, result[key], strict=True)): + if seq_lps: + vals = np.array(seq_lps, dtype=np.float32) # (comp_len_i, 1) + arr[i, offset : offset + vals.shape[0]] = vals[:, 0] + return torch.from_numpy(arr).to(device) + + # topk: (B, T, K) + def _topk_to_tensor(key, k, np_dtype, fill): + arr = np.full((batch_size, completion_length, k), fill, dtype=np_dtype) + for i, (offset, seq_vals) in enumerate(zip(completion_offsets, result[key], strict=True)): + if seq_vals: + vals = np.array(seq_vals, dtype=np_dtype) # (comp_len_i, k) + arr[i, offset : offset + vals.shape[0], :] = vals + return torch.from_numpy(arr).to(device) + + return { + "actual_logprobs": _actual_to_tensor("actual_logprobs"), + "topk_logprobs": _topk_to_tensor("logprobs", K, np.float32, float("-inf")), + "topk_token_ids": _topk_to_tensor("logprob_token_ids", K, np.int64, 0), + } + + def _compute_server_sparse_top_1_divergence_loss( + self, + teacher_result: dict[str, torch.Tensor], + student_log_probs: torch.Tensor, + completion_tokens: torch.Tensor, + labels: torch.Tensor, + ) -> torch.Tensor: + """Compute exact sparse top-1 generalized JSD/KL from server-provided teacher logprobs. + + Args: + teacher_result: dict with ``actual_logprobs`` (B, T), ``topk_logprobs`` (B, T, K), + ``topk_token_ids`` (B, T, K). + student_log_probs: (B, T, V) student log-softmax over vocabulary. + completion_tokens: (B, T) actual token IDs in the completion. + labels: (B, T) with -100 for positions to ignore. + """ + topk_teacher_lps = teacher_result["topk_logprobs"] # (B, T, 1) + topk_token_ids = teacher_result["topk_token_ids"] # (B, T, 1) + actual_teacher_lps = teacher_result["actual_logprobs"] # (B, T) + required = labels != -100 + + missing_actual = required & ~torch.isfinite(actual_teacher_lps) + if missing_actual.any(): + missing_count = int(missing_actual.sum().item()) + total_required = int(required.sum().item()) + raise ValueError( + "Teacher server is missing actual-token logprobs for required reverse-KL positions: " + f"{missing_count}/{total_required}." + ) + if self.beta < 1: + teacher_top1_logprobs = topk_teacher_lps.squeeze(-1) + missing_top1 = required & ~torch.isfinite(teacher_top1_logprobs) + if missing_top1.any(): + missing_count = int(missing_top1.sum().item()) + total_required = int(required.sum().item()) + raise ValueError( + "Teacher server is missing top-1 logprobs for required forward-KL positions: " + f"{missing_count}/{total_required}." + ) + + # Replace -inf teacher logprobs at intra-batch padding (labels == -100) with 0 so + # reverse-KL's student_probs·(log_s - log_t) does not leak +inf into the backward pass. + pad_mask_2d = ~required + pad_mask_3d = pad_mask_2d.unsqueeze(-1) + topk_teacher_lps = torch.where(pad_mask_3d, 0.0, topk_teacher_lps) + actual_teacher_lps = torch.where(pad_mask_2d, 0.0, actual_teacher_lps) + + # Server path only supports "sampled" mode — config validation enforces this, but we guard + # explicitly so future relaxations of the config check don't silently change behaviour. + reverse_token_ids = self._get_reverse_kl_top_1_tokens(student_log_probs, completion_tokens) + # The server path normalizes locally (batchmean), not by num_items_in_batch: teacher logprobs may not cover + # every student completion token (the loss is summed over the trimmed teacher window), so the global token + # count would be the wrong denominator. Gradient-accumulation normalization for the server path is left as a + # follow-up. + return self._compute_sparse_top_1_divergence_loss( + student_log_probs=student_log_probs, + teacher_top1_token_ids=topk_token_ids.squeeze(-1), + teacher_top1_logprobs=topk_teacher_lps.squeeze(-1), + reverse_token_ids=reverse_token_ids, + reverse_teacher_logprobs=actual_teacher_lps, + labels=labels, + ) + + def _compute_server_forward_kl_loss( + self, + teacher_result: dict[str, torch.Tensor], + student_log_probs: torch.Tensor, + labels: torch.Tensor, + ) -> torch.Tensor: + """Compute sparse forward KL from server-provided teacher top-k logprobs (beta==0 path). + + Args: + teacher_result: dict with ``topk_logprobs`` (B, T, K) and ``topk_token_ids`` (B, T, K). + student_log_probs: (B, T, V) student log-softmax over vocabulary. + labels: (B, T) with -100 for positions to ignore. + """ + teacher_topk_logprobs = teacher_result["topk_logprobs"] + teacher_topk_token_ids = teacher_result["topk_token_ids"] + valid = teacher_topk_logprobs > float("-inf") + neg_inf = torch.full((), float("-inf"), dtype=student_log_probs.dtype, device=student_log_probs.device) + student_topk_logprobs = student_log_probs.gather(dim=-1, index=teacher_topk_token_ids) + student_topk_logprobs = torch.where(valid, student_topk_logprobs, neg_inf) + teacher_topk_logprobs = torch.where(valid, teacher_topk_logprobs, neg_inf) + + if self.loss_add_tail: + base_support_mask = valid + student_sparse_log_probs, support_mask = _add_tail_bucket(student_topk_logprobs, base_support_mask) + teacher_sparse_log_probs, _ = _add_tail_bucket(teacher_topk_logprobs, base_support_mask) + else: + support_mask = valid + student_sparse_log_probs = student_topk_logprobs - torch.logsumexp( + student_topk_logprobs, dim=-1, keepdim=True + ) + teacher_sparse_log_probs = teacher_topk_logprobs - torch.logsumexp( + teacher_topk_logprobs, dim=-1, keepdim=True + ) + + jsd = _jsd_divergence( + student_sparse_log_probs, + teacher_sparse_log_probs, + beta=0.0, + support_mask=support_mask, + ) + # See `_compute_server_sparse_top_1_divergence_loss`: the server path normalizes locally, not by + # num_items_in_batch, because the teacher window may not cover every student completion token. + return self._reduce_divergence_loss(jsd, labels=labels, reduction="batchmean") + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + self._raise_if_local_teacher_tokenizer_mismatch() + + if self.use_liger_loss: + loss = self._compute_liger_loss(model, inputs, num_items_in_batch=num_items_in_batch) + return (loss, None) if return_outputs else loss + + # Student forward pass + student_outputs = model( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + ) + prompt_length = self._compute_prompt_length(inputs) + labels = inputs["labels"][:, prompt_length:] + completion_tokens = inputs["input_ids"][:, prompt_length:] + + if self.use_teacher_server: + # Server path: token-level divergence using teacher logprobs. + # The server returns: + # actual_logprobs – (B, T) teacher log p(x_actual) (for reverse KL) + # topk_logprobs – (B, T, K) teacher top-k sorted logprobs (for forward KL) + # topk_token_ids – (B, T, K) corresponding token IDs + teacher_result = self._get_teacher_token_logprobs_from_server(inputs, prompt_length) + + student_logits = student_outputs.logits[:, prompt_length - 1 : -1, :] + student_log_probs = F.log_softmax(student_logits / self.temperature, dim=-1) + + comp_len = teacher_result["actual_logprobs"].shape[1] + completion_tokens = completion_tokens[:, :comp_len] + trimmed_labels = labels[:, :comp_len] + + if self.beta > 0: + loss = self._compute_server_sparse_top_1_divergence_loss( + teacher_result=teacher_result, + student_log_probs=student_log_probs[:, :comp_len, :], + completion_tokens=completion_tokens, + labels=trimmed_labels, + ) + else: + loss = self._compute_server_forward_kl_loss( + teacher_result=teacher_result, + student_log_probs=student_log_probs[:, :comp_len, :], + labels=trimmed_labels, + ) + else: + # Local teacher: exact full-vocabulary loss except for the shared mixed top-1 path. + teacher_logits = self._get_teacher_logits(inputs) + student_logits = student_outputs.logits[:, prompt_length - 1 : -1, :] + teacher_logits = teacher_logits[:, prompt_length - 1 : -1, :] + if self.beta > 0 and self.loss_top_k == 1: + loss = self._compute_local_sparse_top_1_divergence_loss( + student_logits=student_logits, + teacher_logits=teacher_logits, + completion_tokens=completion_tokens, + labels=labels, + num_items_in_batch=num_items_in_batch, + ) + else: + loss = self.generalized_jsd_loss( + student_logits=student_logits, + teacher_logits=teacher_logits, + labels=labels, + beta=self.beta, + temperature=self.temperature, + top_k=self.loss_top_k, + add_tail=self.loss_add_tail, + num_items_in_batch=num_items_in_batch, + ) + + return (loss, student_outputs) if return_outputs else loss + + def _liger_student_forward(self, student, inputs): + """Decoder-only forward used by the Liger JSD path (skips lm_head to save memory).""" + if hasattr(student, "get_decoder") and student.get_decoder() is not None: + decoder = student.get_decoder() + else: + decoder = getattr(student, getattr(student, "base_model_prefix", "model"), student) + return decoder( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + use_cache=False, + ) + + def _compute_liger_loss(self, model, inputs, num_items_in_batch=None): + """Memory-efficient JSD using Liger kernel (operates on hidden states, not full logits).""" + # Route through the DDP/FSDP wrapper via _forward_redirection so that + # DDP.forward() is called and prepare_for_backward() fires correctly. + unwrapped_student = self.accelerator.unwrap_model(model) + student_outputs = self._forward_redirection( + model, unwrapped_student, self._liger_student_forward, unwrapped_student, inputs + ) + + self.teacher_model.eval() + unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model) + if hasattr(unwrapped_teacher, "get_decoder") and unwrapped_teacher.get_decoder() is not None: + base_teacher = unwrapped_teacher.get_decoder() + else: + base_teacher = getattr( + unwrapped_teacher, getattr(unwrapped_teacher, "base_model_prefix", "model"), unwrapped_teacher + ) + with torch.no_grad(): + teacher_outputs = base_teacher( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + use_cache=False, + ) + + student_hidden = student_outputs.last_hidden_state[:, :-1] + teacher_hidden = teacher_outputs.last_hidden_state[:, :-1] + del student_outputs, teacher_outputs + + student_hidden = student_hidden.reshape(-1, student_hidden.shape[-1]) + teacher_hidden = teacher_hidden.reshape(-1, teacher_hidden.shape[-1]) + + labels_mask = inputs["labels"] != -100 + masked_input_ids = torch.where(labels_mask, inputs["input_ids"], torch.full_like(inputs["input_ids"], -100)) + true_labels = masked_input_ids[:, 1:].reshape(-1) + + student_head = unwrapped_student.get_output_embeddings() + teacher_head = unwrapped_teacher.get_output_embeddings() + + loss = self.liger_jsd_loss( + student_input=student_hidden, + student_weight=student_head.weight, + teacher_input=teacher_hidden, + teacher_weight=teacher_head.weight, + true_labels=true_labels, + student_bias=getattr(student_head, "bias", None), + teacher_bias=getattr(teacher_head, "bias", None), + ) + + # The Liger JSD loss normalizes by the local number of valid tokens. Under gradient accumulation we want + # the global normalization, so rescale by `num_valid_local / num_items_in_batch`. + if num_items_in_batch is not None: + num_valid_local = (true_labels != -100).sum().clamp_min(1) + if isinstance(num_items_in_batch, torch.Tensor): + num_items_in_batch = num_items_in_batch.to(loss.device) + loss = loss * num_valid_local / num_items_in_batch + + del student_hidden, teacher_hidden, true_labels + return loss + + def _get_liger_zero3_lm_head_gather_ctx(self, model: nn.Module): + """Context manager for gathering lm_head parameters under Liger + ZeRO-3.""" + if not self.use_liger_loss: + return nullcontext() + + deepspeed_plugin = self.accelerator.state.deepspeed_plugin + if deepspeed_plugin is None or deepspeed_plugin.zero_stage != 3: + return nullcontext() + + import deepspeed + + unwrapped_student = self.accelerator.unwrap_model(model) + unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model) + student_head = unwrapped_student.get_output_embeddings() + teacher_head = unwrapped_teacher.get_output_embeddings() + params = [student_head.weight, teacher_head.weight] + if student_head.bias is not None: + params.append(student_head.bias) + if teacher_head.bias is not None: + params.append(teacher_head.bias) + return deepspeed.zero.GatheredParameters(params, modifier_rank=None) + + # ────────────────────────────────────────────────────────────────────── + # Training step & Logging + # ────────────────────────────────────────────────────────────────────── + + @profiling_decorator + def training_step( + self, model: nn.Module, inputs: dict[str, torch.Tensor | Any], num_items_in_batch: int | None = None + ) -> torch.Tensor: + """Training step with on/off-policy loss tracking and completion stats.""" + buffer_steps = self.args.gradient_accumulation_steps + + with self._get_liger_zero3_lm_head_gather_ctx(model): + loss = super().training_step(model, inputs, num_items_in_batch) + + slice_idx = (self._buffer_step - 1) % buffer_steps + + # Determine if this slice is on-policy + is_on_policy = False + if self._buffered_on_policy_flags is not None and slice_idx < len(self._buffered_on_policy_flags): + is_on_policy = self._buffered_on_policy_flags[slice_idx] + + # Track completion length stats — read from buffered inputs (which reflect on-policy generation) + actual_inputs = self._buffered_inputs[slice_idx] if self._buffered_inputs is not None else inputs + labels = actual_inputs.get("labels") + if labels is not None: + completion_lengths = (labels != -100).sum(dim=1).float() + gathered_lengths = self.accelerator.gather(completion_lengths) + mode = "train" + prefix = "on_policy" if is_on_policy else "off_policy" + self._metrics[mode][f"completions/{prefix}_mean_length"].append(gathered_lengths.mean().item()) + self._metrics[mode][f"completions/{prefix}_max_length"].append(gathered_lengths.max().item()) + self._metrics[mode][f"completions/{prefix}_min_length"].append(gathered_lengths.min().item()) + + # Log fraction of completions that hit max_completion_length (truncated) + max_comp_len = getattr(self.generation_config, "max_new_tokens", None) + if is_on_policy and max_comp_len is not None: + truncated_frac = (gathered_lengths >= max_comp_len).float().mean().item() + self._metrics[mode]["completions/truncated_fraction"].append(truncated_frac) + + # Track loss per policy type + loss_scalar = float(loss.detach()) + step_equiv = 1.0 / self.args.gradient_accumulation_steps + if is_on_policy: + self._on_policy_loss_total += loss_scalar + self._on_policy_step_equiv += step_equiv + else: + self._off_policy_loss_total += loss_scalar + self._off_policy_step_equiv += step_equiv + + return loss + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} + + if mode == "train": + # Aggregate on/off-policy losses across distributed processes + device = self.accelerator.device if hasattr(self.accelerator, "device") else torch.device("cpu") + vec = torch.tensor( + [ + self._on_policy_loss_total, + self._off_policy_loss_total, + self._on_policy_step_equiv, + self._off_policy_step_equiv, + ], + dtype=torch.float64, + device=device, + ) + + if ( + getattr(self.accelerator, "distributed_type", DistributedType.NO) != DistributedType.NO + and dist.is_available() + and dist.is_initialized() + ): + dist.all_reduce(vec, op=dist.ReduceOp.SUM) + + on_sum, off_sum, on_eq, off_eq = vec.tolist() + if on_eq > 0: + logs["on_policy_loss"] = round(on_sum / on_eq, 4) + if off_eq > 0: + logs["off_policy_loss"] = round(off_sum / off_eq, 4) + + self._on_policy_loss_total = self._off_policy_loss_total = 0.0 + self._on_policy_step_equiv = self._off_policy_step_equiv = 0.0 + + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() + + # Log completions to console, wandb, and trackio + should_log_completions = ( + self.log_completions + and self.state.global_step > 0 + and self.state.global_step % self.log_completions_steps == 0 + ) + + if should_log_completions and self.accelerator.is_main_process: + prompts = list(self._textual_logs["prompt"]) + completions = list(self._textual_logs["completion"]) + + if prompts: + _print_completions_sample(prompts, completions, self.state.global_step, self.num_completions_to_print) + + logging_backends = [] + if self.args.report_to and "wandb" in self.args.report_to and wandb.run is not None: + logging_backends.append(wandb) + if self.args.report_to and "trackio" in self.args.report_to: + logging_backends.append(trackio) + + if logging_backends: + import pandas as pd + + table_data = { + "step": [str(self.state.global_step)] * len(prompts), + "prompt": prompts, + "completion": completions, + } + df = pd.DataFrame(table_data) + if self.num_completions_to_print and len(df) > self.num_completions_to_print: + df = df.sample(n=self.num_completions_to_print, random_state=42) + + for logging_backend in logging_backends: + logging_backend.log({"completions": logging_backend.Table(dataframe=df)}) + + # Clear text logs on all processes after the logging interval + if should_log_completions: + self._textual_logs["prompt"].clear() + self._textual_logs["completion"].clear() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/dppo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/dppo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0ce3ffeae4fc9c790f3249ba48a958567c66d35f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/dppo/__init__.py @@ -0,0 +1,17 @@ +# Copyright 2020-2026 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. + + +from .dppo_config import DPPOConfig +from .dppo_trainer import DPPOTrainer diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/dppo/dppo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/dppo/dppo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..92736aac144ad648aeb4b52973535744330963c6 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/dppo/dppo_config.py @@ -0,0 +1,115 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Literal + +from ...trainer.grpo_config import GRPOConfig + + +@dataclass +class DPPOConfig(GRPOConfig): + """ + Configuration class for DPPOTrainer. + + DPPO (Divergence Proximal Policy Optimization) replaces PPO/GRPO's heuristic ratio-clipping with a principled trust + region based on direct policy divergence estimates. + + Paper: "Rethinking the Trust Region in LLM Reinforcement Learning" (arXiv:2602.04879) + + Args: + divergence_type (`Literal["binary_tv", "binary_kl", "topk_tv", "topk_kl"]`, *optional*, defaults to `"binary_tv"`): + Divergence approximation used for the trust-region mask. Binary variants use only per-token log-probs; + top-K variants require storing top-K token IDs and log-probs during rollout generation plus full logits + during training. + + divergence_topk (`int`, *optional*, defaults to `20`): + K for top-K divergence approximations. Only used when `divergence_type` is `"topk_tv"` or `"topk_kl"`. + + clip_ratio_c (`float`, *optional*, defaults to `20.0`): + Upper bound on the importance-sampling ratio for stability. The IS ratio is clamped to [0, clip_ratio_c]. + + epsilon (`float`, inherited from GRPOConfig, default overridden to `0.15`): + Divergence threshold δ_low. Tokens whose divergence exceeds this when the policy moves in the + advantage-decreasing direction are masked. The paper recommends 0.15 for TV divergence and 0.05 for KL + divergence. + + epsilon_high (`float`, inherited from GRPOConfig, default overridden to `0.15`): + Divergence threshold δ_high. Tokens whose divergence exceeds this when the policy moves in the + advantage-increasing direction are masked. The paper recommends 0.15 for TV divergence and 0.05 for KL + divergence. + """ + + divergence_type: Literal["binary_tv", "binary_kl", "topk_tv", "topk_kl"] = field( + default="binary_tv", + metadata={ + "help": "Divergence approximation used for the trust-region mask. Binary variants use only per-token " + "log-probs; top-K variants require storing top-K token IDs and log-probs during rollout generation plus " + "full logits during training." + }, + ) + divergence_topk: int = field( + default=20, + metadata={ + "help": "K for top-K divergence approximations. Only used when `divergence_type` is `'topk_tv'` or " + "`'topk_kl'`." + }, + ) + clip_ratio_c: float = field( + default=20.0, + metadata={ + "help": "Upper bound on the importance-sampling ratio for stability. The IS ratio is clamped to " + "[0, clip_ratio_c]." + }, + ) + epsilon: float = field( + default=0.15, + metadata={ + "help": "Divergence threshold δ_low. Tokens whose divergence exceeds this when the policy moves in the " + "advantage-decreasing direction are masked. The paper recommends 0.15 for TV divergence and 0.05 for KL " + "divergence." + }, + ) + epsilon_high: float = field( + default=0.15, + metadata={ + "help": "Divergence threshold δ_high. Tokens whose divergence exceeds this when the policy moves in the " + "advantage-increasing direction are masked. The paper recommends 0.15 for TV divergence and 0.05 for KL " + "divergence." + }, + ) + + def __post_init__(self): + super().__post_init__() + + if self.divergence_type not in ("binary_tv", "binary_kl", "topk_tv", "topk_kl"): + raise ValueError( + f"divergence_type must be one of 'binary_tv', 'binary_kl', 'topk_tv', 'topk_kl', " + f"got {self.divergence_type!r}" + ) + + if self.divergence_topk < 1: + raise ValueError(f"divergence_topk must be >= 1, got {self.divergence_topk}") + + if self.clip_ratio_c <= 0: + raise ValueError(f"clip_ratio_c must be > 0, got {self.clip_ratio_c}") + + if self.loss_type != "dapo": + raise ValueError(f"loss_type {self.loss_type} is not supported for DPPO") + + if self.top_entropy_quantile != 1.0: + raise ValueError("top_entropy_quantile is not supported for DPPO") + + if self.off_policy_mask_threshold is not None: + raise ValueError("off_policy_mask_threshold is not supported for DPPO") diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/dppo/dppo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/dppo/dppo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..8b4ed4d5efdc9eb2398b54157b2ac800132bbcf2 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/dppo/dppo_trainer.py @@ -0,0 +1,1396 @@ +# Copyright 2020-2026 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 asyncio +import copy +import math +import textwrap +from collections.abc import Callable +from contextlib import nullcontext +from copy import copy as shallow_copy +from typing import Any + +import numpy as np +import torch +import transformers +from accelerate.utils import gather_object +from datasets import Dataset, IterableDataset +from packaging.version import Version +from torch.distributed.fsdp import FullyShardedDataParallel as FSDP +from transformers import ( + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + Trainer, + TrainerCallback, +) +from transformers.utils import is_peft_available + +from ...chat_template_utils import parse_response +from ...data_utils import ( + apply_chat_template, + is_conversational, + prepare_multimodal_messages, +) +from ...extras.profiling import profiling_context, profiling_decorator +from ...models import unwrap_model_for_generation +from ...models.utils import disable_gradient_checkpointing +from ...trainer.grpo_trainer import EnvironmentFactory, GRPOTrainer, RewardFunc, RolloutFunc +from ...trainer.utils import ( + entropy_from_logits, + nanstd, + pad, + selective_log_softmax, + use_adapter, +) +from .dppo_config import DPPOConfig + + +if is_peft_available(): + from peft import PeftConfig, PeftModel + +SAFETY_CLAMP_MAX = 20 + + +def _strip_padding(tensor: torch.Tensor, mask: torch.Tensor) -> list[list]: + """Remove padding from a batched tensor using a mask, returning a ragged list-of-lists.""" + return [row[m].tolist() for row, m in zip(tensor, mask.bool(), strict=True)] + + +class DPPOTrainer(GRPOTrainer): + """ + Trainer for Divergence Proximal Policy Optimization (DPPO). + + DPPO replaces PPO/GRPO's heuristic ratio-clipping with a principled trust region based on direct policy divergence + estimates. PPO-style clipping masks tokens based on probability ratio π/μ, which over-penalizes low-probability + tokens and under-penalizes high-probability tokens. In contrast, DPPO masks based on direct approximation of policy + divergence (e.g TV or KL) ensuring updates stay within a theoretically grounded trust region. + + + Four divergence approximations are supported: + - `binary_tv`: Absolute probability difference |π(a) - μ(a)| (simplest) + - `binary_kl`: Bernoulli KL divergence between old and new token probabilities + - `topk_tv`: Total variation over the top-K tokens of the distribution + - `topk_kl`: KL divergence over the top-K tokens of the distribution + + Args: + model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]): + Model to be trained. Can be either: + + - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using `.from_pretrained` (where `` is derived from the model + config) with the keyword arguments in `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported. + - A [`~peft.PeftModel`] object. Only causal language models are supported. + reward_funcs (`RewardFunc | list[RewardFunc]`): + Reward functions to be used for computing the rewards. To compute the rewards, we call all the reward + functions with the prompts and completions and sum the rewards. Can be either: + + - A single reward function, such as: + - A string: The *model ID* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using [`~transformers.AutoModelForSequenceClassification.from_pretrained`] with `num_labels=1` and the + keyword arguments in `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object: Only sequence classification models are supported. + - A custom reward function: The function is provided with the prompts and the generated completions, + plus any additional columns in the dataset. It should return a list of rewards. Custom reward + functions can be either synchronous or asynchronous and can also return `None` when the reward is + not applicable to those samples. This is useful for multi-task training where different reward + functions apply to different types of samples. When a reward function returns `None` for a sample, + that reward function is excluded from the reward calculation for that sample. For more details, see + [Using a custom reward + function](#using-a-custom-reward-function). + + The trainer's state is also passed to the reward function. The trainer's state is an instance of + [`~transformers.TrainerState`] and can be accessed by accessing the `trainer_state` argument to the + reward function's signature. + - A list of reward functions, where each item can independently be any of the above types. Mixing different + types within the list (e.g., a string model ID and a custom reward function) is allowed. + args ([`DPPOConfig`], *optional*): + Configuration for this trainer. If `None`, a default configuration is used. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + Dataset to use for training. It must include a column `"prompt"`. Any additional columns in the dataset is + ignored. The format of the samples can be either: + + - [Standard](dataset_formats#standard): Each sample contains plain text. + - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role + and content). + eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`): + Dataset to use for evaluation. It must meet the same requirements as `train_dataset`. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. The padding side must be set to "left". If `None`, the + processing class is loaded from the model's name with [`~transformers.AutoProcessor.from_pretrained`]. A + padding token, `tokenizer.pad_token`, must be set. If the processing class has not set a padding token, + `tokenizer.eos_token` will be used as the default. + reward_processing_classes ([`~transformers.PreTrainedTokenizerBase`] or `list[PreTrainedTokenizerBase]`, *optional*): + Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either: + + - A single processing class: Used when `reward_funcs` contains only one reward function. + - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`. + If set to `None`, or if an element of the list corresponding to a [`~transformers.PreTrainedModel`] is + `None`, the tokenizer for the model is automatically loaded using + [`~transformers.AutoTokenizer.from_pretrained`]. For elements in `reward_funcs` that are custom reward + functions (not [`~transformers.PreTrainedModel`]), the corresponding entries in `reward_processing_classes` + are ignored. + callbacks (list of [`~transformers.TrainerCallback`], *optional*): + List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed + in [here](https://huggingface.co/docs/transformers/main_classes/callback). + + If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`] + method. + optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`): + A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your + model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration used to wrap the model. If `None`, the model is not wrapped. + tools (list of `Callable`, *optional*): + A list of callable tool functions (sync or async) that the model can invoke during generation. Each tool + should be a standard Python function with properly type-hinted arguments and return values, and a + Google-style docstring describing its purpose, arguments, and return value. For more details, see: + https://huggingface.co/docs/transformers/en/chat_extras#passing-tools. The model uses the function's name, + type hints, and docstring to determine how to call it. Ensure that the model's chat template supports tool + use and that it has been fine-tuned for tool calling. + rollout_func (`RolloutFunc`, *optional*): + Function to use for generating completions. It receives the list of prompts allocated to the current + process and the trainer instance. It must return a dict with `"prompt_ids"`, `"completion_ids"`, and + `"logprobs"` fields. Any other fields are forwarded to the reward functions. This feature is experimental + and may change or be removed at any time without prior notice. + environment_factory (`EnvironmentFactory`, *optional*): + A callable that creates and returns an environment instance. The environment class should define methods + that can be invoked as tools during generation. Each method should comply with the same requirements as the + `tools` described above. If `environment_factory` is provided, an instance of the environment is created + for each generation in the batch, allowing for parallel and independent interactions. The environment must + also implement a callable `reset` method that can be used to reset state between generations. The `reset` + method should return either `None` or a string: when it returns a string, that string is appended to the + last user message before generation. This feature is experimental and may change or be removed at any time + without prior notice. + """ + + _tag_names = ["trl", "dppo"] + _name = "DPPO" + _paper = { + "title": "Rethinking the Trust Region in LLM Reinforcement Learning", + "id": "2602.04879", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @article{qi2026rethinking, + title = {{Rethinking the Trust Region in LLM Reinforcement Learning}}, + author = {Qi, Penghui and Zhou, Xiangxin and Liu, Zichen and Pang, Tianyu and Du, Chao and Lin, Min and Lee, Wee Sun}, + journal = {arXiv preprint arXiv:2602.04879}, + year = {2026} + }"""), + } + + def __init__( + self, + model: "str | PreTrainedModel | PeftModel", + reward_funcs: RewardFunc | list[RewardFunc], + args: DPPOConfig | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + peft_config: "PeftConfig | None" = None, + tools: list[Callable] | None = None, + rollout_func: RolloutFunc | None = None, + environment_factory: EnvironmentFactory | None = None, + ): + if args is None: + model_name = model if isinstance(model, str) else model.config._name_or_path + model_name = model_name.split("/")[-1] + args = DPPOConfig(f"{model_name}-DPPO") + + self.divergence_type = args.divergence_type + self.divergence_topk = args.divergence_topk + self.clip_ratio_c = args.clip_ratio_c + + super().__init__( + model=model, + reward_funcs=reward_funcs, + args=args, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + reward_processing_classes=reward_processing_classes, + callbacks=callbacks, + optimizers=optimizers, + peft_config=peft_config, + tools=tools, + rollout_func=rollout_func, + environment_factory=environment_factory, + ) + + if self.divergence_type in ["topk_tv", "topk_kl"] and self.use_vllm: + self.vllm_generation.logprobs = self.divergence_topk + + def _tokenize_prompts(self, prompts: list): + """Tokenize prompts and extract images/multimodal fields for generation.""" + if is_conversational({"prompt": prompts[0]}): + images = [] + has_images = False + for prompt in prompts: + prompt_images = [] + for message in prompt: + if isinstance(message["content"], list): + for part in message["content"]: + if part["type"] == "image": + prompt_images.append(part["image"]) + has_images = True + images.append(prompt_images if prompt_images else None) + images = images if has_images else None + + # Workaround for a bug in transformers 5.3.0 where some processors (e.g. Qwen2.5-VL) crash on + # batched unpadded input (transformers#44514). + # Fixed in transformers 5.4.0 (transformers#44563). + needs_padding_workaround = Version("5.3.0") <= Version(transformers.__version__) < Version("5.4.0") + tokenized = self.processing_class.apply_chat_template( + conversation=prompts, + tools=self.tools or None, # `or None`: Llama bug: it renders tool boilerplate for tools=[] + chat_template=self.chat_template, + add_generation_prompt=True, + tokenize=True, + return_dict=True, + **({"padding": True} if needs_padding_workaround else {}), + **self.chat_template_kwargs, + ) + if needs_padding_workaround: + # Unpad input_ids: remove padding tokens using attention_mask to get per-sequence lists + prompt_ids = [ + [tok for tok, m in zip(ids, mask, strict=True) if m] + for ids, mask in zip(tokenized["input_ids"], tokenized["attention_mask"], strict=True) + ] + else: + prompt_ids = tokenized["input_ids"] + multimodal_fields = {k: v for k, v in tokenized.items() if k not in ("input_ids", "attention_mask")} + else: + prompt_ids = self.processing_class(text=prompts)["input_ids"] + images = None + multimodal_fields = {} + return prompt_ids, images, multimodal_fields + + def _generate_single_turn(self, prompt_ids, images, multimodal_fields): + """Generate completions, always extracting sampled token logprobs. + + Returns: + 5-tuple of (prompt_ids, completion_ids, logprobs, topk_logprobs, topk_token_ids). topk_logprobs and + topk_token_ids are None when divergence_type is not topk. + """ + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + needs_topk = self.divergence_type in ["topk_tv", "topk_kl"] + K = self.divergence_topk + + if self.use_vllm: + if self.state.global_step != self._last_loaded_step: + with profiling_context(self, "sync_weights"): + self.vllm_generation.sync_weights() + self._last_loaded_step = self.state.global_step + + num_generations = self.num_generations if mode == "train" else self.num_generations_eval + prompt_ids, completion_ids, logprobs, logprob_token_ids = self.vllm_generation.generate( + prompts=prompt_ids, + images=images, + num_generations=num_generations, + profiler=profiling_context(self, "vLLM.generate"), + ) + + if needs_topk: + # vLLM returns up to K+1 entries sorted by rank (most probable first). + # The sampled token is always included but may be at any position. + # Per the paper, A'_t = TopK(μ, K) ∪ {a_t}. We keep exactly K slots: if the + # sampled token a_t is not in the top-K, it replaces the K-th ranked entry. + topk_logprobs = [] + topk_token_ids = [] + sampled_logprobs = [] + for seq_lps, seq_tids, seq_cids in zip(logprobs, logprob_token_ids, completion_ids, strict=True): + seq_topk_lps, seq_topk_tids, seq_sampled = [], [], [] + for step_lps, step_tids, sampled_tid in zip(seq_lps, seq_tids, seq_cids, strict=True): + idx = step_tids.index(sampled_tid) + seq_sampled.append(step_lps[idx]) + # Take top-K entries, then ensure sampled token is present + tk_lps = step_lps[:K] + tk_tids = step_tids[:K] + if sampled_tid not in tk_tids: + tk_lps[-1] = step_lps[idx] + tk_tids[-1] = sampled_tid + seq_topk_lps.append(tk_lps) + seq_topk_tids.append(tk_tids) + topk_logprobs.append(seq_topk_lps) + topk_token_ids.append(seq_topk_tids) + sampled_logprobs.append(seq_sampled) + else: + sampled_logprobs = [[step_lps[0] for step_lps in seq_lps] for seq_lps in logprobs] + topk_logprobs = None + topk_token_ids = None + + return prompt_ids, completion_ids, sampled_logprobs, topk_logprobs, topk_token_ids + else: + prompt_tensors = [torch.tensor(ids) for ids in prompt_ids] + padded_ids = pad(prompt_tensors, padding_value=self._tokenizer.pad_token_id, padding_side="left") + attention_mask = pad([torch.ones_like(t) for t in prompt_tensors], padding_value=0, padding_side="left") + generate_inputs = {"input_ids": padded_ids, "attention_mask": attention_mask} + for key, value in multimodal_fields.items(): + if isinstance(value, torch.Tensor): + generate_inputs[key] = value + elif isinstance(value, list) and value and isinstance(value[0], list): + generate_inputs[key] = pad([torch.tensor(x) for x in value], padding_value=0, padding_side="left") + else: + generate_inputs[key] = torch.tensor(np.array(value)) + generate_inputs = Trainer._prepare_inputs(self, generate_inputs) + + gen_config = shallow_copy(self.generation_config) + gen_config.output_logits = True + gen_config.return_dict_in_generate = True + + with ( + profiling_context(self, "transformers.generate"), + unwrap_model_for_generation( + self.model_wrapped, + self.accelerator, + gather_deepspeed3_params=self.args.ds3_gather_for_generation, + generation_kwargs=self.generation_kwargs, + ) as unwrapped_model, + torch.no_grad(), + FSDP.summon_full_params(self.model_wrapped, recurse=False) if self.is_fsdp_enabled else nullcontext(), + ): + gen_output = unwrapped_model.generate(**generate_inputs, generation_config=gen_config) + + prompt_ids_tensor, prompt_mask = generate_inputs["input_ids"], generate_inputs["attention_mask"] + prompt_length = prompt_ids_tensor.size(1) + completion_ids = gen_output.sequences[:, prompt_length:] + + sampled_chunks = [] + topk_logps_chunks = [] if needs_topk else None + topk_ids_chunks = [] if needs_topk else None + + for t, logits_t in enumerate(gen_output.logits): + # logits_t: (B, V) + logits_t = logits_t / self.temperature + + # exact sampled-token logprob without allocating (B, V) log_softmax output + logZ_t = torch.logsumexp(logits_t, dim=-1, keepdim=True) + sampled_ids_t = completion_ids[:, t : t + 1] + sampled_lp_t = logits_t.gather(-1, sampled_ids_t) - logZ_t + sampled_chunks.append(sampled_lp_t.cpu()) + + if needs_topk: + topk_logits_t, topk_ids_t = torch.topk(logits_t, k=K, dim=-1) # (B, K), (B, K) + topk_lp_t = topk_logits_t - logZ_t + + # Ensure sampled token is included in A'_t = TopK ∪ {a_t} + missing = ~(topk_ids_t == sampled_ids_t).any(dim=-1) + if missing.any(): + topk_ids_t = topk_ids_t.clone() + topk_lp_t = topk_lp_t.clone() + topk_ids_t[missing, -1] = sampled_ids_t[missing, 0] + topk_lp_t[missing, -1] = sampled_lp_t[missing, 0] + + topk_ids_chunks.append(topk_ids_t.cpu()) + topk_logps_chunks.append(topk_lp_t.cpu()) + + # Mask everything after the first EOS token + is_eos = completion_ids == self._tokenizer.eos_token_id + has_eos = is_eos.any(dim=1) + eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device) + eos_idx[has_eos] = is_eos.int().argmax(dim=1)[has_eos] + sequence_indices = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1) + completion_mask = (sequence_indices <= eos_idx.unsqueeze(1)).int() + prompt_mask_cpu = prompt_mask.bool().cpu() + completion_mask_cpu = completion_mask.bool().cpu() + + prompt_ids_out = _strip_padding(prompt_ids_tensor.cpu(), prompt_mask_cpu) + completion_ids_out = _strip_padding(completion_ids.cpu(), completion_mask_cpu) + logprobs_out = _strip_padding(torch.cat(sampled_chunks, dim=1), completion_mask_cpu) + if needs_topk: + topk_logprobs = _strip_padding(torch.stack(topk_logps_chunks, dim=1), completion_mask_cpu) + topk_token_ids = _strip_padding(torch.stack(topk_ids_chunks, dim=1), completion_mask_cpu) + else: + topk_logprobs = None + topk_token_ids = None + + return prompt_ids_out, completion_ids_out, logprobs_out, topk_logprobs, topk_token_ids + + def _tool_call_loop( + self, prompts, prompt_ids, completion_ids, completions, logprobs, topk_logprobs, topk_token_ids + ): + """Tool execution loop that also threads top-K logprob data alongside logprobs. + + Mirrors GRPOTrainer._tool_call_loop but additionally concatenates topk_logprobs and topk_token_ids the same way + logprobs is concatenated: real data for model-generated tokens, zero-padding for tool-result tokens. When topk + data is None (binary divergence), behaves identically to the parent. + """ + K = self.divergence_topk + has_topk = topk_logprobs is not None + + tool_calls = [completion[0].get("tool_calls") for completion in completions] + idxs_with_tool = [idx for idx, tool_call in enumerate(tool_calls) if tool_call] + tool_calls = [tool_calls[idx] for idx in idxs_with_tool] + tool_mask = [[1] * len(ids) for ids in completion_ids] + tool_call_count = 0 + tool_failure_count = 0 + iteration_num = 0 + while idxs_with_tool and iteration_num < self.max_tool_calling_iterations: + prompt_completion_tools = [prompts[i] for i in idxs_with_tool] + + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + tool_call_list = tool_calls[idx] + prompt_completion_tool = prompt_completion_tools[idx] + sync_tool_dict = self._sync_tool_dicts[idx_with_tool] + async_tool_dict = self._async_tool_dicts[idx_with_tool] + prompt_completion_tool.append(completions[idx_with_tool][-1]) + async_coros = [] + tool_call_results = [] + for tool_call in tool_call_list: + tool_call_count += 1 + if tool_call["type"] == "function": + function = tool_call["function"] + name = function["name"] + try: + if name in sync_tool_dict: + tool_call_results.append((name, sync_tool_dict[name](**function["arguments"]))) + elif name in async_tool_dict: + async_coros.append((name, async_tool_dict[name](**function["arguments"]))) + else: + raise ValueError(f"Tool {name} not found.") + except Exception as err: + tool_failure_count += 1 + tool_call_results.append((name, {"error": str(err)})) + else: + tool_failure_count += 1 + name = tool_call.get("name", "unknown") + tool_call_results.append((name, {"error": f"Unsupported tool call type: {tool_call['type']}"})) + + if async_coros: + + async def _run_async_tools(async_coros): + coros = [coro for _, coro in async_coros] + results = await asyncio.gather(*coros, return_exceptions=True) + return [(name, result) for (name, _), result in zip(async_coros, results, strict=False)] + + async_results = asyncio.run_coroutine_threadsafe( + _run_async_tools(async_coros), self.async_loop + ).result() + + for name, result in async_results: + if isinstance(result, Exception): + tool_failure_count += 1 + tool_call_results.append((name, {"error": str(result)})) + else: + tool_call_results.append((name, result)) + + for name, result in tool_call_results: + tool_message = {"role": "tool", "name": name, "content": str(result)} + prompt_completion_tool.append(tool_message) + completions[idx_with_tool].append(tool_message) + + # Tokenize and filter samples whose length exceeds max allowed length + pct_ids = self.processing_class.apply_chat_template( + prompt_completion_tools, + tools=self.tools or None, # `or None`: Llama bug: it renders tool boilerplate for tools=[] + chat_template=self.chat_template, + add_generation_prompt=True, + tokenize=True, + return_dict=False, + **self.chat_template_kwargs, + ) + if self.use_vllm and self.vllm_mode == "colocate": + max_model_len = self.vllm_generation.llm.llm_engine.model_config.max_model_len + elif not self.use_vllm: + max_model_len = self.model.config.max_position_embeddings + else: + raise NotImplementedError( + f"Unsupported mode detected: use_vllm={self.use_vllm}, vllm_mode={self.vllm_mode}" + ) + overlong = [len(pct) >= max_model_len for pct in pct_ids] + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + if overlong[idx]: + prompt_length = len(prompt_ids[idx_with_tool]) + ct = pct_ids[idx][prompt_length : prompt_length + self.max_completion_length] + completion_ids[idx_with_tool] = ct + tool_mask[idx_with_tool] += [1] * (len(ct) - len(tool_mask[idx_with_tool])) + if logprobs is not None: + logprobs[idx_with_tool] += [0.0] * (len(ct) - len(logprobs[idx_with_tool])) + if has_topk: + topk_logprobs[idx_with_tool] += [[0.0] * K] * (len(ct) - len(topk_logprobs[idx_with_tool])) + topk_token_ids[idx_with_tool] += [[0] * K] * (len(ct) - len(topk_token_ids[idx_with_tool])) + + idxs_with_tool = [idx for idx, o in zip(idxs_with_tool, overlong, strict=True) if not o] + prompt_completion_tools = [pct for pct, o in zip(prompt_completion_tools, overlong, strict=True) if not o] + if not idxs_with_tool: + break + + # Generate new completions after tool execution + pct_prompt_ids, pct_images, pct_multimodal_fields = self._tokenize_prompts(prompt_completion_tools) + ( + prompt_completion_tool_ids, + post_tool_ids, + post_tool_logprobs, + post_tool_topk_logprobs, + post_tool_topk_token_ids, + ) = self._generate_single_turn(pct_prompt_ids, pct_images, pct_multimodal_fields) + + # Sanity check: chat template must be prefix-preserving + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + pct = prompt_completion_tool_ids[idx] + if prompt_ids[idx_with_tool] != pct[: len(prompt_ids[idx_with_tool])]: + raise ValueError( + "The chat template is not prefix-preserving. Please update it to use a prefix-preserving " + "format." + ) + + # Truncate so that pct[len(prompt_ids[idx]):] + post_tool does not exceed max_completion_length + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + prompt_len = len(prompt_ids[idx_with_tool]) + completion_tool_ids = prompt_completion_tool_ids[idx][prompt_len:] + excess_length = len(completion_tool_ids) + len(post_tool_ids[idx]) - self.max_completion_length + if excess_length > 0: + post_tool_ids[idx] = post_tool_ids[idx][:-excess_length] + if logprobs is not None: + post_tool_logprobs[idx] = post_tool_logprobs[idx][:-excess_length] + if has_topk and post_tool_topk_logprobs is not None: + post_tool_topk_logprobs[idx] = post_tool_topk_logprobs[idx][:-excess_length] + post_tool_topk_token_ids[idx] = post_tool_topk_token_ids[idx][:-excess_length] + excess_length = len(completion_tool_ids) + len(post_tool_ids[idx]) - self.max_completion_length + if excess_length > 0: + prompt_completion_tool_ids[idx] = prompt_completion_tool_ids[idx][:-excess_length] + + # Update tool_mask and logprobs: tool result tokens get 0/0.0, post-tool model tokens get 1/real values + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + prompt_completion_tool_length = len(prompt_completion_tool_ids[idx]) + prompt_length = len(prompt_ids[idx_with_tool]) + completion_length = len(completion_ids[idx_with_tool]) + post_tool_length = len(post_tool_ids[idx]) + tool_length = prompt_completion_tool_length - prompt_length - completion_length + tool_mask[idx_with_tool] += [0] * tool_length + [1] * post_tool_length + if logprobs is not None: + logprobs[idx_with_tool] += [0.0] * tool_length + post_tool_logprobs[idx] + if has_topk: + topk_pad = [[0.0] * K] * tool_length + tid_pad = [[0] * K] * tool_length + post_topk_lp = post_tool_topk_logprobs[idx] if post_tool_topk_logprobs is not None else [] + post_topk_tid = post_tool_topk_token_ids[idx] if post_tool_topk_token_ids is not None else [] + topk_logprobs[idx_with_tool] += topk_pad + post_topk_lp + topk_token_ids[idx_with_tool] += tid_pad + post_topk_tid + + # Update completion_ids with the new completions (after tool execution) + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + prompt_length = len(prompt_ids[idx_with_tool]) + pct = prompt_completion_tool_ids[idx] + completion_ids[idx_with_tool] = pct[prompt_length:] + post_tool_ids[idx] + + # Decode post-tool completions + post_tool_completions = [parse_response(self._tokenizer, ids) if ids else {} for ids in post_tool_ids] + + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + if post_tool_completions[idx]: + completions[idx_with_tool].append(post_tool_completions[idx]) + + # Check for further tool calls + tool_calls = [completion.get("tool_calls") for completion in post_tool_completions] + idxs_with_tool = [idx for idx, tool_call in zip(idxs_with_tool, tool_calls, strict=True) if tool_call] + tool_calls = [tool_call for tool_call in tool_calls if tool_call] + iteration_num += 1 + + return ( + tool_mask, + completions, + completion_ids, + logprobs, + topk_logprobs, + topk_token_ids, + tool_call_count, + tool_failure_count, + ) + + def _generate(self, prompts: list): + """Generate completions, handling tool calls, and thread top-K logprob data through the full pipeline. + + Returns: + 9-tuple of (prompt_ids, completion_ids, tool_mask, completions, total_completion_tokens, logprobs, + topk_logprobs, topk_token_ids, extra_fields). + """ + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + needs_topk = self.divergence_type in ["topk_tv", "topk_kl"] + + # Copy the prompts to avoid modifying the original list + prompts = copy.deepcopy(prompts) + + if self.rollout_func is not None: + # Keep vLLM weights in sync for custom rollouts that rely on vLLM utilities. + if self.use_vllm and self.state.global_step != self._last_loaded_step: + with profiling_context(self, "sync_weights"): + self.vllm_generation.sync_weights() + self._last_loaded_step = self.state.global_step + + # Pass prompts to rollout_func preserving structured messages. + # Chat templating must happen inside rollout_func, at the backend boundary, so that + # multimodal content (images, typed content blocks) is not lost before rollout logic runs. + output = self.rollout_func(prompts, self) + required_keys = {"prompt_ids", "completion_ids", "logprobs"} + missing_keys = required_keys - output.keys() + if missing_keys: + missing_keys_list = sorted(missing_keys) + raise ValueError(f"rollout_func must return keys {missing_keys_list} in its output dict.") + extra_fields = {k: v for k, v in output.items() if k not in required_keys} + prompt_ids = output["prompt_ids"] + completion_ids = output["completion_ids"] + logprobs = output["logprobs"] + topk_logprobs = extra_fields.pop("topk_logprobs", None) + topk_token_ids = extra_fields.pop("topk_token_ids", None) + if needs_topk and (topk_logprobs is None or topk_token_ids is None): + raise ValueError( + "rollout_func must return keys ['topk_logprobs', 'topk_token_ids'] when divergence_type is " + f"{self.divergence_type!r}." + ) + else: + prompt_ids, images, multimodal_fields = self._tokenize_prompts(prompts) + prompt_ids, completion_ids, logprobs, topk_logprobs, topk_token_ids = self._generate_single_turn( + prompt_ids, images, multimodal_fields + ) + extra_fields = {} + + # Decode completions. It's important to use `parse_response` when possible, because it handles tool calls. + if is_conversational({"prompt": prompts[0]}): + if ( + Version(transformers.__version__) >= Version("5.0.0") # parse_response added in v5 + and hasattr(self._tokenizer, "response_schema") # attribute not set by default for now + and self._tokenizer.response_schema is not None # only works if the tokenizer has a schema + ): + completions = [[parse_response(self._tokenizer, ids)] for ids in completion_ids] + else: + contents = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + completions = [[{"role": "assistant", "content": content}] for content in contents] + else: + completions = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + + # Extract tool calls from the completions and (possibly) execute them + if self.tools: + ( + tool_mask, + completions, + completion_ids, + logprobs, + topk_logprobs, + topk_token_ids, + tool_call_count, + tool_failure_count, + ) = self._tool_call_loop( + prompts, prompt_ids, completion_ids, completions, logprobs, topk_logprobs, topk_token_ids + ) + else: + tool_mask = extra_fields.pop("env_mask", None) + + # Get completion length per sequence, used for logging + prompt_lengths = torch.tensor([len(ids) for ids in prompt_ids], device=device) + if tool_mask is not None: + completion_lengths = torch.tensor([sum(mask) for mask in tool_mask], device=device) + else: + completion_lengths = torch.tensor([len(ids) for ids in completion_ids], device=device) + agg_prompt_lengths = self.accelerator.gather(prompt_lengths) + agg_completion_lengths = self.accelerator.gather(completion_lengths) + total_prompt_tokens = agg_prompt_lengths.sum() + total_completion_tokens = agg_completion_lengths.sum() + + if mode == "train": + self.state.num_input_tokens_seen += (total_prompt_tokens + total_completion_tokens).item() + self._metrics[mode]["num_tokens"] = [self.state.num_input_tokens_seen] + + self._metrics[mode]["completions/mean_length"].append(agg_completion_lengths.float().mean().item()) + self._metrics[mode]["completions/min_length"].append(agg_completion_lengths.float().min().item()) + self._metrics[mode]["completions/max_length"].append(agg_completion_lengths.float().max().item()) + + eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id] + is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids], device=device) + agg_is_truncated = self.accelerator.gather(is_truncated) + self._metrics[mode]["completions/clipped_ratio"].append(agg_is_truncated.float().mean().item()) + term_completion_lengths = agg_completion_lengths[~agg_is_truncated] + if len(term_completion_lengths) == 0: + term_completion_lengths = torch.zeros(1, device=device) + self._metrics[mode]["completions/mean_terminated_length"].append(term_completion_lengths.float().mean().item()) + self._metrics[mode]["completions/min_terminated_length"].append(term_completion_lengths.float().min().item()) + self._metrics[mode]["completions/max_terminated_length"].append(term_completion_lengths.float().max().item()) + + if self.tools: + agg_tool_call_count = self.accelerator.gather(torch.tensor(tool_call_count, device=device)).sum() + tool_call_frequency = (agg_tool_call_count / len(agg_prompt_lengths)).item() + self._metrics[mode]["tools/call_frequency"].append(tool_call_frequency) + agg_tool_failure_count = self.accelerator.gather(torch.tensor(tool_failure_count, device=device)).sum() + failure_frequency = ( + (agg_tool_failure_count / agg_tool_call_count).item() if agg_tool_call_count > 0 else 0.0 + ) + self._metrics[mode]["tools/failure_frequency"].append(failure_frequency) + + return ( + prompt_ids, + completion_ids, + tool_mask, + completions, + total_completion_tokens, + logprobs, + topk_logprobs, + topk_token_ids, + extra_fields, + ) + + @profiling_decorator + def _get_per_token_logps_with_topk( + self, + model, + input_ids, + attention_mask, + logits_to_keep, + topk_token_ids, + batch_size=None, + compute_entropy=False, + pixel_values=None, + image_grid_thw=None, + num_images=None, + pixel_attention_mask=None, + image_sizes=None, + token_type_ids=None, + mm_token_type_ids=None, + ) -> tuple[torch.Tensor, torch.Tensor | None, torch.Tensor]: + """Compute per-token log-probs, (optionally) entropies, and top-K log-probs in one forward pass. + + Evaluates the current policy's log-probs at the rollout's top-K token IDs from the same forward pass used for + per_token_logps, avoiding an extra model call. + + Args: + topk_token_ids: Rollout policy's top-K token IDs, shape (B, T, K). The current policy's + log-probs are evaluated at these positions. + + Returns: + Tuple of (per_token_logps, entropies, current_topk_logps). + """ + batch_size = batch_size or input_ids.size(0) + all_logps = [] + all_entropies = [] + all_topk_logps = [] + + for start in range(0, input_ids.size(0), batch_size): + end = start + batch_size + input_ids_batch = input_ids[start:end] + attention_mask_batch = attention_mask[start:end] + + model_inputs = {"input_ids": input_ids_batch, "attention_mask": attention_mask_batch} + if image_grid_thw is not None and pixel_values is not None: + rows_per_image = image_grid_thw.prod(dim=-1) + rows_per_sample = torch.split(rows_per_image, num_images) + rows_per_sample = torch.stack([s.sum() for s in rows_per_sample]) + cum_rows = torch.cat([torch.tensor([0], device=rows_per_sample.device), rows_per_sample.cumsum(0)]) + row_start, row_end = cum_rows[start].item(), cum_rows[end].item() + model_inputs["pixel_values"] = pixel_values[row_start:row_end] + cum_imgs = torch.tensor([0] + num_images).cumsum(0) + img_start, img_end = cum_imgs[start], cum_imgs[end] + model_inputs["image_grid_thw"] = image_grid_thw[img_start:img_end] + elif pixel_values is not None: + model_inputs["pixel_values"] = pixel_values[start:end] + if pixel_attention_mask is not None: + model_inputs["pixel_attention_mask"] = pixel_attention_mask[start:end] + if image_sizes is not None: + model_inputs["image_sizes"] = image_sizes[start:end] + if token_type_ids is not None: + model_inputs["token_type_ids"] = token_type_ids[start:end] + if mm_token_type_ids is not None: + model_inputs["mm_token_type_ids"] = mm_token_type_ids[start:end] + + if "logits_to_keep" in self.model_kwarg_keys: + model_inputs["logits_to_keep"] = logits_to_keep + 1 + + model_inputs["use_cache"] = False + + logits = model(**model_inputs).logits + logits = logits[:, :-1, :] + logits = logits[:, -logits_to_keep:, :] + logits = logits / self.temperature + + completion_ids = input_ids_batch[:, -logits_to_keep:] + logps = selective_log_softmax(logits, completion_ids) + all_logps.append(logps) + + if compute_entropy: + with torch.no_grad(): + entropies = entropy_from_logits(logits) + all_entropies.append(entropies) + + with torch.no_grad(): + topk_logps = selective_log_softmax(logits, topk_token_ids[start:end]) + all_topk_logps.append(topk_logps) + + logps = torch.cat(all_logps, dim=0) + entropies = torch.cat(all_entropies, dim=0) if compute_entropy else None + topk_logps = torch.cat(all_topk_logps, dim=0) + return logps, entropies, topk_logps + + def _generate_and_score_completions( + self, inputs: list[dict[str, torch.Tensor | Any]] + ) -> dict[str, torch.Tensor | Any]: + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + + prompts = [x["prompt"] for x in inputs] + + if self.environments: + for prompt, environment, reset_kwargs in zip(prompts, self.environments, inputs, strict=True): + observation = environment.reset(**reset_kwargs) + if observation is None: + continue + prompt[-1]["content"] += observation + + if "images" in inputs[0]: + images = [example.get("images") for example in inputs] + elif "image" in inputs[0]: + images = [[example.get("image")] if example.get("image") is not None else None for example in inputs] + else: + images = None + # Transformers requires at least one image in the batch, otherwise it throws an error + if images is not None and all(img_list == [] for img_list in images): + images = None + + # If the prompts are conversational and the inputs contain images, we need to convert the prompts from + # [{"role": "user", "content": "What color is the sky?"}] to + # [{"role": "user", "content": [{"type": "image", "image": }, {"type": "text", "text": "What color is the sky?"}]}] + if images is not None: + if not is_conversational(inputs[0]): + raise ValueError( + "Multimodal training requires conversational prompts. It looks like the dataset contains " + "non-conversational inputs, likely because a chat template was applied before passing the dataset " + "to the trainer. Please provide the raw conversational prompts and let the trainer apply the chat " + "template internally." + ) + prompts = [ + prepare_multimodal_messages(prompt, images=image_list) + for prompt, image_list in zip(prompts, images, strict=True) + ] + + ( + prompt_ids_list, + completion_ids_list, + tool_mask_list, + completions, + num_items_in_batch, + sampling_per_token_logps_list, + topk_logprobs_list, + topk_token_ids_list, + extra_fields, + ) = self._generate(prompts) + + # Convert lists of token IDs to padded tensors + prompt_ids = [torch.tensor(ids) for ids in prompt_ids_list] + prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids] + prompt_ids = pad( + prompt_ids, + padding_value=self._tokenizer.pad_token_id, + padding_side="left", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + prompt_mask = pad( + prompt_mask, padding_value=0, padding_side="left", pad_to_multiple_of=self.pad_to_multiple_of + ).to(device=device) + completion_ids = [torch.tensor(ids) for ids in completion_ids_list] + completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids] + completion_ids = pad( + completion_ids, + padding_value=self._tokenizer.pad_token_id, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + completion_mask = pad( + completion_mask, padding_value=0, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of + ).to(device=device) + sampling_per_token_logps = [torch.tensor(logps) for logps in sampling_per_token_logps_list] + sampling_per_token_logps = pad( + sampling_per_token_logps, + padding_value=0.0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + if tool_mask_list is not None: + tool_mask = [torch.tensor(mask) for mask in tool_mask_list] + tool_mask = pad( + tool_mask, padding_value=1, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of + ).to(device=device) + else: + tool_mask = None + if topk_logprobs_list is not None: + sampling_topk_logps = [torch.tensor(lp) for lp in topk_logprobs_list] + sampling_topk_logps = pad( + sampling_topk_logps, + padding_value=0.0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + sampling_topk_token_ids = [torch.tensor(tid, dtype=torch.long) for tid in topk_token_ids_list] + sampling_topk_token_ids = pad( + sampling_topk_token_ids, + padding_value=0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + else: + sampling_topk_logps = None + sampling_topk_token_ids = None + + # If mask_truncated_completions is enabled, zero out truncated completions for attention and loss masking + if self.mask_truncated_completions: + eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id] + is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device) + # Mask completion_mask for attention masking + completion_mask = completion_mask * (~is_truncated).unsqueeze(1).int() + # Also mask tool_mask for consistency in multi-turn training + if tool_mask is not None: + tool_mask = tool_mask * (~is_truncated).unsqueeze(1).int() + + # Concatenate prompt_mask with completion_mask for logit computation + prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1) # (B, P+C) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) # (B, P+C) + + logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens + batch_size = self.args.per_device_train_batch_size if mode == "train" else self.args.per_device_eval_batch_size + + num_images = [len(img_list) for img_list in images] if images is not None else None + + # Get forward_kwargs for models with multimodal inputs + if images is not None: + prompts_text = [ + apply_chat_template( + {"prompt": prompt}, self.processing_class, tools=self.tools, **self.chat_template_kwargs + )["prompt"] + for prompt in prompts + ] + prompt_inputs = self.processing_class(images=images, text=prompts_text, padding=True, return_tensors="pt") + prompt_inputs = Trainer._prepare_inputs(self, prompt_inputs) + forward_kwargs = {k: v for k, v in prompt_inputs.items() if k not in ["input_ids", "attention_mask"]} + else: + forward_kwargs = {} + + # If token_type_ids are used, extend them with zeros for the completion part + if "token_type_ids" in forward_kwargs: + token_type_ids = forward_kwargs["token_type_ids"] + if self.pad_to_multiple_of is not None: + padding_size = prompt_ids.size(1) - token_type_ids.size(1) + if padding_size > 0: + token_type_ids = torch.cat( + [token_type_ids.new_zeros((token_type_ids.size(0), padding_size)), token_type_ids], dim=1 + ) + forward_kwargs["token_type_ids"] = torch.cat( + [token_type_ids, token_type_ids.new_zeros(completion_ids.shape)], dim=1 + ) + # If mm_token_type_ids are used, extend them with zeros for the completion part + if "mm_token_type_ids" in forward_kwargs: + mm_token_type_ids = forward_kwargs["mm_token_type_ids"] + if self.pad_to_multiple_of is not None: + padding_size = prompt_ids.size(1) - mm_token_type_ids.size(1) + if padding_size > 0: + mm_token_type_ids = torch.cat( + [mm_token_type_ids.new_zeros((mm_token_type_ids.size(0), padding_size)), mm_token_type_ids], + dim=1, + ) + forward_kwargs["mm_token_type_ids"] = torch.cat( + [mm_token_type_ids, mm_token_type_ids.new_zeros(completion_ids.shape)], dim=1 + ) + + # When gradient checkpointing is enabled with use_reentrant=True (non default), calling the model inside a + # torch.no_grad() block triggers a harmless PyTorch warning ("None of the inputs have requires_grad=True"). + # Temporarily disable checkpointing to avoid this warning during inference. + with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs): + # Compute the per-token log probabilities for the reference model + if self.beta != 0.0: + if self.ref_model is not None: + ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.ref_model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size=batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask and image_sizes + ) + else: + # When training a PEFT adapter, how we obtain the reference depends on the setup: + # - New adapter: disabling adapters yields the base model. + # - Re-training an existing adapter: an initial copy is loaded under the name "ref". + model = self.accelerator.unwrap_model(self.model) + with use_adapter(model, adapter_name="ref" if "ref" in model.peft_config else None): + ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size=batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask and image_sizes + ) + else: + ref_per_token_logps = None + + # Decode + prompts_text = self.processing_class.batch_decode(prompt_ids, skip_special_tokens=True) + completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + + # Merge extra_fields from rollout_func into inputs for reward functions + if extra_fields: + for i, inp in enumerate(inputs): + for key, values in extra_fields.items(): + if isinstance(values, list) and i < len(values): + inp[key] = values[i] + elif not isinstance(values, list): + inp[key] = values + + # Calculate rewards for each reward function. rewards_per_func aggregates rewards across all processes. This is + # important because rewards will be normalized per group, and completions are distributed. We will later slice + # rewards_per_func to extract each process's subset. + rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list) + num_generations = self.num_generations if mode == "train" else self.num_generations_eval + + if self.multi_objective_aggregation == "sum_then_normalize": + # Apply weights to each reward function's output and sum + rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1) + mean_grouped_rewards = rewards.view(-1, num_generations).mean(dim=1) + mean_grouped_rewards = mean_grouped_rewards.repeat_interleave(num_generations, dim=0) + if self.scale_rewards in ["group", "none"]: + # If self.scale_rewards = "none", we'll only use std_rewards to check for zero std for logging + if num_generations > 1: + std_rewards = rewards.view(-1, num_generations).std(dim=1) + std_rewards = std_rewards.repeat_interleave(num_generations, dim=0) + else: # doesn't occur during training, but could occur in eval when num_generations_eval=1 + std_rewards = torch.zeros_like(rewards) + elif self.scale_rewards == "batch": + # Compute global std + if rewards.numel() > 1: + std_rewards = rewards.std().expand_as(rewards) + else: # doesn't occur during training, but could occur in eval when num_generations_eval=batch_size=1 + std_rewards = torch.zeros_like(rewards) + else: + raise ValueError( + f"Invalid value for scale_rewards: {self.scale_rewards}. Must be one of 'batch', 'group', or 'none'." + ) + + advantages = rewards - mean_grouped_rewards + if self.scale_rewards != "none": + advantages = advantages / (std_rewards + 1e-4) + is_std_zero = torch.isclose(std_rewards, torch.zeros_like(std_rewards)) # for logging + + elif self.multi_objective_aggregation == "normalize_then_sum": + grouped = rewards_per_func.view(-1, num_generations, len(self.reward_funcs)) + mean_k = torch.nanmean(grouped, dim=1, keepdim=True) + std_k = nanstd(grouped, dim=1, keepdim=True) if num_generations > 1 else torch.zeros_like(mean_k) + reward_k = (grouped - mean_k) / (std_k + 1e-4) + reward_k = reward_k.view(-1, len(self.reward_funcs)) + rewards = (reward_k * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1) + std_rewards = rewards.std().expand_as(rewards) if rewards.numel() > 1 else torch.zeros_like(rewards) + advantages = (rewards - rewards.mean()) / (std_rewards + 1e-4) + is_std_zero = torch.isclose(std_rewards, torch.zeros_like(std_rewards)) # for logging + + else: + raise ValueError( + f"Invalid multi_objective_aggregation: {self.multi_objective_aggregation}. Must be " + "'sum_then_normalize' or 'normalize_then_sum'." + ) + + # Slice to keep only the local part of the data + process_slice = slice( + self.accelerator.process_index * len(prompts), + (self.accelerator.process_index + 1) * len(prompts), + ) + all_process_advantages = advantages.clone() # keep the aggregated advantages for logging + advantages = advantages[process_slice] + + # Calculate mean reward per function, but only for samples where the function was applied (non-NaN values) + for i, reward_func_name in enumerate(self.reward_func_names): + mean_rewards = torch.nanmean(rewards_per_func[:, i]).item() + self._metrics[mode][f"rewards/{reward_func_name}/mean"].append(mean_rewards) + std_func_rewards = nanstd(rewards_per_func[:, i]).item() + self._metrics[mode][f"rewards/{reward_func_name}/std"].append(std_func_rewards) + rewards = (rewards_per_func * self.reward_weights.to(rewards_per_func.device).unsqueeze(0)).nansum(dim=1) + self._metrics[mode]["reward"].append(rewards.mean().item()) + self._metrics[mode]["reward_std"].append(rewards.std().item()) + self._metrics[mode]["frac_reward_zero_std"].append(is_std_zero.float().mean().item()) + + # Log prompt and completion texts + self._logs["prompt"].extend(gather_object(prompts_text)) + self._logs["completion"].extend(gather_object(completions_text)) + for i, name in enumerate(self.reward_func_names): + self._logs["rewards"][name].extend(rewards_per_func[:, i].tolist()) + self._logs["advantages"].extend(all_process_advantages.tolist()) + + # Flush user-logged extra columns (from log_extra), gathering across processes. + # Keys must be sorted so that all ranks call gather_object in the same order, otherwise values + # get mis-attributed across columns (dict insertion order may differ between processes). + for column in sorted(self._pending_extra_logs): + self._logs["extra"][column].extend(gather_object(self._pending_extra_logs[column])) + self._pending_extra_logs.clear() + + # Flush user-logged metrics (from log_metric), averaging across processes. + # Keys must be sorted so that all ranks call accelerator.gather in the same order, otherwise values + # get mis-attributed across metrics (dict insertion order may differ between processes). + for name in sorted(self._pending_metrics): + values = self._pending_metrics[name] + local_mean = sum(values) / len(values) + global_mean = self.accelerator.gather(torch.tensor(local_mean, device=device)).mean().item() + self._metrics[mode][name].append(global_mean) + self._pending_metrics.clear() + + if images is not None: + self._logs["images"].extend(gather_object(images)) + + output = { + "prompt_ids": prompt_ids, + "prompt_mask": prompt_mask, + "completion_ids": completion_ids, + "completion_mask": completion_mask, + "advantages": advantages, + "num_items_in_batch": num_items_in_batch, + "sampling_per_token_logps": sampling_per_token_logps, + } + if ref_per_token_logps is not None: + output["ref_per_token_logps"] = ref_per_token_logps + if "pixel_values" in forward_kwargs: + output["pixel_values"] = forward_kwargs["pixel_values"] + if "image_grid_thw" in forward_kwargs: + output["image_grid_thw"] = forward_kwargs["image_grid_thw"] + if "pixel_attention_mask" in forward_kwargs: + output["pixel_attention_mask"] = forward_kwargs["pixel_attention_mask"] + if "image_sizes" in forward_kwargs: + output["image_sizes"] = forward_kwargs["image_sizes"] + if "token_type_ids" in forward_kwargs: + output["token_type_ids"] = forward_kwargs["token_type_ids"] + if "mm_token_type_ids" in forward_kwargs: + output["mm_token_type_ids"] = forward_kwargs["mm_token_type_ids"] + if images is not None: + output["num_images"] = num_images + if tool_mask is not None: + output["tool_mask"] = tool_mask + if sampling_topk_logps is not None: + output["sampling_topk_logps"] = sampling_topk_logps + if sampling_topk_token_ids is not None: + output["sampling_topk_token_ids"] = sampling_topk_token_ids + return output + + @torch.no_grad() + def _compute_divergence_mask( + self, + per_token_logps, + sampling_per_token_logps, + advantages, + completion_mask, + current_topk_logps=None, + sampling_topk_logps=None, + ): + """ + Compute a per-token trust-region mask based on the configured divergence type. Tokens where the policy has + diverged too far from the sampling distribution (in a direction that would increase the loss) are masked out. + + Args: + per_token_logps (`torch.Tensor`): + Log-probabilities of the current policy at the sampled tokens, shape `(B, T)`. + sampling_per_token_logps (`torch.Tensor`): + Log-probabilities of the sampling (rollout) policy at the sampled tokens, shape `(B, T)`. + advantages (`torch.Tensor`): + Per-token or per-sequence advantage estimates, broadcastable to `(B, T)`. + completion_mask (`torch.Tensor`): + Binary mask of shape `(B, T)` where `1` indicates valid completion tokens and `0` padding. + current_topk_logps (`torch.Tensor` or `None`): + Log-probabilities of the current policy at the rollout's top-K token IDs, shape `(B, T, K)`. Required + when `divergence_type` is `"topk_tv"` or `"topk_kl"`. + sampling_topk_logps (`torch.Tensor` or `None`): + Log-probabilities of the sampling policy at the rollout's top-K token IDs, shape `(B, T, K)`. Required + when `divergence_type` is `"topk_tv"` or `"topk_kl"`. + + Returns: + `torch.Tensor`: + Float mask of shape `(B, T)` where `1.0` indicates tokens to keep and `0.0` tokens to mask out. + """ + prob = torch.exp(per_token_logps) + sampling_prob = torch.exp(sampling_per_token_logps) + + delta_low = self.epsilon_low + delta_high = self.epsilon_high + + if self.divergence_type == "binary_tv": + # TV = |π - μ| + divergence = (prob - sampling_prob).abs() + # Mask tokens where divergence > threshold AND policy moves away from trust region + invalid_pos = (divergence > delta_high) & (prob > sampling_prob) + invalid_neg = (divergence > delta_low) & (prob < sampling_prob) + mask = torch.where(advantages > 0, ~invalid_pos, ~invalid_neg) + + elif self.divergence_type == "binary_kl": + # Bernoulli KL: D = μ log(μ/π) + (1-μ) log((1-μ)/(1-π)) + kl = sampling_prob * (sampling_per_token_logps - per_token_logps) + (1 - sampling_prob) * ( + torch.log1p(-sampling_prob.clamp(max=1 - 1e-7)) - torch.log1p(-prob.clamp(max=1 - 1e-7)) + ) + + invalid_pos = (kl > delta_high) & (prob > sampling_prob) + invalid_neg = (kl > delta_low) & (prob < sampling_prob) + mask = torch.where(advantages > 0, ~invalid_pos, ~invalid_neg) + + elif self.divergence_type in ("topk_tv", "topk_kl"): + current_topk_probs = torch.exp(current_topk_logps.float()) + rollout_topk_probs = torch.exp(sampling_topk_logps.float()) + + # Aggregate remaining probability mass outside top-K into a single rest bucket. + rollout_rest = (1.0 - rollout_topk_probs.sum(dim=-1)).clamp(min=1e-12) + current_rest = (1.0 - current_topk_probs.sum(dim=-1)).clamp(min=1e-12) + + if self.divergence_type == "topk_tv": + topk_tv = (current_topk_probs - rollout_topk_probs).abs().sum(dim=-1) + rest_tv = (current_rest - rollout_rest).abs() + divergence = (topk_tv + rest_tv) / 2.0 + else: + topk_kl = (rollout_topk_probs * (sampling_topk_logps - current_topk_logps)).sum(dim=-1) + rest_kl = rollout_rest * (rollout_rest.log() - current_rest.log()) + divergence = topk_kl + rest_kl + + invalid_pos = (divergence > delta_high) & (prob > sampling_prob) + invalid_neg = (divergence > delta_low) & (prob < sampling_prob) + mask = torch.where(advantages > 0, ~invalid_pos, ~invalid_neg) + + else: + raise ValueError(f"Unknown divergence_type: {self.divergence_type}") + + return mask.float() * completion_mask + + def _compute_loss(self, model, inputs): + # Compute per-token log probabilities for the model + prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"] + completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"] + input_ids = torch.cat([prompt_ids, completion_ids], dim=1) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + logits_to_keep = completion_ids.size(1) + mask = completion_mask if "tool_mask" not in inputs else completion_mask * inputs["tool_mask"] + + forward_kwargs = { + "pixel_values": inputs.get("pixel_values"), + "image_grid_thw": inputs.get("image_grid_thw"), + "num_images": inputs.get("num_images"), + "pixel_attention_mask": inputs.get("pixel_attention_mask"), + "image_sizes": inputs.get("image_sizes"), + "token_type_ids": inputs.get("token_type_ids"), + "mm_token_type_ids": inputs.get("mm_token_type_ids"), + } + + sampling_topk_token_ids = inputs.get("sampling_topk_token_ids") + if self.divergence_type.startswith("topk_") and sampling_topk_token_ids is not None: + per_token_logps, entropies, current_topk_logps = self._get_per_token_logps_with_topk( + model, + input_ids, + attention_mask, + logits_to_keep, + topk_token_ids=sampling_topk_token_ids, + compute_entropy=True, + **forward_kwargs, + ) + else: + per_token_logps, entropies, _ = self._get_per_token_logps_and_entropies( + model, + input_ids, + attention_mask, + logits_to_keep, + compute_entropy=True, + **forward_kwargs, + ) + current_topk_logps = None + + sampling_per_token_logps = inputs["sampling_per_token_logps"] + sampling_topk_logps = inputs.get("sampling_topk_logps") + + advantages = inputs["advantages"] + if advantages.dim() == 1: + advantages = advantages.unsqueeze(1) + + # DPPO: compute IS ratio (clamped, detached) and divergence mask + log_ratio = per_token_logps - sampling_per_token_logps + ratio = torch.exp(log_ratio.clamp(max=math.log(self.clip_ratio_c))).detach() + divergence_mask = self._compute_divergence_mask( + per_token_logps, + sampling_per_token_logps, + advantages, + mask, + current_topk_logps=current_topk_logps, + sampling_topk_logps=sampling_topk_logps, + ) + + # DPPO loss: -advantages * ratio * mask * log_prob + per_token_loss = -advantages * ratio * divergence_mask * per_token_logps + + # KL divergence with reference model + if self.beta != 0.0: + ref_per_token_logps = inputs["ref_per_token_logps"] + per_token_kl = ( + torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1 + ) + per_token_loss = per_token_loss + self.beta * per_token_kl + + mode = "train" if self.model.training else "eval" + normalizer = inputs["num_items_in_batch"] / self.accelerator.num_processes + loss = (per_token_loss * mask).sum() / normalizer + + # Log metrics + completion_token_count = mask.sum().clamp(min=1.0) + + def masked_batch_mean(x): + if x.shape[1] == 1: + return x.mean() + return (x * mask).sum() / completion_token_count + + if self.beta != 0.0: + mean_kl = masked_batch_mean(per_token_kl) + self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item()) + + mean_entropy = masked_batch_mean(entropies) + self._metrics[mode]["entropy"].append(self.accelerator.gather(mean_entropy).nanmean().item()) + + prob_diff = (torch.exp(per_token_logps) - torch.exp(sampling_per_token_logps)).abs() + self._metrics[mode]["prob_diff/mean"].append( + self.accelerator.gather(masked_batch_mean(prob_diff)).nanmean().item() + ) + per_seq_max = prob_diff.masked_fill(mask == 0, float("-inf")).max(dim=1).values + per_seq_min = prob_diff.masked_fill(mask == 0, float("inf")).min(dim=1).values + self._metrics[mode]["prob_diff/max"].append(self.accelerator.gather(per_seq_max).max().item()) + self._metrics[mode]["prob_diff/min"].append(self.accelerator.gather(per_seq_min).min().item()) + + self._metrics[mode]["advantages/mean"].append(advantages.mean().item()) + self._metrics[mode]["advantages/std"].append(advantages.std().item()) + + # Log divergence mask statistics (analogous to clip_ratio in GRPO) + is_masked = (divergence_mask == 0) & (mask > 0) + is_masked_pos = is_masked & (advantages > 0) + is_masked_neg = is_masked & (advantages < 0) + + mask_ratio_pos = masked_batch_mean(is_masked_pos.float()) + mask_ratio_neg = masked_batch_mean(is_masked_neg.float()) + mask_ratio = masked_batch_mean(is_masked.float()) + + gathered_mask_ratio_neg = self.accelerator.gather(mask_ratio_neg) + self._metrics[mode]["mask_ratio/negative_adv_mean"].append(gathered_mask_ratio_neg.nanmean().item()) + gathered_mask_ratio_pos = self.accelerator.gather(mask_ratio_pos) + self._metrics[mode]["mask_ratio/positive_adv_mean"].append(gathered_mask_ratio_pos.nanmean().item()) + gathered_mask_ratio = self.accelerator.gather(mask_ratio) + self._metrics[mode]["mask_ratio/overall_mean"].append(gathered_mask_ratio.nanmean().item()) + + return loss diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gfpo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gfpo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f91462a911daaff39038ef4cb53f18ffc845bea8 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gfpo/__init__.py @@ -0,0 +1,16 @@ +# Copyright 2020-2026 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. + +from .gfpo_config import GFPOConfig +from .gfpo_trainer import GFPOTrainer diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gfpo/gfpo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gfpo/gfpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..ae529987306eadc276115e425f4509e6dd7f1e1c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gfpo/gfpo_config.py @@ -0,0 +1,35 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field + +from ...trainer.grpo_config import GRPOConfig as _GRPOConfig + + +@dataclass +class GFPOConfig(_GRPOConfig): + num_remains_in_group: int | None = field( + default=None, + metadata={ + "help": "number inputs remains after group filter function, `'num_remains_in_group'` must be >=2 if given." + }, + ) + + def __post_init__(self): + super().__post_init__() + + if self.num_remains_in_group is not None and self.num_remains_in_group >= self.num_generations: + raise ValueError( + f"Number remains in Group {self.num_remains_in_group} must be less than num_generations : {self.num_generations}." + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gfpo/gfpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gfpo/gfpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..8cbaf1c5d77a67ca6d2e1381dfafc591143d464b --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gfpo/gfpo_trainer.py @@ -0,0 +1,464 @@ +# Copyright 2020-2026 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 logging +from collections.abc import Callable +from typing import Any + +import torch +from accelerate.utils import gather_object + +from ...data_utils import apply_chat_template, is_conversational, prepare_multimodal_messages +from ...models.utils import disable_gradient_checkpointing +from ...trainer.grpo_trainer import GRPOTrainer as _GRPOTrainer +from ...trainer.utils import nanmax, nanmin, nanstd, pad + + +logger = logging.getLogger(__name__) + +GroupFilterFunc = Callable[[list[list[Any]], list[list[Any]]], list[list[float]]] + + +class GFPOTrainer(_GRPOTrainer): + def __init__( + self, + model, + reward_funcs, + args=None, + train_dataset=None, + eval_dataset=None, + processing_class=None, + reward_processing_classes=None, + group_filter_func=None, + callbacks=None, + optimizers=(None, None), + peft_config=None, + ): + super().__init__( + model=model, + reward_funcs=reward_funcs, + args=args, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + reward_processing_classes=reward_processing_classes, + callbacks=callbacks, + optimizers=optimizers, + peft_config=peft_config, + ) + self.group_filter_func = group_filter_func + self.num_remains_in_group = args.num_remains_in_group + if self.group_filter_func is None and self.num_remains_in_group is not None: + raise ValueError( + f"Group filter function must not be None when num_remains_in_group ({self.num_remains_in_group}) is given." + ) + if self.group_filter_func is not None and self.num_remains_in_group is None: + logger.warning("Group filter function is not activated since num_remains_in_group is not set") + + def _generate_and_score_completions(self, inputs): + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + + prompts = [x["prompt"] for x in inputs] + + if "images" in inputs[0]: + images = [example.get("images") for example in inputs] + elif "image" in inputs[0]: + images = [[example.get("image")] if example.get("image") is not None else None for example in inputs] + else: + images = None + # Transformers requires at least one image in the batch, otherwise it throws an error + if images is not None and all(img_list == [] for img_list in images): + images = None + + # If the prompts are conversational and the inputs contain images, we need to convert the prompts from + # [{"role": "user", "content": "What color is the sky?"}] to + # [{"role": "user", "content": [{"type": "image", "image": }, {"type": "text", "text": "What color is the sky?"}]}] + if images is not None: + if not is_conversational(inputs[0]): + raise ValueError( + "Multimodal training requires conversational prompts. It looks like the dataset contains " + "non-conversational inputs, likely because a chat template was applied before passing the dataset " + "to the trainer. Please provide the raw conversational prompts and let the trainer apply the chat " + "template internally." + ) + prompts = [ + prepare_multimodal_messages(prompt, images=image_list) + for prompt, image_list in zip(prompts, images, strict=True) + ] + + dataset_images = images # preserve dataset images before _generate may overwrite + ( + prompt_ids_list, + completion_ids_list, + tool_mask_list, + completions, + num_items_in_batch, + sampling_per_token_logps_list, + extra_fields, + images, + tool_images, + ) = self._generate(prompts) + if images is None: + images = dataset_images # restore dataset images (rollout_func path returns None) + + # Convert lists of token IDs to padded tensors + prompt_ids = [torch.tensor(ids) for ids in prompt_ids_list] + prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids] + prompt_ids = pad( + prompt_ids, + padding_value=self._tokenizer.pad_token_id, + padding_side="left", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + prompt_mask = pad( + prompt_mask, + padding_value=0, + padding_side="left", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + completion_ids = [torch.tensor(ids) for ids in completion_ids_list] + completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids] + completion_ids = pad( + completion_ids, + padding_value=self._tokenizer.pad_token_id, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + completion_mask = pad( + completion_mask, + padding_value=0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + if sampling_per_token_logps_list is not None: + sampling_per_token_logps = [torch.tensor(logps) for logps in sampling_per_token_logps_list] + sampling_per_token_logps = pad( + sampling_per_token_logps, + padding_value=0.0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + else: + sampling_per_token_logps = None + + # If mask_truncated_completions is enabled, zero out truncated completions in completion_mask + if self.mask_truncated_completions: + eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id] + is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device) + completion_mask = completion_mask * (~is_truncated).unsqueeze(1).int() + + # Concatenate prompt_mask with completion_mask for logit computation + prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1) # (B, P+C) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) # (B, P+C) + + logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens + batch_size = self.args.per_device_train_batch_size if mode == "train" else self.args.per_device_eval_batch_size + + num_images = [len(img_list) if img_list else 0 for img_list in images] if images is not None else None + + # Get forward_kwargs for models with multimodal inputs + if images is not None: + prompts_text = [ + apply_chat_template({"prompt": prompt}, self.processing_class)["prompt"] for prompt in prompts + ] + prompt_inputs = self.processing_class(images=images, text=prompts_text, padding=True, return_tensors="pt") + prompt_inputs = super()._prepare_inputs(prompt_inputs) + forward_kwargs = {k: v for k, v in prompt_inputs.items() if k not in ["input_ids", "attention_mask"]} + else: + forward_kwargs = {} + + # If token_type_ids are used, extend them with zeros for the completion part + if "token_type_ids" in forward_kwargs: + token_type_ids = forward_kwargs["token_type_ids"] + if self.pad_to_multiple_of is not None: + # Needed only with pad_to_multiple_of: otherwise prompt_ids and token_type_ids must have equal len + padding_size = prompt_ids.size(1) - token_type_ids.size(1) + if padding_size > 0: + token_type_ids = torch.cat( + [token_type_ids.new_zeros((token_type_ids.size(0), padding_size)), token_type_ids], dim=1 + ) + forward_kwargs["token_type_ids"] = torch.cat( + [token_type_ids, token_type_ids.new_zeros(completion_ids.shape)], dim=1 + ) + # If mm_token_type_ids are used, extend them with zeros for the completion part + if "mm_token_type_ids" in forward_kwargs: + mm_token_type_ids = forward_kwargs["mm_token_type_ids"] + if self.pad_to_multiple_of is not None: + # Needed only with pad_to_multiple_of: otherwise prompt_ids and mm_token_type_ids must have equal len + padding_size = prompt_ids.size(1) - mm_token_type_ids.size(1) + if padding_size > 0: + mm_token_type_ids = torch.cat( + [mm_token_type_ids.new_zeros((mm_token_type_ids.size(0), padding_size)), mm_token_type_ids], + dim=1, + ) + forward_kwargs["mm_token_type_ids"] = torch.cat( + [mm_token_type_ids, mm_token_type_ids.new_zeros(completion_ids.shape)], dim=1 + ) + + # When gradient checkpointing is enabled with use_reentrant=True (non default), calling the model inside a + # torch.no_grad() block triggers a harmless PyTorch warning ("None of the inputs have requires_grad=True"). + # Temporarily disable checkpointing to avoid this warning during inference. + with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs): + # If the generation and optimization steps are misaligned—i.e., if generation does not occur at the end of + # a full optimizer step (when gradient_accumulation_steps is not a multiple of generate_every)—then the + # samples may come from an earlier version of the model. In that case, we need to track old_per_token_logps + # for importance sampling. If the steps are aligned, importance sampling isn't necessary and we set + # old_per_token_logps to None. + # When using vLLM, we always compute old_per_token_logps for importance sampling, it was shown that the + # distribution mismatch between vLLM and the training model can be large and harm the training. + generate_every = self.args.steps_per_generation * self.num_iterations # generation frequency + if self.args.gradient_accumulation_steps % generate_every != 0 or ( + self.use_vllm and self.vllm_importance_sampling_correction + ): + old_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask and image_sizes + ) + else: + old_per_token_logps = None + + # Compute the importance sampling ratio when using vLLM, to correct for potential distribution mismatch + if self.use_vllm and self.vllm_importance_sampling_correction: + importance_sampling_ratio = torch.exp(old_per_token_logps - sampling_per_token_logps) + importance_sampling_ratio = torch.clamp( + importance_sampling_ratio, + min=self.vllm_importance_sampling_clip_min, + max=self.vllm_importance_sampling_clip_max, + ) + + # Compute the per-token log probabilities for the reference model + if self.beta != 0.0: + if self.ref_model is not None: + ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.ref_model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size=batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask and image_sizes + ) + else: + with self.accelerator.unwrap_model(self.model).disable_adapter(): + ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size=batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask and image_sizes + ) + else: + ref_per_token_logps = None + + # Decode + prompts_text = self.processing_class.batch_decode(prompt_ids, skip_special_tokens=True) + completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + if is_conversational(inputs[0]): + completions = [] + for prompt, completion in zip(prompts, completions_text, strict=True): + bootstrap = prompt.pop()["content"] if prompt[-1]["role"] == "assistant" else "" + if isinstance(bootstrap, list): # for VLM, the format might be [{"type": "text", "text": "..."}] + assert len(bootstrap) == 1 and bootstrap[0]["type"] == "text" + bootstrap = bootstrap[0]["text"] + completions.append([{"role": "assistant", "content": bootstrap + completion}]) + else: + completions = completions_text + + # Calculate rewards for each reward function. rewards_per_func aggregates rewards across all processes. This is + # important because rewards will be normalized per group, and completions are distributed. We will later slice + # rewards_per_func to extract each process's subset. + rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list) + + # Apply weights to each reward function's output and sum + rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1) + + num_in_group = self.num_generations + num_inputs_in_device = len(prompts) + + if self.num_remains_in_group is not None and mode == "train": + num_in_group = self.num_remains_in_group + + all_completions = gather_object(completions) + + group_filter_scores = self.group_filter_func( + group_completions=[ + all_completions[i : i + 1 * self.num_generations] + for i in range(len(all_completions) // self.num_generations) + ], + group_rewards=rewards.view(-1, self.num_generations).tolist(), + ) + group_filter_scores = torch.tensor(group_filter_scores, device=device) + + _, group_local_indices = torch.topk(group_filter_scores, self.num_remains_in_group, dim=-1) + group_row_offsets = torch.arange(0, len(all_completions), self.num_generations, device=device).unsqueeze(1) + group_global_indices = group_row_offsets + group_local_indices + group_global_indices = group_global_indices.flatten() + + rewards = rewards[group_global_indices] + rewards_per_func = rewards_per_func[group_global_indices, :] + + num_inputs_in_device = int(len(prompts) / self.num_generations * self.num_remains_in_group) + + # Compute grouped-wise rewards + mean_grouped_rewards = rewards.view(-1, num_in_group).mean(dim=1) + + # Normalize the rewards to compute the advantages + mean_grouped_rewards = mean_grouped_rewards.repeat_interleave(num_in_group, dim=0) + advantages = rewards - mean_grouped_rewards + + if self.scale_rewards in ["group", "none"]: + # If self.scale_rewards = "none", we'll still log group level std + std_rewards = rewards.view(-1, num_in_group).std(dim=1) + std_rewards = std_rewards.repeat_interleave(num_in_group, dim=0) + elif self.scale_rewards == "batch": + # Compute global std + std_rewards = rewards.std().expand_as(rewards) + else: + raise ValueError( + f"Invalid value for scale_rewards: {self.scale_rewards}. Must be one of 'batch', 'group', or 'none'." + ) + + is_std_zero = torch.isclose(std_rewards, torch.zeros_like(std_rewards)) + if self.scale_rewards != "none": + advantages = advantages / (std_rewards + 1e-4) + + # Slice to keep only the local part of the data + process_slice = slice( + self.accelerator.process_index * num_inputs_in_device, + (self.accelerator.process_index + 1) * num_inputs_in_device, + ) + all_process_advantages = advantages.clone() # keep the aggregated advantages for logging + advantages = advantages[process_slice] + + if self.num_remains_in_group is not None and mode == "train": + local_input_indices_to_keep = group_global_indices[process_slice] - self.accelerator.process_index * len( + prompts + ) # step is length of prompts + + prompt_ids = prompt_ids[local_input_indices_to_keep] + prompt_mask = prompt_mask[local_input_indices_to_keep] + completion_ids = completion_ids[local_input_indices_to_keep] + completion_mask = completion_mask[local_input_indices_to_keep] + attention_mask = attention_mask[local_input_indices_to_keep] + completion_lengths = completion_mask.sum(1) + agg_completion_lengths = self.accelerator.gather(completion_lengths) + num_items_in_batch = agg_completion_lengths.sum() + + if sampling_per_token_logps is not None: + sampling_per_token_logps = sampling_per_token_logps[local_input_indices_to_keep] + if old_per_token_logps is not None: + old_per_token_logps = old_per_token_logps[local_input_indices_to_keep] + if ref_per_token_logps is not None: + ref_per_token_logps = ref_per_token_logps[local_input_indices_to_keep] + if self.use_vllm and self.vllm_importance_sampling_correction: + importance_sampling_ratio = importance_sampling_ratio[local_input_indices_to_keep] + + # Calculate mean reward per function, but only for samples where the function was applied (non-NaN values) + for i, reward_func_name in enumerate(self.reward_func_names): + mean_rewards = torch.nanmean(rewards_per_func[:, i]).item() + self._metrics[mode][f"rewards/{reward_func_name}/mean"].append(mean_rewards) + std_func_rewards = nanstd(rewards_per_func[:, i]).item() + self._metrics[mode][f"rewards/{reward_func_name}/std"].append(std_func_rewards) + rewards = (rewards_per_func * self.reward_weights.to(rewards_per_func.device).unsqueeze(0)).nansum(dim=1) + self._metrics[mode]["reward"].append(rewards.mean().item()) + self._metrics[mode]["reward_std"].append(rewards.std().item()) + self._metrics[mode]["frac_reward_zero_std"].append(is_std_zero.float().mean().item()) + + # Log prompt and completion texts + all_prompts_text = gather_object(prompts_text) + all_completions_text = gather_object(completions_text) + all_images = gather_object(images) if images is not None else None + if self.num_remains_in_group is not None and mode == "train": + group_global_indices_list = group_global_indices.tolist() + all_prompts_text = [all_prompts_text[i] for i in group_global_indices_list] + all_completions_text = [all_completions_text[i] for i in group_global_indices_list] + if images is not None: + all_images = [all_images[i] for i in group_global_indices_list] + + self._logs["prompt"].extend(all_prompts_text) + self._logs["completion"].extend(all_completions_text) + for i, name in enumerate(self.reward_func_names): + self._logs["rewards"][name].extend(rewards_per_func[:, i].tolist()) + self._logs["advantages"].extend(all_process_advantages.tolist()) + + if images is not None: + self._logs["images"].extend(all_images) + + if self.use_vllm and self.vllm_importance_sampling_correction: + delta = torch.abs(old_per_token_logps - sampling_per_token_logps) + delta = delta[completion_mask.bool()] + mean_delta = torch.mean(delta) if delta.numel() > 0 else torch.tensor(0.0, device=device) + max_delta = torch.max(delta) if delta.numel() > 0 else torch.tensor(0.0, device=device) + self._metrics[mode]["sampling/sampling_logp_difference/mean"].append( + self.accelerator.gather(mean_delta).mean().item() + ) + self._metrics[mode]["sampling/sampling_logp_difference/max"].append( + self.accelerator.gather(max_delta).max().item() + ) + + flat_is_ratio = importance_sampling_ratio[completion_mask.bool()] + min_importance_sampling_ratio = ( + torch.min(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device) + ) + mean_importance_sampling_ratio = ( + torch.mean(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device) + ) + max_importance_sampling_ratio = ( + torch.max(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device) + ) + self._metrics[mode]["sampling/importance_sampling_ratio/min"].append( + nanmin(self.accelerator.gather(min_importance_sampling_ratio)).item() + ) + self._metrics[mode]["sampling/importance_sampling_ratio/mean"].append( + self.accelerator.gather(mean_importance_sampling_ratio).nanmean().item() + ) + self._metrics[mode]["sampling/importance_sampling_ratio/max"].append( + nanmax(self.accelerator.gather(max_importance_sampling_ratio)).item() + ) + + output = { + "prompt_ids": prompt_ids, + "prompt_mask": prompt_mask, + "completion_ids": completion_ids, + "completion_mask": completion_mask, + "advantages": advantages, + "num_items_in_batch": num_items_in_batch, + } + if old_per_token_logps is not None: + output["old_per_token_logps"] = old_per_token_logps + if self.use_vllm and self.vllm_importance_sampling_correction: + output["importance_sampling_ratio"] = importance_sampling_ratio + if ref_per_token_logps is not None: + output["ref_per_token_logps"] = ref_per_token_logps + if "pixel_values" in forward_kwargs: + output["pixel_values"] = forward_kwargs["pixel_values"] + if "image_grid_thw" in forward_kwargs: + output["image_grid_thw"] = forward_kwargs["image_grid_thw"] + if "pixel_attention_mask" in forward_kwargs: + output["pixel_attention_mask"] = forward_kwargs["pixel_attention_mask"] + if "image_sizes" in forward_kwargs: + output["image_sizes"] = forward_kwargs["image_sizes"] + if "token_type_ids" in forward_kwargs: + output["token_type_ids"] = forward_kwargs["token_type_ids"] + if images is not None: + output["num_images"] = num_images + return output diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gkd/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gkd/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d49fe68a623fbca5fdc6cd4581464ac65d892fa9 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gkd/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .gkd_config import GKDConfig +from .gkd_trainer import GKDTrainer + + +__all__ = ["GKDConfig", "GKDTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gkd/gkd_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gkd/gkd_config.py new file mode 100644 index 0000000000000000000000000000000000000000..4ea10761c45228f10c8acb42ce7cb48eba5eede8 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gkd/gkd_config.py @@ -0,0 +1,110 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Any + +from ...trainer.sft_config import SFTConfig + + +@dataclass +class GKDConfig(SFTConfig): + """ + Configuration class for [`experimental.gkd.GKDTrainer`]. + + This class includes only the parameters that are specific to GKD training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] and [`SFTConfig`] documentation. + + Args: + temperature (`float`, *optional*, defaults to `0.9`): + Temperature for sampling. The higher the temperature, the more random the completions. + lmbda (`float`, *optional*, defaults to `0.5`): + Lambda parameter that controls the student data fraction (i.e., the proportion of on-policy + student-generated outputs). + beta (`float`, *optional*, defaults to `0.5`): + Interpolation coefficient between `0.0` and `1.0` of the Generalized Jensen-Shannon Divergence loss. When + beta is `0.0`, the loss is the KL divergence. When beta is `1.0`, the loss is the Inverse KL Divergence. + max_new_tokens (`int`, *optional*, defaults to `128`): + Maximum number of tokens to generate per completion. + teacher_model_name_or_path (`str`, *optional*): + Model name or path of the teacher model. If `None`, the teacher model will be the same as the model being + trained. + teacher_model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the teacher model + from a string. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model. + seq_kd (`bool`, *optional*, defaults to `False`): + Seq_kd parameter that controls whether to perform Sequence-Level KD (can be viewed as supervised FT on + teacher-generated output). + """ + + _VALID_DICT_FIELDS = SFTConfig._VALID_DICT_FIELDS + ["teacher_model_init_kwargs"] + + temperature: float = field( + default=0.9, + metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."}, + ) + lmbda: float = field( + default=0.5, + metadata={ + "help": "Lambda parameter that controls the student data fraction (i.e., the proportion of on-policy " + "student-generated outputs)." + }, + ) + beta: float = field( + default=0.5, + metadata={ + "help": "Interpolation coefficient between `0.0` and `1.0` of the Generalized Jensen-Shannon Divergence " + "loss. When beta is `0.0`, the loss is the KL divergence. When beta is `1.0`, the loss is the Inverse KL " + "Divergence." + }, + ) + max_new_tokens: int = field( + default=128, + metadata={"help": "Maximum number of tokens to generate per completion."}, + ) + teacher_model_name_or_path: str | None = field( + default=None, + metadata={ + "help": "Model name or path of the teacher model. If `None`, the teacher model will be the same as the " + "model being trained." + }, + ) + teacher_model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the " + "teacher model from a string." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropouts in `model`."}, + ) + seq_kd: bool = field( + default=False, + metadata={ + "help": "Seq_kd parameter that controls whether to perform Sequence-Level KD (can be viewed as supervised " + "FT on teacher-generated output)." + }, + ) + + def __post_init__(self): + super().__post_init__() + # check lmbda and beta are in the range [0, 1] + if self.lmbda < 0.0 or self.lmbda > 1.0: + raise ValueError("lmbda must be in the range [0.0, 1.0].") + if self.beta < 0.0 or self.beta > 1.0: + raise ValueError("beta must be in the range [0.0, 1.0].") diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gkd/gkd_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gkd/gkd_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..802fac9623170ab96965c76690af9708f8ec2e87 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gkd/gkd_trainer.py @@ -0,0 +1,505 @@ +# Copyright 2020-2026 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 random +import textwrap +from collections.abc import Callable +from typing import Any + +import torch +import torch.nn as nn +import torch.nn.functional as F +from datasets import Dataset +from transformers import ( + AutoModelForCausalLM, + BaseImageProcessor, + DataCollator, + FeatureExtractionMixin, + GenerationConfig, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, +) +from transformers.trainer_utils import EvalPrediction +from transformers.utils import ModelOutput, is_liger_kernel_available, is_peft_available + +from ...models import prepare_deepspeed +from ...models.utils import _ForwardRedirection, unwrap_model_for_generation +from ...trainer.sft_trainer import SFTTrainer +from ...trainer.utils import disable_dropout_in_model +from ..utils import DataCollatorForChatML, empty_cache +from .gkd_config import GKDConfig + + +if is_peft_available(): + from peft import PeftConfig + +if is_liger_kernel_available(): + from liger_kernel.chunked_loss import LigerFusedLinearJSDLoss + + +class GKDTrainer(SFTTrainer): + """Trainer for Generalized Knowledge Distillation (GKD) of language models. + + For details on GKD, see the paper: [On-Policy Distillation of Language Models: Learning from Self-Generated + Mistakes](https://huggingface.co/papers/2306.13649). + + Args: + model ([`~transformers.PreTrainedModel`] or `torch.nn.Module` or `str`, *optional*): + Model to be trained, or the string identifier of the model to be instantiated from a pretrained model. + teacher_model ([`~transformers.PreTrainedModel`] or `torch.nn.Module` or `str`, *optional*): + Teacher model for knowledge distillation, or the string identifier of the model to be instantiated from a + pretrained model. + args ([`experimental.gkd.GKDConfig`], *optional*): + Training arguments. + data_collator ([`~transformers.DataCollator`], *optional*): + Data collator to batch samples from the dataset. It defaults to a + [`experimental.utils.DataCollatorForChatML`] using the `processing_class`. + train_dataset ([`~datasets.Dataset`], *optional*): + Dataset for training. + eval_dataset ([`~datasets.Dataset`] or `dict` of [`~datasets.Dataset`], *optional*): + Dataset for evaluation. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`], *optional*): + Class to process the data. + compute_metrics (`Callable`, *optional*): + Function to compute metrics at evaluation. Must take in an [`~transformers.EvalPrediction`] and return a + dictionary string to float. + callbacks (`list` of [`~transformers.TrainerCallback`], *optional*): + Callbacks to use during training. + optimizers (`tuple` of `torch.optim.Optimizer` and `torch.optim.lr_scheduler.LambdaLR`, *optional*, defaults to `(None, None)`): + Tuple containing the optimizer and the learning rate scheduler to use for training. + preprocess_logits_for_metrics (`Callable`, *optional*): + Function to preprocess the logits before computing the metrics. Must take in the `logits` and `labels` and + return the logits to be used for metrics computation. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration to use PEFT for training. If `None`, PEFT is not used. If provided, the `model` will be + wrapped with the specified PEFT adapter. + formatting_func (`Callable`, *optional*): + Function to format the dataset. Must take in an example and return an example. + """ + + _tag_names = ["trl", "gkd"] + _name = "GKD" + _paper = { + "title": "On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes", + "id": "2306.13649", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @inproceedings{agarwal2024on-policy, + title = {{On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes}}, + author = {Rishabh Agarwal and Nino Vieillard and Yongchao Zhou and Piotr Stanczyk and Sabela Ramos Garea and Matthieu Geist and Olivier Bachem}, + year = 2024, + booktitle = {The Twelfth International Conference on Learning Representations, {ICLR} 2024, Vienna, Austria, May 7-11, 2024}, + publisher = {OpenReview.net}, + url = {https://openreview.net/forum?id=3zKtaqxLhW}, + }"""), + } + + def __init__( + self, + model: PreTrainedModel | nn.Module | str | None = None, + teacher_model: PreTrainedModel | nn.Module | str = None, + args: GKDConfig | None = None, + data_collator: DataCollator | None = None, # type: ignore + train_dataset: Dataset | None = None, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + processing_class: PreTrainedTokenizerBase + | BaseImageProcessor + | FeatureExtractionMixin + | ProcessorMixin + | None = None, + compute_metrics: Callable[[EvalPrediction], dict] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + peft_config: "PeftConfig | None" = None, + formatting_func: Callable | None = None, + ): + # Ensure Trainer does not drop non-signature columns used by the collator (e.g., "prompts") + args.remove_unused_columns = False + # Respect a user-provided data_collator; otherwise, provide a ChatML collator that + if data_collator is None: + data_collator = DataCollatorForChatML(tokenizer=processing_class, max_length=args.max_length) + + # Ensure SFTTrainer does not pre-process the dataset when using a ChatML collator, + # so that raw conversational fields (e.g., "messages") remain available to the collator. + if args.dataset_kwargs is None: + args.dataset_kwargs = {"skip_prepare_dataset": True} + else: + args.dataset_kwargs["skip_prepare_dataset"] = True + + # Liger fused GKD loss (JSD) + self.use_liger_gkd_loss = False + if args.use_liger_kernel: + # Match the non-Liger path: pure JSD (no hard CE component) and no temperature + # scaling, since `generalized_jsd_loss` is called without a `temperature` argument. + self.liger_jsd_loss = LigerFusedLinearJSDLoss( + beta=args.beta, + ignore_index=-100, + compiled=False, + weight_hard_loss=0.0, + weight_soft_loss=1.0, + ) + self.use_liger_gkd_loss = True + self._forward_redirection = _ForwardRedirection() + + super().__init__( + model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + peft_config=peft_config, + formatting_func=formatting_func, + ) + + if args.teacher_model_init_kwargs is None: + teacher_model_init_kwargs = {} + elif not isinstance(teacher_model, str): + raise ValueError( + "You passed teacher_model_init_kwargs to the GKDConfig, but your teacher_model is already instantiated." + ) + else: + teacher_model_init_kwargs = args.teacher_model_init_kwargs + teacher_model_init_kwargs["dtype"] = ( + teacher_model_init_kwargs["dtype"] + if teacher_model_init_kwargs["dtype"] in ["auto", None] + else getattr(torch, teacher_model_init_kwargs["dtype"]) + ) + + if isinstance(teacher_model, str): + teacher_model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + teacher_model = AutoModelForCausalLM.from_pretrained(teacher_model, **teacher_model_init_kwargs) + + # Disable dropout in the model + if args.disable_dropout: + disable_dropout_in_model(self.model) + + if self.is_deepspeed_enabled: + self.teacher_model = prepare_deepspeed(teacher_model, self.accelerator) + else: + self.teacher_model = self.accelerator.prepare_model(teacher_model, evaluation_mode=True) + + self.lmbda = args.lmbda + self.beta = args.beta + self.temperature = args.temperature + self.seq_kd = args.seq_kd + + generation_kwargs = { + "max_new_tokens": args.max_new_tokens, + "temperature": args.temperature, + "do_sample": True, + "top_k": 0, + "use_cache": False if args.gradient_checkpointing else True, + "pad_token_id": self.processing_class.pad_token_id, + } + self.generation_config = GenerationConfig(**generation_kwargs) + # Keep training-specific generation kwargs to overwrite model's original generation config + self.generation_kwargs = generation_kwargs + # Set custom EOS tokens if they are specified by the model's generation + # config. This is important for models with the Llama 3 chat template, + # which use special tokens <|eot_id|> and <|eom_id|> to mark the end of + # turns or messages. + if ( + hasattr(self.model.generation_config, "eos_token_id") + and self.model.generation_config.eos_token_id is not None + ): + self.generation_config.eos_token_id = self.model.generation_config.eos_token_id + + @staticmethod + def generalized_jsd_loss( + student_logits, + teacher_logits, + labels=None, + beta=0.5, + temperature=1.0, + reduction="batchmean", + num_items_in_batch=None, + ): + """ + Compute the generalized Jensen-Shannon Divergence loss for knowledge distillation using F.kl_div. See Eq. (1) + of https://huggingface.co/papers/2306.13649 for the definition. + + Args: + student_logits: + Tensor of shape (batch_size, sequence_length, vocab_size) + teacher_logits: + Tensor of shape (batch_size, sequence_length, vocab_size) + labels: + Tensor of shape (batch_size, sequence_length) with -100 for padding tokens to ignore when computing + loss + beta: + Interpolation coefficient between 0 and 1 (default: 0.5) + temperature: + Softmax temperature (default: 1.0) + reduction: + Specifies the reduction to apply to the output (default: 'batchmean') + + Returns: + loss: Scalar tensor with the generalized JSD loss + """ + + # Apply temperature scaling + student_logits = student_logits / temperature + teacher_logits = teacher_logits / temperature + + # Compute log probabilities for student and probabilities for teacher + student_log_probs = F.log_softmax(student_logits, dim=-1) + teacher_log_probs = F.log_softmax(teacher_logits, dim=-1) + + if beta == 0: + jsd = F.kl_div(student_log_probs, teacher_log_probs, reduction="none", log_target=True) + elif beta == 1: + jsd = F.kl_div(teacher_log_probs, student_log_probs, reduction="none", log_target=True) + else: + # Compute the log of the mixture distribution + # log(a + b) = log(exp(log(a)) + exp(log(b))) -> for mixture + beta = torch.tensor(beta, dtype=student_log_probs.dtype, device=student_log_probs.device) + mixture_log_probs = torch.logsumexp( + torch.stack([student_log_probs + torch.log1p(-beta), teacher_log_probs + torch.log(beta)]), + dim=0, + ) + + # Compute KL divergences using F.kl_div + # PyTorch differs from the standard mathematical definition, so the order of the probability distributions is swapped compared to that defined in the paper. + kl_teacher = F.kl_div(mixture_log_probs, teacher_log_probs, reduction="none", log_target=True) + kl_student = F.kl_div(mixture_log_probs, student_log_probs, reduction="none", log_target=True) + + # Compute the Generalized Jensen-Shannon Divergence + jsd = beta * kl_teacher + (1 - beta) * kl_student + + # Masking + if labels is not None: + mask = labels != -100 + jsd = jsd[mask] + + # Apply reduction + if num_items_in_batch is not None: + # Normalize by the global number of valid tokens for gradient-accumulation-correct loss (see issue #4719). + jsd_sum = jsd.sum() + if isinstance(num_items_in_batch, torch.Tensor): + num_items_in_batch = num_items_in_batch.to(jsd_sum.device) + return jsd_sum / num_items_in_batch + if reduction == "batchmean": + # clamp_min(1) avoids 0/0 -> nan when a sample has no unmasked positions + # (e.g. completion fully truncated). jsd[mask] is empty -> jsd.sum() == 0, + # so 0/1 == 0 with a valid grad path. + denom = mask.sum().clamp_min(1) if labels is not None else max(jsd.size(0), 1) + return jsd.sum() / denom + elif reduction == "sum": + return jsd.sum() + elif reduction == "mean": + return jsd.mean() + else: + return jsd + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + if self.use_liger_gkd_loss: + # Forward only through the base models (avoid lm_head to save memory). + # Route through the DDP/FSDP wrapper via _forward_redirection so that + # DDP.forward() is called and prepare_for_backward() fires correctly. + unwrapped_student = self.accelerator.unwrap_model(model) + student_outputs = self._forward_redirection( + model, unwrapped_student, self._liger_student_forward, unwrapped_student, inputs + ) + + self.teacher_model.eval() + unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model) + if hasattr(unwrapped_teacher, "get_decoder") and unwrapped_teacher.get_decoder() is not None: + base_teacher = unwrapped_teacher.get_decoder() + else: + base_teacher = getattr( + unwrapped_teacher, getattr(unwrapped_teacher, "base_model_prefix", "model"), unwrapped_teacher + ) + with torch.no_grad(): + teacher_outputs = base_teacher( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + use_cache=False, + ) + + # hidden states (shifted) + student_hidden = student_outputs.last_hidden_state[:, :-1] + teacher_hidden = teacher_outputs.last_hidden_state[:, :-1] + + # Release teacher outputs; keep student_outputs for return_outputs + del teacher_outputs + + # labels mask and labels (shifted) + labels_mask = inputs["labels"] != -100 + masked_input_ids = torch.where( + labels_mask, inputs["input_ids"], torch.full_like(inputs["input_ids"], -100) + ) + true_labels = masked_input_ids[:, 1:].contiguous() + + # Release intermediate tensors + del labels_mask, masked_input_ids + + # heads + student_head = unwrapped_student.get_output_embeddings() + teacher_head = unwrapped_teacher.get_output_embeddings() + + # liger fused jsd loss + loss = self.liger_jsd_loss( + student_input=student_hidden, + student_weight=student_head.weight, + teacher_input=teacher_hidden, + teacher_weight=teacher_head.weight, + true_labels=true_labels, + student_bias=getattr(student_head, "bias", None), + teacher_bias=getattr(teacher_head, "bias", None), + ) + + # The Liger JSD loss normalizes by the local number of valid tokens. Under gradient accumulation we want + # the global normalization, so rescale by `num_valid_local / num_items_in_batch`. + if num_items_in_batch is not None: + num_valid_local = (true_labels != -100).sum().clamp_min(1) + if isinstance(num_items_in_batch, torch.Tensor): + num_items_in_batch = num_items_in_batch.to(loss.device) + loss = loss * num_valid_local / num_items_in_batch + + # Release hidden states after loss computation + del student_hidden, teacher_hidden, true_labels + empty_cache() + if return_outputs: + return (loss, ModelOutput(logits=None, last_hidden_state=student_outputs.last_hidden_state)) + else: + return loss + else: + # compute student output + student_outputs = model( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + ) + + # compute teacher output in eval mode + self.teacher_model.eval() + with torch.no_grad(): + teacher_outputs = self.teacher_model( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + ) + + # Standard causal shift: logits at position i predict the token at i + 1. The `labels != -100` mask + # inside `generalized_jsd_loss` already excludes prompt (and padding) positions, so we do not slice by + # prompt length. Slicing by `inputs["prompts"].shape[1]` (the batch-max prompt width) would drop real + # completion tokens for samples whose prompt is shorter than the batch maximum, since `labels` is padded + # to the full-sequence width independently of `prompts`. + shifted_student_logits = student_outputs.logits[:, :-1, :] + shifted_teacher_logits = teacher_outputs.logits[:, :-1, :] + shifted_labels = inputs["labels"][:, 1:] + + # compute loss + loss = self.generalized_jsd_loss( + student_logits=shifted_student_logits, + teacher_logits=shifted_teacher_logits, + labels=shifted_labels, + beta=self.beta, + num_items_in_batch=num_items_in_batch, + ) + + # empty cache + empty_cache() + + # Return loss + return (loss, student_outputs) if return_outputs else loss + + def _liger_student_forward(self, student, inputs): + """Decoder-only forward used by the Liger JSD path (skips lm_head to save memory).""" + if hasattr(student, "get_decoder") and student.get_decoder() is not None: + decoder = student.get_decoder() + else: + decoder = getattr(student, getattr(student, "base_model_prefix", "model"), student) + return decoder( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + use_cache=False, + ) + + @staticmethod + def generate_on_policy_outputs(model, inputs, generation_config, pad_token_id=None): + # Generate output with respect to the prompt-only + generated_outputs = model.generate( + input_ids=inputs["prompts"], + attention_mask=inputs.get("prompt_attention_mask", None), + generation_config=generation_config, + return_dict_in_generate=True, + ) + + # Get the generated token IDs + generated_tokens = generated_outputs.sequences + # Calculate new attention mask + new_attention_mask = torch.ones_like(generated_tokens) + new_labels = generated_tokens.clone() + + # If there's pad_token_id, set attention mask to 0 for padding tokens + if pad_token_id is not None: + new_labels[new_labels == pad_token_id] = -100 + new_attention_mask[generated_tokens == pad_token_id] = 0 + + # Mask the prompt so only the generated completion contributes to the loss. `generate` echoes + # the prompt back as the first `prompt_length` columns, so masking them with -100 matches the + # collator convention (`labels[:len(prompt)] = -100`) that `compute_loss` relies on. + prompt_length = inputs["prompts"].shape[1] + new_labels[:, :prompt_length] = -100 + + return generated_tokens, new_attention_mask, new_labels + + def training_step( + self, model: nn.Module, inputs: dict[str, torch.Tensor | Any], num_items_in_batch: int | None = None + ) -> torch.Tensor: + """ + Perform a training step for the Generalized Knowledge Distillation (GKD) model. + + This method implements the on-policy learning approach described in the GKD paper. With probability + `self.lmbda`, it generates new responses using the student model, which are then used for training instead of + the original inputs. + """ + if random.random() <= self.lmbda: + with ( + unwrap_model_for_generation( + model, + self.accelerator, + generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762 + ) as unwrapped_model + ): + new_input_ids, new_attention_mask, new_labels = self.generate_on_policy_outputs( + unwrapped_model, inputs, self.generation_config, self.processing_class.pad_token_id + ) + inputs["input_ids"] = new_input_ids + inputs["attention_mask"] = new_attention_mask + inputs["labels"] = new_labels + elif self.seq_kd: + with ( + unwrap_model_for_generation( + self.teacher_model, + self.accelerator, + generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762 + ) as unwrapped_model + ): + new_input_ids, new_attention_mask, new_labels = self.generate_on_policy_outputs( + unwrapped_model, inputs, self.generation_config, self.processing_class.pad_token_id + ) + inputs["input_ids"] = new_input_ids + inputs["attention_mask"] = new_attention_mask + inputs["labels"] = new_labels + + loss = super().training_step(model, inputs, num_items_in_batch) + return loss diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gmpo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gmpo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d97a396205fd4bbeae2719fbda347230bace374d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gmpo/__init__.py @@ -0,0 +1,16 @@ +# Copyright 2020-2026 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. + +from .gmpo_config import GMPOConfig +from .gmpo_trainer import GMPOTrainer diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gmpo/gmpo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gmpo/gmpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..8eb06749e2c98258b9ee66fe6ccbb10d8dcc13a3 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gmpo/gmpo_config.py @@ -0,0 +1,47 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field + +from ...trainer.grpo_config import GRPOConfig + + +@dataclass +class GMPOConfig(GRPOConfig): + # docstyle-ignore + r""" + Configuration class for the [`GMPOTrainer`]. + + [`GMPOConfig`] inherits every parameter from [`GRPOConfig`]; it only changes the meaning and default of the + clipping range. In GMPO, clipping is applied to the per-token *log*-importance ratios (i.e. in log space) before + the geometric mean is taken, so `epsilon` and `epsilon_high` are expressed in log space: the effective ratio + clipping range is `(exp(-epsilon), exp(epsilon_high))`. The [GMPO paper](https://huggingface.co/papers/2507.20673) + recommends a markedly wider range than GRPO/DAPO, `(exp(-0.4), exp(0.4))`, to encourage exploration. + + Parameters: + epsilon (`float`, *optional*, defaults to `0.4`): + Lower-bound clipping value, expressed in log space. The lower bound of the per-token importance ratio is + `exp(-epsilon)`. + epsilon_high (`float`, *optional*): + Upper-bound clipping value, expressed in log space. If `None`, it defaults to the value of `epsilon`. The + upper bound of the per-token importance ratio is `exp(epsilon_high)`. + """ + + epsilon: float = field( + default=0.4, + metadata={ + "help": "Lower-bound clipping value, expressed in log space. The lower bound of the per-token importance " + "ratio is exp(-epsilon). GMPO recommends 0.4." + }, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gmpo/gmpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gmpo/gmpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..806da1cb57872c53f1d83c2eba6b7c53a73998f7 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gmpo/gmpo_trainer.py @@ -0,0 +1,152 @@ +# Copyright 2020-2026 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 torch + +from ...trainer.grpo_trainer import GRPOTrainer +from ...trainer.utils import get_config_model_id, nanmax, nanmin +from .gmpo_config import GMPOConfig + + +class GMPOTrainer(GRPOTrainer): + """ + Trainer for Geometric-Mean Policy Optimization (GMPO). + + GMPO (https://huggingface.co/papers/2507.20673) is a GRPO variant that maximizes the *geometric* mean of the + token-level importance ratios instead of the arithmetic mean. Because the geometric mean is far less sensitive to + outlier ratios, the policy update is more stable and a much wider clipping range can be used. + + The only change w.r.t. [`GRPOTrainer`] is `_compute_loss`. Everything else (generation, reward computation, weight + syncing, metric logging) is inherited unchanged + """ + + _tag_names = ["trl", "gmpo"] + + def __init__(self, model, reward_funcs, args=None, **kwargs): + if args is None: + model_name = model if isinstance(model, str) else get_config_model_id(model.config) + args = GMPOConfig(f"{model_name.split('/')[-1]}-GMPO") + + super().__init__(model, reward_funcs, args=args, **kwargs) + + def _compute_loss(self, model, inputs): + # Compute the per-token log probabilities for the model + prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"] + completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"] + input_ids = torch.cat([prompt_ids, completion_ids], dim=1) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens + mask = completion_mask if "tool_mask" not in inputs else completion_mask * inputs["tool_mask"] + + # Compute the per_token_logps and the entropy at each position in the completion + per_token_logps, entropies, _ = self._get_per_token_logps_and_entropies( + model, + input_ids, + attention_mask, + logits_to_keep, + compute_entropy=True, + pixel_values=inputs.get("pixel_values"), + image_grid_thw=inputs.get("image_grid_thw"), + num_images=inputs.get("num_images"), + pixel_attention_mask=inputs.get("pixel_attention_mask"), + image_sizes=inputs.get("image_sizes"), + token_type_ids=inputs.get("token_type_ids"), + mm_token_type_ids=inputs.get("mm_token_type_ids"), + image_position_ids=inputs.get("image_position_ids"), + ) + + if self.top_entropy_quantile < 1.0: + entropy_mask = self.get_high_entropy_mask(entropies, mask, 1 - self.top_entropy_quantile) + else: + entropy_mask = None + + advantages = inputs["advantages"] + # When num_iterations == 1 and steps_per_generation <= gradient_accumulation_steps, + # old_per_token_logps == per_token_logps, so we skip its computation and use per_token_logps.detach() instead. + old_per_token_logps = inputs.get("old_per_token_logps") + old_per_token_logps = per_token_logps.detach() if old_per_token_logps is None else old_per_token_logps + + # GMPO Objective + # Per-token log importance ratio + log_ratio = per_token_logps - old_per_token_logps + + # Token-level clipping, performed in *log space* for numerical stability. The clip range in + # ratio space is (exp(-epsilon_low), exp(epsilon_high)); the paper recommends exp(±0.4), markedly wider than + # GRPO/DAPO, to encourage exploration. + clamped_log_ratio = torch.clamp(log_ratio, min=-self.epsilon_low, max=self.epsilon_high) + + # sign-aware, one-sided clipping = PPO's trust-region "min" trick written in log-spaces: + advantages_col = advantages.unsqueeze(1) + clipped_log_ratio = torch.where( + advantages_col > 0, + torch.minimum(log_ratio, clamped_log_ratio), + torch.maximum(log_ratio, clamped_log_ratio), + ) + + # Optionally drop low-entropy tokens from the geometric mean + seq_mask = mask * entropy_mask if entropy_mask is not None else mask + + # Geometric mean of the clipped token ratios = exp(mean of clipped log-ratios over valid tokens). The 1/|o_i| + # exponent is the geometric-mean normalization; the paper's ablation shows it is essential. + log_importance_weights = (clipped_log_ratio * seq_mask).sum(-1) / seq_mask.sum(-1).clamp(min=1.0) # (B,) + coef = torch.exp(log_importance_weights) # (B,) sequence-level (geometric-mean) importance weight + + per_sequence_loss = -coef * advantages # (B,) + + # KL regularization toward the reference model (optional; sequence-averaged to match GMPO's sequence-level + # objective). Disabled by default (beta == 0) + if self.beta != 0.0: + ref_per_token_logps = inputs["ref_per_token_logps"] + per_token_kl = ( + torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1 + ) + seq_kl = (per_token_kl * mask).sum(-1) / mask.sum(-1).clamp(min=1.0) # (B,) + per_sequence_loss = per_sequence_loss + self.beta * seq_kl + + # GMPO aggregates with a plain mean over sequences, per token-norm + # already lives inside the geometric mean. + mode = "train" if self.model.training else "eval" + loss = per_sequence_loss.mean() + normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval + loss = loss / normalizer + + # logging + completion_token_count = mask.sum().clamp(min=1.0) + + if self.beta != 0.0: + mean_kl = (per_token_kl * mask).sum() / completion_token_count + self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item()) + + mean_entropy = (entropies * mask).sum() / completion_token_count + self._metrics[mode]["entropy"].append(self.accelerator.gather(mean_entropy).nanmean().item()) + + # Fraction of the tokens pushed into the clipped region, in log-space. + is_high_clipped = (log_ratio > self.epsilon_high) & (advantages_col > 0) + is_low_clipped = (log_ratio < -self.epsilon_low) & (advantages_col < 0) + is_region_clipped = is_high_clipped | is_low_clipped + + low_clip = (is_low_clipped.float() * mask).sum() / completion_token_count + high_clip = (is_high_clipped.float() * mask).sum() / completion_token_count + clip_ratio = (is_region_clipped.float() * mask).sum() / completion_token_count + + gathered_low_clip = self.accelerator.gather(low_clip) + self._metrics[mode]["clip_ratio/low_mean"].append(gathered_low_clip.nanmean().item()) + self._metrics[mode]["clip_ratio/low_min"].append(nanmin(gathered_low_clip).item()) + gathered_high_clip = self.accelerator.gather(high_clip) + self._metrics[mode]["clip_ratio/high_mean"].append(gathered_high_clip.nanmean().item()) + self._metrics[mode]["clip_ratio/high_max"].append(nanmax(gathered_high_clip).item()) + gathered_clip_ratio = self.accelerator.gather(clip_ratio) + self._metrics[mode]["clip_ratio/region_mean"].append(gathered_clip_ratio.nanmean().item()) + + return loss diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9c2a8c1149130a77081ed794d02c7d7629d265bb --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .gold_config import GOLDConfig +from .gold_trainer import GOLDTrainer + + +__all__ = ["GOLDConfig", "GOLDTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/gold.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/gold.py new file mode 100644 index 0000000000000000000000000000000000000000..d136b9af34efa0682fea62c1385eccdd4021e6c0 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/gold.py @@ -0,0 +1,152 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl @ git+https://github.com/huggingface/trl.git", +# "peft", +# "trackio", +# ] +# /// + +# docstyle-ignore +""" +# Full training: +python trl/experimental/gold/gold.py \ + --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \ + --teacher_model_name_or_path Qwen/Qwen2-1.5B-Instruct \ + --dataset_name trl-lib/chatbot_arena_completions \ + --learning_rate 2e-5 \ + --per_device_train_batch_size 4 \ + --gradient_accumulation_steps 8 \ + --output_dir gold-model \ + --num_train_epochs 1 \ + --push_to_hub + +# LoRA: +python trl/experimental/gold/gold.py \ + --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \ + --teacher_model_name_or_path Qwen/Qwen2-1.5B-Instruct \ + --dataset_name trl-lib/chatbot_arena_completions \ + --learning_rate 2e-4 \ + --per_device_train_batch_size 4 \ + --gradient_accumulation_steps 8 \ + --output_dir gold-model \ + --num_train_epochs 1 \ + --push_to_hub \ + --use_peft \ + --lora_r 64 \ + --lora_alpha 16 +""" + +import logging + +from datasets import load_dataset +from transformers import AutoTokenizer, GenerationConfig + +from trl import ( + LogCompletionsCallback, + ModelConfig, + ScriptArguments, + TrlParser, + get_kbit_device_map, + get_peft_config, + get_quantization_config, +) +from trl.experimental.gold.gold_config import GOLDConfig +from trl.experimental.gold.gold_trainer import GOLDTrainer + + +logger = logging.getLogger(__name__) + + +if __name__ == "__main__": + parser = TrlParser((ScriptArguments, GOLDConfig, ModelConfig)) + script_args, training_args, model_args = parser.parse_args_and_config() + + ################ + # Model & Tokenizer + ################ + quantization_config = get_quantization_config(model_args) + model_kwargs = dict( + revision=model_args.model_revision, + attn_implementation=model_args.attn_implementation, + dtype=model_args.dtype, + use_cache=False if training_args.gradient_checkpointing else True, + device_map=get_kbit_device_map() if quantization_config is not None else None, + quantization_config=quantization_config, + ) + training_args.model_init_kwargs = model_kwargs + + if training_args.teacher_tokenizer_name_or_path is None and training_args.use_uld_loss: + training_args.teacher_tokenizer_name_or_path = training_args.teacher_model_name_or_path + teacher_model_kwargs = dict( + revision=training_args.teacher_model_revision, + attn_implementation=model_args.attn_implementation, + dtype=model_args.dtype, + use_cache=True, + device_map=get_kbit_device_map() if quantization_config is not None else None, + quantization_config=quantization_config, + ) + if training_args.teacher_model_init_kwargs is not None: + teacher_model_kwargs.update(training_args.teacher_model_init_kwargs) + training_args.teacher_model_init_kwargs = teacher_model_kwargs + + tokenizer = AutoTokenizer.from_pretrained( + model_args.model_name_or_path, + revision=model_args.model_revision, + ) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + ################ + # Dataset + ################ + dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config) + + ################ + # Training + ################ + eval_dataset = None + if training_args.eval_strategy != "no": + if script_args.dataset_test_split in dataset: + eval_dataset = dataset[script_args.dataset_test_split] + elif "validation" in dataset: + eval_dataset = dataset["validation"] + elif "dev" in dataset: + eval_dataset = dataset["dev"] + + trainer = GOLDTrainer( + model=model_args.model_name_or_path, + teacher_model=training_args.teacher_model_name_or_path, + args=training_args, + train_dataset=dataset[script_args.dataset_train_split], + eval_dataset=eval_dataset, + processing_class=tokenizer, + peft_config=get_peft_config(model_args), + ) + + if training_args.eval_strategy != "no": + generation_config = GenerationConfig( + max_new_tokens=training_args.max_completion_length, do_sample=True, temperature=training_args.temperature + ) + completions_callback = LogCompletionsCallback(trainer, generation_config, num_prompts=8) + trainer.add_callback(completions_callback) + + trainer.train() + + # Save and push to hub + trainer.save_model(training_args.output_dir) + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/gold_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/gold_config.py new file mode 100644 index 0000000000000000000000000000000000000000..54d235ae4734075999deb0425a225fc8258555f4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/gold_config.py @@ -0,0 +1,503 @@ +# Copyright 2020-2026 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 warnings +from dataclasses import dataclass, field +from typing import Any + +from ...trainer.sft_config import SFTConfig + + +@dataclass +class GOLDConfig(SFTConfig): + # docstyle-ignore + r""" + Configuration class for [`GOLDTrainer`]. + + This class includes only the parameters that are specific to GOLD training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] and [`SFTConfig`] documentation. + + Args: + > Parameters that control generation and the training loop + + temperature (`float`, *optional*, defaults to `0.9`): + Temperature for sampling. The higher the temperature, the more random the completions. + top_p (`float`, *optional*, defaults to `0.95`): + If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to + `top_p` or higher are kept for generation. + top_k (`int`, *optional*, defaults to `0`): + Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is + disabled and all tokens are considered. + lmbda (`float`, *optional*, defaults to `0.5`): + Lambda parameter that controls the student data fraction (i.e., the proportion of on-policy + student-generated outputs). + beta (`float`, *optional*, defaults to `0.5`): + Interpolation coefficient between `0.0` and `1.0` of the Generalized Jensen-Shannon Divergence loss. When + beta is `0.0`, the loss is the KL divergence. When beta is `1.0`, the loss is the Inverse KL Divergence. + max_completion_length (`int`, *optional*, defaults to `128`): + Maximum number of tokens to generate per completion. + teacher_model_name_or_path (`str`, *optional*): + Model name or path of the teacher model. If `None`, the teacher model will be the same as the model being + trained. + teacher_model_revision (`str` or `None`, *optional*, defaults to `None`): + Model revision of the teacher model (e.g., branch name, tag, or commit hash). If `None`, the default + revision is used. + teacher_model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the teacher model + from a string. + teacher_tokenizer_name_or_path (`str`, *optional*): + Tokenizer name or path for the teacher model. If None when using ULD loss, will use the same tokenizer as + the student model (not recommended for cross-tokenizer distillation). + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model. + seq_kd (`bool`, *optional*, defaults to `False`): + Seq_kd parameter that controls whether to perform Sequence-Level KD (can be viewed as supervised FT on + teacher-generated output). + num_generations (`int`, *optional*, defaults to `1`): + Number of generations per prompt. Each prompt is repeated this many times in the generation batch. + generation_batch_size (`int` or `None`, *optional*, defaults to `None`): + Number of unique prompts per worker per optimizer step. If `None`, it is computed from + `(per_device_train_batch_size * gradient_accumulation_steps) // num_generations`. + > Parameters that control the ULD loss + + use_uld_loss (`bool`, *optional*, defaults to `False`): + Whether to use Universal Logit Distillation (ULD) loss instead of Generalized Jensen-Shannon Divergence + loss. + use_extended_uld (`bool`, *optional*, defaults to `True`): + Whether to enable extended ULD alignment that uses tokenizers to align and merge token probabilities + across student and teacher tokenizations. When `True`, the trainer will compute token mappings and merge + probabilities for split tokens; when `False`, ULD will use simple positional truncation like in the + original ULD paper. + uld_use_hybrid_loss (`bool`, *optional*, defaults to `False`): + Whether to use a hybrid loss that combines ULD loss and JSD loss. When `True`, the final loss is a + combination of JSD for known token mappings and ULD for unknown token mappings. + uld_hybrid_matched_weight (`float` or `None`, *optional*): + Weight for the matched token loss component when using hybrid ULD + JSD loss. This weight scales the JSD + loss computed over tokens that have a direct mapping between student and teacher tokenizations. If `None`, + uses adaptive weighting based on vocabulary overlap. Must be set together with + `uld_hybrid_unmatched_weight` (both `None` or both `float`). + uld_hybrid_unmatched_weight (`float` or `None`, *optional*): + Weight for the unmatched token loss component when using hybrid ULD + JSD loss. This weight scales the ULD + loss computed over tokens that do not have a direct mapping between student and teacher tokenizations. If + `None`, uses adaptive weighting based on vocabulary overlap. Must be set together with + `uld_hybrid_matched_weight` (both `None` or both `float`). + uld_crossentropy_weight (`float`, *optional*, defaults to `0.0`): + Weight for the cross-entropy loss component in ULD loss. If 0, only ULD distillation loss is used. + uld_distillation_weight (`float`, *optional*, defaults to `1.0`): + Weight for the distillation loss component in ULD loss. + uld_student_temperature (`float`, *optional*, defaults to `1.0`): + Temperature for student logits in ULD loss computation. + uld_teacher_temperature (`float`, *optional*, defaults to `1.0`): + Temperature for teacher logits in ULD loss computation. + uld_skip_student_eos (`bool`, *optional*, defaults to `True`): + Whether to skip EOS token for student in ULD loss computation. + uld_skip_teacher_eos (`bool`, *optional*, defaults to `True`): + Whether to skip EOS token for teacher in ULD loss computation. + > Parameters that control vLLM integration + + use_vllm (`bool`, *optional*, defaults to `False`): + Whether to use vLLM for generating completions from the student model. Requires `vllm` to be installed. + vllm_mode (`str`, *optional*, defaults to `"colocate"`): + Mode for student vLLM integration. Either `"server"` (connect to a running TRL vLLM server) or `"colocate"` + (run vLLM in the same process). + vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`): + Host of the vLLM server for the student model (if `vllm_mode="server"`). + vllm_server_port (`int`, *optional*, defaults to `8001`): + Port of the vLLM server for the student model (if `vllm_mode="server"`). + vllm_server_timeout (`float`, *optional*, defaults to `240.0`): + Timeout for connecting to the student vLLM server (if `vllm_mode="server"`). + vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.9`): + GPU memory utilization for the colocated student vLLM engine (if `vllm_mode="colocate"`). It is recommended + to set this to a low value if the student and teacher models share the same GPU. + vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`): + Tensor parallel size for the colocated student vLLM engine (if `vllm_mode="colocate"`). + vllm_structured_outputs_regex (`str`, *optional*): + Regex for vLLM structured outputs for the student model. + vllm_server_base_url (`str`, *optional*): + Base URL for the vLLM server (e.g., `"http://localhost:8001"`). If provided, `vllm_server_host` and + `vllm_server_port` are ignored. + vllm_group_port (`int`, *optional*, defaults to `51216`): + Port for the vLLM weight-update group (NCCL communicator). Unless the port is occupied, there is no need to + change it. + vllm_max_model_length (`int`, *optional*): + Maximum model sequence length for the colocated vLLM engine when `vllm_mode="colocate"`. Defaults to the + model's maximum context length. + vllm_model_impl (`str`, *optional*, defaults to `"vllm"`): + Model implementation backend to use in vLLM. Use `"vllm"` (default) or `"transformers"`. + vllm_sync_frequency (`int`, *optional*, defaults to `1`): + Frequency (in training steps) to synchronize student model weights to vLLM engine. Set to 1 to sync after + every step. + vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`): + Enable vLLM sleep mode to offload student weights/cache during the optimizer step. Keeps GPU memory usage + low, but waking the engine adds host–device transfer latency. + + > Parameters that control logging + + log_completions (`bool`, *optional*, defaults to `False`): + Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. If `rich` is installed, + it prints the sample. If `wandb` logging is enabled, it logs it to `wandb`. + log_completions_steps (`int`, *optional*, defaults to `100`): + Number of steps between logging (prompt, completion) pairs. Only used if `log_completions` is set to + `True`. + num_completions_to_print (`int` or `None`, *optional*): + Number of completions to print with `rich`. If `None`, all completions are logged. + wandb_log_unique_prompts (`bool`, *optional*, defaults to `True`): + Whether to log the unique prompts to wandb. This will create a new run for each unique prompt. + callbacks (`list[str]`, *optional*, defaults to `[]`): + The callbacks to run during training. + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `learning_rate`: Defaults to `1e-7` instead of `5e-5`. + """ + + _VALID_DICT_FIELDS = SFTConfig._VALID_DICT_FIELDS + ["teacher_model_init_kwargs"] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=1e-7, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + # GOLD-specific parameters + temperature: float = field( + default=0.9, + metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."}, + ) + top_p: float = field( + default=0.95, + metadata={ + "help": "If set to float < 1, only the smallest set of most probable tokens with probabilities that add up to " + "`top_p` or higher are kept for generation." + }, + ) + top_k: int = field( + default=0, + metadata={ + "help": "Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, " + "top-k-filtering is disabled and all tokens are considered." + }, + ) + lmbda: float = field( + default=0.5, + metadata={ + "help": "Lambda parameter that controls the student data fraction (i.e., the proportion of on-policy " + "student-generated outputs)." + }, + ) + beta: float = field( + default=0.5, + metadata={ + "help": "Interpolation coefficient between `0.0` and `1.0` of the Generalized Jensen-Shannon Divergence " + "loss. When beta is `0.0`, the loss is the KL divergence. When beta is `1.0`, the loss is the Inverse KL " + "Divergence." + }, + ) + max_completion_length: int = field( + default=128, + metadata={"help": "Maximum number of tokens to generate per completion."}, + ) + teacher_model_name_or_path: str | None = field( + default=None, + metadata={ + "help": "Model name or path of the teacher model. If `None`, the teacher model will be the same as the " + "model being trained." + }, + ) + teacher_model_revision: str | None = field( + default=None, + metadata={ + "help": "Model revision of the teacher model (e.g., branch name, tag, or commit hash). If `None`, the " + "default revision is used." + }, + ) + teacher_model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the " + "teacher model from a string." + }, + ) + teacher_tokenizer_name_or_path: str | None = field( + default=None, + metadata={ + "help": "Tokenizer name or path for the teacher model. If None when using ULD loss, will use the same " + "tokenizer as the student model (not recommended for cross-tokenizer distillation)." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropouts in `model`."}, + ) + seq_kd: bool = field( + default=False, + metadata={ + "help": "Seq_kd parameter that controls whether to perform Sequence-Level KD (can be viewed as supervised " + "FT on teacher-generated output)." + }, + ) + num_generations: int = field( + default=1, + metadata={ + "help": "Number of generations per prompt. Increasing this will decrease the number of unique prompts per optimization step." + }, + ) + generation_batch_size: int | None = field( + default=None, + metadata={ + "help": "Number of unique prompts per worker per optimizer step. " + "If None, computed from (per_device_train_batch_size * gradient_accumulation_steps) // num_generations." + }, + ) + + # ULD Loss parameters + use_uld_loss: bool = field( + default=False, + metadata={ + "help": "Whether to use Universal Logit Distillation (ULD) loss instead of Generalized Jensen-Shannon Divergence loss." + }, + ) + use_extended_uld: bool = field( + default=True, + metadata={ + "help": ( + "Whether to enable extended ULD alignment that uses tokenizers to align and merge token " + "probabilities across student and teacher tokenizations. When True, the trainer will compute " + "token mappings and merge probabilities for split tokens; when False, ULD will use simple " + "positional truncation like in the original ULD paper." + ) + }, + ) + uld_use_hybrid_loss: bool = field( + default=False, + metadata={ + "help": ( + "Whether to use a hybrid loss that combines ULD loss and JSD loss. When True, the final loss is a " + "a combination of JSD for known token mappings and ULD for unknown token mappings." + ) + }, + ) + uld_hybrid_matched_weight: float | None = field( + default=None, + metadata={ + "help": ( + "Weight for the matched token loss component when using hybrid ULD + JSD loss. This weight scales " + "the JSD loss computed over tokens that have a direct mapping between student and teacher " + "tokenizations. If None, uses adaptive weighting based on vocabulary overlap. Must be set together " + "with uld_hybrid_unmatched_weight (both None or both float)." + ) + }, + ) + uld_hybrid_unmatched_weight: float | None = field( + default=None, + metadata={ + "help": ( + "Weight for the unmatched token loss component when using hybrid ULD + JSD loss. This weight scales " + "the ULD loss computed over tokens that do not have a direct mapping between student and teacher " + "tokenizations. If None, uses adaptive weighting based on vocabulary overlap. Must be set together " + "with uld_hybrid_matched_weight (both None or both float)." + ) + }, + ) + uld_crossentropy_weight: float = field( + default=0.0, + metadata={"help": "Weight for the cross-entropy loss component in ULD loss."}, + ) + uld_distillation_weight: float = field( + default=1.0, + metadata={"help": "Weight for the distillation loss component in ULD loss."}, + ) + uld_student_temperature: float = field( + default=1.0, + metadata={"help": "Temperature for student logits in ULD loss computation."}, + ) + uld_teacher_temperature: float = field( + default=1.0, + metadata={"help": "Temperature for teacher logits in ULD loss computation."}, + ) + + uld_skip_student_eos: bool = field( + default=True, + metadata={"help": "Whether to skip EOS token for student in ULD loss computation."}, + ) + uld_skip_teacher_eos: bool = field( + default=True, + metadata={"help": "Whether to skip EOS token for teacher in ULD loss computation."}, + ) + + # vLLM parameters + use_vllm: bool = field( + default=False, + metadata={"help": "Whether to use vLLM for generating completions. Requires `vllm` to be installed."}, + ) + vllm_mode: str = field( + default="colocate", + metadata={ + "help": 'Mode for vLLM integration. Either "server" (connect to a running TRL vLLM server) or "colocate" (run vLLM in the same process).' + }, + ) + vllm_server_base_url: str | None = field( + default=None, + metadata={ + "help": 'Base URL for the vLLM server (e.g., "http://localhost:8001"). If provided, vllm_server_host and vllm_server_port are ignored.' + }, + ) + vllm_server_host: str = field( + default="0.0.0.0", + metadata={"help": 'Host of the vLLM server when `vllm_mode="server"`.'}, + ) + vllm_server_port: int = field( + default=8001, + metadata={"help": 'Port of the vLLM server when `vllm_mode="server"`.'}, + ) + vllm_server_timeout: float = field( + default=240.0, + metadata={"help": 'Timeout (in seconds) for connecting to the vLLM server when `vllm_mode="server"`.'}, + ) + vllm_group_port: int = field( + default=51216, + metadata={"help": "Port for the vLLM weight-update group (NCCL communicator)."}, + ) + vllm_gpu_memory_utilization: float = field( + default=0.9, + metadata={ + "help": 'GPU memory utilization for the colocated vLLM engine when `vllm_mode="colocate"`. Lower values reduce contention when sharing a device with the student/teacher models.' + }, + ) + vllm_tensor_parallel_size: int = field( + default=1, + metadata={"help": 'Tensor parallel size for the colocated vLLM engine when `vllm_mode="colocate"`.'}, + ) + vllm_max_model_length: int | None = field( + default=None, + metadata={ + "help": 'Maximum model sequence length for the colocated vLLM engine when `vllm_mode="colocate"`. Defaults to the model\'s maximum context length.' + }, + ) + vllm_model_impl: str = field( + default="vllm", + metadata={"help": 'Model implementation backend to use in vLLM. Use "vllm" (default) or "transformers".'}, + ) + vllm_structured_outputs_regex: str | None = field( + default=None, + metadata={"help": "Regex pattern used for vLLM structured outputs (optional)."}, + ) + vllm_sync_frequency: int = field( + default=1, + metadata={ + "help": "Frequency (in training steps) to synchronize model weights to the vLLM engine. Set to 1 to sync after every step." + }, + ) + vllm_enable_sleep_mode: bool = field( + default=False, + metadata={ + "help": "Enable vLLM sleep mode to offload student weights/cache during the optimizer step. Keeps GPU " + "memory usage low, but waking the engine adds host–device transfer latency." + }, + ) + # Parameters that control the logging + log_completions: bool = field( + default=False, + metadata={ + "help": "Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. If `rich` is " + "installed, it prints the sample. If `wandb` logging is enabled, it logs it to `wandb`." + }, + ) + log_completions_steps: int = field( + default=100, + metadata={ + "help": "Number of steps between logging (prompt, completion) pairs. Only used if `log_completions` is " + "set to `True`." + }, + ) + num_completions_to_print: int | None = field( + default=None, + metadata={"help": "Number of completions to print with `rich`. If `None`, all completions are logged."}, + ) + wandb_log_unique_prompts: bool = field( + default=True, + metadata={ + "help": ("Whether to log the unique prompts to wandb. This will create a new run for each unique prompt.") + }, + ) + callbacks: list[str] = field( + default_factory=lambda: [], + metadata={"help": "The callbacks to run during training."}, + ) + + def __post_init__(self): + super().__post_init__() + + # check lmbda and beta are in the range [0, 1] + if self.lmbda < 0.0 or self.lmbda > 1.0: + raise ValueError("lmbda must be in the range [0.0, 1.0].") + if self.beta < 0.0 or self.beta > 1.0: + raise ValueError("beta must be in the range [0.0, 1.0].") + + # Validate that max_length is sufficient for max_completion_length + if self.max_length is not None and self.max_completion_length >= self.max_length: + raise ValueError( + f"max_completion_length ({self.max_completion_length}) must be smaller than max_length ({self.max_length}) " + f"to leave room for the prompt. Consider increasing max_length or reducing max_completion_length." + ) + + if self.num_generations < 1: + raise ValueError(f"num_generations must be at least 1, got {self.num_generations}.") + local_sequence_batch_size = self.per_device_train_batch_size * self.gradient_accumulation_steps + if self.generation_batch_size is None: + self.generation_batch_size = local_sequence_batch_size // self.num_generations + if self.generation_batch_size < 1: + raise ValueError( + f"generation_batch_size must be at least 1. Got generation_batch_size={self.generation_batch_size}." + ) + if self.generation_batch_size * self.num_generations != local_sequence_batch_size: + raise ValueError( + "generation_batch_size and num_generations must exactly partition the local optimizer-step batch. " + "Expected generation_batch_size * num_generations == per_device_train_batch_size * " + f"gradient_accumulation_steps, got {self.generation_batch_size} * {self.num_generations} != " + f"{self.per_device_train_batch_size} * {self.gradient_accumulation_steps}." + ) + if self.num_generations > 1 and self.lmbda < 1.0: + warnings.warn( + f"num_generations={self.num_generations} with lmbda={self.lmbda} means off-policy batches include " + f"{self.num_generations} copies of each sample; consider lmbda=1.0 when num_generations > 1.", + UserWarning, + stacklevel=2, + ) + + # Validate ULD parameters + if self.use_uld_loss: + if self.uld_crossentropy_weight < 0.0: + raise ValueError("uld_crossentropy_weight must be non-negative.") + if self.uld_distillation_weight < 0.0: + raise ValueError("uld_distillation_weight must be non-negative.") + if self.uld_student_temperature <= 0.0: + raise ValueError("uld_student_temperature must be positive.") + if self.uld_teacher_temperature <= 0.0: + raise ValueError("uld_teacher_temperature must be positive.") + + # Validate hybrid loss weights - both must be None or both must be set + if self.uld_use_hybrid_loss: + if (self.uld_hybrid_matched_weight is None) != (self.uld_hybrid_unmatched_weight is None): + raise ValueError( + "uld_hybrid_matched_weight and uld_hybrid_unmatched_weight must both be None (for adaptive " + "weighting) or both be set to numeric values. Got uld_hybrid_matched_weight=" + f"{self.uld_hybrid_matched_weight} and uld_hybrid_unmatched_weight=" + f"{self.uld_hybrid_unmatched_weight}." + ) + if self.uld_hybrid_matched_weight is not None: + if self.uld_hybrid_matched_weight < 0.0: + raise ValueError("uld_hybrid_matched_weight must be non-negative.") + if self.uld_hybrid_unmatched_weight < 0.0: + raise ValueError("uld_hybrid_unmatched_weight must be non-negative.") diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/gold_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/gold_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..8c66fdfbcd82682616752b0a233be8c44f215596 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gold/gold_trainer.py @@ -0,0 +1,2043 @@ +# Copyright 2020-2026 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 random +import textwrap +from collections import defaultdict, deque +from collections.abc import Callable +from contextlib import nullcontext +from functools import partial +from itertools import takewhile +from typing import Any, Optional + +import torch +import torch.distributed as dist +import torch.nn as nn +import torch.nn.functional as F +from accelerate import PartialState +from accelerate.utils import DistributedType, broadcast_object_list, gather_object +from datasets import Dataset, IterableDataset +from torch.utils.data import DataLoader +from transformers import AutoTokenizer, TrainerCallback +from transformers.data.data_collator import DataCollator +from transformers.feature_extraction_utils import FeatureExtractionMixin +from transformers.generation.configuration_utils import GenerationConfig +from transformers.image_processing_utils import BaseImageProcessor +from transformers.integrations.integration_utils import is_wandb_available +from transformers.modeling_utils import PreTrainedModel +from transformers.processing_utils import ProcessorMixin +from transformers.tokenization_utils_base import PreTrainedTokenizerBase +from transformers.trainer_utils import EvalPrediction, seed_worker +from transformers.utils import is_datasets_available, is_liger_kernel_available, is_peft_available, is_rich_available + +from ...data_utils import is_conversational, maybe_convert_to_chatml, pack_dataset +from ...extras.profiling import profiling_decorator +from ...generation.vllm_generation import VLLMGeneration +from ...import_utils import is_vllm_available +from ...models import prepare_deepspeed +from ...models.utils import _ForwardRedirection, unwrap_model_for_generation +from ...trainer.sft_trainer import SFTTrainer +from ...trainer.utils import ( + RepeatSampler, + create_model_from_path, + disable_dropout_in_model, + pad, + split_tensor_dict, +) +from ..utils import ( + DataCollatorForChatML, + empty_cache, + encode_with_byte_offsets, + pad_byte_offsets, + piece_byte_len, +) +from .gold_config import GOLDConfig + + +if is_peft_available(): + from peft import PeftConfig + +if is_wandb_available(): + import wandb + + +if is_liger_kernel_available(): + from liger_kernel.chunked_loss import LigerFusedLinearJSDLoss + +if is_rich_available(): + from rich.console import Console + from rich.panel import Panel + from rich.table import Table + from rich.text import Text + + +def print_prompt_completions_sample_uld( + prompts: list[str], + completions: list[str], + step: int, + num_samples: int = None, +) -> None: + """ + Print out a sample of model completions to the console. + + This function creates a nicely formatted table showing prompt-completion pairs, useful for monitoring model outputs + during training. It requires the `rich` library to be installed. + + Args: + prompts (`list[str]`): + List of prompts. + completions (`list[str]`): + List of completions corresponding to the prompts. + step (`int`): + Current training step number, used in the output title. + num_samples (`int` or `None`, *optional*, defaults to `None`): + Number of random samples to display. If `None` (default), all items will be displayed. + + Example: + ```python + >>> from trl.experimental.gold.gold_trainer import print_prompt_completions_sample_uld + + >>> prompts = ["The sky is", "The sun is"] + >>> completions = [" blue.", " in the sky."] + >>> print_prompt_completions_sample_uld(prompts, completions, 42) + ╭─────────── Step 42 ───────────╮ + │ ┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓ │ + │ ┃ Prompt ┃ Completion ┃ │ + │ ┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩ │ + │ │ The sky is │ blue. │ │ + │ ├────────────┼──────────────┤ │ + │ │ The sun is │ in the sky. │ │ + │ └────────────┴──────────────┘ │ + ╰───────────────────────────────╯ + ``` + """ + if not is_rich_available(): + raise ImportError( + "The function `print_prompt_completions_sample_uld` requires the `rich` library. Please install it with " + "`pip install rich`." + ) + console = Console() + table = Table(show_header=True, header_style="bold white", expand=True) + + # Add columns + table.add_column("Prompt", style="bright_yellow") + table.add_column("Completion", style="bright_green") + + # Some basic input validation + if num_samples is not None: + if num_samples >= len(prompts): + num_samples = None + elif num_samples <= 0: + return + + # Subsample data if num_samples is specified + if num_samples is not None: + indices = random.sample(range(len(prompts)), num_samples) + prompts = [prompts[i] for i in indices] + completions = [completions[i] for i in indices] + + for i in range(len(prompts)): + table.add_row(Text(prompts[i]), Text(completions[i])) + table.add_section() # Adds a separator between rows + + panel = Panel(table, expand=False, title=f"Step {step}", border_style="bold white") + console.print(panel) + + +def build_teacher_inputs_from_texts( + tokenizer: PreTrainedTokenizerBase, + prompt_texts: list[str], + completion_texts: list[str], +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + """Tokenize teacher prompts/completions and produce tensors ready for GOLD loss. + + Returns ``(input_ids, labels, attention_mask, byte_offsets)``. ``byte_offsets`` is a ``[batch, seq, 2]`` tensor of + UTF-8 byte ``(start, end)`` for each token: prompt and padding positions are filled with ``(0, 0)``; completion + tokens carry offsets relative to the corresponding ``completion_text``; the appended EOS gets ``(content_len, + content_len)``. Byte offsets are derived from the fast tokenizer's char offsets via ``encode_with_byte_offsets``. + """ + + pad_token_id = tokenizer.pad_token_id + eos_token_id = tokenizer.eos_token_id + backend = tokenizer.backend_tokenizer + + prompt_token_ids = tokenizer(prompt_texts, add_special_tokens=True)["input_ids"] + completion_encs = encode_with_byte_offsets(backend, completion_texts, add_special_tokens=False) + + sequences: list[torch.Tensor] = [] + attention_masks: list[torch.Tensor] = [] + labels_list: list[torch.Tensor] = [] + offsets_list: list[list[tuple[int, int]]] = [] + + for prompt_ids, (enc_ids, enc_offs), completion_text in zip( + prompt_token_ids, completion_encs, completion_texts, strict=True + ): + # Remove trailing EOS from prompt so completions can extend cleanly + if eos_token_id is not None and prompt_ids and prompt_ids[-1] == eos_token_id: + prompt_ids = prompt_ids[:-1] + + completion_ids = list(enc_ids) + completion_offs = list(enc_offs) + content_len = len(completion_text.encode("utf-8")) + + sequence = list(prompt_ids) + completion_ids + offsets = [(0, 0)] * len(prompt_ids) + completion_offs + if eos_token_id is not None: + sequence.append(eos_token_id) + offsets.append((content_len, content_len)) + + seq_tensor = torch.tensor(sequence, dtype=torch.long) + sequences.append(seq_tensor) + attention_masks.append(torch.ones_like(seq_tensor)) + offsets_list.append(offsets) + + labels = seq_tensor.clone() + labels[: len(prompt_ids)] = -100 + if pad_token_id is not None: + labels[labels == pad_token_id] = -100 + labels_list.append(labels) + + teacher_input_ids = pad( + sequences, + padding_side="right", + padding_value=pad_token_id if pad_token_id is not None else 0, + ) + teacher_attention_mask = pad(attention_masks, padding_side="right", padding_value=0).bool() + teacher_labels = pad(labels_list, padding_side="right", padding_value=-100) + + if eos_token_id is not None: + for row in range(teacher_attention_mask.size(0)): + valid = ( + teacher_input_ids[row] != pad_token_id + if pad_token_id is not None + else teacher_attention_mask[row].bool() + ) + if valid.any(): + last_idx = valid.nonzero(as_tuple=True)[0][-1] + teacher_attention_mask[row, last_idx + 1 :] = False + + target_len = teacher_input_ids.size(1) + teacher_byte_offsets = torch.stack( + [pad_byte_offsets(offs, target_len, padding_side="right") for offs in offsets_list], + dim=0, + ) + + return teacher_input_ids, teacher_labels, teacher_attention_mask, teacher_byte_offsets + + +class ULDLoss(nn.Module): + """ + Universal Logit Distillation Loss. + """ + + def __init__(self, config: GOLDConfig, student_tokenizer=None, teacher_tokenizer=None, device=None): + super().__init__() + self.device = device + self.crossentropy_weight = config.uld_crossentropy_weight + self.distillation_weight = config.uld_distillation_weight + self.student_temperature = config.uld_student_temperature + self.teacher_temperature = config.uld_teacher_temperature + self.skip_student_eos = config.uld_skip_student_eos + self.skip_teacher_eos = config.uld_skip_teacher_eos + self.use_extended_uld = config.use_extended_uld + self.ignore_index = -100 + + # Add tokenizers for enhanced alignment + self.student_tokenizer = student_tokenizer + self.teacher_tokenizer = teacher_tokenizer + + # Hybrid ULD configuration + self.use_hybrid_loss = getattr(config, "uld_use_hybrid_loss", False) + self.hybrid_matched_weight = getattr(config, "uld_hybrid_matched_weight", None) + self.hybrid_unmatched_weight = getattr(config, "uld_hybrid_unmatched_weight", None) + self.beta = getattr(config, "beta", 1.0) # For JSD loss in hybrid matched tokens + + # Initialize vocabulary mapping for hybrid loss + self._vocab_mapping = None + self._teacher_matched_ids = None + self._student_matched_ids = None + if self.use_hybrid_loss and student_tokenizer is not None and teacher_tokenizer is not None: + self._initialize_vocabulary_mapping() + + def __call__( + self, + student_logits, + teacher_logits, + student_labels, + teacher_labels, + student_input_ids, + teacher_input_ids, + student_byte_offsets=None, + teacher_byte_offsets=None, + ): + """ + Compute ULD loss with GKD trainer interface. + + Args: + student_logits: Student model logits [batch_size, seq_len, vocab_size] + teacher_logits: Teacher model logits [batch_size, seq_len, vocab_size] + student_labels: Student target labels [batch_size, seq_len] + teacher_labels: Teacher target labels [batch_size, seq_len] + student_input_ids: Student input token IDs [batch_size, seq_len] + teacher_input_ids: Teacher input token IDs [batch_size, seq_len] + student_byte_offsets: Per-token UTF-8 byte offsets ``[batch, seq, 2]`` + from the data collator (relative to the rendered chat-template message). Required. + teacher_byte_offsets: Per-sample list of completion-relative byte + offsets (one list per batch item) from ``build_teacher_inputs_from_texts``. Required. + + Returns: + Total loss (cross-entropy + distillation) + """ + # Compute cross-entropy loss for student + if self.crossentropy_weight > 0: + shift_logits = student_logits[..., :-1, :].contiguous() + shift_labels = student_labels[..., 1:].contiguous() + loss_fct = nn.CrossEntropyLoss(ignore_index=self.ignore_index) + crossentropy_loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1)) + crossentropy_loss = self.crossentropy_weight * crossentropy_loss + else: + crossentropy_loss = 0.0 + + # Compute distillation loss using ULD approximation + distillation_loss = self._compute_distillation_loss( + student_logits, + teacher_logits, + student_labels, + teacher_labels, + student_input_ids, + teacher_input_ids, + student_byte_offsets=student_byte_offsets, + teacher_byte_offsets=teacher_byte_offsets, + ) + + return crossentropy_loss + distillation_loss + + def _initialize_vocabulary_mapping(self): + """Initialize vocabulary mapping for hybrid ULD loss.""" + # Computing vocabulary mapping for hybrid ULD + + student_vocab = self.student_tokenizer.get_vocab() + teacher_vocab = self.teacher_tokenizer.get_vocab() + + # Create reverse mapping for student + student_token_to_id = dict(student_vocab.items()) + + vocab_mapping = {} + teacher_matched_ids = set() + student_matched_ids = set() + + for token_str, teacher_id in teacher_vocab.items(): + if token_str in student_token_to_id: + student_id = student_token_to_id[token_str] + vocab_mapping[teacher_id] = student_id + teacher_matched_ids.add(teacher_id) + student_matched_ids.add(student_id) + + self._vocab_mapping = vocab_mapping + self._teacher_matched_ids = teacher_matched_ids + self._student_matched_ids = student_matched_ids + + max_matched_teacher_id = max(self._vocab_mapping.keys()) + self.mapping_tensor = torch.full((max_matched_teacher_id + 1,), -1, dtype=torch.long) # -1 for unmapped ids + for k, v in self._vocab_mapping.items(): + self.mapping_tensor[k] = v + if self.device is not None: + self.mapping_tensor = self.mapping_tensor.to(self.device) + + def _compute_distillation_loss( + self, + student_logits, + teacher_logits, + student_labels, + teacher_labels, + student_input_ids, + teacher_input_ids, + student_byte_offsets=None, + teacher_byte_offsets=None, + ): + """ + Compute the Universal Logit Distillation loss with token mapping. + + This version uses actual input_ids for accurate token mapping and multiplies probabilities for split tokens. + Both student_input_ids and teacher_input_ids are required for optimal alignment. + """ + # Get answer regions (same as original) + student_answer_index, student_answer_size = self._get_start_and_size_answers(student_labels) + teacher_answer_index, teacher_answer_size = self._get_start_and_size_answers(teacher_labels) + + if self.skip_student_eos: + student_answer_size = [size - 1 for size in student_answer_size] + if self.skip_teacher_eos: + teacher_answer_size = [size - 1 for size in teacher_answer_size] + + # Handle edge case where all answer sizes are 0 + if ( + not student_answer_size + or not teacher_answer_size + or max(max(student_answer_size), max(teacher_answer_size)) <= 0 + ): + return torch.zeros(1, device=student_logits.device, requires_grad=True) * student_logits.sum() * 1e-8 + + batch_size = student_logits.size(0) + distillation_losses = [] + + for i in range(batch_size): + # Get answer regions for this batch item + student_start = student_answer_index[i] + student_size = student_answer_size[i] + teacher_start = teacher_answer_index[i] + teacher_size = teacher_answer_size[i] + + if student_size <= 0 or teacher_size <= 0: + loss_i = student_logits[i].sum() * 0.0 + distillation_losses.append(loss_i) + continue + + # Extract answer logits + student_answer_logits = student_logits[i, student_start : student_start + student_size] + teacher_answer_logits = teacher_logits[i, teacher_start : teacher_start + teacher_size] + + # Convert to probabilities + student_probs = F.softmax(student_answer_logits / self.student_temperature, dim=-1) + teacher_probs = F.softmax(teacher_answer_logits / self.teacher_temperature, dim=-1) + + # Pass actual input_ids so split-token groups can multiply conditional probabilities. + student_token_ids = student_input_ids[i, student_start : student_start + student_size].tolist() + teacher_token_ids = teacher_input_ids[i, teacher_start : teacher_start + teacher_size].tolist() + + if self.use_extended_uld: + if student_byte_offsets is None or teacher_byte_offsets is None: + raise ValueError("Byte offsets are required when `use_extended_uld=True`.") + + # Both sides are completion-relative, so plain slicing gives a shared byte coordinate system. + s_answer = student_byte_offsets[i, student_start : student_start + student_size].tolist() + t_answer = teacher_byte_offsets[i, teacher_start : teacher_start + teacher_size].tolist() + student_groups, teacher_groups = self._align_by_byte_offsets(s_answer, t_answer) + # Drop degenerate pairs where either side is empty — e.g. teacher's trailing zero-width EOS at + # ``(content_len, content_len)`` paired with an empty student group merges to a zero distribution + # and inflates the loss (only reachable when ``skip_teacher_eos=False``). + paired = [(sg, tg) for sg, tg in zip(student_groups, teacher_groups, strict=False) if sg and tg] + student_groups = [sg for sg, _ in paired] + teacher_groups = [tg for _, tg in paired] + student_aligned = self._merge_probabilities_with_alignment_groups( + student_probs, student_groups, student_token_ids + ) + teacher_aligned = self._merge_probabilities_with_alignment_groups( + teacher_probs, teacher_groups, teacher_token_ids + ) + else: + min_length = min(len(student_token_ids), len(teacher_token_ids)) + student_aligned = student_probs[:min_length, :] + teacher_aligned = teacher_probs[:min_length, :] + + # Apply ULD loss computation + if self.use_hybrid_loss and self._vocab_mapping is not None: + # Use hybrid approach: direct comparison for matched tokens, sorting for unmatched + aligned_loss = self._compute_hybrid_uld_loss(student_aligned, teacher_aligned) + else: + # Original approach: sort all probabilities + student_sorted = student_aligned.sort(dim=-1, descending=True).values + teacher_sorted = teacher_aligned.sort(dim=-1, descending=True).values + + # Pad vocabularies to same size + student_vocab_size = student_sorted.size(-1) + teacher_vocab_size = teacher_sorted.size(-1) + max_vocab_size = max(student_vocab_size, teacher_vocab_size) + + if student_vocab_size < max_vocab_size: + student_sorted = F.pad(student_sorted, (0, max_vocab_size - student_vocab_size)) + if teacher_vocab_size < max_vocab_size: + teacher_sorted = F.pad(teacher_sorted, (0, max_vocab_size - teacher_vocab_size)) + + # Compute L1 distance (ULD approach) + aligned_loss = F.l1_loss(student_sorted, teacher_sorted, reduction="sum") + aligned_loss /= student_aligned.size(0) # Normalize by sequence length + distillation_losses.append(aligned_loss) + + distillation_loss = torch.stack(distillation_losses).mean() + return self.distillation_weight * distillation_loss + + @staticmethod + def _align_by_byte_offsets(s_offsets, t_offsets): + """ + Walk both byte-offset arrays, advancing the side whose current token ends earlier. A group closes when both + sides reach the same byte boundary — the points where the two tokenizers agree on a split. + """ + s_groups, t_groups = [], [] + s_start = t_start = s = t = 0 + n_s, n_t = len(s_offsets), len(t_offsets) + while s < n_s and t < n_t: + s_end, t_end = s_offsets[s][1], t_offsets[t][1] + if s_end < t_end: + s += 1 + elif s_end > t_end: + t += 1 + else: + s += 1 + t += 1 + s_groups.append(list(range(s_start, s))) + t_groups.append(list(range(t_start, t))) + s_start, t_start = s, t + if s < n_s or t < n_t: + s_groups.append(list(range(s_start, n_s))) + t_groups.append(list(range(t_start, n_t))) + return s_groups, t_groups + + def _merge_probabilities_with_alignment_groups(self, probs, alignment_groups, token_ids=None): + """ + Merge probabilities based on alignment groups with corrected conditional probability handling. + + For a group merging tokens at positions [i, i+1, ..., i+k], we compute: + P_merged(y | x) = P(y | x) × P(token_{i+1} | token_i, x) × ... × P(token_{i+k} | ..., x) + + Where: + - P(y | x) is the marginal probability distribution over all vocabulary tokens at position i + - token_{i+1}, ..., token_{i+k} are the ACTUAL tokens that were generated + - The conditional probabilities P(token_j | ..., x) are extracted as SCALARS + - y ranges over all vocabulary tokens at position i + + This ensures the probability of the actual generated sequence is correct (by the chain rule), while introducing + a known bias for counterfactual tokens (since we don't have P(token_{i+k} | y, x) for y != token_i). The merged + distribution is unnormalized but preserves correct relative probabilities. + + Args: + probs: Probability tensor [seq_len, vocab_size] + alignment_groups: List of alignment groups (each group is a list of positions to merge) + token_ids: Actual token IDs that were generated [seq_len]. REQUIRED when any group has + len(group) > 1. If None when multi-token groups exist, raises ValueError. + + Returns: + Merged probability tensor [num_groups, vocab_size] + + Raises: + ValueError: If token_ids is None when merging multi-token groups + """ + if not alignment_groups: + return probs + + # Create aligned tensor + vocab_size = probs.size(-1) + target_len = len(alignment_groups) + aligned_probs = torch.zeros(target_len, vocab_size, device=probs.device, dtype=probs.dtype) + eps = 1e-8 + + # Process each alignment group + for group_idx, group in enumerate(alignment_groups): + # Handle probability merging + if len(group) > 1: + # Multiple tokens map to this group - merge using corrected conditional probability approach + if token_ids is None: + raise ValueError( + "token_ids must be provided when merging multi-token groups. " + "This is required for mathematically correct probability merging." + ) + + # Start with the marginal distribution at the first position + first_pos = group[0] + marginal_probs = probs[first_pos] # P(y | x₀) for all y + + # For each subsequent token in the group, extract the SCALAR conditional probability + # of the actual token that was generated, and multiply + conditional_prob_product = 1.0 + for idx in group[1:]: + # Get the actual token ID that was generated at this position + actual_token_id = token_ids[idx] + # Extract its probability (scalar) + token_prob = probs[idx, actual_token_id].clamp_min(eps) + conditional_prob_product *= token_prob + + # Merge: multiply the scalar conditional prob product with the entire marginal distribution + # This gives: P(y | x_0) × P(token_1 | token_0, x) × ... × P(token_k | ..., x) + # Note: This is unnormalized, but preserves the correct joint probability for the actual sequence + merged_probs = marginal_probs * conditional_prob_product + aligned_probs[group_idx] = merged_probs + + elif len(group) == 1: + aligned_probs[group_idx] = probs[group[0]] + else: + # No tokens map to this group + aligned_probs[group_idx] = torch.zeros_like(probs[0]) + + return aligned_probs + + def _compute_hybrid_uld_loss(self, student_aligned, teacher_aligned): + """ + Compute hybrid ULD loss on aligned probability distributions. This method: + 1. Directly compares probabilities for tokens with matching vocabulary entries + 2. Uses sorting approach only for tokens with different vocabulary entries + + Args: + student_aligned: Aligned student probabilities [seq_len, student_vocab_size] + teacher_aligned: Aligned teacher probabilities [seq_len, teacher_vocab_size] + Returns: + Combined hybrid loss + """ + device = student_aligned.device + # seq_len = student_aligned.size(0) # Unused variable + student_vocab_size = student_aligned.size(-1) + teacher_vocab_size = teacher_aligned.size(-1) + + # Convert sets to sorted tensors for indexing + if self._teacher_matched_ids: + teacher_matched_indices = torch.tensor(sorted(self._teacher_matched_ids), dtype=torch.long, device=device) + student_matched_indices = self.mapping_tensor[teacher_matched_indices] + else: + teacher_matched_indices = torch.tensor([], dtype=torch.long, device=device) + student_matched_indices = torch.tensor([], dtype=torch.long, device=device) + + # Create masks for unmatched tokens + teacher_matched_mask = torch.zeros(teacher_vocab_size, dtype=torch.bool, device=device) + student_matched_mask = torch.zeros(student_vocab_size, dtype=torch.bool, device=device) + + if len(teacher_matched_indices) > 0: + teacher_matched_mask[teacher_matched_indices] = True + student_matched_mask[student_matched_indices] = True + + # 1. JSD loss for matched vocabulary tokens (direct semantic correspondence) + matched_loss = torch.tensor(0.0, device=device) + matched_token_count = 0 + if len(teacher_matched_indices) > 0: + # Extract probabilities for matched tokens + teacher_matched_probs = teacher_aligned[:, teacher_matched_indices] # [seq_len, num_matched] + student_matched_probs = student_aligned[:, student_matched_indices] # [seq_len, num_matched] + matched_token_count = teacher_matched_probs.size(-1) + + # Use JSD loss for semantically aligned tokens + # Convert probabilities back to logits for JSD computation + + # Apply generalized JSD loss to matched tokens + matched_loss = self._compute_jsd_loss_for_matched_tokens(student_matched_probs, teacher_matched_probs) + + # 2. Sorted comparison loss for unmatched vocabulary tokens + teacher_unmatched_mask = ~teacher_matched_mask + student_unmatched_mask = ~student_matched_mask + + teacher_unmatched_probs = teacher_aligned[:, teacher_unmatched_mask] # [seq_len, num_teacher_unmatched] + student_unmatched_probs = student_aligned[:, student_unmatched_mask] # [seq_len, num_student_unmatched] + + unmatched_loss = torch.tensor(0.0, device=device) + if teacher_unmatched_probs.size(-1) > 0 and student_unmatched_probs.size(-1) > 0: + # Sort unmatched probabilities + teacher_unmatched_sorted = teacher_unmatched_probs.sort(dim=-1, descending=True).values + student_unmatched_sorted = student_unmatched_probs.sort(dim=-1, descending=True).values + + # Pad to same size if needed + teacher_unmatched_size = teacher_unmatched_sorted.size(-1) + student_unmatched_size = student_unmatched_sorted.size(-1) + max_unmatched_size = max(teacher_unmatched_size, student_unmatched_size) + + if teacher_unmatched_size < max_unmatched_size: + teacher_unmatched_sorted = F.pad( + teacher_unmatched_sorted, (0, max_unmatched_size - teacher_unmatched_size) + ) + if student_unmatched_size < max_unmatched_size: + student_unmatched_sorted = F.pad( + student_unmatched_sorted, (0, max_unmatched_size - student_unmatched_size) + ) + + # L1 loss on sorted unmatched tokens + unmatched_loss = F.l1_loss(student_unmatched_sorted, teacher_unmatched_sorted, reduction="sum") + unmatched_loss /= student_aligned.size(0) # Normalize by sequence length + + # 3. Combine losses with weights + if self.hybrid_matched_weight is None: + # Use adaptive weighting based on vocabulary overlap + hybrid_matched_weight = matched_token_count / max(1, teacher_vocab_size) + hybrid_unmatched_weight = 1.0 - hybrid_matched_weight + else: + # Use fixed weights provided in config + hybrid_matched_weight = self.hybrid_matched_weight + hybrid_unmatched_weight = self.hybrid_unmatched_weight + + total_loss = hybrid_matched_weight * matched_loss + hybrid_unmatched_weight * unmatched_loss + + # Store matched/unmatched components for logging + self.last_matched_loss = matched_loss + self.last_unmatched_loss = unmatched_loss + + return total_loss + + def _compute_jsd_loss_for_matched_tokens(self, student_logits, teacher_logits): + """ + Compute JSD loss for matched vocabulary tokens. + + Args: + student_logits: Student logits for matched tokens [seq_len, num_matched] + teacher_logits: Teacher logits for matched tokens [seq_len, num_matched] + Returns: + JSD loss for matched tokens + """ + # Reshape to [batch_size * seq_len, vocab_size] format expected by generalized_jsd_loss + batch_seq_len, num_matched = student_logits.shape + + student_logits_reshaped = student_logits.view(-1, num_matched) + teacher_logits_reshaped = teacher_logits.view(-1, num_matched) + + # Use the GOLD generalized JSD loss implementation that accepts probability inputs + jsd_loss = GOLDTrainer.generalized_jsd_loss( + student_logits_reshaped, + teacher_logits_reshaped, + labels=None, # No masking needed for matched tokens + beta=self.beta, # Standard JSD beta + temperature=1.0, # Already applied in main computation + reduction="batchmean", + logits_are_probs=True, + ) + + return jsd_loss + + def _get_start_and_size_answers(self, answer_tensors): + answers_index = [] + answers_size = [] + + for answer in answer_tensors: + answer_mask = answer.ne(self.ignore_index) + if not answer_mask.any(): + answers_index.append(0) + answers_size.append(0) + continue + + valid_indices = answer_mask.nonzero(as_tuple=True)[0] + answers_index.append(int(valid_indices[0].item())) + answers_size.append(int(answer_mask.sum().item())) + return answers_index, answers_size + + +class GOLDTrainer(SFTTrainer): + _tag_names = ["trl", "gold"] + _name = "GOLD" + _paper = { + "title": "Unlocking On-Policy Distillation for Any Model Family", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @misc{patino2025unlocking, + title = {{Unlocking On-Policy Distillation for Any Model Family}}, + author = {Carlos Miguel Patiño and Kashif Rasul and Quentin Gallouédec and Ben Burtenshaw and Sergio Paniego and Vaibhav Srivastav and Thibaud Frere and Ed Beeching and Lewis Tunstall and Leandro von Werra and Thomas Wolf}, + year = 2025, + url = {https://huggingface.co/spaces/HuggingFaceH4/general-on-policy-logit-distillation}, + }"""), + } + + def __init__( + self, + model: PreTrainedModel | nn.Module | str | None = None, + teacher_model: PreTrainedModel | nn.Module | str = None, + args: GOLDConfig | None = None, + data_collator: DataCollator | None = None, # type: ignore + train_dataset: Dataset | None = None, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + processing_class: PreTrainedTokenizerBase + | BaseImageProcessor + | FeatureExtractionMixin + | ProcessorMixin + | None = None, + compute_metrics: Callable[[EvalPrediction], dict] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + peft_config: Optional["PeftConfig"] = None, + ): + self.model_name_or_path = model if isinstance(model, str) else model.config._name_or_path + self.model_revision = (args.model_init_kwargs or {}).get("revision") + + # Respect a user-provided data_collator; otherwise, provide a ChatML collator that + if data_collator is None: + data_collator = DataCollatorForChatML(tokenizer=processing_class, max_length=args.max_length) + + # Liger fused GKD loss (JSD) + self.use_liger_gkd_loss = False + if args.use_liger_kernel: + self.liger_jsd_loss = LigerFusedLinearJSDLoss( + beta=args.beta, + ignore_index=-100, + temperature=args.temperature, + compiled=False, + weight_hard_loss=0.0, + weight_soft_loss=1.0, + ) + self.use_liger_gkd_loss = True + self._forward_redirection = _ForwardRedirection() + + if args.teacher_model_init_kwargs is None: + teacher_model_init_kwargs = {} + elif not isinstance(teacher_model, str): + raise ValueError( + "You passed teacher_model_init_kwargs to the GOLDConfig, but your teacher_model is already instantiated." + ) + else: + teacher_model_init_kwargs = args.teacher_model_init_kwargs + teacher_model_init_kwargs["dtype"] = ( + teacher_model_init_kwargs["dtype"] + if teacher_model_init_kwargs["dtype"] in ["auto", None] + else getattr(torch, teacher_model_init_kwargs["dtype"]) + ) + + if args.use_uld_loss and args.teacher_tokenizer_name_or_path is None: + if isinstance(teacher_model, str): + args.teacher_tokenizer_name_or_path = teacher_model + else: + raise ValueError( + "`teacher_tokenizer_name_or_path` must be set when using ULD loss with a pre-instantiated teacher model." + ) + + if isinstance(teacher_model, str): + init_kwargs = dict(teacher_model_init_kwargs) + if args.teacher_model_revision is not None: + init_kwargs.setdefault("revision", args.teacher_model_revision) + init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + teacher_model = create_model_from_path(teacher_model, **init_kwargs) + self.use_uld_loss = args.use_uld_loss + self.teacher_tokenizer = None + if args.use_uld_loss and args.teacher_tokenizer_name_or_path is not None: + self.teacher_tokenizer = AutoTokenizer.from_pretrained( + args.teacher_tokenizer_name_or_path, trust_remote_code=args.trust_remote_code + ) + if not hasattr(self.teacher_tokenizer, "pad_token") or self.teacher_tokenizer.pad_token is None: + self.teacher_tokenizer.pad_token = self.teacher_tokenizer.eos_token + + # Hybrid ULD loss configuration is handled in ULDLoss class + + super().__init__( + model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + peft_config=peft_config, + ) + + if args.disable_dropout: + disable_dropout_in_model(self.model) + if not args.use_uld_loss: + teacher_model.resize_token_embeddings(self.model.config.get_text_config().vocab_size) + + if self.is_deepspeed_enabled: + self.teacher_model = prepare_deepspeed(teacher_model, self.accelerator) + else: + self.teacher_model = self.accelerator.prepare_model(teacher_model, evaluation_mode=True) + + self.lmbda = args.lmbda + self.beta = args.beta + self.temperature = args.temperature + self.top_p = args.top_p + self.seq_kd = args.seq_kd + self.num_generations = args.num_generations + + # Track per-step loss statistics for on/off-policy batches (used in logging) + self._on_policy_loss_total = 0.0 + self._off_policy_loss_total = 0.0 + self._on_policy_step_equiv = 0.0 + self._off_policy_step_equiv = 0.0 + + # Buffering for rollouts across gradient accumulation steps + self._buffered_inputs = None + self._buffered_on_policy = None + self._buffered_text_logs = None + self._step = 0 + + # Hybrid ULD matched/unmatched accumulators (logged every step when ULD hybrid is used) + self._matched_sum = 0.0 + self._unmatched_sum = 0.0 + self._matched_step_eq = 0.0 + self._unmatched_step_eq = 0.0 + + self.uld_loss_fn = None + if self.use_uld_loss: + self.uld_loss_fn = ULDLoss( + config=args, + student_tokenizer=processing_class, + teacher_tokenizer=self.teacher_tokenizer, + device=self.accelerator.device, + ) + + generation_kwargs = { + "max_new_tokens": args.max_completion_length, + "temperature": args.temperature, + "top_p": args.top_p, + "do_sample": True, + "top_k": args.top_k, + "pad_token_id": self.processing_class.pad_token_id, + } + self.generation_config = GenerationConfig(**generation_kwargs) + # Keep training-specific generation kwargs to overwrite model's original generation config + self.generation_kwargs = generation_kwargs + if ( + hasattr(self.model.generation_config, "eos_token_id") + and self.model.generation_config.eos_token_id is not None + ): + self.generation_config.eos_token_id = self.model.generation_config.eos_token_id + + # Initialize the metrics + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + self._total_train_tokens = 0 + self.log_completions = args.log_completions + self.log_completion_steps = args.log_completions_steps + self.wandb_log_unique_prompts = args.wandb_log_unique_prompts + self.num_completions_to_print = args.num_completions_to_print + # maxlen is set to the total number of forward passes per step. This value of `maxlen` ensures we log only the + # final optimization step. + maxlen = self.accelerator.num_processes * args.per_device_train_batch_size * args.gradient_accumulation_steps + self._textual_logs = { + "prompt": deque(maxlen=maxlen), + "completion": deque(maxlen=maxlen), + "rewards": defaultdict(lambda: deque(maxlen=maxlen)), + "advantages": deque(maxlen=maxlen), + } + + self.use_vllm = args.use_vllm + if self.use_vllm: + if not is_vllm_available(): + raise ImportError( + "vLLM is not available and use_vllm is set to True. Please install vLLM with " + "`pip install vllm` to use it." + ) + self.vllm_generation = VLLMGeneration( + model=self.model, + accelerator=self.accelerator, + processing_class=self.processing_class, + mode=args.vllm_mode, + structured_outputs_regex=args.vllm_structured_outputs_regex, + server_base_url=args.vllm_server_base_url, + server_host=args.vllm_server_host, + server_port=args.vllm_server_port, + group_port=args.vllm_group_port, + server_timeout=args.vllm_server_timeout, + tensor_parallel_size=args.vllm_tensor_parallel_size, + gpu_memory_utilization=args.vllm_gpu_memory_utilization, + max_model_length=args.vllm_max_model_length or args.max_length, + max_num_seqs=args.per_device_train_batch_size * args.gradient_accumulation_steps, + enable_sleep_mode=args.vllm_enable_sleep_mode, + model_impl=args.vllm_model_impl, + repetition_penalty=getattr(args, "repetition_penalty", 1.0), + temperature=args.temperature, + top_p=args.top_p, + top_k=args.top_k, + min_p=getattr(args, "min_p", 0.0), + max_completion_length=args.max_completion_length, + logprobs=None, + ) + self.vllm_sync_frequency = args.vllm_sync_frequency + self._last_vllm_sync_step = -self.vllm_sync_frequency + + def _set_signature_columns_if_needed(self): + super()._set_signature_columns_if_needed() + required_columns = [ + "prompts", + "prompt_attention_mask", + "messages", + "chat_template_kwargs", + "tools", + "original_prompt_text", + "original_completion_text", + "byte_offsets", + "completion_mask", + ] + if self._signature_columns is None: + self._signature_columns = required_columns + else: + for column in required_columns: + if column not in self._signature_columns: + self._signature_columns.append(column) + + def _get_train_sampler(self, dataset=None): + if dataset is None: + dataset = self.train_dataset + return RepeatSampler( + data_source=dataset, + mini_repeat_count=self.num_generations, + batch_size=self.args.generation_batch_size * self.accelerator.num_processes, + repeat_count=self.args.gradient_accumulation_steps, + shuffle=True, + seed=self.args.seed, + ) + + def get_train_dataloader(self): + """ + Override Trainer.get_train_dataloader to load one generation batch per optimizer window. + + The dataloader yields local batches of size `per_device_train_batch_size * gradient_accumulation_steps`. The + `RepeatSampler` (with `repeat_count=gradient_accumulation_steps`) ensures each generation batch is sampled + `gradient_accumulation_steps` times so Trainer's loop iterates the correct number of times. Only the first + batch in each window triggers `_fill_buffer`; the rest are ignored by `_prepare_inputs`. + """ + if self.train_dataset is None: + raise ValueError("Trainer: training requires a train_dataset.") + + train_dataset = self.train_dataset + data_collator = self.data_collator + if is_datasets_available() and isinstance(train_dataset, Dataset): + train_dataset = self._remove_unused_columns(train_dataset, description="training") + else: + data_collator = self._get_collator_with_removed_columns(data_collator, description="training") + + dataloader_params = { + "batch_size": self._train_batch_size * self.args.gradient_accumulation_steps, + "collate_fn": data_collator, + "num_workers": self.args.dataloader_num_workers, + "pin_memory": self.args.dataloader_pin_memory, + "persistent_workers": self.args.dataloader_persistent_workers, + } + + if not isinstance(train_dataset, torch.utils.data.IterableDataset): + dataloader_params["sampler"] = self._get_train_sampler() + dataloader_params["drop_last"] = self.args.dataloader_drop_last + dataloader_params["worker_init_fn"] = partial( + seed_worker, + num_workers=self.args.dataloader_num_workers, + rank=self.args.process_index, + ) + if self.args.dataloader_num_workers > 0: + dataloader_params["prefetch_factor"] = self.args.dataloader_prefetch_factor + + return self.accelerator.prepare(DataLoader(train_dataset, **dataloader_params)) + + @profiling_decorator + def _prepare_inputs(self, generation_batch: dict[str, torch.Tensor | Any]) -> dict[str, torch.Tensor | Any]: + if not self.model.training: + return generation_batch + + buffer_steps = self.args.gradient_accumulation_steps + if self._step % buffer_steps == 0 or self._buffered_inputs is None: + self._fill_buffer(generation_batch, buffer_steps) + + slice_idx = self._step % buffer_steps + inputs = self._buffered_inputs[slice_idx] + self._step += 1 + return inputs + + @staticmethod + def _build_sequence_batch( + new_input_ids: torch.Tensor, + prompt_lengths: torch.Tensor, + pad_token_id: int | None, + attention_mask: torch.Tensor | None = None, + ) -> tuple[torch.Tensor, torch.Tensor]: + """Build attention mask and labels from full sequences and prompt lengths.""" + prompt_lengths = prompt_lengths.to(device=new_input_ids.device, dtype=torch.long) + positions = torch.arange(new_input_ids.shape[1], device=new_input_ids.device).unsqueeze(0) + completion_mask = positions >= prompt_lengths.unsqueeze(1) + + if attention_mask is not None: + new_attention_mask = attention_mask.to(device=new_input_ids.device, dtype=new_input_ids.dtype) + else: + new_attention_mask = torch.ones_like(new_input_ids) + if pad_token_id is not None: + new_attention_mask[new_input_ids == pad_token_id] = 0 + + new_labels = torch.full_like(new_input_ids, -100) + new_labels[completion_mask & new_attention_mask.bool()] = new_input_ids[ + completion_mask & new_attention_mask.bool() + ] + if attention_mask is None and pad_token_id is not None: + new_labels[new_input_ids == pad_token_id] = -100 + + return new_attention_mask, new_labels + + def _maybe_add_completion_byte_offsets(self, updated_slice: dict[str, torch.Tensor | Any]) -> None: + """Attach completion-relative byte offsets to on-policy ULD batches. + + Derived from the sampled ids via ``piece_byte_len`` (no decode→re-encode round-trip). + """ + if not ( + self.use_uld_loss + and self.teacher_tokenizer is not None + and self.uld_loss_fn is not None + and self.uld_loss_fn.use_extended_uld + ): + return + + new_input_ids = updated_slice["input_ids"] + new_labels = updated_slice["labels"] + seq_len = new_input_ids.shape[1] + + rows: list[list[tuple[int, int]]] = [] + for row_ids, row_labels in zip(new_input_ids.cpu().tolist(), new_labels.cpu().tolist(), strict=True): + offs: list[tuple[int, int]] = [(0, 0)] * seq_len + cumulative = 0 + for pos, (tid, label) in enumerate(zip(row_ids, row_labels, strict=True)): + if label == -100: + continue + nb = piece_byte_len(self.processing_class.convert_ids_to_tokens([tid])[0]) + offs[pos] = (cumulative, cumulative + nb) + cumulative += nb + rows.append(offs) + updated_slice["byte_offsets"] = torch.tensor(rows, dtype=torch.long, device=new_input_ids.device) + + @profiling_decorator + def _fill_buffer(self, generation_batch: dict[str, torch.Tensor | Any], buffer_steps: int): + slices = split_tensor_dict(generation_batch, buffer_steps) + + if self.accelerator.is_main_process: + on_policy_flags = [random.random() <= self.lmbda for _ in range(buffer_steps)] + else: + on_policy_flags = [False] * buffer_steps + + on_policy_flags = broadcast_object_list(on_policy_flags, from_process=0) + on_policy_indices = [i for i, flag in enumerate(on_policy_flags) if flag] + + self._buffered_inputs = [None] * buffer_steps + self._buffered_on_policy = on_policy_flags + self._buffered_text_logs = [None] * buffer_steps + + for i, flag in enumerate(on_policy_flags): + if not flag: + slice_inputs = slices[i] + + if ( + self.use_uld_loss + and self.teacher_tokenizer is not None + and ("original_prompt_text" not in slice_inputs or "original_completion_text" not in slice_inputs) + ): + raise ValueError( + "Off-policy batch missing 'original_prompt_text' or 'original_completion_text' fields. " + "Use the default DataCollatorForChatML (or a collator that emits these fields) so the " + "teacher tokenizer has source text to align against." + ) + if ( + self.use_uld_loss + and self.teacher_tokenizer is not None + and self.uld_loss_fn.use_extended_uld + and "byte_offsets" not in slice_inputs + ): + raise ValueError( + "Off-policy batch missing `byte_offsets`. Use the default DataCollatorForChatML or set " + "`use_extended_uld=False`." + ) + + self._buffered_inputs[i] = slice_inputs + + if on_policy_indices: + self._generate_on_policy_for_slices(slices, on_policy_indices) + + @profiling_decorator + def _generate_on_policy_for_slices( + self, slices: list[dict[str, torch.Tensor | Any]], on_policy_indices: list[int] + ): + prompt_ids_list = [] + local_slice_indices = [] + for slice_idx in on_policy_indices: + slice_inputs = slices[slice_idx] + prompt_attention_mask = slice_inputs.get("prompt_attention_mask") + for prompt_idx, prompt in enumerate(slice_inputs["prompts"]): + if prompt_attention_mask is not None: + prompt = prompt[prompt_attention_mask[prompt_idx].bool()] + prompt_ids_list.append(prompt.tolist()) + local_slice_indices.append(slice_idx) + + prompts_text = self.processing_class.batch_decode( + prompt_ids_list, + skip_special_tokens=False, + ) + + if not self.use_vllm: + self._generate_non_vllm_for_slices(slices, on_policy_indices) + return + + if ( + self.state.global_step != self._last_vllm_sync_step + and self.state.global_step >= self._last_vllm_sync_step + self.vllm_sync_frequency + ): + self.vllm_generation.sync_weights() + self._last_vllm_sync_step = self.state.global_step + + _, completion_ids, _, _ = self.vllm_generation.generate( + prompts=prompt_ids_list, + images=None, + num_generations=self.num_generations, + ) + + self._process_completions_to_buffer( + slices, + on_policy_indices, + local_slice_indices, + completion_ids, + prompt_ids_list, + prompts_text, + self.generation_config.max_new_tokens, + ) + + def _generate_non_vllm_for_slices(self, slices: list[dict[str, torch.Tensor | Any]], on_policy_indices: list[int]): + """Fallback generation without vLLM (uses model.generate per slice).""" + with unwrap_model_for_generation( + self.model, + self.accelerator, + generation_kwargs=self.generation_kwargs, + ) as unwrapped_model: + for slice_idx in on_policy_indices: + slice_inputs = slices[slice_idx] + result = self.generate_on_policy_outputs( + unwrapped_model, + slice_inputs, + self.generation_config, + self.processing_class.pad_token_id, + ) + new_input_ids, new_attention_mask, new_labels, prompt_texts, completion_texts = result + + updated_slice = dict(slice_inputs) + updated_slice["input_ids"] = new_input_ids + updated_slice["attention_mask"] = new_attention_mask + updated_slice["labels"] = new_labels + updated_slice["original_prompt_text"] = prompt_texts + updated_slice["original_completion_text"] = completion_texts + self._maybe_add_completion_byte_offsets(updated_slice) + + self._buffered_inputs[slice_idx] = updated_slice + self._buffered_text_logs[slice_idx] = (prompt_texts, completion_texts) + + def _process_completions_to_buffer( + self, + slices: list[dict[str, torch.Tensor | Any]], + on_policy_indices: list[int], + local_slice_indices: list[int], + completion_ids: list, + prompt_ids_list: list[list[int]], + prompts_text: list[str], + max_completion_length: int, + ): + """ + Process vLLM completions and update buffered inputs for on-policy slices. + """ + device = self.accelerator.device + pad_token_id = self.processing_class.pad_token_id if self.processing_class.pad_token_id is not None else 0 + + slice_completions = {idx: [] for idx in on_policy_indices} + slice_prompt_ids = {idx: [] for idx in on_policy_indices} + slice_prompts = {idx: [] for idx in on_policy_indices} + + for i, slice_idx in enumerate(local_slice_indices): + slice_completions[slice_idx].append(completion_ids[i]) + slice_prompt_ids[slice_idx].append(prompt_ids_list[i]) + slice_prompts[slice_idx].append(prompts_text[i]) + + for slice_idx in on_policy_indices: + slice_inputs = slices[slice_idx] + completion_ids_for_slice = slice_completions[slice_idx] + prompt_ids_for_slice = slice_prompt_ids[slice_idx] + prompt_txts = slice_prompts[slice_idx] + + prompt_max_length = max(1, self.args.max_length - max_completion_length) if self.args.max_length else None + truncated_prompt_ids = [] + prompt_attention_masks = [] + truncation_side = getattr(self.processing_class, "truncation_side", "right") + for prompt_ids in prompt_ids_for_slice: + if prompt_max_length and len(prompt_ids) > prompt_max_length: + if truncation_side == "left": + prompt_ids = prompt_ids[-prompt_max_length:] + else: + prompt_ids = prompt_ids[:prompt_max_length] + prompt_tensor = torch.tensor(prompt_ids, device=device, dtype=torch.long) + truncated_prompt_ids.append(prompt_tensor) + prompt_attention_masks.append(torch.ones(len(prompt_ids), device=device, dtype=torch.long)) + + prompt_ids = pad(truncated_prompt_ids, padding_side="left", padding_value=pad_token_id) + prompt_attention_mask = pad(prompt_attention_masks, padding_side="left", padding_value=0) + + # Decode the truncated prompt so the teacher conditions on the same context the student saw. + # `clean_up_tokenization_spaces=False` matches the completion decode below so byte counts stay aligned. + prompt_txts_with_special = self.processing_class.batch_decode( + [ids.tolist() for ids in truncated_prompt_ids], + skip_special_tokens=False, + clean_up_tokenization_spaces=False, + ) + + completion_ids_tensors = [torch.tensor(ids, device=device) for ids in completion_ids_for_slice] + completion_ids_for_text: list[list[int]] = [] + padded_completion_ids_list = [] + completion_attention_masks = [] + for completion_tensor in completion_ids_tensors: + if len(completion_tensor) > max_completion_length: + truncated_completion_tensor = completion_tensor[:max_completion_length] + padded_completion_ids_list.append(truncated_completion_tensor) + completion_ids_for_text.append(truncated_completion_tensor.tolist()) + completion_attention_masks.append( + torch.ones(len(truncated_completion_tensor), device=device, dtype=torch.long) + ) + elif len(completion_tensor) < max_completion_length: + padding_needed = max_completion_length - len(completion_tensor) + padded_tensor = torch.cat( + [ + completion_tensor, + torch.full( + (padding_needed,), + pad_token_id, + device=device, + dtype=completion_tensor.dtype, + ), + ] + ) + padded_completion_ids_list.append(padded_tensor) + completion_ids_for_text.append(completion_tensor.tolist()) + completion_attention_masks.append( + torch.cat( + [ + torch.ones(len(completion_tensor), device=device, dtype=torch.long), + torch.zeros(padding_needed, device=device, dtype=torch.long), + ] + ) + ) + else: + padded_completion_ids_list.append(completion_tensor) + completion_ids_for_text.append(completion_tensor.tolist()) + completion_attention_masks.append( + torch.ones(len(completion_tensor), device=device, dtype=torch.long) + ) + + completion_ids_padded = torch.stack(padded_completion_ids_list) + completion_attention_mask = torch.stack(completion_attention_masks) + + new_input_ids = torch.cat([prompt_ids, completion_ids_padded], dim=1) + new_attention_mask = torch.cat([prompt_attention_mask, completion_attention_mask], dim=1) + prompt_lengths = torch.full((prompt_ids.shape[0],), prompt_ids.shape[1], device=device) + new_attention_mask, new_labels = self._build_sequence_batch( + new_input_ids, + prompt_lengths, + pad_token_id, + attention_mask=new_attention_mask, + ) + + completion_texts = self.processing_class.batch_decode( + completion_ids_for_text, + skip_special_tokens=False, + clean_up_tokenization_spaces=False, + ) + + updated_slice = dict(slice_inputs) + updated_slice["input_ids"] = new_input_ids + updated_slice["attention_mask"] = new_attention_mask + updated_slice["labels"] = new_labels + updated_slice["original_prompt_text"] = prompt_txts_with_special + updated_slice["original_completion_text"] = completion_texts + self._maybe_add_completion_byte_offsets(updated_slice) + + self._buffered_inputs[slice_idx] = updated_slice + self._buffered_text_logs[slice_idx] = (prompt_txts, completion_texts) + + def _prepare_dataset( + self, + dataset: Dataset | IterableDataset, + processing_class: PreTrainedTokenizerBase | BaseImageProcessor | FeatureExtractionMixin | ProcessorMixin, + args, + packing: bool, + formatting_func: Callable[[dict], str] | None, + dataset_name: str, + ) -> Dataset | IterableDataset: + """Preserve original text fields for ULD when needed.""" + column_names = list(next(iter(dataset)).keys()) + is_processed = "input_ids" in column_names + + if packing and self.use_uld_loss and self.teacher_tokenizer is not None: + raise ValueError( + "Packing is not supported with cross-tokenizer ULD because byte-offset alignment is defined per " + "prompt/completion example." + ) + + if not is_processed or (self.use_uld_loss and self.teacher_tokenizer is not None): + return self._prepare_dataset_with_original_text( + dataset, processing_class, args, packing, formatting_func, dataset_name + ) + + return super()._prepare_dataset(dataset, processing_class, args, packing, formatting_func, dataset_name) + + def _prepare_dataset_with_original_text( + self, + dataset: Dataset | IterableDataset, + processing_class: PreTrainedTokenizerBase | BaseImageProcessor | FeatureExtractionMixin | ProcessorMixin, + args, + packing: bool, + formatting_func: Callable[[dict], str] | None, + dataset_name: str, + ) -> Dataset | IterableDataset: + """ + Prepare dataset while preserving original text for cross-tokenizer distillation. + """ + # Build the kwargs for the `map` function + map_kwargs = {} + if isinstance(dataset, Dataset): # IterableDataset does not support num_proc + map_kwargs["num_proc"] = args.dataset_num_proc + + with PartialState().main_process_first(): + # Apply the formatting function if any + if formatting_func is not None: + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Applying formatting function to {dataset_name} dataset" + + def _func(example): + return {"text": formatting_func(example)} + + dataset = dataset.map(_func, batched=False, **map_kwargs) + + # Convert the dataset to ChatML if needed + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Converting {dataset_name} dataset to ChatML" + column_names = next(iter(dataset)).keys() + dataset = dataset.map( + maybe_convert_to_chatml, + remove_columns="conversations" if "conversations" in column_names else None, + **map_kwargs, + ) + + # Add EOS token if needed: non-conversational only + first_example = next(iter(dataset)) + if not is_conversational(first_example): + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Adding EOS to {dataset_name} dataset" + + def add_eos(example, eos_token): + if "text" in example and not example["text"].endswith(eos_token): # language modeling case + example["text"] = example["text"] + eos_token + elif "completion" in example and not example["completion"].endswith(eos_token): + example["completion"] = example["completion"] + eos_token + return example + + dataset = dataset.map( + add_eos, + fn_kwargs={"eos_token": processing_class.eos_token}, + remove_columns="messages" if "messages" in column_names else None, # renamed to "text" + **map_kwargs, + ) + + # Tokenize the dataset while preserving original text + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset (preserving original text)" + + def tokenize_with_original_text(example, processing_class, dataset_text_field, max_length): + """Emit input_ids, attention_mask, byte_offsets, completion_mask, and the original prompt/completion + text. Byte offsets and input_ids come from a single ``encode_with_byte_offsets`` call.""" + backend = processing_class.backend_tokenizer + result = {} + + if "prompt" in example: # prompt-completion case + if is_conversational(example): + prompt_text = processing_class.apply_chat_template( + example["prompt"], + add_generation_prompt=True, + tokenize=False, + **example.get("chat_template_kwargs", {}), + ) + full_text = processing_class.apply_chat_template( + example["prompt"] + example["completion"], + tokenize=False, + **example.get("chat_template_kwargs", {}), + ) + prompt_text = "".join( + x for x, _ in takewhile(lambda x: x[0] == x[1], zip(prompt_text, full_text, strict=False)) + ) + completion_text = full_text[len(prompt_text) :] + else: + prompt_text = example["prompt"] + completion_text = example["completion"] + full_text = prompt_text + completion_text + result["original_prompt_text"] = prompt_text + result["original_completion_text"] = completion_text + elif is_conversational(example): + messages = example["messages"] + assistant_indices = [idx for idx, msg in enumerate(messages) if msg["role"] == "assistant"] + if assistant_indices: + completion_idx = assistant_indices[-1] + prompt_messages = messages[:completion_idx] + full_messages = messages[: completion_idx + 1] + if prompt_messages: + prompt_text = processing_class.apply_chat_template( + prompt_messages, + add_generation_prompt=True, + tokenize=False, + **example.get("chat_template_kwargs", {}), + ) + else: + prompt_text = "" + full_text = processing_class.apply_chat_template( + full_messages, + add_generation_prompt=False, + tokenize=False, + **example.get("chat_template_kwargs", {}), + ) + prompt_text = "".join( + x for x, _ in takewhile(lambda x: x[0] == x[1], zip(prompt_text, full_text, strict=False)) + ) + completion_text = full_text[len(prompt_text) :] + result["original_prompt_text"] = prompt_text + result["original_completion_text"] = completion_text + else: + full_text = processing_class.apply_chat_template( + messages, tokenize=False, **example.get("chat_template_kwargs", {}) + ) + prompt_text = "" + result["original_prompt_text"] = "" + result["original_completion_text"] = full_text + else: + text = example.get(dataset_text_field, example.get("text", "")) + prompt_text = "" + full_text = text + result["original_prompt_text"] = "" + result["original_completion_text"] = text + + # Single backend call: ids and char-derived byte offsets from the same encoding, + # so input_ids[i] is described by full_offs[i] without any boundary slop. + [(input_ids, full_offs)] = encode_with_byte_offsets(backend, [full_text], add_special_tokens=False) + prompt_byte_len = len(prompt_text.encode("utf-8")) + completion_start = next( + (idx for idx, (s, _) in enumerate(full_offs) if s >= prompt_byte_len), + len(input_ids), + ) + # Completion-relative: prompt positions zeroed, completion offsets shifted to + # the assistant content's first byte (matches build_teacher_inputs_from_texts). + byte_offsets = [(0, 0)] * completion_start + [ + (s - prompt_byte_len, e - prompt_byte_len) for s, e in full_offs[completion_start:] + ] + + # Keep the last `max_length` tokens (the completion end). `completion_mask` tracks the + # boundary so it survives truncation without re-tokenizing the prompt. + if max_length is not None and len(input_ids) > max_length: + drop = len(input_ids) - max_length + input_ids = input_ids[drop:] + byte_offsets = byte_offsets[drop:] + completion_start = max(0, completion_start - drop) + # If truncation ate into the completion, rebase the kept completion offsets so they're + # relative to the new (truncated) `original_completion_text` the teacher will re-encode. + if completion_start < len(byte_offsets): + base = byte_offsets[completion_start][0] + if base > 0: + byte_offsets = byte_offsets[:completion_start] + [ + (s - base, e - base) for s, e in byte_offsets[completion_start:] + ] + # Resync the strings the teacher will re-encode with the ids the student kept. + decode = partial( + processing_class.decode, skip_special_tokens=False, clean_up_tokenization_spaces=False + ) + result["original_prompt_text"] = decode(input_ids[:completion_start]) + result["original_completion_text"] = decode(input_ids[completion_start:]) + + result["input_ids"] = input_ids + result["attention_mask"] = [1] * len(input_ids) + result["byte_offsets"] = byte_offsets + result["completion_mask"] = [0] * completion_start + [1] * (len(input_ids) - completion_start) + return result + + dataset = dataset.map( + tokenize_with_original_text, + fn_kwargs={ + "processing_class": processing_class, + "dataset_text_field": args.dataset_text_field, + "max_length": args.max_length, + }, + **map_kwargs, + ) + + # Pack if requested. Truncation already happened in `tokenize_with_original_text`, keeping + # the completion end — so the generic front-truncating `truncate_dataset` is intentionally + # not applied here (it would drop the completion). + if packing: + if args.max_length is None: + raise ValueError("When packing is enabled, `max_length` can't be `None`.") + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Packing {dataset_name} dataset" + + columns_to_keep = ["input_ids", "original_prompt_text", "original_completion_text"] + existing_columns = set(dataset.column_names) + columns_to_select = [col for col in columns_to_keep if col in existing_columns] + + dataset = dataset.select_columns(columns_to_select) + dataset = pack_dataset(dataset, args.max_length, args.packing_strategy, map_kwargs) + + if args.use_liger_kernel: + required_columns = { + "input_ids", + "attention_mask", + "position_ids", + "completion_mask", + "messages", + "original_prompt_text", + "original_completion_text", + "byte_offsets", + } + dataset = dataset.select_columns(required_columns.intersection(dataset.column_names)) + + return dataset + + @staticmethod + def generalized_jsd_loss( + student_logits, + teacher_logits, + labels=None, + beta=0.5, + temperature=1.0, + reduction="batchmean", + logits_are_probs=False, + num_items_in_batch=None, + ): + """ + Compute the generalized Jensen-Shannon Divergence loss for knowledge distillation using F.kl_div. See Eq. (1) + of https://huggingface.co/papers/2306.13649 for the definition. + + Args: + student_logits: + Tensor of shape (batch_size, sequence_length, vocab_size) + teacher_logits: + Tensor of shape (batch_size, sequence_length, vocab_size) + labels: + Tensor of shape (batch_size, sequence_length) with -100 for padding tokens to ignore when computing + loss + beta: + Interpolation coefficient between 0 and 1 (default: 0.5) + temperature: + Softmax temperature (default: 1.0) + reduction: + Specifies the reduction to apply to the output (default: 'batchmean') + + Returns: + loss: Scalar tensor with the generalized JSD loss + """ + + if logits_are_probs: + student_log_probs = torch.log(student_logits.clamp_min(1e-8)) + teacher_log_probs = torch.log(teacher_logits.clamp_min(1e-8)) + else: + # Apply temperature scaling to logits before computing probabilities + student_logits = student_logits / temperature + teacher_logits = teacher_logits / temperature + # Compute log probabilities for student and probabilities for teacher + student_log_probs = F.log_softmax(student_logits, dim=-1) + teacher_log_probs = F.log_softmax(teacher_logits, dim=-1) + + if beta == 0: + jsd = F.kl_div(student_log_probs, teacher_log_probs, reduction="none", log_target=True) + elif beta == 1: + jsd = F.kl_div(teacher_log_probs, student_log_probs, reduction="none", log_target=True) + else: + # Compute the log of the mixture distribution + # log(a + b) = log(exp(log(a)) + exp(log(b))) -> for mixture + beta = torch.tensor(beta, dtype=student_log_probs.dtype, device=student_log_probs.device) + mixture_log_probs = torch.logsumexp( + torch.stack([student_log_probs + torch.log1p(-beta), teacher_log_probs + torch.log(beta)]), + dim=0, + ) + + # Compute KL divergences using F.kl_div + # PyTorch differs from the standard mathematical definition, so the order of the probability distributions is swapped compared to that defined in the paper. + kl_teacher = F.kl_div(mixture_log_probs, teacher_log_probs, reduction="none", log_target=True) + kl_student = F.kl_div(mixture_log_probs, student_log_probs, reduction="none", log_target=True) + + # Compute the Generalized Jensen-Shannon Divergence + jsd = beta * kl_teacher + (1 - beta) * kl_student + + # Masking + if labels is not None: + mask = labels != -100 + jsd = jsd[mask] + + # Apply reduction + if num_items_in_batch is not None: + # Normalize by the global number of valid tokens for gradient-accumulation-correct loss (see issue #4719). + jsd_sum = jsd.sum() + if isinstance(num_items_in_batch, torch.Tensor): + num_items_in_batch = num_items_in_batch.to(jsd_sum.device) + return jsd_sum / num_items_in_batch + if reduction == "batchmean": + # clamp_min(1) avoids 0/0 -> nan when a sample has no unmasked positions + # (e.g. completion fully truncated). jsd[mask] is empty -> jsd.sum() == 0, + # so 0/1 == 0 with a valid grad path. + denom = mask.sum().clamp_min(1) if labels is not None else max(jsd.size(0), 1) + return jsd.sum() / denom + elif reduction == "sum": + return jsd.sum() + elif reduction == "mean": + return jsd.mean() + else: + return jsd + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + if self.use_uld_loss and self.teacher_tokenizer is not None: + # Both DataCollatorForChatML and the on-policy generation path attach these + # fields, so cross-tokenizer ULD never has to round-trip through batch_decode. + prompt_texts = inputs["original_prompt_text"] + completion_texts = inputs["original_completion_text"] + + ( + teacher_input_ids, + teacher_labels, + teacher_attention_mask, + teacher_completion_byte_offsets, + ) = build_teacher_inputs_from_texts(self.teacher_tokenizer, prompt_texts, completion_texts) + + teacher_input_ids = teacher_input_ids.to(self.accelerator.device) + teacher_labels = teacher_labels.to(self.accelerator.device) + teacher_attention_mask = teacher_attention_mask.to(self.accelerator.device) + + outputs_student = model( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + use_cache=False, + ) + + self.teacher_model.eval() + with torch.no_grad(): + outputs_teacher = self.teacher_model( + input_ids=teacher_input_ids, + attention_mask=teacher_attention_mask, + ) + else: + if self.use_liger_gkd_loss: + # Forward only through the base models (avoid lm_head to save memory). + # Route through the DDP/FSDP wrapper via _forward_redirection so that + # DDP.forward() is called and prepare_for_backward() fires correctly. + unwrapped_student = self.accelerator.unwrap_model(model) + student_outputs = self._forward_redirection( + model, unwrapped_student, self._liger_student_forward, unwrapped_student, inputs + ) + + self.teacher_model.eval() + unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model) + if hasattr(unwrapped_teacher, "get_decoder") and unwrapped_teacher.get_decoder() is not None: + base_teacher = unwrapped_teacher.get_decoder() + else: + base_teacher = getattr( + unwrapped_teacher, getattr(unwrapped_teacher, "base_model_prefix", "model"), unwrapped_teacher + ) + with torch.no_grad(): + teacher_outputs = base_teacher( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + use_cache=False, + ) + + student_hidden = student_outputs.last_hidden_state[:, :-1] + teacher_hidden = teacher_outputs.last_hidden_state[:, :-1] + + del student_outputs, teacher_outputs + + student_hidden = student_hidden.reshape(-1, student_hidden.shape[-1]) + teacher_hidden = teacher_hidden.reshape(-1, teacher_hidden.shape[-1]) + + labels_mask = inputs["labels"] != -100 + masked_input_ids = torch.where( + labels_mask, inputs["input_ids"], torch.full_like(inputs["input_ids"], -100) + ) + true_labels = masked_input_ids[:, 1:].reshape(-1) + + student_head = unwrapped_student.get_output_embeddings() + teacher_head = unwrapped_teacher.get_output_embeddings() + + loss = self.liger_jsd_loss( + student_input=student_hidden, + student_weight=student_head.weight, + teacher_input=teacher_hidden, + teacher_weight=teacher_head.weight, + true_labels=true_labels, + student_bias=getattr(student_head, "bias", None), + teacher_bias=getattr(teacher_head, "bias", None), + ) + + # The Liger JSD loss normalizes by the local number of valid tokens. Under gradient accumulation we + # want the global normalization, so rescale by `num_valid_local / num_items_in_batch`. + if num_items_in_batch is not None: + num_valid_local = (true_labels != -100).sum().clamp_min(1) + if isinstance(num_items_in_batch, torch.Tensor): + num_items_in_batch = num_items_in_batch.to(loss.device) + loss = loss * num_valid_local / num_items_in_batch + + del student_hidden, teacher_hidden, true_labels + else: + outputs_student = model( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + ) + + self.teacher_model.eval() + with torch.no_grad(): + outputs_teacher = self.teacher_model( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + ) + + # Standard causal shift: logits at position i predict the token at i + 1. The `labels != -100` mask + # inside `generalized_jsd_loss` already excludes prompt (and padding) positions, so we do not slice by + # prompt length. Slicing by `inputs["prompts"].shape[1]` (the batch-max prompt width) would drop real + # completion tokens for samples whose prompt is shorter than the batch maximum, since `labels` is + # padded to the full-sequence width independently of `prompts`. + shifted_student_logits = outputs_student.logits[:, :-1, :] + shifted_teacher_logits = outputs_teacher.logits[:, :-1, :] + shifted_labels = inputs["labels"][:, 1:] + loss = self.generalized_jsd_loss( + student_logits=shifted_student_logits, + teacher_logits=shifted_teacher_logits, + labels=shifted_labels, + beta=self.beta, + temperature=self.temperature, + num_items_in_batch=num_items_in_batch, + ) + + if self.use_uld_loss and self.teacher_tokenizer is not None: + student_labels = inputs["labels"].clone() + if self.processing_class.pad_token_id is not None: + student_labels[student_labels == self.processing_class.pad_token_id] = -100 + if self.teacher_tokenizer.pad_token_id is not None: + teacher_labels[teacher_labels == self.teacher_tokenizer.pad_token_id] = -100 + + student_byte_offsets = inputs.get("byte_offsets") + if self.uld_loss_fn.use_extended_uld and student_byte_offsets is None: + raise ValueError("Input batches must include `byte_offsets` when `use_extended_uld=True`.") + + loss = self.uld_loss_fn( + student_logits=outputs_student.logits, + teacher_logits=outputs_teacher.logits, + student_labels=student_labels, + teacher_labels=teacher_labels, + student_input_ids=inputs["input_ids"], + teacher_input_ids=teacher_input_ids, + student_byte_offsets=student_byte_offsets, + teacher_byte_offsets=teacher_completion_byte_offsets, + ) + + if hasattr(self.uld_loss_fn, "last_matched_loss") and hasattr(self.uld_loss_fn, "last_unmatched_loss"): + ga = max(1, int(self.args.gradient_accumulation_steps)) + step_eq = 1.0 / ga + matched_val = ( + self.uld_loss_fn.last_matched_loss.item() + if self.uld_loss_fn.last_matched_loss is not None + else 0.0 + ) + unmatched_val = ( + self.uld_loss_fn.last_unmatched_loss.item() + if self.uld_loss_fn.last_unmatched_loss is not None + else 0.0 + ) + + self._matched_sum += matched_val + self._unmatched_sum += unmatched_val + self._matched_step_eq += step_eq + self._unmatched_step_eq += step_eq + + empty_cache() + + return (loss, outputs_student) if return_outputs else loss + + def generate_on_policy_outputs(self, model, inputs, generation_config, pad_token_id=None): + # Generate output with respect to the prompt only + generated_outputs = model.generate( + input_ids=inputs["prompts"], + attention_mask=inputs.get("prompt_attention_mask", None), + generation_config=generation_config, + return_dict_in_generate=True, + ) + # Get the generated token IDs + generated_tokens = generated_outputs.sequences + + batch_size = generated_tokens.size(0) + device = generated_tokens.device + + prompt_mask = inputs.get("prompt_attention_mask") + pad_token_id = pad_token_id if pad_token_id is not None else self.processing_class.pad_token_id + + # model.generate() returns full sequences (prompt + completion), so completions start + # after the full padded prompt width. + prompt_lengths = torch.full((batch_size,), inputs["prompts"].shape[1], dtype=torch.long, device=device) + + new_input_ids = generated_tokens + new_attention_mask, new_labels = self._build_sequence_batch(new_input_ids, prompt_lengths, pad_token_id) + + prompt_texts = [] + completion_texts = [] + for idx in range(batch_size): + length = int(prompt_lengths[idx].item()) + prompt_tokens = inputs["prompts"][idx] + if prompt_mask is not None: + prompt_tokens = prompt_tokens[prompt_mask[idx].bool()] + elif pad_token_id is not None: + prompt_tokens = prompt_tokens[prompt_tokens != pad_token_id] + prompt_texts.append( + self.processing_class.decode( + prompt_tokens.tolist(), + skip_special_tokens=False, + clean_up_tokenization_spaces=False, + ) + ) + completion_tokens = new_input_ids[idx, length:] + completion_tokens = completion_tokens[new_labels[idx, length:] != -100] + completion_texts.append( + self.processing_class.decode( + completion_tokens.tolist(), + skip_special_tokens=False, + clean_up_tokenization_spaces=False, + ) + ) + + return new_input_ids, new_attention_mask, new_labels, prompt_texts, completion_texts + + def _liger_student_forward(self, student, inputs): + """Decoder-only forward used by the Liger JSD path (skips lm_head to save memory).""" + if hasattr(student, "get_decoder") and student.get_decoder() is not None: + decoder = student.get_decoder() + else: + decoder = getattr(student, getattr(student, "base_model_prefix", "model"), student) + return decoder( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + use_cache=False, + ) + + def _get_liger_zero3_lm_head_gather_ctx(self, model: nn.Module): + if not self.use_liger_gkd_loss: + return nullcontext() + + deepspeed_plugin = self.accelerator.state.deepspeed_plugin + if deepspeed_plugin is None or deepspeed_plugin.zero_stage != 3: + return nullcontext() + + import deepspeed + + unwrapped_student = self.accelerator.unwrap_model(model) + unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model) + student_head = unwrapped_student.get_output_embeddings() + teacher_head = unwrapped_teacher.get_output_embeddings() + params = [student_head.weight, teacher_head.weight] + if student_head.bias is not None: + params.append(student_head.bias) + if teacher_head.bias is not None: + params.append(teacher_head.bias) + return deepspeed.zero.GatheredParameters(params, modifier_rank=None) + + @profiling_decorator + def training_step( + self, model: nn.Module, inputs: dict[str, torch.Tensor | Any], num_items_in_batch: int | None = None + ) -> torch.Tensor: + """ + Perform a training step for the General Online Logit Distillation (GOLD) model. + + This method implements the on-policy learning approach described in the GOLD blog post. With probability + `self.lmbda`, it generates new responses using the student model, which are then used for training instead of + the offline original inputs. + """ + buffer_steps = self.args.gradient_accumulation_steps + + # Keep lm_head gathered across forward+backward for Liger + ZeRO-3. + with self._get_liger_zero3_lm_head_gather_ctx(model): + loss = super().training_step(model, inputs, num_items_in_batch) + + slice_idx = (self._step - 1) % buffer_steps + + on_policy = False + if self._buffered_on_policy is not None and slice_idx < len(self._buffered_on_policy): + on_policy = self._buffered_on_policy[slice_idx] + + if on_policy and self._buffered_text_logs is not None and self._buffered_text_logs[slice_idx] is not None: + prompt_texts, completion_texts = self._buffered_text_logs[slice_idx] + self._textual_logs["prompt"].extend(gather_object(prompt_texts)) + self._textual_logs["completion"].extend(gather_object(completion_texts)) + + loss_scalar = float(loss.detach()) + step_equiv = 1.0 / self.args.gradient_accumulation_steps + + if on_policy: + self._on_policy_loss_total += loss_scalar + self._on_policy_step_equiv += step_equiv + else: + self._off_policy_loss_total += loss_scalar + self._off_policy_step_equiv += step_equiv + return loss + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} # average the metrics + + if mode == "train": + device = self.accelerator.device if hasattr(self.accelerator, "device") else torch.device("cpu") + vec = torch.tensor( + [ + self._on_policy_loss_total, + self._off_policy_loss_total, + self._on_policy_step_equiv, + self._off_policy_step_equiv, + self._matched_sum, + self._unmatched_sum, + self._matched_step_eq, + self._unmatched_step_eq, + ], + dtype=torch.float64, + device=device, + ) + + if ( + getattr(self.accelerator, "distributed_type", DistributedType.NO) != DistributedType.NO + and dist.is_available() + and dist.is_initialized() + ): + dist.all_reduce(vec, op=dist.ReduceOp.SUM) + + ( + on_sum, + off_sum, + on_eq, + off_eq, + matched_sum, + unmatched_sum, + matched_eq, + unmatched_eq, + ) = vec.tolist() + + if on_eq > 0: + logs["on_policy_loss"] = round(on_sum / on_eq, 4) + if off_eq > 0: + logs["off_policy_loss"] = round(off_sum / off_eq, 4) + + if matched_eq > 0: + logs["matched_loss"] = round(matched_sum / matched_eq, 4) + if unmatched_eq > 0: + logs["unmatched_loss"] = round(unmatched_sum / unmatched_eq, 4) + + self._on_policy_loss_total = self._off_policy_loss_total = 0.0 + self._on_policy_step_equiv = self._off_policy_step_equiv = 0.0 + self._matched_sum = self._unmatched_sum = 0.0 + self._matched_step_eq = self._unmatched_step_eq = 0.0 + + # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs` + # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() + + if ( + self.accelerator.is_main_process + and self.log_completions + and ((self.state.global_step % self.log_completion_steps) == 0) + ): + if is_rich_available(): + print_prompt_completions_sample_uld( + self._textual_logs["prompt"], + self._textual_logs["completion"], + self.state.global_step, + self.num_completions_to_print, + ) + + if self.args.report_to and "wandb" in self.args.report_to and wandb.run is not None: + import pandas as pd + + table = { + "step": [self.state.global_step] * len(self._textual_logs["prompt"]), + "prompt": self._textual_logs["prompt"], + "completion": self._textual_logs["completion"], + } + df = pd.DataFrame(table) + if self.wandb_log_unique_prompts: + df = df.drop_duplicates(subset=["prompt"]) + if self.num_completions_to_print and len(df) > 0: + df = df.sample(n=self.num_completions_to_print, random_state=42) + wandb.log({"completions": wandb.Table(dataframe=df)}) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/grpo_with_replay_buffer/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/grpo_with_replay_buffer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..708ea62d6740e6ca43c7de21bb716abce1e7c284 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/grpo_with_replay_buffer/__init__.py @@ -0,0 +1,16 @@ +# Copyright 2020-2026 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. + +from .grpo_with_replay_buffer_config import GRPOWithReplayBufferConfig +from .grpo_with_replay_buffer_trainer import GRPOWithReplayBufferTrainer, ReplayBuffer diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/grpo_with_replay_buffer/grpo_with_replay_buffer_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/grpo_with_replay_buffer/grpo_with_replay_buffer_config.py new file mode 100644 index 0000000000000000000000000000000000000000..9955af51dcf2264c905452e7bb578f3041a60b5c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/grpo_with_replay_buffer/grpo_with_replay_buffer_config.py @@ -0,0 +1,34 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field + +from ...trainer.grpo_config import GRPOConfig + + +@dataclass +class GRPOWithReplayBufferConfig(GRPOConfig): + """ + New Parameters: + replay_buffer_size (`int`, *optional*, defaults to `64`): + A cache that stores the rollouts with the highest advantage scores and variance per group. If a new + group has 0 variance, it is replaced with a group sampled from the replay buffer. + """ + + replay_buffer_size: int = field( + default=64, + metadata={ + "help": "A cache that stores the rollouts with the highest advantage scores and variance per group. If a new group has 0 variance, it is replaced with a group sampled from the replay buffer." + }, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/grpo_with_replay_buffer/grpo_with_replay_buffer_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/grpo_with_replay_buffer/grpo_with_replay_buffer_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..3ab9617170a30d282f2602eb5145a25cbd3b8c7c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/grpo_with_replay_buffer/grpo_with_replay_buffer_trainer.py @@ -0,0 +1,797 @@ +# Copyright 2020-2026 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 heapq +from typing import Any + +import torch +from accelerate.utils import gather_object + +from ...data_utils import apply_chat_template, is_conversational, prepare_multimodal_messages +from ...models.utils import disable_gradient_checkpointing +from ...trainer.grpo_trainer import GRPOTrainer +from ...trainer.utils import nanmax, nanmin, nanstd, pad +from .grpo_with_replay_buffer_config import GRPOWithReplayBufferConfig + + +class ReplayBuffer: + """ + A simple replay buffer to store and sample previously seen rollouts. + """ + + def __init__(self, max_size: int): + self.max_size = max_size + self.heap = [] # Min-heap of (score, data) tuples + + def add(self, scores: list[float], data: list[dict]): + for score, datum in zip(scores, data, strict=True): + if len(self.heap) < self.max_size: + heapq.heappush(self.heap, (score, datum)) + else: + # Only add if score is better than worst (minimum) item + if score > self.heap[0][0]: + heapq.heapreplace(self.heap, (score, datum)) + + def sample(self, num_samples: int) -> list[dict[str, torch.Tensor]]: + if not self.heap: + return None + + # Sample by normalized scores + scores = torch.tensor([item[0] for item in self.heap], dtype=torch.float32) + probabilities = scores / scores.sum() + replacement = False + if num_samples > len(self.heap): + replacement = True + chosen_indices = torch.multinomial(probabilities, num_samples, replacement=replacement).tolist() + return [self.heap[i][1] for i in chosen_indices] + + +class GRPOWithReplayBufferTrainer(GRPOTrainer): + def __init__(self, args: GRPOWithReplayBufferConfig | None = None, **kwargs): + super().__init__(args=args, **kwargs) + self.replay_buffer = ReplayBuffer(args.replay_buffer_size) if args.replay_buffer_size > 0 else None + + def _generate_and_score_completions( + self, inputs: list[dict[str, torch.Tensor | Any]] + ) -> dict[str, torch.Tensor | Any]: + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + + prompts = [x["prompt"] for x in inputs] + + if "images" in inputs[0]: + images = [example.get("images") for example in inputs] + elif "image" in inputs[0]: + images = [[example.get("image")] if example.get("image") is not None else None for example in inputs] + else: + images = None + # Transformers requires at least one image in the batch, otherwise it throws an error + if images is not None and all(img_list == [] for img_list in images): + images = None + + # If the prompts are conversational and the inputs contain images, we need to convert the prompts from + # [{"role": "user", "content": "What color is the sky?"}] to + # [{"role": "user", "content": [{"type": "image", "image": }, {"type": "text", "text": "What color is the sky?"}]}] + if images is not None: + if not is_conversational(inputs[0]): + raise ValueError( + "Multimodal training requires conversational prompts. It looks like the dataset contains " + "non-conversational inputs, likely because a chat template was applied before passing the dataset " + "to the trainer. Please provide the raw conversational prompts and let the trainer apply the chat " + "template internally." + ) + prompts = [ + prepare_multimodal_messages(prompt, images=image_list) + for prompt, image_list in zip(prompts, images, strict=True) + ] + + dataset_images = images # preserve dataset images before _generate may overwrite + ( + prompt_ids_list, + completion_ids_list, + tool_mask_list, + completions, + num_items_in_batch, + sampling_per_token_logps_list, + extra_fields, + images, + tool_images, + ) = self._generate(prompts) + if images is None: + images = dataset_images # restore dataset images (rollout_func path returns None) + + # Convert lists of token IDs to padded tensors + prompt_ids = [torch.tensor(ids) for ids in prompt_ids_list] + prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids] + prompt_ids = pad( + prompt_ids, + padding_value=self._tokenizer.pad_token_id, + padding_side="left", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + prompt_mask = pad( + prompt_mask, + padding_value=0, + padding_side="left", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + completion_ids = [torch.tensor(ids) for ids in completion_ids_list] + completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids] + completion_ids = pad( + completion_ids, + padding_value=self._tokenizer.pad_token_id, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + completion_mask = pad( + completion_mask, + padding_value=0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + if sampling_per_token_logps_list is not None: + sampling_per_token_logps = [torch.tensor(logps) for logps in sampling_per_token_logps_list] + sampling_per_token_logps = pad( + sampling_per_token_logps, + padding_value=0.0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + else: + sampling_per_token_logps = None + if self.tools: + tool_mask = [torch.tensor(mask) for mask in tool_mask_list] + tool_mask = pad( + tool_mask, + padding_value=1, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) # 0 for tool result tokens, 1 elsewhere + + # If mask_truncated_completions is enabled, zero out truncated completions in completion_mask + if self.mask_truncated_completions: + eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id] + is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device) + completion_mask = completion_mask * (~is_truncated).unsqueeze(1).int() + + # Concatenate prompt_mask with completion_mask for logit computation + prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1) # (B, P+C) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) # (B, P+C) + + logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens + batch_size = self.args.per_device_train_batch_size if mode == "train" else self.args.per_device_eval_batch_size + + num_images = [len(img_list) if img_list else 0 for img_list in images] if images is not None else None + + # Get forward_kwargs for models with multimodal inputs + if images is not None: + prompts_text = [ + apply_chat_template( + {"prompt": prompt}, self.processing_class, tools=self.tools, **self.chat_template_kwargs + )["prompt"] + for prompt in prompts + ] + prompt_inputs = self.processing_class(images=images, text=prompts_text, padding=True, return_tensors="pt") + prompt_inputs = super()._prepare_inputs(prompt_inputs) + forward_kwargs = {k: v for k, v in prompt_inputs.items() if k not in ["input_ids", "attention_mask"]} + else: + forward_kwargs = {} + + # If token_type_ids are used, extend them with zeros for the completion part + if "token_type_ids" in forward_kwargs: + token_type_ids = forward_kwargs["token_type_ids"] + if self.pad_to_multiple_of is not None: + # Needed only with pad_to_multiple_of: otherwise prompt_ids and token_type_ids must have equal len + padding_size = prompt_ids.size(1) - token_type_ids.size(1) + if padding_size > 0: + token_type_ids = torch.cat( + [token_type_ids.new_zeros((token_type_ids.size(0), padding_size)), token_type_ids], dim=1 + ) + forward_kwargs["token_type_ids"] = torch.cat( + [token_type_ids, token_type_ids.new_zeros(completion_ids.shape)], dim=1 + ) + # If mm_token_type_ids are used, extend them with zeros for the completion part + if "mm_token_type_ids" in forward_kwargs: + mm_token_type_ids = forward_kwargs["mm_token_type_ids"] + if self.pad_to_multiple_of is not None: + # Needed only with pad_to_multiple_of: otherwise prompt_ids and mm_token_type_ids must have equal len + padding_size = prompt_ids.size(1) - mm_token_type_ids.size(1) + if padding_size > 0: + mm_token_type_ids = torch.cat( + [mm_token_type_ids.new_zeros((mm_token_type_ids.size(0), padding_size)), mm_token_type_ids], + dim=1, + ) + forward_kwargs["mm_token_type_ids"] = torch.cat( + [mm_token_type_ids, mm_token_type_ids.new_zeros(completion_ids.shape)], dim=1 + ) + + # When gradient checkpointing is enabled with use_reentrant=True (non default), calling the model inside a + # torch.no_grad() block triggers a harmless PyTorch warning ("None of the inputs have requires_grad=True"). + # Temporarily disable checkpointing to avoid this warning during inference. + with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs): + # If the generation and optimization steps are misaligned—i.e., if generation does not occur at the end of + # a full optimizer step (when gradient_accumulation_steps is not a multiple of generate_every)—then the + # samples may come from an earlier version of the model. In that case, we need to track old_per_token_logps + # for importance sampling. If the steps are aligned, importance sampling isn't necessary and we set + # old_per_token_logps to None. + # When using vLLM, we always compute old_per_token_logps for importance sampling, it was shown that the + # distribution mismatch between vLLM and the training model can be large and harm the training. + generate_every = self.args.steps_per_generation * self.num_iterations # generation frequency + if self.args.gradient_accumulation_steps % generate_every != 0 or ( + self.use_vllm and self.vllm_importance_sampling_correction + ): + old_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask and image_sizes + ) + else: + old_per_token_logps = None + + # Compute the importance sampling ratio when using vLLM, to correct for potential distribution mismatch + if self.use_vllm and self.vllm_importance_sampling_correction: + importance_sampling_ratio = torch.exp(old_per_token_logps - sampling_per_token_logps) + importance_sampling_ratio = torch.clamp( + importance_sampling_ratio, + min=self.vllm_importance_sampling_clip_min, + max=self.vllm_importance_sampling_clip_max, + ) + + # Compute the per-token log probabilities for the reference model + if self.beta != 0.0: + if self.ref_model is not None: + ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.ref_model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size=batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask and image_sizes + ) + else: + with self.accelerator.unwrap_model(self.model).disable_adapter(): + ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size=batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask and image_sizes + ) + else: + ref_per_token_logps = None + + # Decode + prompts_text = self.processing_class.batch_decode(prompt_ids, skip_special_tokens=True) + completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + + # Merge extra_fields from rollout_func into inputs for reward functions + if extra_fields: + for i, inp in enumerate(inputs): + for key, values in extra_fields.items(): + if isinstance(values, list) and i < len(values): + inp[key] = values[i] + elif not isinstance(values, list): + inp[key] = values + + # Calculate rewards for each reward function. rewards_per_func aggregates rewards across all processes. This is + # important because rewards will be normalized per group, and completions are distributed. We will later slice + # rewards_per_func to extract each process's subset. + rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list) + + # Apply weights to each reward function's output and sum + rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1) + + # Compute grouped-wise rewards + mean_grouped_rewards = rewards.view(-1, self.num_generations).mean(dim=1) + + # Normalize the rewards to compute the advantages + mean_grouped_rewards = mean_grouped_rewards.repeat_interleave(self.num_generations, dim=0) + advantages = rewards - mean_grouped_rewards + + grouped_std_rewards = rewards.view(-1, self.num_generations).std(dim=1) + grouped_std_rewards = grouped_std_rewards.repeat_interleave(self.num_generations, dim=0) + + if self.scale_rewards in ["group", "none"]: + # If self.scale_rewards = "none", we'll still log group level std + std_rewards = grouped_std_rewards.clone() + elif self.scale_rewards == "batch": + # Compute global std + std_rewards = rewards.std().expand_as(rewards) + else: + raise ValueError( + f"Invalid value for scale_rewards: {self.scale_rewards}. Must be one of 'batch', 'group', or 'none'." + ) + + is_std_zero = torch.isclose(std_rewards, torch.zeros_like(std_rewards)) + if self.scale_rewards != "none": + advantages = advantages / (std_rewards + 1e-4) + + # Slice to keep only the local part of the data + process_slice = slice( + self.accelerator.process_index * len(prompts), + (self.accelerator.process_index + 1) * len(prompts), + ) + all_process_advantages = advantages.clone() # keep the aggregated advantages for logging + advantages = advantages[process_slice] + grouped_std_rewards = grouped_std_rewards[process_slice] + + # Calculate mean reward per function, but only for samples where the function was applied (non-NaN values) + for i, reward_func_name in enumerate(self.reward_func_names): + mean_rewards = torch.nanmean(rewards_per_func[:, i]).item() + self._metrics[mode][f"rewards/{reward_func_name}/mean"].append(mean_rewards) + std_func_rewards = nanstd(rewards_per_func[:, i]).item() + self._metrics[mode][f"rewards/{reward_func_name}/std"].append(std_func_rewards) + rewards = (rewards_per_func * self.reward_weights.to(rewards_per_func.device).unsqueeze(0)).nansum(dim=1) + self._metrics[mode]["reward"].append(rewards.mean().item()) + self._metrics[mode]["reward_std"].append(rewards.std().item()) + self._metrics[mode]["frac_reward_zero_std"].append(is_std_zero.float().mean().item()) + + # Log prompt and completion texts + self._logs["prompt"].extend(gather_object(prompts_text)) + self._logs["completion"].extend(gather_object(completions_text)) + for i, name in enumerate(self.reward_func_names): + self._logs["rewards"][name].extend(rewards_per_func[:, i].tolist()) + self._logs["advantages"].extend(all_process_advantages.tolist()) + + if images is not None: + self._logs["images"].extend(gather_object(images)) + + if self.use_vllm and self.vllm_importance_sampling_correction: + delta = torch.abs(old_per_token_logps - sampling_per_token_logps) + mask = completion_mask.bool() if not self.tools else (completion_mask * tool_mask).bool() + delta = delta[mask] + mean_delta = torch.mean(delta) if delta.numel() > 0 else torch.tensor(0.0, device=device) + max_delta = torch.max(delta) if delta.numel() > 0 else torch.tensor(0.0, device=device) + self._metrics[mode]["sampling/sampling_logp_difference/mean"].append( + self.accelerator.gather(mean_delta).mean().item() + ) + self._metrics[mode]["sampling/sampling_logp_difference/max"].append( + self.accelerator.gather(max_delta).max().item() + ) + + flat_is_ratio = importance_sampling_ratio[mask] + min_importance_sampling_ratio = ( + torch.min(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device) + ) + mean_importance_sampling_ratio = ( + torch.mean(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device) + ) + max_importance_sampling_ratio = ( + torch.max(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device) + ) + self._metrics[mode]["sampling/importance_sampling_ratio/min"].append( + nanmin(self.accelerator.gather(min_importance_sampling_ratio)).item() + ) + self._metrics[mode]["sampling/importance_sampling_ratio/mean"].append( + self.accelerator.gather(mean_importance_sampling_ratio).nanmean().item() + ) + self._metrics[mode]["sampling/importance_sampling_ratio/max"].append( + nanmax(self.accelerator.gather(max_importance_sampling_ratio)).item() + ) + outputs_after_sampling_buffer = self.update_with_replay_buffer( + advantages, + grouped_std_rewards, + prompt_ids, + prompt_mask, + completion_ids, + completion_mask, + forward_kwargs, + num_items_in_batch, + old_per_token_logps, + ref_per_token_logps, + importance_sampling_ratio if self.use_vllm and self.vllm_importance_sampling_correction else None, + ) + if outputs_after_sampling_buffer is not None: + return outputs_after_sampling_buffer + else: + output = { + "prompt_ids": prompt_ids, + "prompt_mask": prompt_mask, + "completion_ids": completion_ids, + "completion_mask": completion_mask, + "advantages": advantages, + "num_items_in_batch": num_items_in_batch, + } + if old_per_token_logps is not None: + output["old_per_token_logps"] = old_per_token_logps + if self.use_vllm and self.vllm_importance_sampling_correction: + output["importance_sampling_ratio"] = importance_sampling_ratio + if ref_per_token_logps is not None: + output["ref_per_token_logps"] = ref_per_token_logps + if "pixel_values" in forward_kwargs: + output["pixel_values"] = forward_kwargs["pixel_values"] + if "image_grid_thw" in forward_kwargs: + output["image_grid_thw"] = forward_kwargs["image_grid_thw"] + if "pixel_attention_mask" in forward_kwargs: + output["pixel_attention_mask"] = forward_kwargs["pixel_attention_mask"] + if "image_sizes" in forward_kwargs: + output["image_sizes"] = forward_kwargs["image_sizes"] + if "token_type_ids" in forward_kwargs: + output["token_type_ids"] = forward_kwargs["token_type_ids"] + if images is not None: + output["num_images"] = num_images + if self.tools: + output["tool_mask"] = tool_mask + return output + + def slice_group_data( + self, data: torch.Tensor, mask: torch.Tensor, group_idx: int + ) -> tuple[torch.Tensor, torch.Tensor]: + """ + Slices the input data and mask tensors for a specific group index. Also trims the sequence length to the + maximum length in the group based on the mask. + + Args: + data: Tensor of shape (num_groups * num_generations, seq_length) + mask: Tensor of shape (num_groups * num_generations, seq_length) + group_idx: Index of the group to slice + Returns: + Tuple of (sliced_data, sliced_mask) for the specified group, with sequence length trimmed to the maximum + length in the group. + """ + start_idx = group_idx * self.num_generations + end_idx = (group_idx + 1) * self.num_generations + group_data = data[start_idx:end_idx] + group_mask = mask[start_idx:end_idx] + group_max_len = group_mask.sum(dim=1).max().item() + return group_data[:, :group_max_len], group_mask[:, :group_max_len] + + def update_replay_buffer( + self, + groups_with_variance: torch.Tensor, + group_advantages: torch.Tensor, + group_std_rewards: torch.Tensor, + prompt_ids: torch.Tensor, + prompt_mask: torch.Tensor, + completion_ids: torch.Tensor, + completion_mask: torch.Tensor, + forward_kwargs: dict, + optional_vision_fields: list[str] = None, + old_per_token_logps: torch.Tensor | None = None, + ref_per_token_logps: torch.Tensor | None = None, + importance_sampling_ratio: float | None = None, + ) -> None: + """ + Update the replay buffer with groups that have reward variance (std > 0). + + Args: + groups_with_variance: Boolean tensor indicating which groups have reward variance + group_advantages: Tensor of shape (num_groups, num_generations) containing advantage values + group_std_rewards: Tensor of shape (num_groups, num_generations) containing std of rewards per group + prompt_ids: Tensor containing prompt token IDs + prompt_mask: Tensor containing prompt attention masks + completion_ids: Tensor containing completion token IDs + completion_mask: Tensor containing completion attention masks + forward_kwargs: Dictionary containing additional prompt inputs (vision data, etc.) + optional_vision_fields: List of optional vision-related fields to include if present in forward_kwargs + old_per_token_logps: Optional tensor of old per-token log probabilities + ref_per_token_logps: Optional tensor of reference per-token log probabilities + importance_sampling_ratio: Optional importance sampling correction ratio + """ + # Prepare buffered outputs for groups with variance + buffered_outputs = [] + for _, group_idx in enumerate(groups_with_variance.nonzero(as_tuple=True)[0].unique().tolist()): + group_prompt_ids, group_prompt_mask = self.slice_group_data(prompt_ids, prompt_mask, group_idx) + group_completion_ids, group_completion_mask = self.slice_group_data( + completion_ids, completion_mask, group_idx + ) + + # Store unpadded data in the buffer + buffered_output = { + "prompt_ids": group_prompt_ids, + "completion_ids": group_completion_ids, + "advantages": group_advantages[group_idx].tolist(), + "prompt_mask": group_prompt_mask, + "completion_mask": group_completion_mask, + } + + # Add optional fields if they exist + optional_fields = { + "old_per_token_logps": old_per_token_logps if old_per_token_logps is not None else None, + "ref_per_token_logps": ref_per_token_logps if ref_per_token_logps is not None else None, + } + + for field_name, field_data in optional_fields.items(): + if field_data is not None: + buffered_output[field_name] = self.slice_group_data(field_data, completion_mask, group_idx)[0] + + # Add importance sampling if needed + if self.use_vllm and self.vllm_importance_sampling_correction: + buffered_output["importance_sampling_ratio"] = importance_sampling_ratio + + if optional_vision_fields: + # Add vision-related fields if they exist + for field_name in optional_vision_fields: + if field_name in forward_kwargs: + buffered_output[field_name] = self.slice_group_data( + forward_kwargs[field_name], prompt_mask, group_idx + )[0] + + buffered_outputs.append(buffered_output) + + if groups_with_variance.any(): + # Calculate replay buffer scores for groups with variance + replay_buffer_scores = (group_advantages.abs() * group_std_rewards).sum(dim=-1)[groups_with_variance] + # Add all groups to replay buffer at once (batch operation) + self.replay_buffer.add(replay_buffer_scores.tolist(), buffered_outputs) + + def sample_from_replay_buffer( + self, num_samples: int, optional_vision_fields: list[str] = None, optional_tensor_fields: list[str] = None + ) -> list[dict]: + """ + Sample groups from the replay buffer. + + Args: + num_samples: Number of samples to draw from the replay buffer + optional_vision_fields: List of optional vision-related fields to include if present in sampled data + optional_tensor_fields: List of optional tensor fields to include if present in sampled data + Returns: + List of sampled data dictionaries from the replay buffer + """ + sampled = self.replay_buffer.sample(num_samples=num_samples) + + # Extract and concatenate sampled data + sampled_data = { + "prompt_ids": [], + "prompt_mask": [], + "completion_ids": [], + "completion_mask": [], + "advantages": [], + } + + all_optional_fields = (optional_tensor_fields or []) + (optional_vision_fields or []) + # Initialize containers for optional fields if they exist in sampled data + for field in all_optional_fields: + if sampled and field in sampled[0]: + sampled_data[field] = [] + + # Extract data from each sampled item + for item in sampled: + # Handle core fields + for key in ["prompt_ids", "prompt_mask", "completion_ids", "completion_mask"]: + sampled_data[key].append(item[key]) + + # Handle advantages (list, not tensor) + sampled_data["advantages"].append(item["advantages"]) + + # Handle optional fields + for field in all_optional_fields: + if field in item: + sampled_data[field].append(item[field]) + + return sampled_data + + def update_with_replay_buffer( + self, + group_advantages: torch.Tensor, + group_std_rewards: torch.Tensor, + prompt_ids: torch.Tensor, + prompt_mask: torch.Tensor, + completion_ids: torch.Tensor, + completion_mask: torch.Tensor, + forward_kwargs: dict, + num_items_in_batch: int, + old_per_token_logps: torch.Tensor | None = None, + ref_per_token_logps: torch.Tensor | None = None, + importance_sampling_ratio: float | None = None, + ) -> None: + """ + Update current batch data with samples from replay buffer. + + Groups with reward variance (std > 0) are added to the replay buffer and then replaced with samples from the + buffer to improve training stability. + + Args: + group_advantages: Tensor of shape (num_groups, num_generations) containing advantage values + group_std_rewards: Tensor of shape (num_groups, num_generations) containing std of rewards per group + prompt_ids: Tensor containing prompt token IDs + prompt_mask: Tensor containing prompt attention masks + completion_ids: Tensor containing completion token IDs + completion_mask: Tensor containing completion attention masks + forward_kwargs: Dictionary containing additional prompt inputs (vision data, etc.) + num_items_in_batch: Number of items in the current batch + old_per_token_logps: Optional tensor of old per-token log probabilities + ref_per_token_logps: Optional tensor of reference per-token log probabilities + importance_sampling_ratio: Optional importance sampling correction ratio + """ + if self.replay_buffer.max_size <= 0: + return + + # Groups to consider for adding to the replay buffer + groups_with_variance = group_std_rewards.max(dim=0).values > 0 + # Groups to replace from the replay buffer + groups_without_variance = ~groups_with_variance + + # Track which optional fields are present in sampled data + optional_tensor_fields = ["old_per_token_logps", "ref_per_token_logps"] + vision_fields = ["pixel_values", "image_grid_thw", "pixel_attention_mask", "image_sizes"] + + self.update_replay_buffer( + groups_with_variance, + group_advantages, + group_std_rewards, + prompt_ids, + prompt_mask, + completion_ids, + completion_mask, + forward_kwargs, + vision_fields, + old_per_token_logps, + ref_per_token_logps, + importance_sampling_ratio, + ) + + # Sample from replay buffer to replace groups with variance + num_groups_to_replace = groups_without_variance.sum().item() + if not num_groups_to_replace: + return + + sampled_data = self.sample_from_replay_buffer( + num_samples=num_groups_to_replace, + optional_vision_fields=vision_fields, + optional_tensor_fields=optional_tensor_fields, + ) + + # Pad sampled data if they are shorter than the current batch sequences + # Or pad the current batch if sampled are longer + current_batch_prompt_seq_len = prompt_ids.size(1) + current_batch_completion_seq_len = completion_ids.size(1) + + groups_to_replace_idxs = groups_with_variance.logical_not().nonzero(as_tuple=True)[0].unique().tolist() + + # Determine target (max) sequence lengths once + sampled_prompt_lengths = [t.size(1) for t in sampled_data["prompt_ids"]] + sampled_completion_lengths = [t.size(1) for t in sampled_data["completion_ids"]] + target_prompt_len = max([current_batch_prompt_seq_len] + sampled_prompt_lengths) + target_completion_len = max([current_batch_completion_seq_len] + sampled_completion_lengths) + + # If any sampled prompt is longer, pad the whole batch prompt tensors once (left padding) + if target_prompt_len > current_batch_prompt_seq_len: + prompt_ids = pad( + list(prompt_ids.unbind(0)), + padding_value=self._tokenizer.pad_token_id, + pad_to_multiple_of=target_prompt_len, + padding_side="left", + ) + prompt_mask = pad( + list(prompt_mask.unbind(0)), padding_value=0, pad_to_multiple_of=target_prompt_len, padding_side="left" + ) + # If any sampled completion is longer, pad the whole batch completion tensors once (right padding) + if target_completion_len > current_batch_completion_seq_len: + completion_ids = pad( + list(completion_ids.unbind(0)), + padding_value=self._tokenizer.pad_token_id, + pad_to_multiple_of=target_completion_len, + padding_side="right", + ) + completion_mask = pad( + list(completion_mask.unbind(0)), + padding_value=0, + pad_to_multiple_of=target_completion_len, + padding_side="right", + ) + if old_per_token_logps is not None: + old_per_token_logps = pad( + list(old_per_token_logps.unbind(0)), + padding_value=0.0, + pad_to_multiple_of=target_completion_len, + padding_side="right", + ) + if ref_per_token_logps is not None: + ref_per_token_logps = pad( + list(ref_per_token_logps.unbind(0)), + padding_value=0.0, + pad_to_multiple_of=target_completion_len, + padding_side="right", + ) + + # Replace per-group data, padding only sampled groups that are shorter than the target + for i, group_idx in enumerate(groups_to_replace_idxs): + start_idx = group_idx * self.num_generations + end_idx = (group_idx + 1) * self.num_generations + idx_range = slice(start_idx, end_idx) + + # Pad sampled prompt to target length if needed + if sampled_data["prompt_ids"][i].size(1) < target_prompt_len: + sampled_data["prompt_ids"][i] = pad( + sampled_data["prompt_ids"][i], + padding_value=self._tokenizer.pad_token_id, + pad_to_multiple_of=target_prompt_len, + padding_side="left", + ) + sampled_data["prompt_mask"][i] = pad( + sampled_data["prompt_mask"][i], + padding_value=0, + pad_to_multiple_of=target_prompt_len, + padding_side="left", + ) + + # Pad sampled completion to target length if needed + if sampled_data["completion_ids"][i].size(1) < target_completion_len: + sampled_data["completion_ids"][i] = pad( + sampled_data["completion_ids"][i], + padding_value=self._tokenizer.pad_token_id, + pad_to_multiple_of=target_completion_len, + padding_side="right", + ) + sampled_data["completion_mask"][i] = pad( + sampled_data["completion_mask"][i], + padding_value=0, + pad_to_multiple_of=target_completion_len, + padding_side="right", + ) + if "old_per_token_logps" in sampled_data: + sampled_data["old_per_token_logps"][i] = pad( + sampled_data["old_per_token_logps"][i], + padding_value=0.0, + pad_to_multiple_of=target_completion_len, + padding_side="right", + ) + if "ref_per_token_logps" in sampled_data: + sampled_data["ref_per_token_logps"][i] = pad( + sampled_data["ref_per_token_logps"][i], + padding_value=0.0, + pad_to_multiple_of=target_completion_len, + padding_side="right", + ) + + # Assign (replace) group slice + prompt_ids[idx_range] = sampled_data["prompt_ids"][i] + prompt_mask[idx_range] = sampled_data["prompt_mask"][i] + completion_ids[idx_range] = sampled_data["completion_ids"][i] + completion_mask[idx_range] = sampled_data["completion_mask"][i] + group_advantages[group_idx] = sampled_data["advantages"][i] + + if "old_per_token_logps" in sampled_data: + old_per_token_logps[idx_range] = sampled_data["old_per_token_logps"][i] + if "ref_per_token_logps" in sampled_data: + ref_per_token_logps[idx_range] = sampled_data["ref_per_token_logps"][i] + + for field in vision_fields: + if field in sampled_data and field in forward_kwargs: + forward_kwargs[field][idx_range] = sampled_data[field][i] + + # Prepare final outputs after sampling and replacement + outputs_after_sampling_buffer = { + "prompt_ids": prompt_ids, + "prompt_mask": prompt_mask, + "completion_ids": completion_ids, + "completion_mask": completion_mask, + "advantages": group_advantages, + } + + # Replace optional tensor fields if they exist + for field in optional_tensor_fields: + if field in sampled_data: + outputs_after_sampling_buffer[field] = ( + old_per_token_logps if field == "old_per_token_logps" else ref_per_token_logps + ) + + # Replace vision fields if they exist + for field in vision_fields: + if field in sampled_data and field in forward_kwargs: + outputs_after_sampling_buffer[field] = forward_kwargs[field] + + outputs_after_sampling_buffer["num_items_in_batch"] = num_items_in_batch + if self.use_vllm and self.vllm_importance_sampling_correction: + outputs_after_sampling_buffer["importance_sampling_ratio"] = importance_sampling_ratio + + return outputs_after_sampling_buffer diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gspo_token/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gspo_token/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4c9814fddca65cfe8d5ccabccc9d646141e19364 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gspo_token/__init__.py @@ -0,0 +1,15 @@ +# Copyright 2020-2026 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. + +from .grpo_trainer import GRPOTrainer diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gspo_token/grpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gspo_token/grpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..2e2cc940b23361f76886ef4dee93e0e9b360327b --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/gspo_token/grpo_trainer.py @@ -0,0 +1,161 @@ +# Copyright 2020-2026 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 torch + +from ...trainer.grpo_trainer import GRPOTrainer as _GRPOTrainer +from ...trainer.utils import nanmax, nanmin + + +class GRPOTrainer(_GRPOTrainer): + def _compute_loss(self, model, inputs): + # Compute the per-token log probabilities for the model + prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"] + completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"] + input_ids = torch.cat([prompt_ids, completion_ids], dim=1) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens + + # Compute the per_token_logps and the entropy at each position in the completion + per_token_logps, entropies, _ = self._get_per_token_logps_and_entropies( + model, + input_ids, + attention_mask, + logits_to_keep, + compute_entropy=True, + pixel_values=inputs.get("pixel_values"), + image_grid_thw=inputs.get("image_grid_thw"), + num_images=inputs.get("num_images"), + pixel_attention_mask=inputs.get("pixel_attention_mask"), + image_sizes=inputs.get("image_sizes"), + token_type_ids=inputs.get("token_type_ids"), + ) + + if self.top_entropy_quantile < 1.0: + entropy_mask = self.get_high_entropy_mask(entropies, completion_mask, 1 - self.top_entropy_quantile) + else: + entropy_mask = None + + # Compute the KL divergence between the model and the reference model + if self.beta != 0.0: + ref_per_token_logps = inputs["ref_per_token_logps"] + per_token_kl = ( + torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1 + ) + + # Compute the loss + advantages = inputs["advantages"] + # In the base GRPO implementation, advantages are expected to have shape (B,). To support subclasses that + # provide advantages with shape (B, T) (e.g., MiniLLM), we *conditionally* unsqueeze the tensor. + if advantages.dim() == 1: + advantages = advantages.unsqueeze(1) + # When num_iterations == 1 and steps_per_generation <= gradient_accumulation_steps, + # old_per_token_logps == per_token_logps. In this case we can skip its computation + # (see _generate_and_score_completions) and instead use per_token_logps.detach(). + # The exception is when using vLLM, where we always compute old_per_token_logps + # for importance sampling + old_per_token_logps = inputs.get("old_per_token_logps") + old_per_token_logps = per_token_logps.detach() if old_per_token_logps is None else old_per_token_logps + + log_ratio = per_token_logps - old_per_token_logps + if self.importance_sampling_level == "token": + log_importance_weights = log_ratio + elif self.importance_sampling_level == "sequence": + log_importance_weights = (log_ratio * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0) + log_importance_weights = log_importance_weights.unsqueeze(-1) + elif self.importance_sampling_level == "sequence_token": + # GSPO-token: sg[si(θ)] * πθ(yi,t)/sg[πθ(yi,t)] + seq_level_log_weight = (log_ratio * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0) + seq_level_log_weight = seq_level_log_weight.detach().unsqueeze(-1) # Stop gradient + log_importance_weights = per_token_logps - per_token_logps.detach() + seq_level_log_weight + else: + raise ValueError( + f"Unknown importance sampling level: {self.importance_sampling_level}. Possible values are 'token' " + "and 'sequence'." + ) + # From here, log_importance_weights (and all subsequent tensors, coef_1, coef_2, etc.) shape depends on + # importance_sampling_level: "token" level: (B, T); "sequence" level: (B, 1) + + coef_1 = torch.exp(log_importance_weights) + coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high) + + # Two-sided clipping + if self.args.delta is not None: + coef_1 = torch.clamp(coef_1, max=self.args.delta) + + per_token_loss1 = coef_1 * advantages + per_token_loss2 = coef_2 * advantages + per_token_loss = -torch.min(per_token_loss1, per_token_loss2) + if entropy_mask is not None: + per_token_loss = per_token_loss * entropy_mask + + if self.use_vllm and self.vllm_importance_sampling_correction: + per_token_loss = per_token_loss * inputs["importance_sampling_ratio"] + + if self.beta != 0.0: + per_token_loss = per_token_loss + self.beta * per_token_kl + + mode = "train" if self.model.training else "eval" + if self.loss_type == "grpo": + loss = ((per_token_loss * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0)).mean() + normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval + loss = loss / normalizer + elif self.loss_type == "bnpo": + loss = (per_token_loss * completion_mask).sum() / completion_mask.sum().clamp(min=1.0) + normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval + loss = loss / normalizer + elif self.loss_type == "dr_grpo": + loss = (per_token_loss * completion_mask).sum() / (per_token_loss.size(0) * self.max_completion_length) + normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval + loss = loss / normalizer + elif self.loss_type == "dapo": + normalizer = inputs["num_items_in_batch"] / self.accelerator.num_processes + loss = (per_token_loss * completion_mask).sum() / normalizer + else: + raise ValueError(f"Unknown loss type: {self.loss_type}") + + # Log the metrics + completion_token_count = completion_mask.sum().clamp(min=1.0) + + def masked_batch_mean(x): + if x.shape[1] == 1: # when importance_sampling_level == "sequence" + return x.mean() + else: + return (x * completion_mask).sum() / completion_token_count + + if self.beta != 0.0: + mean_kl = masked_batch_mean(per_token_kl) + self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item()) + + mean_entropy = masked_batch_mean(entropies) + self._metrics[mode]["entropy"].append(self.accelerator.gather(mean_entropy).nanmean().item()) + + # Compute the clipped probability ratios + is_low_clipped = (coef_1 < 1 - self.epsilon_low) & (advantages < 0) + is_high_clipped = (coef_1 > 1 + self.epsilon_high) & (advantages > 0) + is_region_clipped = is_low_clipped | is_high_clipped + + low_clip = masked_batch_mean(is_low_clipped.float()) + high_clip = masked_batch_mean(is_high_clipped.float()) + clip_ratio = masked_batch_mean(is_region_clipped.float()) + + gathered_low_clip = self.accelerator.gather(low_clip) + self._metrics[mode]["clip_ratio/low_mean"].append(gathered_low_clip.nanmean().item()) + self._metrics[mode]["clip_ratio/low_min"].append(nanmin(gathered_low_clip).item()) + gathered_high_clip = self.accelerator.gather(high_clip) + self._metrics[mode]["clip_ratio/high_mean"].append(gathered_high_clip.nanmean().item()) + self._metrics[mode]["clip_ratio/high_max"].append(nanmax(gathered_high_clip).item()) + gathered_clip_ratio = self.accelerator.gather(clip_ratio) + self._metrics[mode]["clip_ratio/region_mean"].append(gathered_clip_ratio.nanmean().item()) + return loss diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/harbor/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/harbor/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..882377f2b21b5e41875014bc2b8d8b85de530de8 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/harbor/__init__.py @@ -0,0 +1,32 @@ +# Copyright 2020-2026 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. + +"""Harbor × TRL integration (experimental). + +Train on Harbor agentic task suites with `GRPOTrainer` via `environment_factory`, with a pluggable base agent +(harness). Requires `harbor` installed in the same interpreter (`pip install trl[harbor]`, Python >= 3.12); `harbor` is +imported lazily so this module imports without it. + +```python +from trl.experimental.harbor import HarborSpec + +spec = HarborSpec("AdithyaSK/data_agent_rl_environment_train", agent="bash", num_tasks=64) +``` +""" + +from ._env import AGENTS, HarborBashEnv, HarborEnv +from ._spec import HarborSpec + + +__all__ = ["AGENTS", "HarborBashEnv", "HarborEnv", "HarborSpec"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/harbor/_env.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/harbor/_env.py new file mode 100644 index 0000000000000000000000000000000000000000..fdef9800e264cc283b7c955e9195080b8f6032d2 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/harbor/_env.py @@ -0,0 +1,231 @@ +# Copyright 2020-2026 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. + +"""Harbor-backed environments for `GRPOTrainer(environment_factory=...)`. + +A `HarborEnv` wraps a Harbor sandbox + verifier. TRL drives the rollout loop: it calls the env's tool methods during +generation and reads `env.reward` afterwards. The pluggable "base agent" is the harness — the set of tool methods the +env exposes + how it submits. `HarborBashEnv` is the single-`bash`-tool harness (submit by writing +`/workdir/answer.txt`); subclass `HarborEnv` to add your own. + +Harbor's API is async and its sandbox client is bound to the event loop it was created on, so each env owns one loop +and drives start/exec/verify/stop through it synchronously (TRL's tool loop is sync). `harbor` is imported lazily, so +importing this module does not require it installed (install `trl[harbor]`, which needs Python >= 3.12). +""" + +import asyncio +import tempfile +import threading +import uuid +from pathlib import Path + + +_NO_REWARD = object() # sentinel: reward not computed yet (0.0 is a valid reward) + + +class HarborEnv: + """Base TRL environment backed by a Harbor sandbox + verifier. + + Subclasses define the tool methods (the harness). The lifecycle TRL drives per rollout: `reset(task_dir)` (start + the task's sandbox, return its instruction) -> tool methods (exec into the sandbox) -> `reward` (run the verifier + once, lazily, after the rollout). + + Args: + environment_type (`str`, *optional*, defaults to `"docker"`): + Harbor sandbox backend, passed through to Harbor (`"docker"`, `"e2b"`, `"daytona"`, ...). + """ + + #: Extra guidance appended to the task instruction by the harness subclass. + PROMPT_SUFFIX: str = "" + + def __init__(self, environment_type: str = "docker"): + self._environment_type = environment_type + # Harbor's async sandbox client is bound to the loop it was created on, so we run that loop on a + # dedicated daemon thread and submit coroutines to it via `run_coroutine_threadsafe`. This works + # whether the caller is on a plain thread (GRPOTrainer drives tools from the main thread) or + # already inside a running event loop (AsyncGRPOTrainer's rollout worker calls tool methods from + # its own loop, where `loop.run_until_complete` would raise "another loop is already running"). + self._loop = asyncio.new_event_loop() + self._loop_thread = threading.Thread(target=self._loop.run_forever, daemon=True) + self._loop_thread.start() + self._env = None # harbor BaseEnvironment for the current task + self._task = None + self._paths = None + self._reward = _NO_REWARD + + def _run(self, coro): + """Run a coroutine on this env's loop (which lives on its own thread) and block for the result.""" + return asyncio.run_coroutine_threadsafe(coro, self._loop).result() + + def reset(self, task_dir: str | None = None, **kwargs) -> str: + if task_dir is None: + raise ValueError("HarborEnv.reset requires `task_dir` (provided by the dataset row).") + instruction = self._run(self._start(task_dir)) + self._reward = _NO_REWARD + return instruction + self.PROMPT_SUFFIX + + def _exec(self, command: str, timeout: int = 180) -> str: + """Run a shell command in the sandbox; return combined stdout+stderr (truncated to 8k).""" + result = self._run(self._env.exec(command, timeout_sec=timeout)) + out = (result.stdout or "") + (result.stderr or "") + if len(out) > 8000: + out = out[:8000] + "\n... [truncated]" + return out or f"(empty output, rc={result.return_code})" + + @property + def reward(self) -> float: + # Submission = the agent wrote /workdir/answer.txt during the rollout; the verifier reads it. + # Computed once, lazily, on first read (TRL reads this after the rollout via reward_funcs). + # A fresh env that was never `reset` (e.g. the trainer probing tool methods via + # `inspect.getmembers`, which evaluates properties) has no sandbox/task to verify — return 0.0 + # without invoking the verifier, which would start the Harbor backend and import `harbor`. + if self._env is None: + return 0.0 + if self._reward is _NO_REWARD: + self._reward = self._run(self._verify()) + return self._reward + + # ── harbor lifecycle (async, run on this env's loop) ──────────────────── + + async def _start(self, task_dir: str) -> str: + from harbor.environments.factory import EnvironmentFactory + from harbor.models.task.task import Task + from harbor.models.trial.config import EnvironmentConfig as TrialEnvironmentConfig + from harbor.models.trial.paths import TrialPaths + + await self._stop() # tear down the previous task's sandbox + self._task = Task(task_dir=Path(task_dir)) + self._paths = TrialPaths(trial_dir=Path(tempfile.mkdtemp(prefix="harbor_trl_"))) + self._env = EnvironmentFactory.create_environment_from_config( + config=TrialEnvironmentConfig(type=self._environment_type), + environment_dir=self._task.paths.environment_dir, + environment_name=self._task.short_name, + session_id=uuid.uuid4().hex, + trial_paths=self._paths, + task_env_config=self._task.config.environment, + ) + await self._env.start(force_build=False) + await self._upload_build_files() # some sandbox builds (e.g. E2B from_dockerfile) drop COPY'd files + await self._env.run_healthcheck() # task pre-agent hook (e.g. pull data into /home/user/input) + await self._env.exec("mkdir -p /workdir /home/user/input") + await self._setup() # harness-specific sandbox prep (e.g. start a Jupyter kernel) + return self._task.instruction + + async def _upload_build_files(self) -> None: + """Replicate the task Dockerfile's `COPY` directives into the sandbox. + + E2B's remote `from_dockerfile` build honors `RUN` steps but silently drops files `COPY`'d from the build + context, which breaks healthchecks that run those files (e.g. a data-pull script). We re-create them at + runtime: `upload_file` writes as the sandbox `user`, so we stage each file in a user-writable tmp path and `mv` + it into place as root (destinations like `/opt` are root-owned). Idempotent. Handles the common ``COPY + `` form; flags / globs / ``--from`` are skipped. + """ + dockerfile = self._task.paths.environment_dir / "Dockerfile" + if not dockerfile.exists(): + return + for line in dockerfile.read_text().splitlines(): + s = line.strip() + if not s.upper().startswith("COPY ") or "--from" in s: + continue + parts = [p for p in s[len("COPY ") :].split() if not p.startswith("--")] + if len(parts) < 2: + continue + *srcs, dst = parts + for src in srcs: + local = self._task.paths.environment_dir / src + if not local.is_file(): + continue + remote = dst if (len(srcs) == 1 and not dst.endswith("/")) else dst.rstrip("/") + "/" + Path(src).name + parent = remote.rsplit("/", 1)[0] or "/" + tmp = "/tmp/" + uuid.uuid4().hex + await self._env.upload_file(local, tmp) + await self._env.exec(f"mkdir -p {parent} && mv {tmp} {remote}", user="root") + + async def _setup(self) -> None: + """Harness-specific sandbox preparation, run once per `reset` after the sandbox is up. + + Override to upload helper files (`await self._env.upload_file(...)`) or start servers in the sandbox. The + default is a no-op (the bash harness needs nothing beyond the base setup). + """ + + async def _verify(self) -> float: + from harbor.models.trial.config import VerifierConfig + from harbor.models.trial.paths import EnvironmentPaths + from harbor.verifier.factory import VerifierFactory + + # Pre-create the verifier dir (test.sh redirects stdout there; the shell can't mkdir the parent). + env_paths = EnvironmentPaths.for_os(self._env.os) + await self._env.empty_dirs([env_paths.verifier_dir], chmod=True) + # Carry the task's [verifier].env (e.g. expected-answer / judge-model settings) into the verifier, + # mirroring Harbor's trial runner (`override_env=`). A default trial `VerifierConfig()` is otherwise + # correct here — the task verifier has no trial-level import_path/kwargs to forward. + verifier = VerifierFactory.create_verifier_from_config( + VerifierConfig(), + task=self._task, + trial_paths=self._paths, + environment=self._env, + override_env=self._task.config.verifier.env or None, + ) + result = await verifier.verify() + rewards = result.rewards or {} + return float(rewards.get("reward", next(iter(rewards.values()), 0.0))) + + async def _stop(self) -> None: + if self._env is not None: + try: + await self._env.stop(delete=True) + finally: + self._env = None + + def __del__(self): + try: + self._run(self._stop()) + except Exception: # noqa: BLE001 — best-effort teardown + pass + finally: + self._loop.call_soon_threadsafe(self._loop.stop) + + +_BASH_PROMPT_SUFFIX = ( + "\n\nYou have a single `bash` tool: run a shell command in the sandbox and get its stdout+stderr. " + "The dataset files are in /home/user/input/. Python 3 + pandas + numpy + scikit-learn are " + "preinstalled. **Submit your final answer by writing it to /workdir/answer.txt via the `bash` " + 'tool**, e.g. `echo -n "" > /workdir/answer.txt`. Stating the answer in prose does NOT submit ' + "it; only writing the file counts. Keep the answer short, and do not end your turn without submitting." +) + + +class HarborBashEnv(HarborEnv): + """Single-`bash`-tool harness; submit by writing `/workdir/answer.txt`.""" + + PROMPT_SUFFIX = _BASH_PROMPT_SUFFIX + + def bash(self, command: str) -> str: + """ + Run a shell command in the sandbox and return its combined stdout+stderr. The shell is non-stateful between + calls. Use it to explore files (ls, head, cat), run Python (`python3 -c "..."`), and submit the answer (`echo + -n "" > /workdir/answer.txt`). + + Args: + command: The shell command to run. + + Returns: + The command's combined stdout and stderr. + """ + return self._exec(command) + + +#: Built-in harnesses, selectable by name in `HarborSpec(agent=...)`. Pass a `HarborEnv` subclass (or an +#: import path / file path resolving to one) for a custom harness. +AGENTS: dict[str, type[HarborEnv]] = {"bash": HarborBashEnv} diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/harbor/_spec.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/harbor/_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..9f0f374c06bec9d524b0d3fd1e96d8d3e918ca54 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/harbor/_spec.py @@ -0,0 +1,216 @@ +# Copyright 2020-2026 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. + +"""User-facing spec for the Harbor × TRL integration (mirror of ``OpenRewardSpec``). + +Construct **one** ``HarborSpec`` and read three properties off it — ``.train_dataset``, ``.environment_factory``, +``.reward_funcs`` — each plugging into the matching ``GRPOTrainer`` kwarg: + +```python +from trl import GRPOConfig, GRPOTrainer +from trl.experimental.harbor import HarborSpec + +spec = HarborSpec("AdithyaSK/data_agent_rl_environment_train", agent="bash", num_tasks=64) + +trainer = GRPOTrainer( + model="Qwen/Qwen3.5-4B", + args=GRPOConfig(num_generations=8, max_steps=50, max_tool_calling_iterations=25), + train_dataset=spec.train_dataset, + environment_factory=spec.environment_factory, + reward_funcs=spec.reward_funcs, +) +trainer.train() +``` + +A Harbor *task* is a directory (``instruction.md`` + ``task.toml`` + ``environment/`` + ``tests/``); the dataset is a +tree of them. The ``environment_factory`` env runs Harbor in-process (see ``_env.py``), so ``harbor`` must be installed +in the same interpreter (``pip install trl[harbor]``, Python >= 3.12). The **base agent** (harness/tool surface) is +selected by ``agent=`` — ``"bash"`` today, or a custom ``HarborEnv`` subclass. +""" + +from __future__ import annotations + +import os +from collections.abc import Callable +from functools import cached_property, partial +from pathlib import Path +from typing import Any + +from ._env import AGENTS, HarborEnv + + +def _outcome_reward_func(environments=None, environment_reward=None, **_) -> list[float]: + """Default reward: the Harbor verifier's scalar per rollout. + + `GRPOTrainer` passes the live env instances as `environments=` (read `env.reward`); `AsyncGRPOTrainer` runs envs in + its rollout worker and passes the already-captured per-rollout rewards as `environment_reward=`. Support both so + the same spec plugs into either trainer. + """ + if environment_reward is not None: + return [float(r) for r in environment_reward] + return [float(env.reward) for env in environments] + + +def _resolve_agent(agent: str | type[HarborEnv]) -> type[HarborEnv]: + """Resolve the `agent=` selector to a `HarborEnv` subclass. + + Accepts a `HarborEnv` subclass, a built-in name (`"bash"`), a module import path (`"pkg.module:Class"`), or a file + path (`"path/to/file.py:Class"`). + """ + if isinstance(agent, type): + cls = agent + elif agent in AGENTS: + cls = AGENTS[agent] + elif ":" in agent: + import importlib + import importlib.util + + target, _, cls_name = agent.rpartition(":") # rpartition: don't split a Windows drive (``D:\...``) + if target.endswith(".py") or os.path.sep in target: # file path -> load module from file + spec = importlib.util.spec_from_file_location(Path(target).stem, target) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + else: # dotted module path on sys.path + module = importlib.import_module(target) + cls = getattr(module, cls_name) + else: + raise ValueError( + f"Unknown agent {agent!r}; use a built-in name ({sorted(AGENTS)}), an import path " + "'pkg.module:Class', a file path 'path/to/file.py:Class', or a HarborEnv subclass." + ) + if not (isinstance(cls, type) and issubclass(cls, HarborEnv)): + raise TypeError(f"agent {agent!r} must resolve to a HarborEnv subclass, got {cls!r}") + return cls + + +def _read_task_meta(task_dir: Path) -> dict[str, Any]: + """Pull a few useful fields out of ``task.toml`` for the dataset rows / reward funcs.""" + try: + import tomllib # stdlib on Python 3.11+; lazy so the module imports on 3.10 (e.g. doc build) + + cfg = tomllib.loads((task_dir / "task.toml").read_text()) + except Exception: # noqa: BLE001 + return {} + meta = cfg.get("metadata", {}) + return { + "gold_answer": meta.get("gold_answer"), + "reward_mode": meta.get("reward_mode_initial"), + "difficulty_level": meta.get("difficulty_level"), + "kaggle_dataset": meta.get("kaggle_dataset_name"), + } + + +class HarborSpec: + """Single spec object that wires a Harbor task suite into a TRL trainer. + + Args: + dataset (`str`): + A Hugging Face dataset repo id holding a Harbor task tree (e.g. + `"AdithyaSK/data_agent_rl_environment_train"`), or a local path to a directory containing a `tasks/` + subtree. Each task is a dir with `instruction.md` / `task.toml` / `environment/` / `tests/`. + agent (`str` or `type`, *optional*, defaults to `"bash"`): + The base agent / harness — i.e. the tool surface the env exposes. One of: a built-in name (`"bash"`), an + import path `"package.module:ClassName"`, a file path `"path/to/file.py:ClassName"`, or a + [`~trl.experimental.harbor.HarborEnv`] subclass directly. + environment_type (`str`, *optional*, defaults to `"docker"`): + Harbor sandbox backend, passed through to Harbor (whatever it supports — `"docker"`, `"e2b"`, `"daytona"`, + `"gke"`, `"modal"`, `"runloop"`, ...). Not validated here; Harbor validates. `"docker"` is Harbor's own + default; pick `"e2b"` to offload sandboxing to the cloud. + num_tasks (`int`, *optional*): + Cap on the number of tasks pulled into the dataset. `None` uses every task in the tree. + indices (`list[int]`, *optional*): + Specific task indices (into the sorted task list). Mutually exclusive with `num_tasks`. + include_metadata (`bool`, *optional*, defaults to `True`): + Fold per-task `task.toml` metadata (gold_answer, difficulty, ...) into the dataset rows. + """ + + def __init__( + self, + dataset: str, + *, + agent: str | type[HarborEnv] = "bash", + environment_type: str = "docker", + num_tasks: int | None = None, + indices: list[int] | None = None, + include_metadata: bool = True, + ) -> None: + if num_tasks is not None and indices is not None: + raise ValueError("Provide num_tasks or indices, not both.") + self._dataset = dataset + self._environment_type = environment_type + self._num_tasks = num_tasks + self._indices = indices + self._include_metadata = include_metadata + self._env_cls = _resolve_agent(agent) + + # ── public surface ────────────────────────────────────────────── + + @cached_property + def _task_dirs(self) -> list[Path]: + """Resolve the dataset to a sorted list of local task directories (downloading if needed).""" + local = Path(self._dataset) + if (local / "tasks").is_dir(): + root = local / "tasks" + elif local.is_dir() and any(local.glob("*/task.toml")): + root = local + else: + # Treat as an HF dataset repo id; download the task tree. + from huggingface_hub import snapshot_download + + path = Path(snapshot_download(self._dataset, repo_type="dataset", allow_patterns=["tasks/**"])) + root = path / "tasks" + dirs = sorted(p.parent for p in root.glob("*/task.toml")) + if self._indices is not None: + dirs = [dirs[i] for i in self._indices] + elif self._num_tasks is not None: + dirs = dirs[: self._num_tasks] + if not dirs: + raise ValueError(f"No tasks (dir with task.toml) found under {root}") + return dirs + + @cached_property + def train_dataset(self): + """A `datasets.Dataset` of tasks. Plugs into TRL's `train_dataset=`. + + Columns: `prompt` (empty user message — TRL appends the env's instruction from `reset`), `task_dir` (passed to + `reset`), `task_index`, and per-task metadata when `include_metadata`. + """ + from datasets import Dataset + + dirs = self._task_dirs + rows: dict[str, list[Any]] = { + "prompt": [[{"role": "user", "content": ""}] for _ in dirs], + "task_dir": [str(d) for d in dirs], + # task_index is the position in the sorted suite, so it matches the `indices` selector. + "task_index": list(self._indices) if self._indices is not None else list(range(len(dirs))), + } + if self._include_metadata: + metas = [_read_task_meta(d) for d in dirs] + for key in ("gold_answer", "reward_mode", "difficulty_level", "kaggle_dataset"): + rows[key] = [m.get(key) for m in metas] + return Dataset.from_dict(rows) + + @cached_property + def environment_factory(self) -> Callable[[], HarborEnv]: + """Zero-arg callable returning a fresh harness env. Plugs into TRL's `environment_factory=`. + + Returns a `functools.partial` (not a closure) so it stays picklable — `AsyncGRPOTrainer` runs its rollout + worker in a separate process and pickles the factory to it (closures/lambdas would fail). + """ + return partial(self._env_cls, environment_type=self._environment_type) + + @property + def reward_funcs(self) -> Callable[..., list[float]]: + """Default outcome reward (Harbor verifier scalar). Plugs into TRL's `reward_funcs=`.""" + return _outcome_reward_func diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/kto/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/kto/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d7c21e2316bff7d621faa06622584271ee176d0e --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/kto/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .kto_config import KTOConfig +from .kto_trainer import KTOTrainer + + +__all__ = ["KTOConfig", "KTOTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/kto/kto_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/kto/kto_config.py new file mode 100644 index 0000000000000000000000000000000000000000..45e0c65bc7fd6c6559ff6b93ee69b2d2dd9f7736 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/kto/kto_config.py @@ -0,0 +1,199 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Any + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class KTOConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`experimental.kto.KTOTrainer`]. + + This class includes only the parameters that are specific to KTO training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + 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: + > Parameters that control the model + + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model` + argument of the [`KTOTrainer`] is provided as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and + [`~transformers.AutoProcessor.from_pretrained`]. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model and reference model. + + > Parameters that control the data preprocessing + + dataset_num_proc (`int`, *optional*): + Number of processes to use for processing the dataset. + max_length (`int` or `None`, *optional*, defaults to `1024`): + Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from the left. + If `None`, no truncation is applied. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + precompute_ref_log_probs (`bool`, *optional*, defaults to `False`): + Whether to precompute the reference model log probabilities for the entire training dataset before + training. This allows to save memory during training, as the reference model does not need to be kept in + memory. + precompute_ref_batch_size (`int`, *optional*): + Batch size to use when precomputing reference model log probabilities. This can be set higher than the + training batch size to speed up preprocessing. If `None`, defaults to `per_device_train_batch_size` for + training and `per_device_eval_batch_size` for evaluation. + + > Parameters that control the training + + loss_type (`str`, *optional*, defaults to `"kto"`): + Type of loss to use. Possible values are: + + - `"kto"`: KTO loss from the [KTO](https://huggingface.co/papers/2402.01306) paper. + - `"apo_zero_unpaired"`: Unpaired variant of APO-zero loss from the + [APO](https://huggingface.co/papers/2408.06266) paper. + + beta (`float`, *optional*, defaults to `0.1`): + Parameter controlling the deviation from the reference model. Higher β means less deviation from the + reference model. + desirable_weight (`float`, *optional*, defaults to `1.0`): + Desirable losses are weighed by this factor to counter unequal number of desirable and undesirable pairs. + undesirable_weight (`float`, *optional*, defaults to `1.0`): + Undesirable losses are weighed by this factor to counter unequal number of desirable and undesirable pairs. + activation_offloading (`bool`, *optional*, defaults to `False`): + Whether to offload the activations to the CPU. + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `1e-6` instead of `5e-5`. + > - `train_sampling_strategy`: Defaults to `"sequential"` instead of `"random"`. Loss types + > that estimate the KL divergence term (all except `"apo_zero_unpaired"`) require sequential + > sampling because the KL completion for each example is precomputed against its neighbors in + > a fixed-order batch; any other strategy breaks that pairing. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=1e-6, + metadata={"help": "The initial learning rate for AdamW."}, + ) + train_sampling_strategy: str = field( + default="sequential", + metadata={ + "help": "Sampler to use for the training dataloader. Loss types that estimate the KL divergence term " + "(all except `'apo_zero_unpaired'`) require `'sequential'` because the KL completion for each example is " + "precomputed against its neighbors in a fixed-order batch; any other strategy breaks that pairing. " + "Possible values are `'random'`, `'sequential'`, and `'group_by_length'`.", + "choices": ["random", "sequential", "group_by_length"], + }, + ) + + # Parameters that control the model + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument of " + "the `KTOTrainer` is provided as a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the model and reference model."}, + ) + + # Parameters that control the data preprocessing + dataset_num_proc: int | None = field( + default=None, + metadata={"help": "Number of processes to use for processing the dataset."}, + ) + max_length: int | None = field( + default=1024, + metadata={ + "help": "Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from " + "the left. If `None`, no truncation is applied." + }, + ) + pad_to_multiple_of: int | None = field( + default=None, + metadata={"help": "If set, the sequences will be padded to a multiple of this value."}, + ) + precompute_ref_log_probs: bool = field( + default=False, + metadata={ + "help": "Whether to precompute the reference model log probabilities for the entire training dataset " + "before training. This allows to save memory during training, as the reference model does not need to be " + "kept in memory." + }, + ) + precompute_ref_batch_size: int | None = field( + default=None, + metadata={ + "help": "Batch size to use when precomputing reference model log probabilities. This can be set higher " + "than the training batch size to speed up preprocessing. If `None`, defaults to " + "`per_device_train_batch_size` for training and `per_device_eval_batch_size` for evaluation." + }, + ) + + # Parameters that control the training + loss_type: str = field( + default="kto", + metadata={ + "help": "Type of loss to use.", + "choices": ["kto", "apo_zero_unpaired"], + }, + ) + beta: float = field( + default=0.1, + metadata={ + "help": "Parameter controlling the deviation from the reference model. Higher β means less deviation from " + "the reference model." + }, + ) + desirable_weight: float = field( + default=1.0, + metadata={ + "help": "Desirable losses are weighed by this factor to counter unequal number of desirable and " + "undesirable pairs.", + }, + ) + undesirable_weight: float = field( + default=1.0, + metadata={ + "help": "Undesirable losses are weighed by this factor to counter unequal number of desirable and " + "undesirable pairs.", + }, + ) + activation_offloading: bool = field( + default=False, + metadata={"help": "Whether to offload the activations to the CPU."}, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/kto/kto_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/kto/kto_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..1b6630db48df38ea89eee60c882c569e3c979ac1 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/kto/kto_trainer.py @@ -0,0 +1,1470 @@ +# Copyright 2020-2026 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 contextlib +import os +import textwrap +from collections import defaultdict +from collections.abc import Callable +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import torch +import transformers +from accelerate import PartialState, logging +from accelerate.utils import is_peft_model, tqdm +from datasets import Dataset, IterableDataset, IterableDatasetDict, concatenate_datasets +from datasets.fingerprint import Hasher +from packaging.version import Version +from torch.nn import functional as F +from torch.utils.data import DataLoader, SequentialSampler +from transformers import ( + AutoProcessor, + DataCollator, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, +) +from transformers.data.data_collator import DataCollatorMixin +from transformers.trainer_utils import EvalLoopOutput, has_length +from transformers.utils import is_peft_available + +from ...data_utils import ( + apply_chat_template, + extract_prompt, + is_conversational, + prepare_multimodal_messages, + unpair_preference_dataset, +) +from ...import_utils import is_liger_kernel_available +from ...models import get_act_offloading_ctx_manager +from ...models.utils import disable_gradient_checkpointing, prepare_deepspeed, prepare_fsdp +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import ( + create_model_from_path, + disable_dropout_in_model, + flush_left, + get_config_model_id, + hash_module, + pad, + selective_log_softmax, + use_adapter, +) +from .kto_config import KTOConfig + + +if is_liger_kernel_available(): + from liger_kernel.chunked_loss import LigerFusedLinearKTOLoss + +if is_peft_available(): + import peft + from peft import LoraConfig, PeftConfig, PeftModel, get_peft_model + + +logger = logging.get_logger(__name__) + +RUNNING_NAME = "running.pt" + + +def get_dataset_column_names(dataset: Dataset | IterableDataset) -> list[str]: + return list(next(iter(dataset)).keys()) if dataset.column_names is None else dataset.column_names + + +def _get_kl_completion_ids(batch: dict[str, list[Any]]) -> dict[str, list[Any]]: + """ + Creates mismatched pairs of prompts and completions for the KL dataset by adding a +1 offset to the order of + completions. For best results, the mismatched outputs y' used to estimate the KL term for a batch should be the + same set as the matched outputs y used to estimate the rewards in that batch, just paired with different x. + """ + batch["completion_ids"] = [batch["completion_ids"][-1]] + batch["completion_ids"][:-1] + return batch + + +@dataclass +class DataCollatorForUnpairedPreference(DataCollatorMixin): + """ + Data collator for unpaired preference data. Assembles completions from raw token IDs and pads sequences to the + maximum length of the batch. + + Each example is expected to contain `"prompt_ids"`, `"completion_ids"` (and optionally `"KL_completion_ids"`) keys. + The collator returns a dictionary with the following keys for each prefix (`"completion"` and, if present, + `"KL_completion"`): + - `"{prefix}_input_ids"`: full prompt + completion token IDs, padded to the batch maximum length. + - `"{prefix}_attention_mask"`: attention mask, padded with 0s. + - `"{prefix}_mask"`: binary mask where 1 marks completion tokens and 0 marks prompt or padding tokens. + + Args: + pad_token_id (`int`): + Token ID to use for padding `input_ids` sequences. + max_length (`int`, *optional*): + Maximum sequence length after assembly. Sequences longer than `max_length` are truncated from the end. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + return_tensors (`str`, *optional*, defaults to `"pt"`): + The tensor type to return. Currently, only `"pt"` (PyTorch tensors) is supported. + """ + + pad_token_id: int + max_length: int | None = None + pad_to_multiple_of: int | None = None + return_tensors: str = "pt" + + def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]: + batch = {} + for prefix, ids_key in [("completion", "completion_ids"), ("KL_completion", "KL_completion_ids")]: + if ids_key not in examples[0]: + continue + + full_ids_list = [] + completion_mask_list = [] + for ex in examples: + prompt_ids = ex["prompt_ids"] + answer_ids = ex[ids_key] + full_ids = prompt_ids + answer_ids + completion_mask = [0] * len(prompt_ids) + [1] * len(answer_ids) + if self.max_length is not None: + full_ids = full_ids[: self.max_length] + completion_mask = completion_mask[: self.max_length] + full_ids_list.append(full_ids) + completion_mask_list.append(completion_mask) + + batch[f"{prefix}_input_ids"] = pad( + [torch.tensor(ids, dtype=torch.int64) for ids in full_ids_list], + padding_value=self.pad_token_id, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + batch[f"{prefix}_attention_mask"] = pad( + [torch.ones(len(ids), dtype=torch.int64) for ids in full_ids_list], + padding_value=0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + batch[f"{prefix}_mask"] = pad( + [torch.tensor(m, dtype=torch.int64) for m in completion_mask_list], + padding_value=0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + + if "ref_logps" in examples[0]: + batch["ref_logps"] = torch.tensor([ex["ref_logps"] for ex in examples]) + if "ref_KL_logps" in examples[0]: + batch["ref_KL_logps"] = torch.tensor([ex["ref_KL_logps"] for ex in examples]) + batch["label"] = [ex["label"] for ex in examples] + return batch + + +@dataclass +class DataCollatorForVisionUnpairedPreference(DataCollatorMixin): + """ + Data collator for vision unpaired preference data. Performs tokenization and image processing on-the-fly. + + Unlike the text-only [`DataCollatorForUnpairedPreference`], this collator does not expect pre-tokenized inputs. + Instead, it takes raw examples with `"prompt"`, `"completion"`, and `"images"` (or `"image"`) keys and processes + them at collation time. When `calculate_kl` is `True`, the collator also produces KL sequences by cycling + completions within the batch — the same mismatching strategy as the text-only path, but done here rather than as a + dataset pre-processing step. + + Each input example should contain at least: + - A `"prompt"` key with either a plain text string or a list of message dicts. + - A `"completion"` key with a plain text string or a list of message dicts. + - An `"images"` key holding a list of images, or an `"image"` key holding a single image. + - A `"label"` key (`bool`) indicating whether the completion is desirable. + + The collator outputs: + - `"completion_input_ids"`, `"completion_attention_mask"`, `"completion_mask"`: full prompt+completion sequence. + - `"pixel_values"` and any additional processor outputs (e.g., `"image_grid_thw"`). + - `"label"`: list of booleans. + - When `calculate_kl=True`: `"KL_completion_input_ids"`, `"KL_completion_attention_mask"`, `"KL_completion_mask"` + for the cycled KL sequences. + + Args: + processor ([`~transformers.ProcessorMixin`]): + The processor used to tokenize text and process images. + max_length (`int`, *optional*): + Maximum sequence length. Sequences longer than `max_length` are truncated. + calculate_kl (`bool`, *optional*, defaults to `True`): + Whether to produce KL sequences by cycling completions within the batch. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + return_tensors (`str`, *optional*, defaults to `"pt"`): + The tensor type to return. Only `"pt"` is supported. + """ + + processor: ProcessorMixin + max_length: int | None = None + calculate_kl: bool = True + pad_to_multiple_of: int | None = None + return_tensors: str = "pt" + + def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]: + if self.pad_to_multiple_of is not None: + raise NotImplementedError( + "Padding to a multiple of a value is not yet implemented for vision-language modeling and " + "prompt-completion data." + ) + if "image" in examples[0]: + for example in examples: + example["images"] = [example.pop("image")] + images = [example["images"] for example in examples] + # Transformers requires at least one image in the batch, otherwise it throws an error + if all(img_list == [] for img_list in images): + images = None + if is_conversational(examples[0]): # conversational case + for example in examples: + example["prompt"] = prepare_multimodal_messages(example["prompt"], images=example["images"]) + example["completion"] = prepare_multimodal_messages(example["completion"]) + examples = [apply_chat_template(example, self.processor) for example in examples] + + prompts = [example["prompt"] for example in examples] + completions = [example["completion"] for example in examples] + + processed_prompts = self.processor( + images=images, + text=prompts, + padding=True, + padding_side="left", + return_tensors=self.return_tensors, + add_special_tokens=False, # to avoid adding the BOS twice, see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens + ) + processed_completions = self.processor( + text=completions, + padding=True, + padding_side="right", + return_tensors=self.return_tensors, + add_special_tokens=False, # to avoid adding the BOS twice, see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens + ) + + # Concatenate prompts and completions + prompt_ids, prompt_mask = processed_prompts["input_ids"], processed_prompts["attention_mask"] + completion_ids, completion_mask = processed_completions["input_ids"], processed_completions["attention_mask"] + input_ids = torch.cat((prompt_ids, completion_ids), dim=1) + attention_mask = torch.cat((prompt_mask, completion_mask), dim=1) + completion_mask = torch.cat((torch.zeros_like(prompt_mask), completion_mask), dim=1) + + has_tti = "token_type_ids" in processed_prompts + has_mm_tti = "mm_token_type_ids" in processed_prompts + + if has_tti: # special case for Gemma + prompt_token_type_ids = processed_prompts["token_type_ids"] + completion_token_type_ids = processed_completions["token_type_ids"] + token_type_ids = torch.cat((prompt_token_type_ids, completion_token_type_ids), dim=1) + if has_mm_tti: # special case for Qwen2.5-VL + prompt_mm_token_type_ids = processed_prompts["mm_token_type_ids"] + completion_mm_token_type_ids = processed_completions.get( + "mm_token_type_ids", torch.zeros_like(completion_ids) + ) + mm_token_type_ids = torch.cat((prompt_mm_token_type_ids, completion_mm_token_type_ids), dim=1) + + # Flush left to reduce padding + if has_tti and has_mm_tti: + attention_mask, input_ids, completion_mask, token_type_ids, mm_token_type_ids = flush_left( + attention_mask, input_ids, completion_mask, token_type_ids, mm_token_type_ids + ) + elif has_tti: + attention_mask, input_ids, completion_mask, token_type_ids = flush_left( + attention_mask, input_ids, completion_mask, token_type_ids + ) + elif has_mm_tti: + attention_mask, input_ids, completion_mask, mm_token_type_ids = flush_left( + attention_mask, input_ids, completion_mask, mm_token_type_ids + ) + else: + attention_mask, input_ids, completion_mask = flush_left(attention_mask, input_ids, completion_mask) + + # Truncate if necessary + if self.max_length is not None: + input_ids = input_ids[:, : self.max_length] + attention_mask = attention_mask[:, : self.max_length] + completion_mask = completion_mask[:, : self.max_length] + if has_tti: + token_type_ids = token_type_ids[:, : self.max_length] + if has_mm_tti: + mm_token_type_ids = mm_token_type_ids[:, : self.max_length] + + # Build the output dictionary + output = processed_prompts # we take processed_prompts because it contains the images + output.pop("input_ids", None) + output.pop("attention_mask", None) + output["completion_input_ids"] = input_ids + output["completion_attention_mask"] = attention_mask + output["completion_mask"] = completion_mask + if has_tti: + output["token_type_ids"] = token_type_ids + if has_mm_tti: + output["mm_token_type_ids"] = mm_token_type_ids + + if self.calculate_kl: + # Cycle completions by +1 within the batch to create mismatched KL pairs — same strategy as + # _get_kl_completion_ids in the text-only path, but done here to keep the VLM dataset fully raw. + kl_completions = completions[-1:] + completions[:-1] + processed_kl = self.processor( + text=kl_completions, + padding=True, + padding_side="right", + return_tensors=self.return_tensors, + add_special_tokens=False, # to avoid adding the BOS twice, see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens + ) + kl_ids = processed_kl["input_ids"] + kl_mask = processed_kl["attention_mask"] + + kl_input_ids = torch.cat((prompt_ids, kl_ids), dim=1) + kl_attention_mask = torch.cat((prompt_mask, kl_mask), dim=1) + kl_completion_mask = torch.cat((torch.zeros_like(prompt_mask), kl_mask), dim=1) + + # Build KL token-type tensors using the original (pre-flush) prompt tensors + if has_tti: + kl_completion_token_type_ids = processed_kl.get("token_type_ids", torch.zeros_like(kl_ids)) + kl_token_type_ids = torch.cat((prompt_token_type_ids, kl_completion_token_type_ids), dim=1) + if has_mm_tti: + kl_completion_mm_token_type_ids = processed_kl.get("mm_token_type_ids", torch.zeros_like(kl_ids)) + kl_mm_token_type_ids = torch.cat((prompt_mm_token_type_ids, kl_completion_mm_token_type_ids), dim=1) + + if has_tti and has_mm_tti: + kl_attention_mask, kl_input_ids, kl_completion_mask, kl_token_type_ids, kl_mm_token_type_ids = ( + flush_left( + kl_attention_mask, kl_input_ids, kl_completion_mask, kl_token_type_ids, kl_mm_token_type_ids + ) + ) + elif has_tti: + kl_attention_mask, kl_input_ids, kl_completion_mask, kl_token_type_ids = flush_left( + kl_attention_mask, kl_input_ids, kl_completion_mask, kl_token_type_ids + ) + elif has_mm_tti: + kl_attention_mask, kl_input_ids, kl_completion_mask, kl_mm_token_type_ids = flush_left( + kl_attention_mask, kl_input_ids, kl_completion_mask, kl_mm_token_type_ids + ) + else: + kl_attention_mask, kl_input_ids, kl_completion_mask = flush_left( + kl_attention_mask, kl_input_ids, kl_completion_mask + ) + + # Truncate if necessary + if self.max_length is not None: + kl_input_ids = kl_input_ids[:, : self.max_length] + kl_attention_mask = kl_attention_mask[:, : self.max_length] + kl_completion_mask = kl_completion_mask[:, : self.max_length] + if has_tti: + kl_token_type_ids = kl_token_type_ids[:, : self.max_length] + if has_mm_tti: + kl_mm_token_type_ids = kl_mm_token_type_ids[:, : self.max_length] + + output["KL_completion_input_ids"] = kl_input_ids + output["KL_completion_attention_mask"] = kl_attention_mask + output["KL_completion_mask"] = kl_completion_mask + if has_tti: + output["KL_completion_token_type_ids"] = kl_token_type_ids + if has_mm_tti: + output["KL_completion_mm_token_type_ids"] = kl_mm_token_type_ids + + output["label"] = [ex["label"] for ex in examples] + return output + + +class KTOTrainer(_BaseTrainer): + """ + Initialize KTOTrainer. + + Args: + model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]): + Model to be trained. Can be either: + + - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using `.from_pretrained` (where `` is derived from the model + config) with the keyword arguments in `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported. + - A [`~peft.PeftModel`] object. Only causal language models are supported. + ref_model ([`~transformers.PreTrainedModel`], *optional*): + Reference model used to compute the reference log probabilities. + + - If provided, this model is used directly as the reference policy. + - If `None`, the trainer will automatically use the initial policy corresponding to `model`, i.e. the model + state before KTO training starts. + args ([`experimental.kto.KTOConfig`], *optional*): + Configuration for this trainer. If `None`, a default configuration is used. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + The dataset to use for training. + eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`): + The dataset to use for evaluation. + processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. The padding side must be set to "left". If `None`, the + processing class is loaded from the model's name with [`~transformers.AutoProcessor.from_pretrained`]. A + padding token, `tokenizer.pad_token`, must be set. If the processing class has not set a padding token, + `tokenizer.eos_token` will be used as the default. + data_collator ([`~transformers.DataCollator`], *optional*): + The data collator to use for training. If None is specified, the default data collator + ([`~experimental.kto.kto_trainer.DataCollatorForUnpairedPreference`]) will be used which will pad the + sequences to the maximum length of the sequences in the batch. + callbacks (`list[transformers.TrainerCallback]`): + The callbacks to use for training. + optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): + The optimizer and scheduler to use for training. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration used to wrap the model. If `None`, the model is not wrapped. + compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*): + The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to + metric values. + """ + + _tag_names = ["trl", "kto"] + _name = "KTO" + _paper = { + "title": "KTO: Model Alignment as Prospect Theoretic Optimization", + "id": "2402.01306", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @article{ethayarajh2024kto, + title = {{KTO: Model Alignment as Prospect Theoretic Optimization}}, + author = {Kawin Ethayarajh and Winnie Xu and Niklas Muennighoff and Dan Jurafsky and Douwe Kiela}, + year = 2024, + eprint = {arXiv:2402.01306}, + }"""), + } + + def __init__( + self, + model: "str | PreTrainedModel | PeftModel", + ref_model: PreTrainedModel | None = None, + args: KTOConfig | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + data_collator: DataCollator | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + peft_config: "PeftConfig | None" = None, + compute_metrics: Callable[[EvalLoopOutput], dict] | None = None, + ): + # Args + if args is None: + model_name = model if isinstance(model, str) else get_config_model_id(model.config) + model_name = model_name.split("/")[-1] + args = KTOConfig(f"{model_name}-KTO") + + if train_dataset is None: + raise ValueError("`train_dataset` is required") + elif isinstance(train_dataset, IterableDataset): + # IterableDataset requires dispatch_batches=False because Accelerate's dispatch mode may try to concatenate + # batches from multiple processes, leading to mismatch errors. + if args.accelerator_config.dispatch_batches is True: + logger.warning( + "You are using an `IterableDataset` for training with `dispatch_batches=True`. `dispatch_batches` " + "is forced to `False` when using an `IterableDataset`. To remove this warning, unset " + "`dispatch_batches` in `KTOConfig` or set it to `False`." + ) + args.accelerator_config.dispatch_batches = False + + # Model + if isinstance(model, str): + model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + model = create_model_from_path(model, **model_init_kwargs) + else: + if args.model_init_kwargs is not None: + logger.warning( + "You passed `model_init_kwargs` to the KTOConfig, but your model is already instantiated. " + "The `model_init_kwargs` will be ignored." + ) + # Non-quantized models do not have the `is_loaded_in_{8,4}bit` attributes, whereas quantized models do + _is_quantized_model = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False) + if ref_model is model: + raise ValueError( + "`model` and `ref_model` cannot be the same object. In most cases you should omit `ref_model` and " + "we'll initialize it to a copy of `model` for you." + ) + + # Processing class + if processing_class is None: + processing_class = AutoProcessor.from_pretrained( + get_config_model_id(model.config), trust_remote_code=args.trust_remote_code + ) + if isinstance(processing_class, ProcessorMixin): + self._tokenizer = processing_class.tokenizer + self._is_vlm = True + elif isinstance(processing_class, PreTrainedTokenizerBase): + self._tokenizer = processing_class + self._is_vlm = False + else: + raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`") + if self._tokenizer.pad_token is None: + self._tokenizer.pad_token = self._tokenizer.eos_token + + # PEFT + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge " + "and unload the existing adapter, save the resulting base model, and then pass that base model along " + "with the new `peft_config` to the trainer." + ) + # Create PEFT model + # ZeRO-3 + PEFT for non-quantized models: + # - PEFT's default autocast_adapter_dtype=True upcasts LoRA adapter params to fp32 even when the base model is bf16. + # - ZeRO-3's _allgather_params_coalesced allocates output buffers using the dtype of the first persistent parameter, + # so mixed-dtype persistent_parameters (bf16 base + fp32 LoRA) cause a TypeError on the first optimizer step. + # - Passing autocast_adapter_dtype=False keeps adapter params in the base model dtype (bf16), fixing the mismatch. + # - This is safe: the fp32 upcast is a QLoRA-specific concern (low-bit quantized base models), not needed for + # non-quantized bf16 training. + # - See: + # - TRL issue: https://github.com/huggingface/trl/issues/6089 + # - Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/8072 + # - autocast_adapter_dtype was introduced in PEFT 0.12.0; before, no upcast existed: no need to pass the kwarg + get_peft_model_kwargs = {} + if ( + args.deepspeed_plugin is not None + and args.deepspeed_plugin.zero_stage == 3 + and not _is_quantized_model + and Version(peft.__version__) >= Version("0.12.0") + ): + get_peft_model_kwargs["autocast_adapter_dtype"] = False + model = get_peft_model(model, peft_config, **get_peft_model_kwargs) + + elif is_peft_model(model) and ref_model is None: + # If the model is a PEFT model with a pretrained adapter, we need to create a "ref" adapter that is a copy + # of the "default" adapter, so that we can use it as the reference model during KTO training. PEFT only + # supports one adapter per model when the LoRA config uses `target_parameters` (see peft#3340), so in that + # case we skip the "ref" adapter and compute the reference log probs with adapters disabled, i.e. with the + # base model. + default_config = model.peft_config["default"] + if isinstance(default_config, LoraConfig) and default_config.target_parameters: + logger.warning( + "PEFT can't add a frozen reference adapter alongside one that uses `target_parameters` " + "(peft#3340), so the reference log probs are computed from the base model (adapters disabled). " + "If you wrapped the model only to apply LoRA, pass a `peft_config` to the trainer instead; if you " + "wrapped it deliberately (pretrained adapter or custom init), note that the base model matches " + "your adapter only when it's freshly zero-initialized. If it is, this warning is safe to ignore." + ) + else: + model.add_adapter("ref", default_config) + for name, param in model.named_parameters(): + if ".default." in name: + ref_name = name.replace(".default.", ".ref.") + ref_param = model.get_parameter(ref_name) + ref_param.data.copy_(param.data) + + # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally + # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489 + if is_peft_model(model) and args.gradient_checkpointing: + model.enable_input_require_grads() + + # When using QLoRA, the PEFT adapter weights are converted to bf16 to follow the recommendations from the + # original paper (see https://huggingface.co/papers/2305.14314, paragraph 3). Normally, this can be done by + # passing `autocast_adapter_dtype=False` to `get_peft_model`, but this option is not yet supported for + # quantized models. See: https://github.com/huggingface/peft/issues/2889 + if _is_quantized_model: + for param in model.parameters(): + if param.requires_grad: + param.data = param.data.to(torch.bfloat16) + + # Vision dataset detection + dataset_sample = next(iter(train_dataset)) + self._is_vision_dataset = "image" in dataset_sample or "images" in dataset_sample + if self._is_vision_dataset and not self._is_vlm: + raise ValueError( + "The dataset appears to be vision-related (contains 'image' or 'images' keys), but the provided " + "model does not seem to be a vision-language model. Please check your model and dataset." + ) + if self._is_vision_dataset and args.precompute_ref_log_probs: + raise ValueError( + "`precompute_ref_log_probs=True` is not supported for vision datasets. For vision-language " + "models, all data processing is performed on the fly rather than upfront. " + "Set `precompute_ref_log_probs=False`." + ) + if self._is_vision_dataset and ("chosen" in dataset_sample or "rejected" in dataset_sample): + raise ValueError( + "Vision datasets must be in unpaired format with `completion` and `label` columns. " + "Paired format (`chosen`/`rejected`) is not supported for vision datasets because " + "iterating over the full dataset to unpair it would be too expensive for large image " + "collections. Unpair your dataset first: `dataset = unpair_preference_dataset(dataset)`." + ) + + # Data collator + calculate_kl = args.loss_type not in ["apo_zero_unpaired"] + if data_collator is None and not self._is_vision_dataset: + data_collator = DataCollatorForUnpairedPreference( + pad_token_id=self._tokenizer.pad_token_id, + max_length=args.max_length, + pad_to_multiple_of=args.pad_to_multiple_of, + ) + elif data_collator is None and self._is_vision_dataset: + data_collator = DataCollatorForVisionUnpairedPreference( + processor=processing_class, + max_length=args.max_length, + calculate_kl=calculate_kl, + pad_to_multiple_of=args.pad_to_multiple_of, + ) + + # Training arguments + self.beta = args.beta + self.precompute_ref_logps = args.precompute_ref_log_probs + self.loss_type = args.loss_type + self.desirable_weight = args.desirable_weight + self.undesirable_weight = args.undesirable_weight + self.aux_loss_enabled = getattr(model.config, "output_router_logits", False) + self.aux_loss_coef = getattr(model.config, "router_aux_loss_coef", 0.0) + self.calculate_KL = calculate_kl + if self.calculate_KL and args.train_sampling_strategy != "sequential": + raise ValueError( + f"Loss type `'{args.loss_type}'` estimates the KL divergence term and requires " + f"`train_sampling_strategy='sequential'` because the KL completion for each example is precomputed " + f"against its neighbors in a fixed-order batch; any other strategy breaks that pairing. " + f"Got `train_sampling_strategy='{args.train_sampling_strategy}'`." + ) + if self.calculate_KL and args.per_device_train_batch_size <= 1: + raise ValueError( + "Actual (not effective) batch size must be > 1. KTO will not work properly because the KL term will be equivalent to the implied reward." + ) + if self.aux_loss_enabled and self.aux_loss_coef == 0.0: + logger.warning( + "You set `output_router_logits` to `True` in the model config, but `router_aux_loss_coef` is set to " + "`0.0`, meaning the auxiliary loss will not be used. Either set `router_aux_loss_coef` to a value " + "greater than `0.0`, or set `output_router_logits` to `False` if you don't want to use the auxiliary " + "loss.", + ) + + # Dataset + # Skip dataset preparation for VLMs: tokenization and image processing happen on-the-fly in the collator. + if not self._is_vision_dataset: + train_dataset = self._prepare_dataset(train_dataset, processing_class, args, "train") + if eval_dataset is not None: + if isinstance(eval_dataset, dict): + eval_dataset = { + key: self._prepare_dataset(dataset, processing_class, args, key) + for key, dataset in eval_dataset.items() + } + else: + eval_dataset = self._prepare_dataset(eval_dataset, processing_class, args, "eval") + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + ) + + # Initialize activation offloading context + if self.args.activation_offloading: + self.maybe_activation_offload_context = get_act_offloading_ctx_manager(model=self.model) + else: + self.maybe_activation_offload_context = contextlib.nullcontext() + + # Reference model + if ref_model is None: + if is_peft_model(self.model) or args.precompute_ref_log_probs: + # If PEFT is used, the reference model is not needed since the adapter can be disabled to revert to the + # initial model. If precompute_ref_log_probs is True, the reference model does not need to be kept in + # memory during training. + self.ref_model = None + else: + ref_model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if self.args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + ref_model_init_kwargs["device_map"] = None + ref_model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + ref_model_path = get_config_model_id(self.model.config) + self.ref_model = create_model_from_path(ref_model_path, **ref_model_init_kwargs) + else: + self.ref_model = ref_model + + # Disable dropout in the model and reference model + if args.disable_dropout: + disable_dropout_in_model(model) + if self.ref_model is not None: + disable_dropout_in_model(self.ref_model) + + # Initialize the metrics + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + + # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the + # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set + # self.model_accepts_loss_kwargs to False to enable scaling. + self.model_accepts_loss_kwargs = False + + # Add tags to the model + self.model.add_model_tags(self._tag_names) + + if self.ref_model is not None: + if self.is_deepspeed_enabled: + self.ref_model = prepare_deepspeed(self.ref_model, self.accelerator) + elif self.is_fsdp_enabled: + self.ref_model = prepare_fsdp(self.ref_model, self.accelerator) + else: + self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True) + + self.use_liger_kernel = args.use_liger_kernel + # Import Liger kernel if enabled + if self.use_liger_kernel: + if not is_liger_kernel_available(): + raise ImportError( + "You set `use_liger_kernel=True` but the liger kernel is not available. " + "Please install liger-kernel first: `pip install liger-kernel`" + ) + if self.loss_type in ["apo_zero_unpaired"]: + raise ValueError( + "You cannot set `loss_type='apo_zero_unpaired'` with liger-kernel." + "Only KTO loss is supported with liger-kernel." + ) + if self.precompute_ref_logps: + raise ValueError( + "You cannot use `precompute_ref_log_probs=True` with liger kernel. Please set " + "`precompute_ref_log_probs=False`." + ) + if is_peft_model(self.model): + raise ValueError( + "You cannot use `use_liger_kernel=True` with Peft models. Please set `use_liger_kernel=False`." + ) + self.liger_loss_fn = LigerFusedLinearKTOLoss(beta=self.beta, use_ref_model=(self.ref_model is not None)) + + if self.precompute_ref_logps: + if isinstance(self.train_dataset, IterableDataset) or isinstance( + self.eval_dataset, (IterableDataset, IterableDatasetDict) + ): + raise ValueError( + "`precompute_ref_log_probs=True` is not supported with IterableDataset. Please use a map-style " + "Dataset or set `precompute_ref_log_probs=False`." + ) + self.train_dataset = self._precompute_ref_logps( + self.train_dataset, + "train", + self.args.precompute_ref_batch_size or self.args.per_device_train_batch_size, + ) + if self.eval_dataset is not None: + if isinstance(self.eval_dataset, dict): + self.eval_dataset = { + name: self._precompute_ref_logps( + dataset, name, self.args.precompute_ref_batch_size or self.args.per_device_eval_batch_size + ) + for name, dataset in self.eval_dataset.items() + } + else: + self.eval_dataset = self._precompute_ref_logps( + self.eval_dataset, + "eval", + self.args.precompute_ref_batch_size or self.args.per_device_eval_batch_size, + ) + + def _tokenize( + self, + processing_class: PreTrainedTokenizerBase | ProcessorMixin, + input: str | list, + **kwargs, + ) -> dict[str, list]: + """Tokenize a single example for dataset preprocessing. + + Dispatches to `apply_chat_template` for conversational input (list of message dicts) and to `__call__` for + non-conversational input (str). + + Args: + processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`]): + The tokenizer or processor to use. + input (`str` or `list`): + A string for non-conversational input, or a list of message dicts for conversational input. + **kwargs: + Forwarded to `apply_chat_template` (e.g. `add_generation_prompt`, `return_assistant_tokens_mask`). + + Returns: + `dict` with at least an `"input_ids"` key mapping to a flat `list[int]`. + """ + if isinstance(input, list): # conversational: list of message dicts + if self._is_vlm: + input = prepare_multimodal_messages(input) + result = processing_class.apply_chat_template(input, tokenize=True, return_dict=True, **kwargs) + else: # non-conversational: plain text string + result = processing_class(text=input) + # VLMs emit a batch dimension even for single examples; unwrap it + if self._is_vlm: + return {k: v[0] for k, v in result.items()} + return result + + def _get_kl_dataset( + self, + dataset: Dataset | IterableDataset, + dataset_name: str, + args: KTOConfig, + ) -> Dataset | IterableDataset: + """ + Creates the KL dataset by creating mismatched (prompt, completion) pairs for KL divergence estimation. + + Args: + dataset (`Dataset` or `IterableDataset`): + Tokenized dataset with `prompt_ids` and `completion_ids` columns. + dataset_name (`str`): + Name used in progress bar descriptions. + args ([`KTOConfig`]): + Training arguments providing `per_device_train_batch_size` and `dataset_num_proc`. + + Returns: + `Dataset` or `IterableDataset` with a single `KL_completion_ids` column. + """ + map_kwargs = {} + if isinstance(dataset, Dataset): # IterableDataset does not support num_proc or desc + map_kwargs["num_proc"] = args.dataset_num_proc + map_kwargs["desc"] = f"Extracting KL {dataset_name} dataset" + kl_dataset = dataset.map( + _get_kl_completion_ids, batched=True, batch_size=args.per_device_train_batch_size, **map_kwargs + ) + + def rename_kl_fn(example): + return {"KL_completion_ids": example["completion_ids"]} + + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Assembling KL {dataset_name} dataset" + column_names = get_dataset_column_names(dataset) + kl_dataset = kl_dataset.map( + rename_kl_fn, + remove_columns=[c for c in get_dataset_column_names(kl_dataset) if c in column_names], + **map_kwargs, + ) + return kl_dataset + + def _prepare_dataset( + self, + dataset: Dataset | IterableDataset, + processing_class: PreTrainedTokenizerBase | ProcessorMixin, + args: KTOConfig | None, + dataset_name: str, + ) -> Dataset | IterableDataset: + # Build the kwargs for the `map` function + map_kwargs = {} + if isinstance(dataset, Dataset): # IterableDataset does not support num_proc + map_kwargs["num_proc"] = args.dataset_num_proc + + # Compute that only on the main process for faster data processing. + # see: https://github.com/huggingface/trl/pull/1255 + with PartialState().main_process_first(): + # Extract the prompt if needed + first_example = next(iter(dataset)) + if "prompt" not in first_example: + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Extracting prompt from {dataset_name} dataset" + dataset = dataset.map(extract_prompt, **map_kwargs) + + # Unpair the dataset if needed + first_example = next(iter(dataset)) + if "chosen" in first_example and "rejected" in first_example: + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Unpairing {dataset_name} dataset" + dataset = unpair_preference_dataset(dataset, **map_kwargs) + + # Add EOS token if needed: non-conversational only + first_example = next(iter(dataset)) + if not is_conversational(first_example): + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Adding EOS to {dataset_name} dataset" + + def add_eos(example, eos_token): + if not example["completion"].endswith(eos_token): + example["completion"] = example["completion"] + eos_token + return example + + dataset = dataset.map(add_eos, fn_kwargs={"eos_token": self._tokenizer.eos_token}, **map_kwargs) + + # Tokenize dataset + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset" + + def tokenize_fn(example, processing_class): + if is_conversational(example): + chat_template_kwargs = example.get("chat_template_kwargs", {}) + prompt_ids = self._tokenize( + processing_class, + example["prompt"], + add_generation_prompt=True, + **chat_template_kwargs, + )["input_ids"] + prompt_completion_ids = self._tokenize( + processing_class, + example["prompt"] + example["completion"], + **chat_template_kwargs, + )["input_ids"] + else: + prompt_ids = self._tokenize(processing_class, example["prompt"])["input_ids"] + prompt_completion_ids = self._tokenize( + processing_class, example["prompt"] + example["completion"] + )["input_ids"] + + if not prompt_completion_ids[: len(prompt_ids)] == prompt_ids: + logger.warning( + "Mismatch between tokenized prompt and the start of tokenized prompt+completion. " + "This may be due to unexpected tokenizer behavior, whitespace issues, or special " + "token handling. Verify that the tokenizer is processing text consistently." + ) + + return { + "prompt_ids": prompt_ids, + "completion_ids": prompt_completion_ids[len(prompt_ids) :], + } + + dataset = dataset.map(tokenize_fn, fn_kwargs={"processing_class": processing_class}, **map_kwargs) + + # Get KL datasets if needed + if self.calculate_KL: + # create pairs for estimating the KL term by flipping the matched pairs in each batch of size total_batch_size + # i.e., (x_1, y_1), ..., (x_n, y_n) --> (x_1, y_n), ..., (x_n, y_1) = (x'_1, y'_1), ..., (x'_n, y'_n) + kl_dataset = self._get_kl_dataset(dataset, dataset_name, args) + dataset = concatenate_datasets([dataset, kl_dataset], axis=1) + + # Calculate dataset desirability balance + if dataset_name == "train" and isinstance(dataset, Dataset): # IterableDataset does not support len + num_desirable = max(sum(dataset["label"]), 1) + num_undesirable = max(len(dataset["label"]) - num_desirable, 1) # "label" is binary + + if num_desirable != num_undesirable: + # The lower and upper bounds come from Eq. (8) of https://huggingface.co/papers/2402.01306 + des_weight_lower_bound = round((num_undesirable * self.undesirable_weight / num_desirable) * 1, 2) + des_weight_upper_bound = round( + (num_undesirable * self.undesirable_weight / num_desirable) * 1.33, 2 + ) + und_weight_lower_bound = round((num_desirable * self.desirable_weight / num_undesirable) / 1.33, 2) + und_weight_upper_bound = round((num_desirable * self.desirable_weight / num_undesirable) / 1, 2) + + des_weight_in_range = des_weight_lower_bound <= self.desirable_weight <= des_weight_upper_bound + und_weight_in_range = und_weight_lower_bound <= self.undesirable_weight <= und_weight_upper_bound + + if not (des_weight_in_range or und_weight_in_range): + logger.warning( + "You have different amounts of desirable/positive and undesirable/negative examples but the " + "weights on the desirable and undesirable losses don't seem to be in an ideal range. Based " + f"on your data, we recommend EITHER " + f"desirable_weight in [{des_weight_lower_bound}, {des_weight_upper_bound}] or " + f"undesirable_weight in [{und_weight_lower_bound}, {und_weight_upper_bound}] (but NOT BOTH). " + "See the documentation on how to optimally set these weights.", + ) + return dataset + + def _set_signature_columns_if_needed(self): + # If `self.args.remove_unused_columns` is True, non-signature columns are removed. + # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids" + # and "attention_mask"). + if self._signature_columns is None: + if self._is_vision_dataset: + self._signature_columns = [ + "prompt", + "completion", + "image", + "images", + "label", + "chat_template_kwargs", + ] + else: + self._signature_columns = [ + "prompt_ids", + "completion_ids", + "KL_completion_ids", + "label", + "ref_logps", + "ref_KL_logps", + ] + + def _precompute_ref_logps(self, dataset: Dataset, name: str, batch_size: int) -> Dataset: + model_hash = hash_module(self.ref_model or self.model) + fingerprint = Hasher.hash((dataset._fingerprint, model_hash, self.calculate_KL)) + cache_file = dataset._get_cache_file_path(fingerprint) + if os.path.exists(cache_file): + return concatenate_datasets([dataset, Dataset.from_file(cache_file)], axis=1) + + dataloader = DataLoader( + dataset, + batch_size=batch_size, + collate_fn=self.data_collator, + num_workers=self.args.dataloader_num_workers, + pin_memory=self.args.dataloader_pin_memory, + shuffle=False, + ) + data_loader = self.accelerator.prepare(dataloader) + ref_logps = [] + ref_KL_logps = [] + for padded_batch in tqdm(iterable=data_loader, desc=f"Computing reference log probs for {name} dataset"): + ref_logp, ref_KL_logp = self.compute_ref_log_probs(padded_batch) + if self.calculate_KL: + ref_logp, ref_KL_logp = self.accelerator.gather_for_metrics((ref_logp, ref_KL_logp)) + ref_KL_logps.append(ref_KL_logp.cpu()) + else: + ref_logp = self.accelerator.gather_for_metrics(ref_logp) + ref_logps.append(ref_logp.cpu()) + + ref_logps = torch.cat(ref_logps) + if self.calculate_KL: + ref_KL_logps = torch.cat(ref_KL_logps) + + if self.accelerator.is_main_process: + + def add_ref_logps(batch, indices): + result = {"ref_logps": ref_logps[indices]} + if self.calculate_KL: + result.update({"ref_KL_logps": ref_KL_logps[indices]}) + return result + + dataset.map( + add_ref_logps, + with_indices=True, + batched=True, + remove_columns=dataset.column_names, + new_fingerprint=fingerprint, + desc=f"Caching reference log probs for {name} dataset", + ) + self.accelerator.wait_for_everyone() + + return concatenate_datasets([dataset, Dataset.from_file(cache_file)], axis=1) + + def compute_ref_log_probs(self, inputs): + """Computes reference log probabilities for a single padded batch.""" + with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs): + if self.ref_model is None: + if is_peft_model(self.model): + model = self.accelerator.unwrap_model(self.model) + with use_adapter(model, adapter_name="ref" if "ref" in model.peft_config else None): + completion_logits = self.model( + inputs["completion_input_ids"], + attention_mask=inputs["completion_attention_mask"], + ).logits + + if self.calculate_KL: + KL_logits = self.model( + inputs["KL_completion_input_ids"], + attention_mask=inputs["KL_completion_attention_mask"], + ).logits + else: + completion_logits = self.model( + inputs["completion_input_ids"], + attention_mask=inputs["completion_attention_mask"], + ).logits + + if self.calculate_KL: + KL_logits = self.model( + inputs["KL_completion_input_ids"], + attention_mask=inputs["KL_completion_attention_mask"], + ).logits + else: + completion_logits = self.ref_model( + inputs["completion_input_ids"], attention_mask=inputs["completion_attention_mask"] + ).logits + + if self.calculate_KL: + KL_logits = self.ref_model( + inputs["KL_completion_input_ids"], + attention_mask=inputs["KL_completion_attention_mask"], + ).logits + + shift_logits = completion_logits[:, :-1, :] + per_token_logps = selective_log_softmax(shift_logits, inputs["completion_input_ids"][:, 1:]) + per_token_logps[inputs["completion_mask"][:, 1:] == 0] = 0.0 + completion_logps = per_token_logps.sum(-1) + + if self.calculate_KL: + shift_KL_logits = KL_logits[:, :-1, :] + KL_per_token_logps = selective_log_softmax(shift_KL_logits, inputs["KL_completion_input_ids"][:, 1:]) + KL_per_token_logps[inputs["KL_completion_mask"][:, 1:] == 0] = 0.0 + KL_logps = KL_per_token_logps.sum(-1) + else: + KL_logps = None + + return completion_logps, KL_logps + + def _compute_kl_logps(self, model, batch): + """Compute KL log probabilities for a given batch.""" + KL_logps = None + if self.calculate_KL: + _non_model_keys = { + "completion_input_ids", + "completion_attention_mask", + "completion_mask", + "KL_completion_mask", + "KL_completion_token_type_ids", + "KL_completion_mm_token_type_ids", + "label", + "ref_logps", + "ref_KL_logps", + } + KL_model_kwargs = {k: v for k, v in batch.items() if k not in _non_model_keys} + KL_model_kwargs["input_ids"] = KL_model_kwargs.pop("KL_completion_input_ids") + KL_model_kwargs["attention_mask"] = KL_model_kwargs.pop("KL_completion_attention_mask") + # KL sequences have different widths from the main completion after flush_left; override token-type + # tensors with the KL-specific ones the collator built for exactly this purpose. + if "KL_completion_token_type_ids" in batch: + KL_model_kwargs["token_type_ids"] = batch["KL_completion_token_type_ids"] + if "KL_completion_mm_token_type_ids" in batch: + KL_model_kwargs["mm_token_type_ids"] = batch["KL_completion_mm_token_type_ids"] + + with torch.no_grad(): + KL_logits = model(**KL_model_kwargs).logits + + shift_KL_logits = KL_logits[:, :-1, :] + KL_per_token_logps = selective_log_softmax(shift_KL_logits, batch["KL_completion_input_ids"][:, 1:]) + KL_per_token_logps[batch["KL_completion_mask"][:, 1:] == 0] = 0.0 + KL_logps = KL_per_token_logps.sum(-1) + return KL_logps + + def _compute_loss_liger(self, model, inputs, return_outputs): + if return_outputs: + raise RuntimeError( + "return_outputs=True is not supported with the Liger KTO loss. The Liger loss computes the loss " + "without materializing logits, so outputs cannot be returned." + ) + mode = "train" if self.model.training else "eval" + batch = {k: (v.to(self.accelerator.device) if isinstance(v, torch.Tensor) else v) for k, v in inputs.items()} + + labels = torch.tensor(batch["label"]) + num_chosen = labels.sum().to(self.accelerator.device) + num_rejected = (len(labels) - num_chosen).to(self.accelerator.device) + + policy_KL_logps = self._compute_kl_logps(model, batch) + ref_KL_logps = self._compute_kl_logps(self.ref_model, batch) + if self.calculate_KL: + kl = (policy_KL_logps - ref_KL_logps).mean().detach() + kl = self.accelerator.gather_for_metrics(kl).mean().clamp(min=0) + else: + kl = torch.zeros(1).to(self.accelerator.device) + + _non_model_keys = { + "completion_mask", + "KL_completion_input_ids", + "KL_completion_attention_mask", + "KL_completion_mask", + "KL_completion_token_type_ids", + "KL_completion_mm_token_type_ids", + "label", + "ref_logps", + "ref_KL_logps", + } + model_kwargs = {k: v for k, v in batch.items() if k not in _non_model_keys} + model_kwargs["input_ids"] = model_kwargs.pop("completion_input_ids") + model_kwargs["attention_mask"] = model_kwargs.pop("completion_attention_mask") + model_kwargs["use_cache"] = False + if self.aux_loss_enabled: + model_kwargs["output_router_logits"] = True + + # `base_model` gives the inner module (skipping `lm_head`) — text decoder for LMs, multimodal wrapper for + # VLMs (so vision-token injection runs before the text decoder). `get_decoder()` won't do: on VLMs it + # returns just the text stack and feeds image-placeholder IDs through it. + # Pre-5.0 transformers VLMs set `base_model_prefix = ""` so `base_model is self` (re-runs `lm_head`). + # Fall back to `.model` there. + if self._is_vlm and Version(transformers.__version__) < Version("5.0.0"): + backbone, ref_backbone = model.model, self.ref_model.model + else: + backbone, ref_backbone = model.base_model, self.ref_model.base_model + + outputs = backbone(**model_kwargs) + + # reference model + with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs): + ref_outputs = ref_backbone(**{k: v for k, v in model_kwargs.items() if k != "output_router_logits"}) + lm_head = model.get_output_embeddings() + ref_lm_head = self.ref_model.get_output_embeddings() + + shift_completion_mask = batch["completion_mask"][:, 1:] + target = batch["completion_input_ids"][:, 1:].clone() + target[shift_completion_mask == 0] = -100 + + ( + loss, + ( + chosen_logps_sum, + rejected_logps_sum, + chosen_logits_sum, + rejected_logits_sum, + chosen_rewards_sum, + rejected_rewards_sum, + ), + ) = self.liger_loss_fn( + _input=outputs.last_hidden_state[:, :-1], + lin_weight=lm_head.weight, + target=target, + bias=lm_head.bias if hasattr(lm_head, "bias") else None, + preference_labels=torch.tensor(batch["label"], dtype=torch.bool).to(self.accelerator.device), + ref_input=ref_outputs.last_hidden_state[:, :-1], + ref_weight=ref_lm_head.weight, + ref_bias=ref_lm_head.bias if hasattr(lm_head, "bias") else None, + kl=kl, + ) + if self.aux_loss_enabled: + loss += self.aux_loss_coef * outputs.aux_loss + + self._metrics[mode]["kl"].append(kl.item()) + + all_num_chosen = self.accelerator.gather_for_metrics(num_chosen).sum().item() + all_num_rejected = self.accelerator.gather_for_metrics(num_rejected).sum().item() + + if all_num_chosen > 0: + self._metrics[mode]["rewards/chosen"].append( + self.accelerator.gather_for_metrics(chosen_rewards_sum.nansum()).nansum().item() / all_num_chosen + ) + self._metrics[mode]["logps/chosen"].append( + self.accelerator.gather_for_metrics(chosen_logps_sum.nansum()).nansum().item() / all_num_chosen + ) + self._metrics[mode]["logits/chosen"].append( + self.accelerator.gather_for_metrics(chosen_logits_sum.nansum()).nansum().item() / all_num_chosen + ) + + if all_num_rejected > 0: + self._metrics[mode]["rewards/rejected"].append( + self.accelerator.gather_for_metrics(rejected_rewards_sum.nansum()).nansum().item() / all_num_rejected + ) + self._metrics[mode]["logps/rejected"].append( + self.accelerator.gather_for_metrics(rejected_logps_sum.nansum()).nansum().item() / all_num_rejected + ) + self._metrics[mode]["logits/rejected"].append( + self.accelerator.gather_for_metrics(rejected_logits_sum.nansum()).nansum().item() / all_num_rejected + ) + + return loss + + def _compute_loss(self, model, inputs, return_outputs): + """Compute the KTO loss and other metrics for the given batch of inputs for train or test.""" + mode = "train" if self.model.training else "eval" + batch = {k: (v.to(self.accelerator.device) if isinstance(v, torch.Tensor) else v) for k, v in inputs.items()} + + labels = torch.tensor(batch["label"]) + num_chosen = labels.sum().to(self.accelerator.device) + num_rejected = (len(labels) - num_chosen).to(self.accelerator.device) + + policy_KL_logps = self._compute_kl_logps(model, batch) + + _non_model_keys = { + "completion_mask", + "KL_completion_input_ids", + "KL_completion_attention_mask", + "KL_completion_mask", + "KL_completion_token_type_ids", + "KL_completion_mm_token_type_ids", + "label", + "ref_logps", + "ref_KL_logps", + } + model_kwargs = {k: v for k, v in batch.items() if k not in _non_model_keys} + model_kwargs["input_ids"] = model_kwargs.pop("completion_input_ids") + model_kwargs["attention_mask"] = model_kwargs.pop("completion_attention_mask") + if self.aux_loss_enabled: + model_kwargs["output_router_logits"] = True + + outputs = model(**model_kwargs) + if self.aux_loss_enabled: + aux_loss = outputs.aux_loss + + shift_logits = outputs.logits[:, :-1, :] + per_token_logps = selective_log_softmax(shift_logits, batch["completion_input_ids"][:, 1:]) + per_token_logps[batch["completion_mask"][:, 1:] == 0] = 0.0 + completion_logps = per_token_logps.sum(-1) + + if completion_logps.shape[0] != len(batch["label"]): + raise ValueError( + "There is a mismatch between the number of examples in this batch and the number of " + "examples for which an output sequence was predicted." + ) + + device = outputs.logits.device + bool_labels = torch.as_tensor(batch["label"], dtype=torch.bool, device=device) + chosen_idx = torch.nonzero(bool_labels, as_tuple=False).view(-1) + rejected_idx = torch.nonzero(~bool_labels, as_tuple=False).view(-1) + + policy_chosen_logps = completion_logps.index_select(0, chosen_idx) + policy_rejected_logps = completion_logps.index_select(0, rejected_idx) + policy_chosen_logits = outputs.logits.index_select(0, chosen_idx) + policy_rejected_logits = outputs.logits.index_select(0, rejected_idx) + + if self.precompute_ref_logps: + ref_chosen_logps = batch["ref_logps"].index_select(0, chosen_idx) + ref_rejected_logps = batch["ref_logps"].index_select(0, rejected_idx) + if self.calculate_KL: + ref_KL_logps = batch["ref_KL_logps"] + else: + ref_KL_logps = None + else: + ref_model_kwargs = {k: v for k, v in model_kwargs.items() if k != "output_router_logits"} + with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs): + if is_peft_model(self.model) and self.ref_model is None: + ref_model_unwrapped = self.accelerator.unwrap_model(self.model) + with use_adapter( + ref_model_unwrapped, adapter_name="ref" if "ref" in ref_model_unwrapped.peft_config else None + ): + ref_KL_logps = self._compute_kl_logps(self.model, batch) + ref_outputs = self.model(**ref_model_kwargs) + else: + ref_KL_logps = self._compute_kl_logps(self.ref_model, batch) + ref_outputs = self.ref_model(**ref_model_kwargs) + ref_shift_logits = ref_outputs.logits[:, :-1, :] + ref_per_token_logps = selective_log_softmax(ref_shift_logits, batch["completion_input_ids"][:, 1:]) + ref_per_token_logps[batch["completion_mask"][:, 1:] == 0] = 0.0 + ref_completion_logps = ref_per_token_logps.sum(-1) + ref_chosen_logps = ref_completion_logps.index_select(0, chosen_idx) + ref_rejected_logps = ref_completion_logps.index_select(0, rejected_idx) + + if self.calculate_KL: + kl = (policy_KL_logps - ref_KL_logps).mean().detach() + kl = self.accelerator.gather_for_metrics(kl).mean().clamp(min=0) + else: + kl = torch.zeros(1).to(policy_chosen_logps.device) + # Chosen losses + if policy_chosen_logps.shape[0] != 0 or ref_chosen_logps.shape[0] != 0: + chosen_logratios = policy_chosen_logps - ref_chosen_logps + + if self.loss_type == "kto": + # Eqn (7) of the KTO paper (https://huggingface.co/papers/2402.01306) + chosen_losses = 1 - F.sigmoid(self.beta * (chosen_logratios - kl)) + elif self.loss_type == "apo_zero_unpaired": + # Unpaired variant of Eqn (7) of the APO paper (https://huggingface.co/papers/2408.06266) + # Use this loss when you believe the chosen outputs are better than your model's default output + chosen_losses = 1 - F.sigmoid(self.beta * chosen_logratios) + + chosen_rewards = self.beta * chosen_logratios.detach() + + else: + # lists can't be empty -- if they are, then accelerate.gather will hang + chosen_losses = torch.Tensor([]).to(self.accelerator.device) + chosen_rewards = torch.Tensor([]).to(self.accelerator.device) + # Rejected losses + if policy_rejected_logps.shape[0] != 0 or ref_rejected_logps.shape[0] != 0: + rejected_logratios = policy_rejected_logps - ref_rejected_logps + + if self.loss_type == "kto": + rejected_losses = 1 - F.sigmoid(self.beta * (kl - rejected_logratios)) + elif self.loss_type == "apo_zero_unpaired": + rejected_losses = F.sigmoid(self.beta * rejected_logratios) + + rejected_rewards = self.beta * rejected_logratios.detach() + else: + # lists can't be empty -- if they are, then accelerate.gather will hang + rejected_losses = torch.Tensor([]).to(self.accelerator.device) + rejected_rewards = torch.Tensor([]).to(self.accelerator.device) + losses = torch.cat( + (self.desirable_weight * chosen_losses, self.undesirable_weight * rejected_losses), + 0, + ) + + self._metrics[mode]["kl"].append(kl.item()) + + all_num_chosen = self.accelerator.gather_for_metrics(num_chosen).sum().item() + all_num_rejected = self.accelerator.gather_for_metrics(num_rejected).sum().item() + + if all_num_chosen > 0: + self._metrics[mode]["rewards/chosen"].append( + self.accelerator.gather_for_metrics(chosen_rewards.nansum()).nansum().item() / all_num_chosen + ) + self._metrics[mode]["logps/chosen"].append( + self.accelerator.gather_for_metrics(policy_chosen_logps.nansum()).nansum().item() / all_num_chosen + ) + self._metrics[mode]["logits/chosen"].append( + self.accelerator.gather_for_metrics(policy_chosen_logits.nansum()).nansum().item() / all_num_chosen + ) + + if all_num_rejected > 0: + self._metrics[mode]["rewards/rejected"].append( + self.accelerator.gather_for_metrics(rejected_rewards.nansum()).nansum().item() / all_num_rejected + ) + self._metrics[mode]["logps/rejected"].append( + self.accelerator.gather_for_metrics(policy_rejected_logps.nansum()).nansum().item() / all_num_rejected + ) + self._metrics[mode]["logits/rejected"].append( + self.accelerator.gather_for_metrics(policy_rejected_logits.nansum()).nansum().item() / all_num_rejected + ) + + loss = losses.nanmean() + if self.aux_loss_enabled: + loss += self.aux_loss_coef * aux_loss + + return (loss, outputs) if return_outputs else loss + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + try: + if self.use_liger_kernel: + return self._compute_loss_liger(model, inputs, return_outputs) + return self._compute_loss(model, inputs, return_outputs) + except ValueError as e: + if "Image features and image tokens do not match" in str(e) and self.args.max_length is not None: + raise ValueError( + f"The current `max_length` ({self.args.max_length}) is too short and causes image placeholder " + f"tokens in `input_ids` to be truncated, while the corresponding image features remain intact. " + f"Please increase `max_length` or set it to `None` to disable truncation." + ) from e + raise + + def _get_train_sampler(self, train_dataset: Dataset | None = None) -> torch.utils.data.Sampler | None: + if self.calculate_KL and Version(transformers.__version__) < Version("5.2.0"): + if train_dataset is None: + train_dataset = self.train_dataset + if train_dataset is None or not has_length(train_dataset): + return None + return SequentialSampler(train_dataset) + return super()._get_train_sampler(train_dataset) + + # During eval, Trainer calls prediction_step. If no labels are present in the inputs, it only runs forward and + # returns logits. We override prediction_step to force compute_loss, because this trainer doesn't involve labels. + def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys=None): + inputs = self._prepare_inputs(inputs) + with torch.no_grad(), self.compute_loss_context_manager(): + if prediction_loss_only: + loss = self.compute_loss(model, inputs, return_outputs=False) # logits aren't materialized with liger + logits, labels = None, None + else: + loss, outputs = self.compute_loss(model, inputs, return_outputs=True) + logits, labels = outputs.logits, inputs["completion_input_ids"] + return loss, logits, labels + + # Override training step to add activation offloading context. + def training_step(self, *args, **kwargs): + with self.maybe_activation_offload_context: + return super().training_step(*args, **kwargs) + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} # average the metrics + if "rewards/chosen" in metrics and "rewards/rejected" in metrics: + metrics["rewards/margins"] = metrics["rewards/chosen"] - metrics["rewards/rejected"] + # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs` + # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/merge_model_callback.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/merge_model_callback.py new file mode 100644 index 0000000000000000000000000000000000000000..2f8478759204105aa02eea715b884c755bfc9757 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/merge_model_callback.py @@ -0,0 +1,352 @@ +# Copyright 2020-2026 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 logging +import os + +import torch +from huggingface_hub import HfApi +from transformers import TrainerCallback + +from ..import_utils import is_mergekit_available +from ..trainer.utils import get_config_model_id + + +if is_mergekit_available(): + from mergekit.config import MergeConfiguration + from mergekit.merge import MergeOptions, run_merge + + +# Logger for module-level logging +logger = logging.getLogger(__name__) + + +def upload_model_to_hf(folder_path: str, repo_id: str): + api = HfApi() + # Create the repository if it doesn't exist + repo = api.create_repo(repo_id, repo_type="model") + + # Upload the folder to the specified repository + api.upload_folder( + folder_path=folder_path, + repo_id=repo.repo_id, + repo_type=repo.repo_type, + ) + + +class MergeConfig: + r""" + Configuration class for merging two models using `mergekit`. + + This class provides a structured way to configure and generate merge configurations for various merge methods, such + as `linear`, `ties`, `dare_ties`, and `slerp`. + + Args: + method (`str`, *optional*, defaults to `"linear"`): + Merge method to use. Supported methods include: + + - `"linear"`: Linearly combines two models with specified weights. + - `"ties"`: Combines two models using the TIES method with density parameters. + - `"dare_ties"`: A variant of TIES for domain adaptation. + - `"slerp"`: Combines models using spherical linear interpolation. + + Note: + + For more details about the merge methods and how they are implemented, see the [MergeKit GitHub + repository](https://github.com/arcee-ai/mergekit?tab=readme-ov-file#merge-methods). + + Attributes: + method (`str`): The merge method to use. + policy_model_path (`str` or `None`): Path to the policy model. + target_model_path (`str` or `None`): Path to the target model. + policy_model_weight (`float`): Weight for the policy model (for `linear` and `ties` methods). + target_model_weight (`float`): Weight for the target model (for `linear` and `ties` methods). + policy_model_density (`list[float]`): Density parameters for the policy model (for `ties` and `dare_ties`). + target_model_density (`list[float]`): Density parameters for the target model (for `ties` and `dare_ties`). + normalize (`float` or `None`): Normalization factor for the TIES method. + t_values (`float` or `None`): Interpolation factor for the SLERP method. + dtype (`str`): Data type to use for merging, e.g., `"float16"`. + """ + + def __init__(self, method: str = "linear"): + if not is_mergekit_available(): + raise ImportError("MergeConfig requires the `mergekit` extra. To install, run `pip install mergekit`.") + self.method = method + self.policy_model_path = None + self.target_model_path = None + + # Initialize relevant parameters based on the method + if method == "linear": + self.policy_model_weight = 0.5 + self.target_model_weight = 0.5 + self.dtype = "float16" + elif method == "ties": + self.policy_model_weight = 1.0 + self.policy_model_density = [1.0, 0.7, 0.1] + self.target_model_weight = 1.0 + self.target_model_density = [1.0] + self.normalize = 1.0 + self.dtype = "float16" + elif method == "dare_ties": + self.policy_model_weight = 1.0 + self.policy_model_density = [1.0, 0.7, 0.1] + self.target_model_weight = 1.0 + self.target_model_density = [1.0] + self.normalize = 1.0 + self.dtype = "float16" + elif method == "slerp": + self.t_values = 0.5 + self.dtype = "float16" + else: + raise ValueError(f"Unsupported merge method: {method}") + + def create_merge_config_linear(self) -> "MergeConfiguration": + """ + Creates a merge configuration for a linear merge of two models with specified weights. + """ + # Create the merge configuration dictionary + merge_config_dict = { + "dtype": self.dtype, + "merge_method": "linear", + "models": [ + {"model": self.policy_model_path, "parameters": {"weight": self.policy_model_weight}}, + {"model": self.target_model_path, "parameters": {"weight": self.target_model_weight}}, + ], + } + + # Create the MergeConfiguration from the dictionary + merge_config = MergeConfiguration.model_validate(merge_config_dict) + + return merge_config + + def create_merge_config_ties(self) -> "MergeConfiguration": + """ + Creates a merge configuration for a TIES merge of two models, with specified weights and densities. + """ + # Create the TIES merge configuration dictionary + merge_config_dict = { + "merge_method": "ties", + "slices": None, # Optional slices if needed + "models": [ + { + "model": { + "model": {"path": self.target_model_path, "revision": None}, + "lora": None, + "override_architecture": None, + }, + "parameters": {"density": self.target_model_density, "weight": self.target_model_weight}, + }, + { + "model": { + "model": {"path": self.policy_model_path, "revision": None}, + "lora": None, + "override_architecture": None, + }, + "parameters": {"density": self.policy_model_density, "weight": self.policy_model_weight}, + }, + ], + "parameters": {"normalize": self.normalize}, + "base_model": { + "model": {"path": self.policy_model_path, "revision": None}, + "lora": None, + "override_architecture": None, + }, + "dtype": self.dtype, + "tokenizer_source": None, + "tokenizer": None, + "chat_template": None, + "out_dtype": None, + } + + # Create the MergeConfiguration from the dictionary + merge_config = MergeConfiguration.model_validate(merge_config_dict) + + return merge_config + + def create_merge_config_dare_ties(self) -> "MergeConfiguration": + """ + Creates a merge configuration for a DARE TIES merge of two models, with specified weights and densities. + """ + # Create the DARE TIES merge configuration dictionary + merge_config_dict = { + "merge_method": "dare_ties", + "slices": None, # Optional slices if needed + "models": [ + { + "model": { + "model": {"path": self.target_model_path, "revision": None}, + "lora": None, + "override_architecture": None, + }, + "parameters": {"density": self.target_model_density, "weight": self.target_model_weight}, + }, + { + "model": { + "model": {"path": self.policy_model_path, "revision": None}, + "lora": None, + "override_architecture": None, + }, + "parameters": {"density": self.policy_model_density, "weight": self.policy_model_weight}, + }, + ], + "parameters": {"normalize": self.normalize}, + "base_model": { + "model": {"path": self.policy_model_path, "revision": None}, + "lora": None, + "override_architecture": None, + }, + "dtype": self.dtype, + "tokenizer_source": None, + "tokenizer": None, + "chat_template": None, + "out_dtype": None, + } + + # Create the MergeConfiguration from the dictionary + merge_config = MergeConfiguration.model_validate(merge_config_dict) + + return merge_config + + def create_merge_config_slerp(self) -> "MergeConfiguration": + """ + Creates a merge configuration for a SLERP merge of a model with a base model. + """ + + # Create the SLERP merge configuration dictionary + merge_config_dict = { + "merge_method": "slerp", + "slices": None, # Optional slices if needed + "models": [ + { + "model": { + "model": {"path": self.target_model_path, "revision": None}, + "lora": None, + "override_architecture": None, + }, + "parameters": None, # No specific parameters for SLERP model + } + ], + "parameters": { + "t": self.t_values # Set the t values for SLERP + }, + "base_model": { + "model": {"path": self.policy_model_path, "revision": None}, + "lora": None, + "override_architecture": None, + }, + "dtype": self.dtype, + "tokenizer_source": None, + "tokenizer": None, + "chat_template": None, + "out_dtype": None, + } + + # Create the MergeConfiguration from the dictionary + merge_config = MergeConfiguration.model_validate(merge_config_dict) + + return merge_config + + def create(self) -> "MergeConfiguration": + if self.method == "linear": + return self.create_merge_config_linear() + elif self.method == "ties": + return self.create_merge_config_ties() + elif self.method == "dare_ties": + return self.create_merge_config_dare_ties() + elif self.method == "slerp": + return self.create_merge_config_slerp() + + +def merge_models(config: "MergeConfiguration", out_path: str): + """ + Merge two models using mergekit + + Args: + config (`MergeConfiguration`): The merge configuration. + out_path (`str`): The output path for the merged model. + """ + if not is_mergekit_available(): + raise ImportError("merge_models requires the `mergekit` extra. To install, run `pip install mergekit`.") + run_merge( + config, + out_path=out_path, + options=MergeOptions( + device="auto", + cuda=torch.cuda.is_available(), + copy_tokenizer=True, + lazy_unpickle=False, + low_cpu_memory=False, + ), + ) + + +class MergeModelCallback(TrainerCallback): + r""" + A [`~transformers.TrainerCallback`] that merges the policy model (the model being trained) with another model based + on a merge configuration. + + Args: + merge_config ([`experimental.merge_model_callback.MergeConfig`], *optional*): + Configuration used for the merging process. If not provided, the default + [`~experimental.merge_model_callback.MergeConfig`] is used. + merge_at_every_checkpoint (`bool`, *optional*, defaults to `False`): + Whether to merge the model at every checkpoint. + push_to_hub (`bool`, *optional*, defaults to `False`): + Whether to push the merged model to the Hub after merging. + + Example: + + ```python + from trl.experimental.merge_model_callback import MergeConfig, MergeModelCallback + + config = MergeConfig() + merge_callback = MergeModelCallback(config) + trainer = DPOTrainer(..., callbacks=[merge_callback]) + ``` + """ + + def __init__( + self, + merge_config: "MergeConfig | None" = None, + merge_at_every_checkpoint: bool = False, + push_to_hub: bool = False, + ): + if not is_mergekit_available(): + raise ImportError( + "MergeModelCallback requires the `mergekit` extra. To install, run `pip install mergekit`." + ) + self.merge_config = merge_config or MergeConfig() + self.merge_at_every_checkpoint = merge_at_every_checkpoint + self.push_to_hub = push_to_hub + + def _merge_and_maybe_push(self, output_dir, global_step, model): + checkpoint_path = os.path.join(output_dir, f"checkpoint-{global_step}") + self.merge_config.policy_model_path = checkpoint_path + if self.merge_config.target_model_path is None: + self.merge_config.target_model_path = get_config_model_id(model.config) + merge_path = os.path.join(checkpoint_path, "merged") + + merge_models(self.merge_config.create(), merge_path) + + if self.push_to_hub: + repo_name = f"{output_dir}_checkpoint-{global_step}_merged" + upload_model_to_hf(merge_path, repo_name) + + def on_save(self, args, state, control, model=None, **kwargs): + if self.merge_at_every_checkpoint: + self._merge_and_maybe_push(args.output_dir, state.global_step, model) + + def on_train_end(self, args, state, control, model=None, **kwargs): + if not self.merge_at_every_checkpoint: + self._merge_and_maybe_push(args.output_dir, state.global_step, model) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/minillm/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/minillm/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..07bc38f0ef9973010a3eed3c9adf4ef5137ec6b1 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/minillm/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .minillm_config import MiniLLMConfig +from .minillm_trainer import MiniLLMTrainer + + +__all__ = ["MiniLLMConfig", "MiniLLMTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/minillm/minillm_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/minillm/minillm_config.py new file mode 100644 index 0000000000000000000000000000000000000000..678868aabb8aa78a50eb53282ca390364674b82d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/minillm/minillm_config.py @@ -0,0 +1,137 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Any + +from ...trainer.base_config import _BaseConfig +from ...trainer.grpo_config import GRPOConfig + + +@dataclass +class MiniLLMConfig(GRPOConfig): + """ + Configuration class for [`MiniLLMTrainer`]. + + This class includes only the parameters that are specific to MiniLLM training. For a full list of training + arguments, please refer to the [`~transformers.TrainingArguments`] and [`GRPOConfig`] documentation. + + Args: + teacher_model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the teacher model + from a string. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model. + rkl_advantage (`bool`, *optional*, defaults to `True`): + Whether to add the reverse KL advantage to the reward advantage. + single_step_decomposition (`bool`, *optional*, defaults to `True`): + Whether to use single-step decomposition for the KL divergence computation. + kd_temperature (`float`, *optional*, defaults to `1.0`): + Temperature for knowledge distillation. Higher temperatures produce softer probability distributions over + classes. + gamma (`float`, *optional*, defaults to `0.0`): + Discount factor for future rewards in reinforcement learning. + length_normalization (`bool`, *optional*, defaults to `True`): + Whether to apply length normalization to the rewards. + """ + + _VALID_DICT_FIELDS = GRPOConfig._VALID_DICT_FIELDS + ["teacher_model_init_kwargs"] + + teacher_model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the " + "teacher model from a string." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropouts in `model`."}, + ) + rkl_advantage: bool = field( + default=True, + metadata={"help": "Whether to add the reverse KL advantage to the reward advantage."}, + ) + single_step_decomposition: bool = field( + default=True, + metadata={"help": "Whether to use single-step decomposition for the KL divergence computation."}, + ) + kd_temperature: float = field( + default=1.0, + metadata={ + "help": "Temperature for knowledge distillation. Higher temperatures produce softer probability " + "distributions over classes." + }, + ) + gamma: float = field( + default=0.0, + metadata={"help": "Discount factor for future rewards in reinforcement learning."}, + ) + length_normalization: bool = field( + default=True, + metadata={"help": "Whether to apply length normalization to the rewards."}, + ) + + def __post_init__(self): + # We do not use the post_init of GRPOConfig because: + # 1. num_generations can be < 2 in MiniLLMConfig. Scale_rewards must be set to "none" to avoid nan. + _BaseConfig.__post_init__(self) + + self.scale_rewards = {True: "group", False: "none"}.get(self.scale_rewards, self.scale_rewards) + if self.num_generations == 1: + self.scale_rewards = "none" + + num_processes = self.world_size + # The current default effective batch size + if self.generation_batch_size is None and self.steps_per_generation is None: + self.steps_per_generation = self.gradient_accumulation_steps + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + elif self.generation_batch_size is not None and self.steps_per_generation is None: + # Just ensure the value is divisible by the global batch size + if self.generation_batch_size % (self.per_device_train_batch_size * num_processes) != 0: + raise ValueError( + f"generation_batch_size ({self.generation_batch_size}) must be divisible by the global batch size " + f"({self.per_device_train_batch_size * num_processes})." + ) + self.steps_per_generation = self.generation_batch_size // ( + self.per_device_train_batch_size * num_processes + ) + elif self.generation_batch_size is None and self.steps_per_generation is not None: + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + else: + raise ValueError( + "'generation_batch_size' and 'steps_per_generation' can not be both configured at the same time" + ) + + if self.do_eval and self.eval_strategy != "no": + # Determine the number of generations to use for evaluation + num_generations = self.num_generations_eval or self.num_generations + + # Just ensure the value is divisible by the global batch size + if (self.per_device_eval_batch_size * num_processes) % num_generations != 0: + raise ValueError( + f"The global eval batch size ({self.per_device_eval_batch_size} * {num_processes}) must be " + f"divisible by the number of generations used for evaluation ({num_generations})." + ) + + # The generation batch must contain full prompt groups (no partials), so it must be divisible by + # num_generations. + if self.generation_batch_size % self.num_generations != 0: + raise ValueError( + f"generation_batch_size ({self.generation_batch_size}) must be divisible by num_generations " + f"({self.num_generations})." + ) + + if self.delta is not None and self.use_liger_kernel: + raise ValueError("Liger kernel does not support two-sided GRPO loss yet.") diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/minillm/minillm_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/minillm/minillm_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..4105afe4c1753ada381b668a73f4c4bfa1d8e75e --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/minillm/minillm_trainer.py @@ -0,0 +1,411 @@ +# Copyright 2020-2026 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 textwrap + +import torch +import torch.nn as nn +import torch.nn.functional as F +import transformers +from datasets import Dataset, IterableDataset +from packaging.version import Version +from transformers import ( + AutoModelForCausalLM, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, +) +from transformers.utils import is_peft_available + +from ...models import prepare_deepspeed +from ...trainer.grpo_trainer import GRPOTrainer, RewardFunc, RolloutFunc +from ...trainer.utils import disable_dropout_in_model, get_config_model_id +from ..utils import empty_cache +from .minillm_config import MiniLLMConfig + + +if is_peft_available(): + from peft import PeftConfig + + +def dummy_reward_func(completions: list, **kwargs): + # placeholder reward function when no reward function is provided + return [1.0 for _ in completions] + + +class MiniLLMTrainer(GRPOTrainer): + """ + Trainer for the Knowledge Distillation of Language Models (MiniLLM) method. This algorithm was initially proposed + in the paper [Knowledge Distillation of Large Language Models](https://huggingface.co/papers/2306.08543). + + Example: + + ```python + from datasets import load_dataset + from trl.experimental.minillm import MiniLLMTrainer + + dataset = load_dataset("trl-lib/tldr", split="train") + + trainer = MiniLLMTrainer( + model="Qwen/Qwen3-0.6B", + teacher_model="Qwen/Qwen3-1.7B", + train_dataset=dataset, + ) + trainer.train() + ``` + + Args: + model (`str | PreTrainedModel`): + Model to be trained. Can be either: + + - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using [`~transformers.AutoModelForCausalLM.from_pretrained`] with the keyword arguments in + `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported. + teacher_model (`PreTrainedModel | nn.Module | str`): + Teacher model used for knowledge distillation. Instantiated similarly to `model`. + reward_funcs (`RewardFunc | list[RewardFunc]`, *optional*): + Reward functions to be used for computing the rewards. To compute the rewards, we call all the reward + functions with the prompts and completions and sum the rewards. Can be either: + + - A single reward function, such as: + - A string: The *model ID* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using [`~transformers.AutoModelForSequenceClassification.from_pretrained`] with `num_labels=1` and the + keyword arguments in `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object: Only sequence classification models are supported. + - A custom reward function: The function is provided with the prompts and the generated completions, + plus any additional columns in the dataset. It should return a list of rewards. Custom reward + functions can also return `None` when the reward is not applicable to those samples. This is useful + for multi-task training where different reward functions apply to different types of samples. When a + reward function returns `None` for a sample, that reward function is excluded from the reward + calculation for that sample. For more details, see [Using a custom reward + function](#using-a-custom-reward-function). + + The trainer's state is also passed to the reward function. The trainer's state is an instance of + [`~transformers.TrainerState`] and can be accessed by accessing the `trainer_state` argument to the + reward function's signature. + - A list of reward functions, where each item can independently be any of the above types. Mixing different + types within the list (e.g., a string model ID and a custom reward function) is allowed. + args ([`experimental.minillm.MiniLLMConfig`], *optional*): + Configuration for this trainer. If `None`, a default configuration is used. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + Dataset to use for training. It must include a column `"prompt"`. Any additional columns in the dataset is + ignored. The format of the samples can be either: + + - [Standard](dataset_formats#standard): Each sample contains plain text. + - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role + and content). + eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`): + Dataset to use for evaluation. It must meet the same requirements as `train_dataset`. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. The padding side must be set to "left". If `None`, the + processing class is loaded from the model's name with [`~transformers.AutoProcessor.from_pretrained`]. A + padding token, `tokenizer.pad_token`, must be set. If the processing class has not set a padding token, + `tokenizer.eos_token` will be used as the default. + reward_processing_classes ([`~transformers.PreTrainedTokenizerBase`] or `list[PreTrainedTokenizerBase]`, *optional*): + Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either: + + - A single processing class: Used when `reward_funcs` contains only one reward function. + - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`. + If set to `None`, or if an element of the list corresponding to a [`~transformers.PreTrainedModel`] is + `None`, the tokenizer for the model is automatically loaded using + [`~transformers.AutoTokenizer.from_pretrained`]. For elements in `reward_funcs` that are custom reward + functions (not [`~transformers.PreTrainedModel`]), the corresponding entries in `reward_processing_classes` + are ignored. + callbacks (list of [`~transformers.TrainerCallback`], *optional*): + List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed + in [here](https://huggingface.co/docs/transformers/main_classes/callback). + + If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`] + method. + optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`, *optional*, defaults to `(None, None)`): + A tuple containing the optimizer and the scheduler to use. Will default to an instance of [`AdamW`] on your + model and a scheduler given by [`get_linear_schedule_with_warmup`] controlled by `args`. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration used to wrap the model. If `None`, the model is not wrapped. + rollout_func (`RolloutFunc`, *optional*): + Function to use for generating completions. It must take prompts, args, and processing_class as parameters + and return a dict with `"prompt_ids"`, `"completion_ids"`, and `"logprobs"` fields. Any other fields that + are forwarded to the reward functions. This feature is experimental and may change or be removed at any + time without prior notice. + """ + + _tag_names = ["trl", "minillm"] + _name = "MiniLLM" + _paper = { + "title": "MiniLLM: Knowledge Distillation of Large Language Models", + "id": "2306.08543", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @inproceedings{ + gu2024minillm, + title={{MiniLLM: Knowledge Distillation of Large Language Models}}, + author={Yuxian Gu and Li Dong and Furu Wei and Minlie Huang}, + booktitle={The Twelfth International Conference on Learning Representations}, + year={2024}, + url={https://openreview.net/forum?id=5h0qf7IBZZ} + }"""), + } + + def __init__( + self, + model: str | PreTrainedModel, + teacher_model: PreTrainedModel | nn.Module | str, + reward_funcs: RewardFunc | list[RewardFunc] | None = None, + args: MiniLLMConfig | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + peft_config: "PeftConfig | None" = None, + rollout_func: RolloutFunc | None = None, + ): + if reward_funcs is None: + reward_funcs = [dummy_reward_func] + + # Args + if args is None: + model_name = model if isinstance(model, str) else get_config_model_id(model.config) + model_name = model_name.split("/")[-1] + args = MiniLLMConfig(f"{model_name}-MiniLLM") + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model, + reward_funcs, + args=args, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + reward_processing_classes=reward_processing_classes, + callbacks=callbacks, + optimizers=optimizers, + peft_config=peft_config, + rollout_func=rollout_func, + ) + + if args.teacher_model_init_kwargs is None: + teacher_model_init_kwargs = {} + elif not isinstance(teacher_model, str): + raise ValueError( + "You passed teacher_model_init_kwargs to the MiniLLMConfig, but your teacher_model is already instantiated." + ) + else: + teacher_model_init_kwargs = args.teacher_model_init_kwargs + teacher_model_init_kwargs["dtype"] = ( + teacher_model_init_kwargs["dtype"] + if teacher_model_init_kwargs["dtype"] in ["auto", None] + else getattr(torch, teacher_model_init_kwargs["dtype"]) + ) + + if isinstance(teacher_model, str): + teacher_model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + teacher_model = AutoModelForCausalLM.from_pretrained(teacher_model, **teacher_model_init_kwargs) + + # Disable dropout in the model + if args.disable_dropout: + disable_dropout_in_model(self.model) + + if self.is_deepspeed_enabled: + self.teacher_model = prepare_deepspeed(teacher_model, self.accelerator) + else: + self.teacher_model = self.accelerator.prepare_model(teacher_model, evaluation_mode=True) + + self.temperature = args.temperature + self.kd_temperature = args.kd_temperature + self.single_step_decomposition = args.single_step_decomposition + self.rkl_advantage = args.rkl_advantage + self.gamma = args.gamma + self.length_normalization = args.length_normalization + + def _single_step_decomposition_loss( + self, + student_log_probs: torch.Tensor, + teacher_log_probs: torch.Tensor, + mask: torch.Tensor | None = None, + reduction: str = "batchmean", + ): + """ + Compute the MiniLLM loss for knowledge distillation using F.kl_div. See Eq. (1) of + https://huggingface.co/papers/2306.08543 for the definition. + + Args: + student_log_probs: + Per-token log-probabilities from the student, of shape (batch_size, sequence_length) + teacher_log_probs: + Per-token log-probabilities from the teacher, of shape (batch_size, sequence_length) + mask: + Optional boolean tensor of shape (batch_size, sequence_length) selecting the tokens to include in the + loss (e.g. excluding padding) + reduction: + Specifies the reduction to apply to the output: 'batchmean' (default), 'sum' or 'mean'; any other value + returns the unreduced per-token loss + + Returns: + loss: Scalar tensor with the single-step KL regularization loss (unreduced if `reduction` is not one of the + above) + """ + reg_loss = F.kl_div( + teacher_log_probs, student_log_probs, reduction="none", log_target=True + ) # (batch_size, sequence_length) + + # Masking + if mask is not None: + reg_loss = reg_loss[mask] + + # Apply reduction + if reduction == "batchmean": + return reg_loss.sum() / mask.sum() if mask is not None else reg_loss.sum() / reg_loss.size(0) + elif reduction == "sum": + return reg_loss.sum() + elif reduction == "mean": + return reg_loss.mean() + else: + return reg_loss + + def _compute_advantage( + self, + student_log_probs_on_labels: torch.Tensor, + teacher_log_probs_on_labels: torch.Tensor, + mask: torch.Tensor | None = None, + ) -> torch.Tensor: + r"""Compute the advantage for Reverse KL Divergence. + + Mostly following [this + implementation](https://github.com/microsoft/LMOps/blob/e210d2c026b9958617887762400778ace81172e6/minillm/minillm/losses.py#L37-L49). + + $$ \text{rewards}_t = \text{teacher\_log\_probs\_on\_labels}_t - \text{student\_log\_probs\_on\_labels}_t $$ + + If length normalization is enabled: + + $$ \text{lengths}_t = \sum_{i=t}^{T} \gamma^{i-t} $$ + + $$ \text{advantages}_t = \frac{\sum_{i=t}^{T} \gamma^{i-t} R_i}{\text{lengths}_t} $$ + + Otherwise: + + $$ \text{advantages}_t = \sum_{i=t}^{T} \gamma^{i-t} R_i $$ + + Args: + student_log_probs_on_labels: Log probabilities of the student model on the labels. + Shape: (batch_size, sequence_length) + teacher_log_probs_on_labels: Log probabilities of the teacher model on the labels. + Shape: (batch_size, sequence_length) + mask: Optional mask to apply to the log probabilities. Shape: (batch_size, sequence_length) + Returns: + advantage: Computed advantage. Shape: (batch_size, sequence_length) + """ + response_length = student_log_probs_on_labels.size(1) + if mask is None: + mask = torch.ones_like(student_log_probs_on_labels) + mask = mask.float() + student_log_probs_on_labels = student_log_probs_on_labels * mask + teacher_log_probs_on_labels = teacher_log_probs_on_labels * mask + + rewards = teacher_log_probs_on_labels - student_log_probs_on_labels # (batch_size, sequence_length) + + if self.gamma > 0.0: + gamma_pow = torch.pow(self.gamma, torch.arange(response_length, device=rewards.device)) + + advantages = rewards * gamma_pow + advantages = advantages.flip(1).cumsum(dim=1).flip(1) + + if self.length_normalization: + mask = torch.where(mask < 0.5, 1e-4, mask) + lengths = mask * gamma_pow + lengths = lengths.flip(1).cumsum(dim=1).flip(1) + advantages = advantages / lengths + else: + advantages = rewards + + return advantages + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + input_ids = torch.cat([inputs["prompt_ids"], inputs["completion_ids"]], dim=1) + attention_mask = torch.cat([inputs["prompt_mask"], inputs["completion_mask"]], dim=1) + labels = input_ids.clone() + labels[attention_mask == 0] = -100 + + # Compute student output + student_outputs = model(input_ids=input_ids, attention_mask=attention_mask, use_cache=False) + + # Compute teacher output in eval mode + self.teacher_model.eval() + with torch.no_grad(): + teacher_outputs = self.teacher_model(input_ids=input_ids, attention_mask=attention_mask, use_cache=False) + + # Slice the logits for the generated tokens using the inputs["prompts"] lengths + prompt_lengths = inputs["prompt_ids"].shape[1] + student_logits = student_outputs.logits[:, prompt_lengths - 1 : -1, :] + teacher_logits = teacher_outputs.logits[:, prompt_lengths - 1 : -1, :] + shifted_labels = input_ids[:, prompt_lengths:] + + # Apply temperature scaling + student_logits = student_logits / self.kd_temperature + teacher_logits = teacher_logits / self.kd_temperature + + # Compute log probabilities for student and probabilities for teacher + student_log_probs = F.log_softmax(student_logits, dim=-1) + teacher_log_probs = F.log_softmax(teacher_logits, dim=-1) + + student_log_probs_on_labels = torch.gather( + student_log_probs, dim=-1, index=shifted_labels.unsqueeze(-1) + ).squeeze(-1) + teacher_log_probs_on_labels = torch.gather( + teacher_log_probs, dim=-1, index=shifted_labels.unsqueeze(-1) + ).squeeze(-1) + + mask = shifted_labels != -100 + + if self.rkl_advantage: + reverse_kl_advantage = self._compute_advantage( + student_log_probs_on_labels=student_log_probs_on_labels, + teacher_log_probs_on_labels=teacher_log_probs_on_labels, + mask=mask, + ) + + inputs["advantages"] = inputs["advantages"].unsqueeze(1) + reverse_kl_advantage + + # Compute GRPO loss on verifiable reward + loss = self._compute_loss(model, inputs) + + # Compute loss + if self.single_step_decomposition: + single_step_decomposition_loss = self._single_step_decomposition_loss( + student_log_probs=student_log_probs, + teacher_log_probs=teacher_log_probs, + mask=mask, + ) + + loss += single_step_decomposition_loss + + # Empty cache + empty_cache() + + # Return loss + return (loss, student_outputs) if return_outputs else loss diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/nash_md/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/nash_md/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5b80c1515bed13913e9497e35e6f79552deb40dc --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/nash_md/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .nash_md_config import NashMDConfig +from .nash_md_trainer import NashMDTrainer + + +__all__ = ["NashMDConfig", "NashMDTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/nash_md/nash_md_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/nash_md/nash_md_config.py new file mode 100644 index 0000000000000000000000000000000000000000..2d52d08ecbe7bde752f9b1ae3455c56bf31e445d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/nash_md/nash_md_config.py @@ -0,0 +1,46 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field + +from ..online_dpo import OnlineDPOConfig + + +@dataclass +class NashMDConfig(OnlineDPOConfig): + r""" + Configuration class for the [`experimental.nash_md.NashMDTrainer`]. + + Subclass of [`experimental.online_dpo.OnlineDPOConfig`] we can use all its arguments and add the following: + + Parameters: + mixture_coef (`float` or `list[float]`, *optional*, defaults to `0.5`): + Logit mixture coefficient for the model and reference model. If a list of floats is provided then the + mixture coefficient is selected for each new epoch and the last coefficient is used for the rest of the + epochs. + """ + + mixture_coef: list[float] = field( + default_factory=lambda: [0.5], + metadata={ + "help": "Logit mixture coefficient for the model and reference model. If a list of floats is provided " + "then the mixture coefficient is selected for each new epoch and the last coefficient is used for the " + "rest of the epochs." + }, + ) + + def __post_init__(self): + super().__post_init__() + if hasattr(self.mixture_coef, "__len__") and len(self.mixture_coef) == 1: + self.mixture_coef = self.mixture_coef[0] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/nash_md/nash_md_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/nash_md/nash_md_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..fd2f7c816c38135d376e4ac99f96d5a88a579a91 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/nash_md/nash_md_trainer.py @@ -0,0 +1,509 @@ +# Copyright 2020-2026 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 textwrap +from collections.abc import Callable +from typing import Any + +import torch +import torch.nn as nn +import torch.nn.functional as F +from datasets import Dataset, IterableDataset +from transformers import ( + BaseImageProcessor, + FeatureExtractionMixin, + GenerationMixin, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, +) +from transformers.trainer_utils import EvalPrediction +from transformers.training_args import OptimizerNames +from transformers.utils import is_peft_available + +from ...data_utils import maybe_apply_chat_template +from ...models.utils import unwrap_model_for_generation +from ...trainer.utils import selective_log_softmax +from ..online_dpo import OnlineDPOTrainer +from ..utils import empty_cache, get_reward, truncate_right +from .nash_md_config import NashMDConfig + + +if is_peft_available(): + from peft import PeftConfig, PeftModel + + +class GeometricMixtureWrapper(GenerationMixin): + """ + Geometric Mixture generation wrapper that samples from the logits of two model's geometric mixture. + + Args: + model ([`~transformers.PreTrainedModel`]): The model to be wrapped. + ref_model ([`~transformers.PreTrainedModel`]): The reference model. + generation_config ([`~transformers.GenerationConfig`]): The generation config. + mixture_coef (`float`, *optional* - default: 0.5): The mixture coefficient. + """ + + main_input_name = "input_ids" + _supports_cache_class = False + _supports_static_cache = False + _is_stateful = False + + def __init__(self, model, ref_model, generation_config, mixture_coef=0.5, device=None): + super().__init__() + + self.model = model + self.config = model.config + self.ref_model = ref_model + self.generation_config = generation_config + self.mixture_coef = mixture_coef + self.device = device + if hasattr(self.model, "_is_stateful"): + self._is_stateful = self.model._is_stateful + + def __call__(self, *args, **kwargs): + return self.forward(*args, **kwargs) + + @torch.inference_mode() + def forward(self, *args, **kwargs): + model_outputs = self.model(*args, **kwargs) + model_logits = model_outputs.logits + ref_model_logits = self.ref_model(*args, **kwargs).logits + + model_outputs.logits = torch.nn.functional.log_softmax( + self.mixture_coef * ref_model_logits + (1 - self.mixture_coef) * model_logits, dim=-1 + ) + + return model_outputs + + def prepare_inputs_for_generation(self, *args, **kwargs): + # turn off cache in the generation config + kwargs["use_cache"] = False + model_inputs = self.model.prepare_inputs_for_generation(*args, **kwargs) + _ = self.ref_model.prepare_inputs_for_generation(*args, **kwargs) + + return model_inputs + + def _validate_model_class(self): + self.model._validate_model_class() + + def _validate_model_kwargs(self, model_kwargs): + return self.model._validate_model_kwargs(model_kwargs) + + +class NashMDTrainer(OnlineDPOTrainer): + """ + Trainer for the Nash-MD method. + + It is implemented as a subclass of [`experimental.online_dpo.OnlineDPOTrainer`]. + + Args: + model ([`~transformers.PreTrainedModel`]): + The model to train, preferably an `AutoModelForCausalLM`. + ref_model ([`~transformers.PreTrainedModel`]): + Hugging Face transformer model with a casual language modelling head. Used for implicit reward computation + and loss. If no reference model is provided, the trainer will create a reference model with the same + architecture as the model to be optimized. + reward_funcs ([`~transformers.PreTrainedModel`]): + The reward model to score completions with, preferably an + [`~transformers.AutoModelForSequenceClassification`]. + args ([`experimental.nash_md.NashMDConfig`]): + The NashMD config arguments to use for training. + data_collator ([`~transformers.DataCollator`]): + The data collator to use for training. If None is specified, the default data collator + ([`experimental.utils.DPODataCollatorWithPadding`]) will be used which will pad the sequences to the + maximum length of the sequences in the batch, given a dataset of paired sequences. + train_dataset ([`~datasets.Dataset`]): + The dataset to use for training. + eval_dataset ([`~datasets.Dataset`]): + The dataset to use for evaluation. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. If provided, will be used to automatically process the inputs + for the model, and it will be saved along the model to make it easier to rerun an interrupted training or + reuse the fine-tuned model. + peft_config ([`~peft.PeftConfig`], *optional*): + The peft config to use for training. + compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*): + The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to + metric values. + callbacks (`list[transformers.TrainerCallback]`): + The callbacks to use for training. + optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): + The optimizer and scheduler to use for training. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`): + The function to use to preprocess the logits before computing the metrics. + """ + + _tag_names = ["trl", "nash-md"] + _name = "Nash-MD" + _paper = { + "title": "Nash Learning from Human Feedback", + "id": "2312.00886", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @inproceedings{munos2024nash, + title = {{Nash Learning from Human Feedback}}, + author = {R{\'{e}}mi Munos and Michal Valko and Daniele Calandriello and Mohammad Gheshlaghi Azar and Mark Rowland and Zhaohan Daniel Guo and Yunhao Tang and Matthieu Geist and Thomas Mesnard and C{\\^{o}}me Fiegel and Andrea Michi and Marco Selvi and Sertan Girgin and Nikola Momchev and Olivier Bachem and Daniel J. Mankowitz and Doina Precup and Bilal Piot}, + year = 2024, + booktitle = {Forty-first International Conference on Machine Learning, {ICML} 2024, Vienna, Austria, July 21-27, 2024}, + publisher = {OpenReview.net}, + url = {https://openreview.net/forum?id=Y5AmNYiyCQ} + }"""), + } + + def __init__( + self, + model: PreTrainedModel | nn.Module = None, + ref_model: PreTrainedModel | nn.Module = None, + reward_funcs: PreTrainedModel | nn.Module | None = None, + args: NashMDConfig | None = None, + data_collator: Callable | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + processing_class: PreTrainedTokenizerBase + | BaseImageProcessor + | FeatureExtractionMixin + | ProcessorMixin + | None = None, + peft_config: "PeftConfig | None" = None, + compute_metrics: Callable[[EvalPrediction], dict] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + ) -> None: + super().__init__( + model=model, + ref_model=ref_model, + reward_funcs=reward_funcs, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + reward_processing_classes=processing_class, + peft_config=peft_config, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + self._mixture_coef = self.args.mixture_coef + + # Overwrite the stats dictionary to include NashMD specific statistics + self.stats = { + # Remove "non_score_reward", "rlhf_reward", "scores_margin" + # Add "mixture_coef" + "loss/kl": [], + "objective/entropy": [], + "loss/score": [], + "rewards/probabilities": [], + "rewards/accuracies": [], + "rewards/margins": [], + "logps/chosen": [], + "logps/rejected": [], + "val/model_contain_eos_token": [], + "val/ref_contain_eos_token": [], + "rewards/chosen": [], + "rewards/rejected": [], + "beta": [], + "mixture_coef": [], + } + if len(self.reward_funcs) != 1: + raise ValueError("NashMDTrainer only supports one reward function/model.") + self.reward_funcs = self.reward_funcs[0] + + @property + def mixture_coef(self): + if isinstance(self._mixture_coef, list): + epoch = self.state.epoch + return self._mixture_coef[epoch] if epoch < len(self._mixture_coef) else self._mixture_coef[-1] + else: + return self._mixture_coef + + def _generate_completions(self, model, prompts): + # Generate completions from the policy model. + with ( + unwrap_model_for_generation( + model, + self.accelerator, + generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762 + ) as unwrapped_policy_for_gen_ctx + ): + model_output = unwrapped_policy_for_gen_ctx.generate( + input_ids=prompts["input_ids"], + attention_mask=prompts["attention_mask"], + generation_config=self.generation_config, + ) + + # Get the DDP/FSDP unwrapped version of the main model. + # This will be the policy model for GeometricMixtureWrapper (PEFT adapters active if PEFT is used). + policy_model_for_gmw = self.accelerator.unwrap_model(model) + + # Determine the correct reference model for GeometricMixtureWrapper. + # This also needs to be DDP/FSDP unwrapped. + ref_model_for_gmw: torch.nn.Module + if self.ref_model is None: + # No explicit ref_model is provided. + # Use the base of the main `model` if it's a PEFT model. + # policy_model_for_gmw is already DDP-unwrapped. + if is_peft_available() and isinstance(policy_model_for_gmw, PeftModel): + ref_model_for_gmw = policy_model_for_gmw.get_base_model() + else: + # Not a PEFT model (or PEFT not available), or already a base model. + # Use the DDP-unwrapped policy model itself as the reference. + ref_model_for_gmw = policy_model_for_gmw + else: + # An explicit ref_model is provided. Unwrap it for DDP/FSDP. + ref_model_for_gmw = self.accelerator.unwrap_model(self.ref_model) + + # Both models given to GeometricMixtureWrapper (policy_model_for_gmw and ref_model_for_gmw) are DDP-unwrapped. + with torch.no_grad(): # Ensure no_grad context for mixture model generation + mixture_model = GeometricMixtureWrapper( + model=policy_model_for_gmw, + ref_model=ref_model_for_gmw, + generation_config=self.generation_config, + mixture_coef=self.mixture_coef, + device=self.accelerator.device, + ) + + # TODO: use self._override_model_generation_config for both models? + mixture_output = mixture_model.generate( + input_ids=prompts["input_ids"], + attention_mask=prompts["attention_mask"], + generation_config=self.generation_config, + ) + + return model_output, mixture_output + + def _process_completions(self, model_output, mixture_output, prompts): + context_length = prompts["input_ids"].shape[1] + + # Process model completions + model_completion_ids = model_output[:, context_length:] + model_completion_ids, model_completion_mask = truncate_right( + model_completion_ids, self.processing_class.eos_token_id, self.processing_class.pad_token_id + ) + model_data = { + "input_ids": torch.cat((prompts["input_ids"], model_completion_ids), dim=1), + "attention_mask": torch.cat((prompts["attention_mask"], model_completion_mask), dim=1), + "raw": prompts["raw"], + } + + # Process reference model completions + mixture_completion_ids = mixture_output[:, context_length:] + mixture_completion_ids, mixture_completion_mask = truncate_right( + mixture_completion_ids, self.processing_class.eos_token_id, self.processing_class.pad_token_id + ) + mixture_data = { + "input_ids": torch.cat((prompts["input_ids"], mixture_completion_ids), dim=1), + "attention_mask": torch.cat((prompts["attention_mask"], mixture_completion_mask), dim=1), + "raw": prompts["raw"], + } + + return model_data, mixture_data + + def _compute_rewards(self, model_data, mixture_data, context_length): + with torch.no_grad(): + _, model_scores, _ = get_reward( + self.reward_funcs, model_data["input_ids"], self.processing_class.pad_token_id, context_length + ) + _, mixture_scores, _ = get_reward( + self.reward_funcs, mixture_data["input_ids"], self.processing_class.pad_token_id, context_length + ) + + # Apply EOS penalty if needed + if self.args.missing_eos_penalty is not None: + model_contain_eos = torch.any(model_data["input_ids"] == self.processing_class.eos_token_id, dim=-1) + mixture_contain_eos = torch.any(mixture_data["input_ids"] == self.processing_class.eos_token_id, dim=-1) + model_scores[~model_contain_eos] -= self.args.missing_eos_penalty + mixture_scores[~mixture_contain_eos] -= self.args.missing_eos_penalty + + return model_scores, mixture_scores + + def _compute_logprobs(self, model, model_data, context_length): + def compute_logprobs_for_data(m, data): + output = m(data["input_ids"], attention_mask=data["attention_mask"]) + logits = output.logits[:, context_length - 1 : -1] + token_logprobs = selective_log_softmax(logits, data["input_ids"][:, context_length:]) + return token_logprobs + + # Compute logprobs for model completions under the model + model_logprobs_model_data = compute_logprobs_for_data(model, model_data) + + # Compute logprobs of model completions under the reference model + with torch.no_grad(): + if self.ref_model is None: + with model.disable_adapter(): + ref_logprobs_model_data = compute_logprobs_for_data(model, model_data) + else: + ref_logprobs_model_data = compute_logprobs_for_data(self.ref_model, model_data) + + # Mask padding tokens + model_padding_mask = model_data["attention_mask"][:, context_length:] == 0 + model_logprobs_model_data = model_logprobs_model_data.masked_fill(model_padding_mask, 0.0) + ref_logprobs_model_data = ref_logprobs_model_data.masked_fill(model_padding_mask, 0.0) + + return (model_logprobs_model_data, ref_logprobs_model_data) + + def _compute_losses( + self, + model_logprobs_model_data, + ref_logprobs_model_data, + probability, + ): + # reinforce score where 0.5 is a control variate + score = (probability - 0.5) * model_logprobs_model_data.sum(1) + + # kl divergence via reinforce + with torch.no_grad(): + log_ratio = model_logprobs_model_data - ref_logprobs_model_data + kl_div_log = log_ratio.sum(1) + kl_div_loss = (log_ratio * model_logprobs_model_data).sum(1) + + # final loss + loss = self.beta * kl_div_loss - score + + return loss.mean(), score, kl_div_log + + def _log_statistics( + self, + model_data, + mixture_data, + model_logprobs_model_data, + ref_logprobs_model_data, + probability, + score, + kl_div, + context_length, + model_scores, + mixture_scores, + ): + # Helper function to gather and compute mean + def gather_mean(tensor): + return self.accelerator.gather_for_metrics(tensor).mean().item() + + # Log score + self.stats["loss/score"].append(gather_mean(score)) + # Log KL divergence + self.stats["loss/kl"].append(gather_mean(kl_div)) + + # Log logprobs + model_logprobs_model_data_sum = model_logprobs_model_data.sum(1) + ref_logprobs_model_data_sum = ref_logprobs_model_data.sum(1) + + self.stats["logps/chosen"].append(gather_mean(model_logprobs_model_data_sum)) + self.stats["logps/rejected"].append(gather_mean(ref_logprobs_model_data_sum)) + + # Log rewards + self.stats["rewards/chosen"].append(gather_mean(model_scores)) + self.stats["rewards/rejected"].append(gather_mean(mixture_scores)) + + # Log probabilities + self.stats["rewards/probabilities"].append(gather_mean(probability)) + + # Calculate entropy for model data + entropy_model_data = -model_logprobs_model_data.sum(1) + self.stats["objective/entropy"].append(gather_mean(entropy_model_data)) + + # Calculate margins + margin = model_logprobs_model_data_sum - ref_logprobs_model_data_sum + self.stats["rewards/margins"].append(gather_mean(margin)) + + # Calculate accuracy + accuracy = (margin > 0).float() + self.stats["rewards/accuracies"].append(gather_mean(accuracy)) + + # Log EOS token statistics + model_eos = (model_data["input_ids"][:, context_length:] == self.processing_class.eos_token_id).any(dim=1) + mixture_eos = (mixture_data["input_ids"][:, context_length:] == self.processing_class.eos_token_id).any(dim=1) + self.stats["val/model_contain_eos_token"].append(gather_mean(model_eos.float())) + self.stats["val/ref_contain_eos_token"].append(gather_mean(mixture_eos.float())) + + # Log beta and mixture coef + self.stats["beta"].append(self.beta) + self.stats["mixture_coef"].append(self.mixture_coef) + + def training_step( + self, model: nn.Module, inputs: dict[str, torch.Tensor | Any], num_items_in_batch: int | None = None + ) -> torch.Tensor: + model.train() + + # Apply chat template and tokenize the input + batch_size = len(next(iter(inputs.values()))) + prompts = inputs["prompt"] + inputs = [{k: v[i] for k, v in inputs.items()} for i in range(batch_size)] + inputs = [maybe_apply_chat_template(x, self.processing_class) for x in inputs] + inputs = [self.tokenize_row(x, self.model.config.is_encoder_decoder, self.processing_class) for x in inputs] + inputs = self.data_collator(inputs) + + # need the prompt_ only + inputs = self._prepare_inputs(inputs) + context_length = inputs["prompt_input_ids"].shape[1] + prompts = { + "input_ids": inputs["prompt_input_ids"], + "attention_mask": inputs["prompt_attention_mask"], + "raw": prompts, + } + del inputs + + # Sample completions from both the model and the reference model + model_output, mixture_output = self._generate_completions(model, prompts) + + # Process model completions + model_data, mixture_data = self._process_completions(model_output, mixture_output, prompts) + + # Compute rewards + model_scores, mixture_scores = self._compute_rewards(model_data, mixture_data, context_length) + # probability of the model data vs the mixture data + probability = F.sigmoid(model_scores - mixture_scores) + + # Compute logprobs + model_logprobs_model_data, ref_logprobs_model_data = self._compute_logprobs(model, model_data, context_length) + + # Compute loss + loss, score, kl_div = self._compute_losses(model_logprobs_model_data, ref_logprobs_model_data, probability) + + # Log everything + self._log_statistics( + model_data, + mixture_data, + model_logprobs_model_data.detach(), + ref_logprobs_model_data, + probability, + score.detach(), + kl_div.detach(), + context_length, + model_scores, + mixture_scores, + ) + + if ( + self.args.torch_empty_cache_steps is not None + and self.state.global_step % self.args.torch_empty_cache_steps == 0 + ): + empty_cache() + + kwargs = {} + # For LOMO optimizers you need to explicitly use the learning rate + if self.args.optim in [OptimizerNames.LOMO, OptimizerNames.ADALOMO]: + kwargs["learning_rate"] = self._get_learning_rate() + + if self.args.n_gpu > 1: + loss = loss.mean() # mean() to average on multi-gpu parallel training + + self.accelerator.backward(loss, **kwargs) + + return loss.detach() / self.args.gradient_accumulation_steps diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/online_dpo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/online_dpo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2a109cabc240f871544e5ccc56ee5616794c0ba9 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/online_dpo/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .online_dpo_config import OnlineDPOConfig +from .online_dpo_trainer import OnlineDPOTrainer + + +__all__ = ["OnlineDPOConfig", "OnlineDPOTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/online_dpo/online_dpo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/online_dpo/online_dpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..8d28fe107ed916d7de2c09989e957487e5972793 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/online_dpo/online_dpo_config.py @@ -0,0 +1,390 @@ +# Copyright 2020-2026 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 warnings +from dataclasses import dataclass, field +from typing import Any + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class OnlineDPOConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`experimental.online_dpo.OnlineDPOTrainer`]. + + This class includes only the parameters that are specific to Online DPO training. For a full list of training + arguments, please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this + class may differ from those in [`~transformers.TrainingArguments`]. + + 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: + reward_model_path (`str`, *optional*): + Path to the reward model. + max_new_tokens (`int`, *optional*, defaults to `64`): + Maximum number of tokens to generate per completion. + max_length (`int`, *optional*, defaults to `512`): + Maximum total length of the sequence (prompt + completion) used to compute log probabilities. If the + sequence exceeds this limit, the leftmost tokens will be truncated to preserve as much of the completion as + possible. + temperature (`float`, *optional*, defaults to `0.9`): + Temperature for sampling. The higher the temperature, the more random the completions. + missing_eos_penalty (`float`, *optional*): + Penalty applied to the score when the model fails to generate an EOS token. This is useful to encourage to + generate completions shorter than the maximum length (`max_new_tokens`). The penalty must be a positive + value. + beta (`float` or `list[float]`, *optional*, defaults to `0.1`): + Parameter controlling the deviation from the reference model. Higher β means less deviation from the + reference model. For the IPO loss (`loss_type="ipo"`), β is the regularization parameter denoted by τ in + the [paper](https://huggingface.co/papers/2310.12036). If a list of floats is provided then the β is + selected for each new epoch and the last β is used for the rest of the epochs. + loss_type (`str`, *optional*, defaults to `"sigmoid"`): + Type of loss to use. Possible values are: + + - `"sigmoid"`: sigmoid loss from the original [DPO](https://huggingface.co/papers/2305.18290) paper. + - `"ipo"`: IPO loss from the [IPO](https://huggingface.co/papers/2310.12036) paper. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model and reference model. + + > Parameters that control generation + + top_p (`float`, *optional*, defaults to `1.0`): + Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to + `1.0` to consider all tokens. + top_k (`int`, *optional*, defaults to `0`): + Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is + disabled and all tokens are considered. + min_p (`float`, *optional*): + Minimum token probability, which will be scaled by the probability of the most likely token. It must be a + value between `0.0` and `1.0`. Typical values are in the `0.01-0.2` range. + repetition_penalty (`float`, *optional*, defaults to `1.0`): + Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far. + Values > `1.0` encourage the model to use new tokens, while values < `1.0` encourage the model to repeat + tokens. + cache_implementation (`str`, *optional*): + Implementation of the cache method for faster generation when `use_vllm` is set to `False`. + generation_kwargs (`dict[str, Any]`, *optional*): + Additional keyword arguments to pass to [`~transformers.GenerationConfig`] (if using transformers) or + `SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the + generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict + with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them. + + > Parameters that control generation acceleration powered by vLLM + + use_vllm (`bool`, *optional*, defaults to `False`): + Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation + instead of the default model.generate(). Requires `vllm` to be installed. + vllm_model_impl (`str`, *optional*, defaults to `"vllm"`): + Model implementation to use for vLLM. Must be one of `"transformers"` or `"vllm"`. `"transformers"`: Use + the `transformers` backend for model implementation. `"vllm"`: Use the `vllm` library for model + implementation. + vllm_mode (`str`, *optional*, defaults to `"colocate"`): + Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `"server"` or + `"colocate"`. + + - `"server"`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM + server is running (start with `trl vllm-serve`). + - `"colocate"`: vLLM will run in the same process and share the training GPUs. This avoids the need for a + separate server but may cause resource contention with training. + vllm_structured_outputs_regex (`str`, *optional*): + Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled. + + > Parameters that control the vLLM server (only used when `vllm_mode` is `"server"`) + + vllm_server_base_url (`str`, *optional*): + Base URL for the vLLM server (e.g., `"http://localhost:8000"`). If provided, `vllm_server_host` and + `vllm_server_port` are ignored. + vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`): + Host of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided. + vllm_server_port (`int`, *optional*, defaults to `8000`): + Port of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided. + vllm_server_timeout (`float`, *optional*, defaults to `240.0`): + Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the + timeout, a `ConnectionError` is raised. + vllm_group_port (`int`, *optional*, defaults to `51216`): + Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port + is occupied, there is no need to change it. + + > Parameters that control colocated vLLM execution (only used when `vllm_mode` is `"colocate"`) + + vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.55`): + Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to + `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when + launching the vLLM server via the `--vllm_gpu_memory_utilization` flag. + vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`): + Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to + `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when + launching the vLLM server via the `--vllm_tensor_parallel_size` flag. + vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`): + Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but + waking the engine adds host–device transfer latency. + + > Other parameters + + ds3_gather_for_generation (`bool`, *optional*, defaults to `True`): + This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation, + improving generation speed. However, disabling this option allows training models that exceed the VRAM + capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible + with vLLM generation. + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the model from a + string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`]. Also applied to reward-model and reward-tokenizer + loads. + reward_weights (`list[float]`, *optional*): + Weights for combining multiple reward functions. Must match the number of reward functions. If `None`, all + reward functions are equally weighted. + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `5e-7` instead of `5e-5`. + > - `remove_unused_columns`: Defaults to `False` instead of `True`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=5e-7, + metadata={"help": "The initial learning rate for AdamW."}, + ) + remove_unused_columns: bool = field( + default=False, + metadata={"help": "Whether or not to automatically remove the columns unused by the model forward method."}, + ) + + reward_model_path: str | None = field( + default=None, + metadata={"help": "Path to the reward model."}, + ) + max_new_tokens: int = field( + default=64, + metadata={"help": "Maximum number of tokens to generate per completion."}, + ) + max_length: int = field( + default=512, + metadata={ + "help": "Maximum total length of the sequence (prompt + completion) used to compute log probabilities. If " + "the sequence exceeds this limit, the leftmost tokens will be truncated to preserve as much of the " + "completion as possible." + }, + ) + temperature: float = field( + default=0.9, + metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."}, + ) + top_p: float = field( + default=1.0, + metadata={ + "help": "Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. " + "Set to 1.0 to consider all tokens." + }, + ) + top_k: int = field( + default=0, + metadata={ + "help": "Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, " + "top-k-filtering is disabled and all tokens are considered." + }, + ) + min_p: float | None = field( + default=None, + metadata={ + "help": "Minimum token probability, which will be scaled by the probability of the most likely token. It " + "must be a value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range." + }, + ) + repetition_penalty: float = field( + default=1.0, + metadata={ + "help": "Float that penalizes new tokens based on whether they appear in the prompt and the generated " + "text so far. Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model " + "to repeat tokens." + }, + ) + generation_kwargs: dict | None = field( + default=None, + metadata={ + "help": "Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or " + "`SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the " + "generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that " + "conflict with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them." + }, + ) + cache_implementation: str | None = field( + default=None, + metadata={"help": "Implementation of the cache method for faster generation when use_vllm is set to False."}, + ) + missing_eos_penalty: float | None = field( + default=None, + metadata={ + "help": "Penalty applied to the score when the model fails to generate an EOS token. This is useful to " + "encourage to generate completions shorter than the maximum length (`max_new_tokens`). The penalty must be " + "a positive value." + }, + ) + beta: list[float] = field( + default_factory=lambda: [0.1], + metadata={ + "help": "Parameter controlling the deviation from the reference model. Higher β means less deviation from " + "the reference model. For the IPO loss (`loss_type='ipo'`), β is the regularization parameter denoted by " + "τ in the [paper](https://huggingface.co/papers/2310.12036). If a list of floats is provided then the β " + "is selected for each new epoch and the last β is used for the rest of the epochs." + }, + ) + loss_type: str = field( + default="sigmoid", + metadata={ + "help": "Type of loss to use.", + "choices": ["sigmoid", "ipo"], + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the model."}, + ) + use_vllm: bool = field( + default=False, + metadata={ + "help": "Whether to use vLLM for generating completions. Requires vLLM to be installed " + "(`pip install trl[vllm]`)." + }, + ) + vllm_model_impl: str = field( + default="vllm", + metadata={ + "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: " + "Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for " + "model implementation." + }, + ) + vllm_structured_outputs_regex: str | None = field( + default=None, + metadata={"help": "Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled."}, + ) + vllm_gpu_memory_utilization: float | None = field( + default=0.55, + metadata={ + "help": "Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set " + "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when " + "launching the vLLM server via the `--vllm_gpu_memory_utilization` flag.", + }, + ) + vllm_mode: str = field( + default="colocate", + metadata={ + "help": "Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or " + "`'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure " + "a TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same " + "process and share the training GPUs. This avoids the need for a separate server but may cause resource " + "contention with training.", + }, + ) + vllm_server_base_url: str | None = field( + default=None, + metadata={ + "help": "Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` " + "and `vllm_server_port` are ignored.", + }, + ) + vllm_server_host: str = field( + default="0.0.0.0", + metadata={"help": "Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."}, + ) + vllm_server_port: int = field( + default=8000, + metadata={"help": "Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."}, + ) + vllm_server_timeout: float = field( + default=240.0, + metadata={ + "help": "Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up " + "after the timeout, a `ConnectionError` is raised.", + }, + ) + vllm_group_port: int = field( + default=51216, + metadata={ + "help": "Port number for the weight update group. This is used to communicate with the vLLM server. " + "Unless the port is occupied, there is no need to change it.", + }, + ) + vllm_tensor_parallel_size: int = field( + default=1, + metadata={ + "help": "Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set " + "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when " + "launching the vLLM server via the `--vllm_tensor_parallel_size` flag.", + }, + ) + vllm_enable_sleep_mode: bool = field( + default=False, + metadata={ + "help": "Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory " + "usage low, but waking the engine adds host–device transfer latency." + }, + ) + ds3_gather_for_generation: bool = field( + default=True, + metadata={ + "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for " + "generation, improving generation speed. However, disabling this option allows training models that " + "exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation. Disabling this option " + "is not compatible with vLLM generation." + }, + ) + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the model " + "from a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models that ship custom Python code from the Hub. Forwarded to " + "`AutoModelForCausalLM.from_pretrained`. Also applied to reward-model and reward-tokenizer loads." + }, + ) + reward_weights: list[float] | None = field( + default=None, + metadata={ + "help": "Weights for combining multiple reward functions. Must match the number of reward functions. " + "If None, all reward functions are equally weighted." + }, + ) + + def __post_init__(self): + super().__post_init__() + + if hasattr(self.beta, "__len__") and len(self.beta) == 1: + self.beta = self.beta[0] + + if self.max_new_tokens >= self.max_length: + warnings.warn( + f"The configuration has `max_new_tokens` ({self.max_new_tokens}) >= `max_length` ({self.max_length}). " + "This will cause prompts to be truncated or completely removed in the forward pass. " + "To preserve prompts, ensure e.g. `max_length > max_new_tokens + 512`. ", + stacklevel=3, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/online_dpo/online_dpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/online_dpo/online_dpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..83dc28d26fb3e3d098321bf1e90ae79e825de7e6 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/online_dpo/online_dpo_trainer.py @@ -0,0 +1,1354 @@ +# Copyright 2020-2026 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import re +import textwrap +from collections.abc import Callable +from contextlib import nullcontext +from pathlib import Path +from typing import Any + +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.data +import transformers +from accelerate import logging +from accelerate.utils import broadcast_object_list, gather_object, is_peft_model +from datasets import Dataset +from packaging.version import Version +from torch.distributed.fsdp import FullyShardedDataParallel as FSDP +from torch.utils.data import IterableDataset +from transformers import ( + AutoModelForCausalLM, + AutoModelForSequenceClassification, + AutoTokenizer, + DataCollator, + GenerationConfig, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, + is_bitsandbytes_available, +) +from transformers.models.auto.modeling_auto import MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES +from transformers.trainer_utils import EvalPrediction +from transformers.training_args import OptimizerNames +from transformers.utils import is_peft_available, is_sagemaker_mp_enabled + +from ...data_utils import apply_chat_template, is_conversational, maybe_apply_chat_template +from ...extras.profiling import profiling_context +from ...generation.vllm_client import VLLMClient +from ...import_utils import is_vllm_available +from ...models.utils import prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import disable_dropout_in_model, ensure_master_addr_port, get_config_model_id +from ..utils import DPODataCollatorWithPadding, create_reference_model, empty_cache, prepare_peft_model, truncate_right +from .online_dpo_config import OnlineDPOConfig + + +if is_peft_available(): + from peft import PeftConfig + + +if is_sagemaker_mp_enabled(): + from smdistributed.modelparallel import __version__ as SMP_VERSION + + IS_SAGEMAKER_MP_POST_1_10 = Version(SMP_VERSION) >= Version("1.10") + +else: + IS_SAGEMAKER_MP_POST_1_10 = False + + +if Version(transformers.__version__) >= Version("5.2.0"): + from transformers.trainer_pt_utils import nested_gather + + +if is_vllm_available(): + from vllm import LLM, SamplingParams + from vllm.sampling_params import StructuredOutputsParams + +if is_bitsandbytes_available(): + import bitsandbytes as bnb + +logger = logging.get_logger(__name__) + +# A reward function can be a string, interpreted as a model ID and loaded as a pretrained model, a pretrained model, or +# a callable that returns a list of floats (the rewards). The callable receives prompts, completions, and additional +# arguments from the trainer (refer to the trainer's source for details). To ensure forward compatibility, it should +# accept **kwargs. +RewardFunc = str | PreTrainedModel | Callable[..., list[float | None]] + + +class OnlineDPOTrainer(_BaseTrainer): + r""" + Initialize OnlineDPOTrainer. + + Args: + model (`str | nn.Module | PreTrainedModel`): + Model to be trained. Can be either: + + - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using [`~transformers.AutoModelForCausalLM.from_pretrained`] with the keyword arguments in + `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported. + ref_model ([`~transformers.PreTrainedModel`] or `torch.nn.Module` or `None`): + The reference model to use for training. If None is specified, the reference model will be created from the + model. + reward_funcs (`RewardFunc | list[RewardFunc]`): + Reward functions to be used for computing the rewards. To compute the rewards, we call all the reward + functions with the prompts and completions and sum the rewards. Can be either: + + - A single reward function: Can be a string (path to model), a [`~transformers.PreTrainedModel`], or a + custom callable function. + - A list of reward functions: Must all be of compatible types. + args ([`experimental.online_dpo.OnlineDPOConfig`]): + The online DPO config arguments to use for training. + data_collator ([`~transformers.DataCollator`]): + The data collator to use for training. If None is specified, the default data collator + ([`experimental.utils.DPODataCollatorWithPadding`]) will be used which will pad the sequences to the + maximum length of the sequences in the batch, given a dataset of paired sequences. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + The dataset to use for training. + eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`): + The dataset to use for evaluation. + processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. If provided, will be used to automatically process the inputs + for the model, and it will be saved along the model to make it easier to rerun an interrupted training or + reuse the fine-tuned model. + reward_processing_classes ([`~transformers.PreTrainedTokenizerBase`] or `list[PreTrainedTokenizerBase]`, *optional*): + Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either: + + - A single processing class: Used when `reward_funcs` contains only one reward function. + - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`. + + If set to `None`, the tokenizer for each model-based reward function is automatically loaded using + [`~transformers.AutoTokenizer.from_pretrained`]. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration used to wrap the model. If `None`, the model is not wrapped. + compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*): + The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to + metric values. + callbacks (`list[transformers.TrainerCallback]`): + The callbacks to use for training. + optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): + The optimizer and scheduler to use for training. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`): + The function to use to preprocess the logits before computing the metrics. + """ + + _tag_names = ["trl", "online-dpo"] + _name = "Online DPO" + _paper = { + "title": "Direct Language Model Alignment from Online AI Feedback", + "id": "2402.04792", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @article{guo2024direct, + title = {{Direct Language Model Alignment from Online AI Feedback}}, + author = {Shangmin Guo and Biao Zhang and Tianlin Liu and Tianqi Liu and Misha Khalman and Felipe Llinares and Alexandre Ram{\'{e}} and Thomas Mesnard and Yao Zhao and Bilal Piot and Johan Ferret and Mathieu Blondel}, + year = 2024, + eprint = {arXiv:2402.04792} + }"""), + } + + def __init__( + self, + model: PreTrainedModel | nn.Module | str, + ref_model: PreTrainedModel | nn.Module | None = None, + reward_funcs: RewardFunc | list[RewardFunc] | None = None, + args: OnlineDPOConfig | None = None, + data_collator: DataCollator | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None, + peft_config: "PeftConfig | None" = None, + compute_metrics: Callable[[EvalPrediction], dict] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + ) -> None: + if train_dataset is None: + raise ValueError("`train_dataset` is required") + + if ref_model is model: + raise ValueError( + "`model` and `ref_model` cannot be the same object. If you want `ref_model` to be the " + "same as `model`, either omit the `ref_model` argument or pass `None`." + ) + + self.ref_model = ref_model + + if reward_funcs is None: + raise ValueError("`reward_funcs` must be provided.") + + # Handle reward_funcs + if not isinstance(reward_funcs, list): + reward_funcs = [reward_funcs] + self.reward_func_names = [] + + # Process reward functions (convert strings to models, collect names) + model_init_kwargs = args.model_init_kwargs or {} + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + for i, reward_func in enumerate(reward_funcs): + if isinstance(reward_func, str): + # Load model from string path + reward_funcs[i] = AutoModelForSequenceClassification.from_pretrained( + reward_func, num_labels=1, **model_init_kwargs + ) + if isinstance(reward_funcs[i], nn.Module): + self.reward_func_names.append(get_config_model_id(reward_funcs[i].config).split("/")[-1]) + else: + self.reward_func_names.append(reward_funcs[i].__name__) + self.reward_funcs = reward_funcs + + # Handle reward processing classes for reward_funcs + if reward_processing_classes is None: + reward_processing_classes = [None] * len(reward_funcs) + elif not isinstance(reward_processing_classes, list): + reward_processing_classes = [reward_processing_classes] + else: + if len(reward_processing_classes) != len(reward_funcs): + raise ValueError("The number of reward processing classes must match the number of reward functions.") + + self.reward_processing_classes = [] + for reward_processing_class_i, reward_func in zip(reward_processing_classes, reward_funcs, strict=True): + if isinstance(reward_func, PreTrainedModel): + if reward_processing_class_i is None: + reward_processing_class_i = AutoTokenizer.from_pretrained( + reward_func.config._name_or_path, trust_remote_code=args.trust_remote_code + ) + if reward_processing_class_i.pad_token_id is None: + reward_processing_class_i.pad_token = reward_processing_class_i.eos_token + # Set pad token ID on reward model config + reward_func.config.pad_token_id = reward_processing_class_i.pad_token_id + self.reward_processing_classes.append(reward_processing_class_i) + + # Handle reward_weights + if args.reward_weights is not None: + if len(args.reward_weights) != len(self.reward_funcs): + raise ValueError( + f"Number of reward weights ({len(args.reward_weights)}) must match number of reward " + f"functions ({len(self.reward_funcs)})" + ) + self.reward_weights = torch.tensor(args.reward_weights, dtype=torch.float32) + else: + self.reward_weights = torch.ones(len(self.reward_funcs), dtype=torch.float32) + + if args is None: + raise ValueError("`args` must be provided.") + + # Check that the processing_class is provided + if processing_class is None: + raise ValueError("`processing_class` must be provided.") + + model_init_kwargs = args.model_init_kwargs or {} + if isinstance(model, str): + model_id = model + + # Handle dtype in model_init_kwargs + dtype = model_init_kwargs.get("dtype", "auto") + if isinstance(dtype, torch.dtype) or dtype == "auto" or dtype is None: + pass + elif isinstance(dtype, str): + dtype = getattr(torch, dtype) + model_init_kwargs["dtype"] = dtype + else: + raise ValueError( + "Invalid `dtype` passed to `OnlineDPOConfig`. Expected either 'auto' or a string " + f"representing a `torch.dtype` (e.g., 'float32'), but got {dtype}." + ) + model_init_kwargs["device_map"] = model_init_kwargs.get("device_map", "auto") + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + + model = AutoModelForCausalLM.from_pretrained(model_id, **model_init_kwargs) + else: + if args.model_init_kwargs is not None: + raise ValueError( + "You passed `model_init_kwargs` to the `OnlineDPOConfig`, but your model is already instantiated. " + "This argument can only be used when the `model` argument is a string." + ) + self.is_encoder_decoder = model.config.is_encoder_decoder + self.is_vision_model = model.config.model_type in MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES.keys() + + # PEFT + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if peft_config is not None or is_peft_model(model): + model = prepare_peft_model(model, peft_config, args) + + # Enable gradient checkpointing if requested + if args.gradient_checkpointing: + model = self._enable_gradient_checkpointing(model, args) + + # Disable dropout in the model and reference model + if args.disable_dropout: + disable_dropout_in_model(model) + if self.ref_model is not None: + disable_dropout_in_model(self.ref_model) + + # Handle the ref_model + # Usually, the user wants the ref model to be the initial version of the model. When using PEFT, it's easy to + # get the ref model, as it's just the model with a disabled adapter. When not using PEFT, we need to create + # the ref model from the model by copying it and disable the gradients and set it in evaluation mode. + if ref_model is None: # No ref model provided, the most common case + if peft_config is None: + self.ref_model = create_reference_model(model) # copy, disable gradients, set eval mode + else: + self.ref_model = None # we don't need a ref model here, we can just disable the adapter. + else: # rare case, the user provided a ref model + self.ref_model = ref_model + self.ref_model.eval() + + # Disable the gradient and set the reward model in eval mode + if reward_funcs is not None: + for reward_func in reward_funcs: + if isinstance(reward_func, PreTrainedModel): + reward_func.eval() + + self.max_length = args.max_length + + self.stats = { + "objective/kl": [], + "objective/entropy": [], + "objective/non_score_reward": [], + "rewards/chosen": [], + "rewards/rejected": [], + "rewards/accuracies": [], + "rewards/margins": [], + "logps/chosen": [], + "logps/rejected": [], + "val/contain_eos_token": [], + "beta": [], + } + if self.reward_funcs is not None: + self.stats["objective/rlhf_reward"] = [] + self.stats["objective/scores_margin"] = [] + self.stats["objective/scores"] = [] + + # Store generation parameters for later use + self.use_vllm = args.use_vllm + self.num_generations = 2 # Generate 2 completions per prompt for Online DPO + self.temperature = args.temperature + self.top_p = args.top_p + self.top_k = args.top_k + self.min_p = args.min_p + self.repetition_penalty = args.repetition_penalty + self.vllm_mode = args.vllm_mode if args.use_vllm else None + self.vllm_gpu_memory_utilization = args.vllm_gpu_memory_utilization + self.vllm_tensor_parallel_size = args.vllm_tensor_parallel_size + self.vllm_model_impl = args.vllm_model_impl + + # Handle pad token for processors or tokenizers + if isinstance(processing_class, ProcessorMixin): + self._tokenizer = processing_class.tokenizer + elif isinstance(processing_class, PreTrainedTokenizerBase): + self._tokenizer = processing_class + else: + raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`") + + if self._tokenizer.pad_token is None: + self._tokenizer.pad_token = self._tokenizer.eos_token + + # Vision tokens for VLM support + self.image_token_id = getattr(processing_class, "image_token_id", None) + self.vision_start_token_id = getattr(processing_class, "vision_start_token_id", None) + self.vision_end_token_id = getattr(processing_class, "vision_end_token_id", None) + # Get the image token string for token collapsing + self.image_token = None + if self.image_token_id is not None: + self.image_token = self._tokenizer.decode([self.image_token_id]) + + # Define the collator if not provided + if data_collator is None: + data_collator = DPODataCollatorWithPadding(pad_token_id=self._tokenizer.pad_token_id) + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + # Add tags for models that have been loaded with the correct transformers version + if hasattr(self.model, "add_model_tags"): + self.model.add_model_tags(self._tag_names) + + self._beta = args.beta + + # Set up generation configuration and vLLM after super().__init__ + if self.use_vllm: + if not is_vllm_available(): + raise ImportError( + "vLLM is not available and `use_vllm` is set to True. Please install vLLM with " + "`pip install trl[vllm]` to use it." + ) + + if self.vllm_mode == "server": + if self.accelerator.is_main_process: + if args.vllm_server_base_url is not None: + base_url = args.vllm_server_base_url + else: + base_url = f"http://{args.vllm_server_host}:{args.vllm_server_port}" + self.vllm_client = VLLMClient( + base_url=base_url, group_port=args.vllm_group_port, connection_timeout=args.vllm_server_timeout + ) + + # Determine device type (supports cuda, xpu, etc.) + accelerator_type = torch.accelerator.current_accelerator().type + current_device = getattr(torch, accelerator_type).current_device() + self.vllm_client.init_communicator(device=current_device) + else: + self.vllm_client = None + elif self.vllm_mode == "colocate": + # vLLM dynamically adjusts the size of the key-value cache based on available GPU memory at instantiation. + # A larger cache size improves speed, so we would expect gpu_memory_utilization=1. + # However, at this stage, the optimizer's weights are not yet loaded onto the GPU; they will be loaded + # after the first optimizer step and remain in GPU memory throughout training. So we must reserve enough + # space for them. + # Configure vLLM parameters + vllm_quantization = None + if is_bitsandbytes_available(): + for _, module in model.named_modules(): + if isinstance(module, bnb.nn.Linear4bit): + vllm_quantization = "bitsandbytes" + break + elif isinstance(module, bnb.nn.Linear8bitLt): + raise ValueError("vLLM does not support in-flight 8-bit quantization.") + vllm_kwargs = { + "model": model.name_or_path, + "tensor_parallel_size": self.vllm_tensor_parallel_size, + "gpu_memory_utilization": self.vllm_gpu_memory_utilization, + "model_impl": self.vllm_model_impl, + "max_num_seqs": self.args.per_device_train_batch_size * self.vllm_tensor_parallel_size, + "max_model_len": args.max_length + args.max_new_tokens, # max_length includes prompt + completion + "distributed_executor_backend": "external_launcher", + # Feed identical seed for tp groups to ensure sampling results are the same across workers + "seed": self.accelerator.process_index // self.vllm_tensor_parallel_size, + # Latest vLLM v1 memory profiler is misled by the high default value (i.e., 32768) + "max_num_batched_tokens": 4096, + "enable_sleep_mode": self.args.vllm_enable_sleep_mode, + "quantization": vllm_quantization, + } + + # vLLM requires the environment variables to be set for distributed training. + os.environ["RANK"] = str(self.accelerator.process_index) + os.environ["LOCAL_RANK"] = str(self.accelerator.local_process_index) + os.environ["WORLD_SIZE"] = str(self.accelerator.num_processes) + # Ensure distributed rendezvous variables are set without colliding across concurrent runs + ensure_master_addr_port() + + self.llm = LLM(**vllm_kwargs) + if self.args.vllm_enable_sleep_mode: + self.llm.sleep(level=2) + else: + raise ValueError(f"vllm_mode must be either 'server' or 'colocate', got '{self.vllm_mode}'.") + # vLLM specific sampling arguments + self.structured_outputs_regex = args.vllm_structured_outputs_regex + self._last_loaded_step = -1 # tag to avoid useless loading during grad accumulation + + # Set up vLLM generation config + generation_kwargs = { + "n": 2, # 2 generations per prompt for Online DPO + "repetition_penalty": self.repetition_penalty, + "temperature": self.temperature, + "top_p": self.top_p, + "top_k": self.top_k, + "min_p": 0.0 if self.min_p is None else self.min_p, + "max_tokens": args.max_new_tokens, + "detokenize": False, # to avoid vllm to decode (we don't need it) + } + if args.generation_kwargs is not None: + generation_kwargs.update(args.generation_kwargs) + if self.structured_outputs_regex is not None: + if generation_kwargs.get("structured_outputs") is not None: + logger.warning( + "Both `vllm_structured_outputs_regex` and `generation_kwargs['structured_outputs']` are set; " + "`vllm_structured_outputs_regex` takes precedence." + ) + generation_kwargs["structured_outputs"] = StructuredOutputsParams(regex=self.structured_outputs_regex) + elif isinstance(structured_outputs_kwargs := generation_kwargs.get("structured_outputs"), dict): + generation_kwargs["structured_outputs"] = StructuredOutputsParams(**structured_outputs_kwargs) + self.generation_config = SamplingParams(**generation_kwargs) + + # When using vLLM, the main process is responsible for loading the model weights. This can cause process + # desynchronization and seems to lead to DeepSpeed hanging during initialization. To prevent this, we + # synchronize all processes after vLLM has been fully initialized. + self.accelerator.wait_for_everyone() + else: + # Set up transformers generation config + generation_kwargs = { + "max_new_tokens": args.max_new_tokens, + "do_sample": True, + "pad_token_id": self._tokenizer.pad_token_id, + "bos_token_id": self._tokenizer.bos_token_id, + "eos_token_id": self._tokenizer.eos_token_id, + "temperature": self.temperature, + "top_k": self.top_k, + "top_p": self.top_p, + "repetition_penalty": self.repetition_penalty, + "use_cache": True if not self.args.gradient_checkpointing else False, + } + # Add min_p if supported + if self.min_p is not None: + generation_kwargs["min_p"] = self.min_p + if args.generation_kwargs is not None: + generation_kwargs.update(args.generation_kwargs) + # Remove None values + generation_kwargs = {k: v for k, v in generation_kwargs.items() if v is not None} + self.generation_config = GenerationConfig(**generation_kwargs) + # Keep training-specific generation kwargs to overwrite model's original generation config + self.generation_kwargs = generation_kwargs + + if self.ref_model is not None: + if self.is_deepspeed_enabled: + self.ref_model = prepare_deepspeed(self.ref_model, self.accelerator) + elif self.is_fsdp_enabled: + self.ref_model = prepare_fsdp(self.ref_model, self.accelerator) + else: + self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True) + if self.reward_funcs is not None: + for i, reward_func in enumerate(self.reward_funcs): + if isinstance(reward_func, PreTrainedModel): + if self.is_deepspeed_enabled: + self.reward_funcs[i] = prepare_deepspeed(reward_func, self.accelerator) + else: + # set device placement to True to make `prepare_model` move `reward_func` to device when using fsdp + self.reward_funcs[i] = self.accelerator.prepare_model( + reward_func, evaluation_mode=True, device_placement=True + ) + + @property + def beta(self): + if isinstance(self._beta, list): + epoch = self.state.epoch + return self._beta[epoch] if epoch < len(self._beta) else self._beta[-1] + else: + return self._beta + + @staticmethod + def tokenize_row(feature, is_encoder_decoder: bool, tokenizer: PreTrainedTokenizerBase) -> dict[str, Any]: + """Tokenize a single row from a DPO specific dataset.""" + if not is_encoder_decoder: + batch = tokenizer(feature["prompt"], add_special_tokens=False) + # Add BOS token to head of prompt. Avoid adding if it's already there + if tokenizer.bos_token_id is not None: + prompt_len_input_ids = len(batch["input_ids"]) + if prompt_len_input_ids == 0 or tokenizer.bos_token_id != batch["input_ids"][0]: + batch["input_ids"] = [tokenizer.bos_token_id] + batch["input_ids"] + batch["attention_mask"] = [1] + batch["attention_mask"] + else: + batch = tokenizer(feature["prompt"], add_special_tokens=True) + batch = {f"prompt_{key}": value for key, value in batch.items()} + return batch + + def _enable_gradient_checkpointing(self, model: PreTrainedModel, args: OnlineDPOConfig) -> PreTrainedModel: + """Enables gradient checkpointing for the model.""" + # Ensure use_cache is disabled + model.config.use_cache = False + + # Enable gradient checkpointing on the base model for PEFT + if is_peft_model(model): + model.base_model.gradient_checkpointing_enable() + # Enable gradient checkpointing for non-PEFT models + else: + model.gradient_checkpointing_enable() + + model.enable_input_require_grads() + return model + + def _generate_vllm(self, prompts, images=None): + eos_token_id = self._tokenizer.eos_token_id + pad_token_id = self._tokenizer.pad_token_id + + # Generate completion_ids and prompt_ids based on mode + if self.vllm_mode == "server": + completion_ids, prompt_ids = self._generate_vllm_server(prompts, images) + elif self.vllm_mode == "colocate": + completion_ids, prompt_ids = self._generate_vllm_colocate(prompts, images) + + # Shared padding, masking, and tensor conversion logic + max_prompt_length = max(len(ids) for ids in prompt_ids) + prompt_mask = [[0] * (max_prompt_length - len(ids)) + [1] * len(ids) for ids in prompt_ids] + prompt_ids = [[pad_token_id] * (max_prompt_length - len(ids)) + ids for ids in prompt_ids] + max_tokens = self.generation_config.max_tokens + completion_mask = [[1] * len(ids) + [0] * (max_tokens - len(ids)) for ids in completion_ids] + completion_ids = [ + ids + [eos_token_id] if ids[-1] != eos_token_id and len(ids) < max_tokens else ids + for ids in completion_ids + ] + completion_ids = [ids + [pad_token_id] * (max_tokens - len(ids)) for ids in completion_ids] + + # Convert to tensors + prompt_ids = torch.tensor(prompt_ids, device=self.accelerator.device) + prompt_mask = torch.tensor(prompt_mask, device=self.accelerator.device) + completion_ids = torch.tensor(completion_ids, device=self.accelerator.device) + completion_mask = torch.tensor(completion_mask, device=self.accelerator.device) + + return prompt_ids, prompt_mask, completion_ids, completion_mask + + def _generate_vllm_server(self, prompts, images=None): + """Generate completions using vLLM server mode""" + has_images = images is not None + + # Update vLLM server weights if needed + if hasattr(self, "_last_loaded_step") and self.state.global_step != self._last_loaded_step: + self._move_model_to_vllm() + self._last_loaded_step = self.state.global_step + elif not hasattr(self, "_last_loaded_step"): + self._move_model_to_vllm() + self._last_loaded_step = self.state.global_step + + # Apply chat template if conversational + if is_conversational({"prompt": prompts[0]}): + prompts_text = [apply_chat_template({"prompt": p}, self.processing_class)["prompt"] for p in prompts] + else: + prompts_text = prompts + # Gather all prompts to main process + all_prompts = gather_object(prompts_text) + if has_images: + all_images = gather_object(images) + + if self.accelerator.is_main_process: + # Since 'prompts' contains 'num_generations' duplicates, we first take unique prompts, and generate + # num_generations outputs for each one. This is faster than generating outputs for each duplicate + # prompt individually. + ordered_set_of_prompts = all_prompts[:: self.num_generations] + if has_images: + ordered_set_of_images = [ + [img] if img is not None else None for img in all_images[:: self.num_generations] + ] + else: + ordered_set_of_images = None + completion_ids = self.vllm_client.generate( + prompts=ordered_set_of_prompts, + images=ordered_set_of_images, + n=self.num_generations, + repetition_penalty=self.repetition_penalty, + temperature=self.temperature, + top_p=self.top_p, + top_k=-1 if self.top_k is None else self.top_k, + min_p=0.0 if self.min_p is None else self.min_p, + max_tokens=self.generation_config.max_tokens, + structured_outputs_regex=self.structured_outputs_regex + if hasattr(self, "structured_outputs_regex") + else None, + generation_kwargs=self.args.generation_kwargs, + )["completion_ids"] + # Flatten: each prompt generates 2 completions + completion_ids = [[comp_id] for prompt_completions in completion_ids for comp_id in prompt_completions] + else: + completion_ids = [None] * (len(all_prompts) * 2) + + # Broadcast completions to all processes + completion_ids = broadcast_object_list(completion_ids, from_process=0) + + # Each process takes its slice + process_slice = slice( + self.accelerator.process_index * len(prompts) * 2, + (self.accelerator.process_index + 1) * len(prompts) * 2, + ) + completion_ids = completion_ids[process_slice] + + # Create prompt_ids by tokenizing locally + prompt_inputs = self.processing_class( + text=prompts_text, + return_tensors="pt", + padding=True, + padding_side="left", + add_special_tokens=False, + ) + prompt_ids = [] + for prompt_tokens in prompt_inputs["input_ids"]: + prompt_ids.extend([prompt_tokens.tolist(), prompt_tokens.tolist()]) # 2 copies for 2 completions + return completion_ids, prompt_ids + + def _generate_vllm_colocate(self, prompts, images=None): + """Generate completions using vLLM colocate mode""" + if self.args.vllm_enable_sleep_mode: + # wake up colocated vLLM instances if needed + torch.cuda.empty_cache() # required to avoid OOM in some cases + self.llm.wake_up(tags=["weights"]) + + # Update model weights if needed - only after gradient accumulation completes + if self.state.global_step != self._last_loaded_step: + self._move_model_to_vllm() + self._last_loaded_step = self.state.global_step + + # Apply chat template if conversational + if is_conversational({"prompt": prompts[0]}): + prompts_text = [apply_chat_template({"prompt": p}, self.processing_class)["prompt"] for p in prompts] + else: + prompts_text = prompts + + # Prepare vLLM inputs with images if available + if images is not None: + vllm_inputs = [] + for prompt, image in zip(prompts_text, images, strict=True): + if image is not None: + vllm_inputs.append({"prompt": prompt, "multi_modal_data": {"image": image}}) + else: + vllm_inputs.append(prompt) + else: + vllm_inputs = prompts_text + + if self.args.vllm_enable_sleep_mode: + self.llm.wake_up(tags=["kv_cache"]) + + outputs = self.llm.generate(vllm_inputs, self.generation_config, use_tqdm=False) + + completion_ids = [list(output.outputs[i].token_ids) for i in range(2) for output in outputs] + prompt_ids = [list(output.prompt_token_ids) for _ in range(2) for output in outputs] + if self.args.vllm_enable_sleep_mode: + self.llm.sleep(level=2) + + return completion_ids, prompt_ids + + def _sync_fsdp2_params_to_vllm(self, module: nn.Module): + # For FSDP2, module.state_dict() already covers all parameters, so no need for recursion + for name, param in module.state_dict().items(): + # When using PEFT, we need to recover the original parameter name + name = name.removeprefix("base_model.model.").replace(".base_layer", "") + # Skip PEFT layers: they don’t exist in vLLM, and they are merged already. + if is_peft_model(module) and module.prefix in name: + continue + # When module to save, remove its prefix and discard the original module + if "original_module" in name: + continue + name = self._fix_param_name_to_vllm(name, extra_prefixes=["modules_to_save.default."]) + + if param.is_cpu: + param = param.to(torch.device("cuda")) + param = param.full_tensor() + + if self.vllm_mode == "server" and self.accelerator.is_main_process: + self.vllm_client.update_named_param(name, param) + elif self.vllm_mode == "colocate": + llm_model = self.llm.llm_engine.model_executor.driver_worker.model_runner.model + llm_model.load_weights([(name, param)]) + + def _move_model_to_vllm(self): + # For DeepSpeed ZeRO-3 and FSDP, we need to gather all parameters before operations + deepspeed_plugin = self.accelerator.state.deepspeed_plugin + zero_stage_3 = deepspeed_plugin is not None and deepspeed_plugin.zero_stage == 3 + if zero_stage_3: + import deepspeed + + gather_if_zero3 = deepspeed.zero.GatheredParameters + else: + gather_if_zero3 = nullcontext + + if is_peft_model(self.model): + # With PEFT and FSDP/DeepSpeed ZeRO Stage 3, we must gather the full model at once before merging, as + # merging adapters in a sharded manner is not supported. + # TODO: does this work with FSDP? + with gather_if_zero3(list(self.model.parameters())): + self.model.merge_adapter() + + # Update vLLM weights while parameters are gathered + if self.is_fsdp_enabled: # note if using FSDP, gather_if_zero3 is nullcontext + # Update vLLM weights while parameters are gathered + # For PEFT with FSDP we need to use the memory efficient post-order traversal + fsdp_plugin = getattr(self.accelerator.state, "fsdp_plugin", None) + fsdp_version = getattr(fsdp_plugin, "fsdp_version", 1) if fsdp_plugin else 1 + if fsdp_version == 1: + self._sync_fsdp1_params_to_vllm( + self.model + ) # use memory-efficient post-order traversal for FSDP + elif fsdp_version == 2: + self._sync_fsdp2_params_to_vllm(self.model) + else: + # DeepSpeed ZeRO-3 with PEFT + for name, param in self.model.named_parameters(): + # When using PEFT, we need to recover the original parameter name + name = name.removeprefix("base_model.model.").replace(".base_layer", "") + # Skip PEFT layers: they don’t exist in vLLM, and they are merged already. + if self.model.prefix in name: + continue + # When module to save, remove its prefix and discard the original module + if "original_module" in name: + continue + name = self._fix_param_name_to_vllm(name, extra_prefixes=["modules_to_save.default."]) + + if self.vllm_mode == "server" and self.accelerator.is_main_process: + self.vllm_client.update_named_param(name, param.data) + elif self.vllm_mode == "colocate": + llm_model = self.llm.llm_engine.model_executor.driver_worker.model_runner.model + llm_model.load_weights([(name, param.data)]) + # Unmerge adapters while parameters are still gathered + self.model.unmerge_adapter() + # Parameters will automatically be repartitioned when exiting the context + else: + # For non-PEFT models, simply gather (if needed) and update each parameter individually. + if self.is_fsdp_enabled: + fsdp_plugin = getattr(self.accelerator.state, "fsdp_plugin", None) + fsdp_version = getattr(fsdp_plugin, "fsdp_version", 1) if fsdp_plugin else 1 + if fsdp_version == 1: + self._sync_fsdp1_params_to_vllm(self.model) # use memory-efficient post-order traversal for FSDP + elif fsdp_version == 2: + self._sync_fsdp2_params_to_vllm(self.model) + else: + for name, param in self.model.named_parameters(): + name = self._fix_param_name_to_vllm(name) + with gather_if_zero3([param]): + if self.vllm_mode == "server" and self.accelerator.is_main_process: + self.vllm_client.update_named_param(name, param.data) + elif self.vllm_mode == "colocate": + llm_model = self.llm.llm_engine.model_executor.driver_worker.model_runner.model + llm_model.load_weights([(name, param.data)]) + + # Reset cache on vLLM + if self.vllm_mode == "server" and self.accelerator.is_main_process: + self.vllm_client.reset_prefix_cache() + elif self.vllm_mode == "colocate": + self.llm.reset_prefix_cache() + + def _sync_fsdp1_params_to_vllm(self, module: nn.Module, prefix: str = "", visited=None): + """Memory-efficient post-order traversal of FSDP modules to extract full parameters and sync with vLLM.""" + # For FSDP1, we need to recurse into children and also use summon_full_params + if visited is None: + visited = set() + for child_name, child_module in module.named_children(): + child_prefix = f"{prefix}.{child_name}" if prefix else child_name + self._sync_fsdp1_params_to_vllm( + child_module, prefix=child_prefix, visited=visited + ) # recurse into the child + + if isinstance(module, FSDP): + with FSDP.summon_full_params(module, recurse=False, writeback=False): + for param_name, param in module.named_parameters(): + full_name = f"{prefix}.{param_name}" if prefix else param_name + full_name = self._fix_param_name_to_vllm(full_name, extra_prefixes=["_fsdp_wrapped_module."]) + + if full_name in visited: + continue # skip FSDP subtrees already traversed + visited.add(full_name) + + if self.vllm_mode == "server" and self.accelerator.is_main_process: + self.vllm_client.update_named_param(full_name, param.data) + elif self.vllm_mode == "colocate": + llm_model = self.llm.llm_engine.model_executor.driver_worker.model_runner.model + llm_model.load_weights([(full_name, param.data)]) + + def _fix_param_name_to_vllm(self, name, extra_prefixes: list[str] | None = None): + """Clean parameter names for vLLM compatibility""" + extra_prefixes = extra_prefixes or [] + prefixes = ["_checkpoint_wrapped_module."] + extra_prefixes + for prefix in prefixes: + name = name.replace(prefix, "") + return name + + def process_vision_row( + self, features: dict[str, list | torch.Tensor], processing_class=None + ) -> dict[str, list[int]]: + """ + Process a vision row for VLM models (adapted from DPO trainer) + """ + processor = processing_class or self.processing_class + processed_features = processor(images=[features["image"]], text=features["prompt"], add_special_tokens=False) + + prompt_input_ids = processed_features["input_ids"][0] + + # Create the output dict with required fields + output = { + "prompt_input_ids": prompt_input_ids, + "prompt_attention_mask": processed_features["attention_mask"][0], + } + + # Add vision-specific fields + if "pixel_values" in processed_features: + output["pixel_values"] = processed_features["pixel_values"][0] + if "pixel_attention_mask" in processed_features: + output["pixel_attention_mask"] = processed_features["pixel_attention_mask"][0] + if "image_sizes" in processed_features: + output["image_sizes"] = processed_features["image_sizes"][0] + + return output + + def _generate(self, model, prompts, images=None): + """Generate completions using the model""" + device = next(model.parameters()).device + eos_token_id = self._tokenizer.eos_token_id + pad_token_id = self._tokenizer.pad_token_id + + # Apply chat template and tokenize the input + inputs = [{"prompt": prompt} for prompt in prompts] + + # Add images if provided (VLM support) + if images is not None: + for i, image in enumerate(images): + inputs[i]["image"] = image + + # Apply chat template to get text prompts + prompts_text = [maybe_apply_chat_template(x, self.processing_class)["prompt"] for x in inputs] + + # Handle image token collapsing/removal + # The chat template sometimes inserts a single image token into the prompt text. However, when this text is + # later tokenized, the single image token string is expanded into multiple image token IDs, depending on the + # image size. We need to handle this properly. + if self.image_token is not None and images is not None: + escaped_img_token = re.escape(self.image_token) + # Search for the image token in the chat template + if hasattr(self.processing_class, "chat_template") and self.processing_class.chat_template: + if re.search(escaped_img_token, self.processing_class.chat_template): + # Collapse repeated image tokens back into a single token + prompts_text = [ + re.sub(rf"({escaped_img_token})+", self.image_token, text) for text in prompts_text + ] + else: + # If the chat template doesn't use the image token, remove all instances + if self.vision_end_token_id is not None: + escaped_eoi_token = re.escape(self._tokenizer.decode([self.vision_end_token_id])) + prompts_text = [ + re.sub(rf"({escaped_img_token})+{escaped_eoi_token}", "", text) for text in prompts_text + ] + else: + # If vision_end_token_id is None, just remove the image tokens + prompts_text = [re.sub(rf"({escaped_img_token})+", "", text) for text in prompts_text] + + # Prepare kwargs for processing class + kwargs = {} + if images is not None: + kwargs = {"images": [[img] for img in images]} + + # Process inputs using the processing class (handles both VLM and LLM) + prompt_inputs = self.processing_class( + text=prompts_text, + return_tensors="pt", + padding=True, + padding_side="left", + add_special_tokens=False, + **kwargs, + ) + + prompt_inputs = {k: v.to(device) for k, v in prompt_inputs.items()} + # Convert vision inputs to model's dtype for proper computation + if "pixel_values" in prompt_inputs: + # Handle DataParallel wrapped models + model_dtype = getattr(model, "dtype", None) + if model_dtype is None and hasattr(model, "module"): + model_dtype = model.module.dtype + if model_dtype is not None: + prompt_inputs["pixel_values"] = prompt_inputs["pixel_values"].to(model_dtype) + + # Sample 2 completions per prompt of size `max_new_tokens` from the model + prompt_ids = prompt_inputs["input_ids"].repeat(2, 1) + prompt_mask = prompt_inputs["attention_mask"].repeat(2, 1) + + # Prepare vision inputs if available + vision_generation_kwargs = {} + if self.is_vision_model and images is not None: + if "pixel_values" in prompt_inputs: + vision_generation_kwargs["pixel_values"] = prompt_inputs["pixel_values"].repeat(2, 1, 1, 1) + if "pixel_attention_mask" in prompt_inputs: + vision_generation_kwargs["pixel_attention_mask"] = prompt_inputs["pixel_attention_mask"].repeat(2, 1) + if "image_sizes" in prompt_inputs: + vision_generation_kwargs["image_sizes"] = prompt_inputs["image_sizes"].repeat(2, 1) + if "image_grid_thw" in prompt_inputs: + vision_generation_kwargs["image_grid_thw"] = prompt_inputs["image_grid_thw"].repeat(2, 1) + + with ( + profiling_context(self, "transformers.generate"), + unwrap_model_for_generation( + model, + self.accelerator, + gather_deepspeed3_params=self.args.ds3_gather_for_generation, + generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762 + ) as unwrapped_model, + torch.no_grad(), + FSDP.summon_full_params(self.model_wrapped, recurse=False) if self.is_fsdp_enabled else nullcontext(), + ): + # Setup cache implementation if specified + if self.args.cache_implementation is not None: + unwrapped_model.generation_config.cache_implementation = self.args.cache_implementation + + # Standard generation + output = unwrapped_model.generate( + input_ids=prompt_ids, + attention_mask=prompt_mask, + generation_config=self.generation_config, + **vision_generation_kwargs, + ) + + completion_ids = output[:, prompt_ids.size(1) :] + completion_ids, completion_mask = truncate_right(completion_ids, eos_token_id, pad_token_id) + + return prompt_ids, prompt_mask, completion_ids, completion_mask + + def _calculate_rewards_from_functions(self, prompts, completions, completion_ids_list, **reward_kwargs): + """ + Calculate rewards using reward functions + """ + device = self.accelerator.device + rewards_per_func = torch.zeros(len(prompts), len(self.reward_funcs), device=device) + + # Add trainer state to reward kwargs for dynamic reward shaping + reward_kwargs["trainer_state"] = self.state + + for i, (reward_func, reward_processing_class) in enumerate( + zip(self.reward_funcs, self.reward_processing_classes, strict=True) + ): + if isinstance(reward_func, nn.Module): # Model-based reward function + # Handle conversational vs text input + if is_conversational({"prompt": prompts[0]}): + messages = [{"messages": p + c} for p, c in zip(prompts, completions, strict=True)] + texts = [apply_chat_template(x, reward_processing_class)["text"] for x in messages] + else: + texts = [p + c for p, c in zip(prompts, completions, strict=True)] + + # Tokenize and get reward scores + reward_inputs = reward_processing_class( + text=texts, return_tensors="pt", padding=True, padding_side="right", add_special_tokens=False + ) + reward_inputs = {k: v.to(device) for k, v in reward_inputs.items()} + + with torch.inference_mode(): + rewards_per_func[:, i] = reward_func(**reward_inputs).logits[:, 0] # Shape (B*G,) + else: + # Custom reward function + output_reward_func = reward_func( + prompts=prompts, completions=completions, completion_ids=completion_ids_list, **reward_kwargs + ) + # Convert None values to NaN + output_reward_func = [reward if reward is not None else torch.nan for reward in output_reward_func] + rewards_per_func[:, i] = torch.tensor(output_reward_func, dtype=torch.float32, device=device) + + # Weight and sum across all reward functions + if self.reward_weights is not None: + total_rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1) + else: + total_rewards = rewards_per_func.nansum(dim=1) + + return total_rewards + + def _forward(self, model, prompt_ids, prompt_mask, completion_ids, completion_mask, vision_inputs=None): + # Get the number of tokens to truncate from prompt + num_tokens_to_truncate = max(prompt_ids.size(1) + completion_ids.size(1) - self.max_length, 0) + + # Truncate left to avoid oom + prompt_ids = prompt_ids[:, num_tokens_to_truncate:] + prompt_mask = prompt_mask[:, num_tokens_to_truncate:] + + # Concat the prompt and completion + prompt_completion_ids = torch.cat((prompt_ids, completion_ids), dim=1) + prompt_completion_mask = torch.cat((prompt_mask, completion_mask), dim=1) + + # Prepare model kwargs with vision inputs if available + model_kwargs = {"attention_mask": prompt_completion_mask} + if vision_inputs is not None: + if "pixel_values" in vision_inputs: + model_kwargs["pixel_values"] = vision_inputs["pixel_values"] + if "pixel_attention_mask" in vision_inputs: + model_kwargs["pixel_attention_mask"] = vision_inputs["pixel_attention_mask"] + if "image_sizes" in vision_inputs: + model_kwargs["image_sizes"] = vision_inputs["image_sizes"] + if "image_grid_thw" in vision_inputs: + model_kwargs["image_grid_thw"] = vision_inputs["image_grid_thw"] + + # Get the logprobs of the completions from the model + output = model(prompt_completion_ids, **model_kwargs) + + # There is 1 offset, because the model predicts the next token + prompt_len = prompt_ids.size(1) + start_idx = prompt_len - 1 if prompt_len > 0 else 0 + # Only slice off the last logit when we have a prompt, otherwise we need all logits + end_idx = -1 if prompt_len > 0 else None + logits = output.logits[:, start_idx:end_idx] + + # Take the completion tokens logprob + logprobs = torch.take_along_dim(logits.log_softmax(dim=-1), completion_ids.unsqueeze(-1), dim=2).squeeze(-1) + return logprobs + + def training_step( + self, model: nn.Module, inputs: dict[str, torch.Tensor | Any], num_items_in_batch: int | None = None + ) -> torch.Tensor: + model.train() + + prompts = inputs["prompt"] + batch_size = len(prompts) + + # Handle images for VLM support + has_images = "image" in inputs + images = None + if has_images: + images = inputs["image"] + # Convert conversational prompts to include image tokens + for prompt in prompts: + if isinstance(prompt, list): + for message in prompt: + if not isinstance(message, dict): + continue + content = message.get("content") + role = message.get("role") + if isinstance(content, str): + if role == "user": + message["content"] = [{"type": "image"}, {"type": "text", "text": content}] + elif role == "system": + message["content"] = [{"type": "text", "text": content}] + + if self.args.use_vllm: + prompt_ids, prompt_mask, completion_ids, completion_mask = self._generate_vllm(prompts, images) + else: + prompt_ids, prompt_mask, completion_ids, completion_mask = self._generate(model, prompts, images) + + contain_eos_token = torch.any(completion_ids == self._tokenizer.eos_token_id, dim=-1) + + # Extract vision inputs if available for VLM support + vision_inputs = None + if has_images and self.is_vision_model and not self.args.use_vllm: + # For vision models with transformers generation, we need to prepare vision inputs + # Process the images to get vision inputs that can be passed through the forward pass + vision_inputs = {} + kwargs = {"images": [[img] for img in images]} + processed = self.processing_class( + text=[""] * len(images), # Dummy text for vision processing + return_tensors="pt", + **kwargs, + ) + # Handle DataParallel wrapped models + model_device = getattr(model, "device", None) + model_dtype = getattr(model, "dtype", None) + if model_device is None and hasattr(model, "module"): + model_device = model.module.device + model_dtype = model.module.dtype + # Move vision tensors to device and convert to model dtype + # Need to duplicate for 2 completions per prompt + if "pixel_values" in processed: + vision_inputs["pixel_values"] = ( + processed["pixel_values"].to(model_device, dtype=model_dtype).repeat(2, 1, 1, 1) + ) + if "pixel_attention_mask" in processed: + vision_inputs["pixel_attention_mask"] = processed["pixel_attention_mask"].to(model_device).repeat(2, 1) + if "image_sizes" in processed: + vision_inputs["image_sizes"] = processed["image_sizes"].to(model_device).repeat(2, 1) + if "image_grid_thw" in processed: + vision_inputs["image_grid_thw"] = processed["image_grid_thw"].to(model_device).repeat(2, 1) + + logprobs = self._forward(model, prompt_ids, prompt_mask, completion_ids, completion_mask, vision_inputs) + with torch.no_grad(): + if self.ref_model is not None: + ref_logprobs = self._forward( + self.ref_model, prompt_ids, prompt_mask, completion_ids, completion_mask, vision_inputs + ) + else: # peft case: we just need to disable the adapter + with self.model.disable_adapter(): + ref_logprobs = self._forward( + self.model, prompt_ids, prompt_mask, completion_ids, completion_mask, vision_inputs + ) + + # Decode the completions, and format them if the input is conversational + device = logprobs.device + completions = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + if is_conversational({"prompt": prompts[0]}): + completions = [[{"role": "assistant", "content": completion}] for completion in completions] + + # Get the reward from reward functions + # First create completion_ids_list for custom reward functions + completion_ids_list = [completion_ids[i].tolist() for i in range(completion_ids.shape[0])] + + # Extract additional fields from inputs for reward functions + reward_kwargs = {} + keys = [key for key in inputs if key not in ["prompt"]] + for key in keys: + if isinstance(inputs[key], (list, tuple)): + # Repeat input fields to match number of completions (2 per prompt) + reward_kwargs[key] = inputs[key] * 2 + else: + reward_kwargs[key] = inputs[key] + + # Calculate rewards using reward functions + rewards = self._calculate_rewards_from_functions( + prompts=2 * prompts, completions=completions, completion_ids_list=completion_ids_list, **reward_kwargs + ) + + # Apply missing EOS penalty if configured + if self.args.missing_eos_penalty is not None: + rewards[~contain_eos_token] -= self.args.missing_eos_penalty + + # Split rewards into chosen/rejected pairs + first_half, second_half = rewards.split(batch_size) + mask = first_half >= second_half + + batch_range = torch.arange(batch_size, device=device) + chosen_indices = batch_range + (~mask * batch_size) + rejected_indices = batch_range + (mask * batch_size) + + # Build tensor so that the first half is the chosen examples and the second half the rejected examples + cr_indices = torch.cat((chosen_indices, rejected_indices), dim=0) # cr = chosen and rejected + cr_logprobs = logprobs[cr_indices] + cr_ref_logprobs = ref_logprobs[cr_indices] + + # mask out the padding tokens + padding_mask = ~completion_mask.bool() + cr_padding_mask = padding_mask[cr_indices] + + cr_logprobs_sum = (cr_logprobs * ~cr_padding_mask).sum(1) + cr_ref_logprobs_sum = (cr_ref_logprobs * ~cr_padding_mask).sum(1) + + # Split the chosen and rejected examples + chosen_logprobs_sum, rejected_logprobs_sum = torch.split(cr_logprobs_sum, batch_size) + chosen_ref_logprobs_sum, rejected_ref_logprobs_sum = torch.split(cr_ref_logprobs_sum, batch_size) + pi_logratios = chosen_logprobs_sum - rejected_logprobs_sum + ref_logratios = chosen_ref_logprobs_sum - rejected_ref_logprobs_sum + + logits = pi_logratios - ref_logratios + + if self.args.loss_type == "sigmoid": + losses = -F.logsigmoid(self.beta * logits) + elif self.args.loss_type == "ipo": + losses = (logits - 1 / (2 * self.beta)) ** 2 + else: + raise NotImplementedError(f"invalid loss type {self.args.loss_type}") + + loss = losses.mean() + + # Log everything + if self.reward_funcs is not None: + # When using reward_funcs, we have rewards instead of scores + scores_margin = rewards[chosen_indices] - rewards[rejected_indices] + self.stats["objective/scores_margin"].append( + self.accelerator.gather_for_metrics(scores_margin.mean()).mean().item() + ) + self.stats["objective/scores"].append(self.accelerator.gather_for_metrics(rewards.mean()).mean().item()) + self.stats["val/contain_eos_token"].append(contain_eos_token.float().mean().item()) + self.stats["logps/chosen"].append(self.accelerator.gather_for_metrics(chosen_logprobs_sum).mean().item()) + self.stats["logps/rejected"].append(self.accelerator.gather_for_metrics(rejected_logprobs_sum).mean().item()) + + kl = logprobs - ref_logprobs + mean_kl = kl.sum(1).mean() + self.stats["objective/kl"].append(self.accelerator.gather_for_metrics(mean_kl).mean().item()) + non_score_reward = (-self.beta * kl).sum(1) + mean_non_score_reward = non_score_reward.mean() + self.stats["objective/non_score_reward"].append( + self.accelerator.gather_for_metrics(mean_non_score_reward).mean().item() + ) + if self.reward_funcs is not None: + # Calculate RLHF reward by combining rewards with non_score_reward + rlhf_reward = rewards + non_score_reward + self.stats["objective/rlhf_reward"].append(self.accelerator.gather_for_metrics(rlhf_reward).mean().item()) + + mean_entropy = -logprobs.sum(1).mean() + self.stats["objective/entropy"].append(self.accelerator.gather_for_metrics(mean_entropy).mean().item()) + chosen_rewards = self.beta * (chosen_logprobs_sum - chosen_ref_logprobs_sum) + gathered_chosen_rewards = self.accelerator.gather_for_metrics(chosen_rewards) + self.stats["rewards/chosen"].append(gathered_chosen_rewards.mean().item()) + rejected_rewards = self.beta * (rejected_logprobs_sum - rejected_ref_logprobs_sum) + gathered_rejected_rewards = self.accelerator.gather_for_metrics(rejected_rewards) + self.stats["rewards/rejected"].append(gathered_rejected_rewards.mean().item()) + margin = gathered_chosen_rewards - gathered_rejected_rewards + self.stats["rewards/margins"].append(margin.mean().item()) + accuracy = margin > 0 + self.stats["rewards/accuracies"].append(accuracy.float().mean().item()) + self.stats["beta"].append(self.beta) + + if ( + self.args.torch_empty_cache_steps is not None + and self.state.global_step % self.args.torch_empty_cache_steps == 0 + ): + empty_cache() + + kwargs = {} + + # For LOMO optimizers you need to explicitly use the learning rate + if self.args.optim in [OptimizerNames.LOMO, OptimizerNames.ADALOMO]: + kwargs["learning_rate"] = self._get_learning_rate() + + if self.args.n_gpu > 1: + loss = loss.mean() # mean() to average on multi-gpu parallel training + + self.accelerator.backward(loss, **kwargs) + + return loss.detach() / self.args.gradient_accumulation_steps + + # Same as Trainer._maybe_log_save_evaluate but log our metrics + def _maybe_log_save_evaluate( + self, tr_loss, grad_norm, model, trial, epoch, ignore_keys_for_eval, start_time, learning_rate=None + ): + if self.control.should_log and self.state.global_step > self._globalstep_last_logged: + logs: dict[str, float] = {} + + # all_gather + mean() to get average loss over all processes + if Version(transformers.__version__) >= Version("5.2.0"): + tr_loss_scalar = nested_gather(tr_loss, self.args.parallel_mode).mean().item() + else: + tr_loss_scalar = self._nested_gather(tr_loss).mean().item() + + # reset tr_loss to zero + tr_loss -= tr_loss + + logs["loss"] = round(tr_loss_scalar / (self.state.global_step - self._globalstep_last_logged), 4) + if grad_norm is not None: + logs["grad_norm"] = grad_norm.detach().item() if isinstance(grad_norm, torch.Tensor) else grad_norm + if learning_rate is not None: + logs["learning_rate"] = learning_rate + else: + logs["learning_rate"] = self._get_learning_rate() + + # Add our metrics + for key, val in self.stats.items(): + logs[key] = sum(val) / len(val) + self.stats = {key: [] for key in self.stats} # reset stats + + self._total_loss_scalar += tr_loss_scalar + self._globalstep_last_logged = self.state.global_step + self.store_flos() + self.log(logs, start_time) + + metrics = None + if self.control.should_evaluate: + metrics = self._evaluate(trial, ignore_keys_for_eval) + is_new_best_metric = self._determine_best_metric(metrics=metrics, trial=trial) + + if self.args.save_strategy == "best": + self.control.should_save = is_new_best_metric + + if self.control.should_save: + self._save_checkpoint(model, trial) + self.control = self.callback_handler.on_save(self.args, self.state, self.control) + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openenv/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openenv/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4325e17f284102bd02848b432cd9d9ffedd32f58 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openenv/__init__.py @@ -0,0 +1,18 @@ +# Copyright 2020-2026 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. + +from .utils import generate_rollout_completions + + +__all__ = ["generate_rollout_completions"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openenv/utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openenv/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f8f4d573854a4fa9cf93fb8f7a354d54c7fad0c9 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openenv/utils.py @@ -0,0 +1,214 @@ +# Copyright 2020-2026 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. + +from typing import Any + +import torch + +from ...data_utils import is_conversational +from ...extras.profiling import profiling_context +from ...import_utils import is_vllm_available + + +if is_vllm_available(): + from vllm import SamplingParams + from vllm.sampling_params import StructuredOutputsParams + + +def _build_base_generation_kwargs( + trainer, + overrides: dict[str, Any] | None = None, +) -> dict[str, Any]: + """Build base generation kwargs common to both colocate and server modes.""" + generation_kwargs: dict[str, Any] = { + "n": 1, + "temperature": trainer.temperature, + "top_k": trainer.top_k, + "min_p": 0.0 if trainer.min_p is None else trainer.min_p, + "max_tokens": trainer.max_completion_length, + } + if trainer.repetition_penalty is not None: + generation_kwargs["repetition_penalty"] = trainer.repetition_penalty + if trainer.top_p is not None: + generation_kwargs["top_p"] = trainer.top_p + + if trainer.args.generation_kwargs is not None: + generation_kwargs.update(trainer.args.generation_kwargs) + + if overrides is not None: + generation_kwargs.update(overrides) + + generation_kwargs = {key: value for key, value in generation_kwargs.items() if value is not None} + + if generation_kwargs.get("n", 1) != 1: + raise ValueError("generate_rollout_completions expects n=1.") + + return generation_kwargs + + +def _build_colocate_sampling_params( + trainer, + overrides: dict[str, Any] | None = None, + *, + logprobs: bool = True, +) -> "SamplingParams": + """Build SamplingParams for colocate mode.""" + generation_kwargs = _build_base_generation_kwargs(trainer, overrides) + + # Add colocate-specific parameters + if trainer.vllm_generation.structured_outputs_regex: + generation_kwargs["structured_outputs"] = StructuredOutputsParams( + regex=trainer.vllm_generation.structured_outputs_regex + ) + if logprobs: + generation_kwargs["logprobs"] = 0 + + return SamplingParams(**generation_kwargs) + + +def _build_server_generation_kwargs( + trainer, + overrides: dict[str, Any] | None = None, +) -> dict[str, Any]: + """Build generation kwargs for server mode.""" + return _build_base_generation_kwargs(trainer, overrides) + + +def generate_rollout_completions( + trainer, + prompts: list[str], + *, + generation_overrides: dict[str, Any] | None = None, + as_chat: bool | None = None, +) -> list[dict[str, Any]]: + """ + Generate completions for custom rollouts when vLLM is running in colocate or server mode. + + Returns one result per prompt, containing prompt and completion token ids along with per-token log probabilities + and the generated text. + """ + + if not prompts: + return [] + + if not trainer.use_vllm: + raise RuntimeError("Custom rollouts require vLLM to call generate_rollout_completions.") + + if trainer.vllm_mode == "server": + return _generate_rollout_completions_server(trainer, prompts, generation_overrides, as_chat) + elif trainer.vllm_mode == "colocate": + return _generate_rollout_completions_colocate(trainer, prompts, generation_overrides, as_chat) + else: + raise ValueError(f"vllm_mode must be 'server' or 'colocate', got '{trainer.vllm_mode}'") + + +def _generate_rollout_completions_server( + trainer, + prompts: list[str], + generation_overrides: dict[str, Any] | None = None, + as_chat: bool | None = None, +) -> list[dict[str, Any]]: + """Generate completions using vLLM server mode.""" + generation_kwargs = _build_server_generation_kwargs(trainer, generation_overrides) + + if as_chat is None: + as_chat = prompts and is_conversational({"prompt": prompts[0]}) + + with profiling_context(trainer, "vLLM.generate_rollout_server"): + if as_chat: + # Prompts are raw message dicts; use .chat() so the vLLM server applies the chat template + output = trainer.vllm_generation.vllm_client.chat( + messages=prompts, + **generation_kwargs, + chat_template_kwargs=trainer.chat_template_kwargs, + tools=trainer.tools or None, + chat_template=trainer.chat_template, + ) + else: + output = trainer.vllm_generation.vllm_client.generate(prompts=prompts, **generation_kwargs) + + # Format results to match colocate output format + results: list[dict[str, Any]] = [] + for i in range(len(prompts)): + results.append( + { + "prompt_ids": output["prompt_ids"][i], + "completion_ids": list(output["completion_ids"][i]), + "logprobs": list(output["logprobs"][i]), + "text": trainer.processing_class.decode(output["completion_ids"][i], skip_special_tokens=True), + } + ) + + return results + + +def _generate_rollout_completions_colocate( + trainer, + prompts: list[str], + generation_overrides: dict[str, Any] | None = None, + as_chat: bool | None = None, +) -> list[dict[str, Any]]: + """Generate completions using vLLM colocate mode.""" + sampling_params = _build_colocate_sampling_params(trainer, generation_overrides) + prompts_for_generation = prompts + original_size = len(prompts) + + if trainer.vllm_tensor_parallel_size > 1: + gathered_prompts = [None for _ in range(trainer.vllm_tensor_parallel_size)] + torch.distributed.all_gather_object(gathered_prompts, prompts, group=trainer.vllm_generation.tp_group) + prompts_for_generation = [prompt for group_prompts in gathered_prompts for prompt in group_prompts] + + if as_chat is None: + as_chat = prompts_for_generation and is_conversational({"prompt": prompts_for_generation[0]}) + + if trainer.args.vllm_enable_sleep_mode: + trainer.vllm_generation.llm.wake_up(tags=["kv_cache"]) + # Work around for https://github.com/vllm-project/vllm/issues/29341 + trainer.vllm_generation.llm.collective_rpc("reload_weights") + + with profiling_context(trainer, "vLLM.generate_rollout"): + if as_chat: + vllm_outputs = trainer.vllm_generation.llm.chat( + prompts_for_generation, sampling_params=sampling_params, use_tqdm=False + ) + else: + vllm_outputs = trainer.vllm_generation.llm.generate( + prompts_for_generation, sampling_params=sampling_params, use_tqdm=False + ) + + results: list[dict[str, Any]] = [] + for request in vllm_outputs: + if not request.outputs: + results.append({"prompt_ids": request.prompt_token_ids, "completion_ids": [], "logprobs": [], "text": ""}) + continue + sequence = request.outputs[0] + logprobs = [next(iter(token_logprob.values())).logprob for token_logprob in sequence.logprobs] + results.append( + { + "prompt_ids": request.prompt_token_ids, + "completion_ids": sequence.token_ids, + "logprobs": logprobs, + "text": sequence.text, + } + ) + + if trainer.vllm_tensor_parallel_size > 1: + local_rank_in_group = torch.distributed.get_rank(group=trainer.vllm_generation.tp_group) + tp_slice = slice(local_rank_in_group * original_size, (local_rank_in_group + 1) * original_size) + results = results[tp_slice] + + if trainer.args.vllm_enable_sleep_mode: + trainer.vllm_generation.llm.sleep(level=2) + + return results diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openreward/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openreward/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..eae7806a5a213157f814cead9b2d76158ea07bb4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openreward/__init__.py @@ -0,0 +1,18 @@ +# Copyright 2020-2026 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. + +from ._spec import OpenRewardSpec + + +__all__ = ["OpenRewardSpec"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openreward/_spec.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openreward/_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..76dd6b0d91e9f29dd428f57983df17c430acb3cf --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openreward/_spec.py @@ -0,0 +1,359 @@ +# Copyright 2020-2026 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. + +"""User-facing spec object for the OpenReward × TRL integration. + +The user constructs **one** ``OpenRewardSpec`` (a thin specification holding the env target + a few options) and reads +three properties off of it — ``.train_dataset``, ``.environment_factory``, ``.reward_funcs`` — each of which plugs +directly into the matching ``GRPOTrainer`` kwarg: + +```python +from trl import GRPOConfig, GRPOTrainer +from trl.experimental.openreward import OpenRewardSpec + +spec = OpenRewardSpec("Eigent/SETA", num_tasks=64) + +trainer = GRPOTrainer( + model="Qwen/Qwen3-4B", + args=GRPOConfig(num_generations=2, max_steps=5, max_tool_calling_iterations=20), + train_dataset=spec.train_dataset, + environment_factory=spec.environment_factory, + reward_funcs=spec.reward_funcs, +) +trainer.train() +``` + +Backed by the official ``openreward`` SDK (lazy-imported); install with ``pip install trl[openreward]``. +""" + +from __future__ import annotations + +import logging +import os +from collections.abc import Callable +from functools import cached_property +from typing import Any + +from .environment import _import_openreward, _RolloutEnvironment, _spec_to_dict + + +logger = logging.getLogger(__name__) + + +def _tool_specs_from_session_list_tools(out: Any) -> list[Any]: + """Normalise ``session.list_tools()`` / ``environment.list_tools()`` to a flat list. + + The client SDK (``openreward.api``) returns ``list[ToolSpec]`` directly. + """ + return list(out) + + +def _to_spec(task) -> dict[str, Any]: + """Normalise an SDK ``Task`` (or already-a-dict) to its task_spec dict.""" + if isinstance(task, dict): + return task + return task.task_spec + + +def _outcome_only_reward_func(environments, **_): + """Default reward function: last non-null reward in each rollout's trajectory. + + Suitable for sparse-outcome envs (e.g. SETA, where only `submit_solution` returns a non-null reward). Override by + passing a different callable to ``reward_funcs=``. + """ + return [env.reward for env in environments] + + +class OpenRewardSpec: + """Single spec object that wires an ORS environment into a TRL trainer. + + Args: + target (`str`): + Either an openreward.ai catalog name (`"Eigent/SETA"`) or a URL pointing at any ORS server + (`"https://you-seta.hf.space"`, `"http://localhost:8080"`). Auto-detected by the presence of `://` in the + string. + num_tasks (`int`, *optional*): + Cap on the number of tasks pulled into the dataset. ``None`` uses every task the env exposes. + split (`str`, *optional*, defaults to `"train"`): + Which split's task list to draw from. + indices (`list[int]`, *optional*): + Specific task indices to train on. Mutually exclusive with ``num_tasks``. Useful for debugging or + curriculum subsets. + api_key (`str`, *optional*): + ``OPENREWARD_API_KEY`` override. Only used when ``target`` is a catalog name. + secrets (`dict[str, str]`, *optional*): + Per-session secrets forwarded to ``env.session(secrets=)``. + env_name (`str`, *optional*): + Override for the env name to look up on the server. Rarely needed. + include_metadata (`bool`, *optional*, defaults to `True`): + Fold per-task metadata (`difficulty`, `category`, `tags`, ...) into the dataset rows so reward funcs can + read them via TRL's ``inputs`` argument. + discover_task_tools (`bool`, *optional*, defaults to `True`): + If ``True``, opens a short-lived ORS session and uses ``session.list_tools()`` so task-specific tools + (``GET …/task_tools`` per ORS — e.g. ``@tool(shared=False)`` and ``list_task_tools()``) are bound for GRPO. + If probe fails, falls back to ``environment.list_tools()`` only. Set ``False`` to skip the extra session + (shared tools only / offline quirks). + task_tools_discovery_index (`int`, *optional*): + Task index used only for the discovery session when set; **overrides** multi-index probing below. When + omitted and ``indices=`` is set, discovery opens one probe session per **distinct** entry in ``indices`` + (sorted) and **merges** tool specs by name so task-specific tools from every listed task are bound. When + omitted and ``num_tasks`` / full-list mode is used, probes task ``0`` only. Ignored when + ``discover_task_tools=False``. + """ + + def __init__( + self, + target: str, + *, + num_tasks: int | None = None, + split: str = "train", + indices: list[int] | None = None, + api_key: str | None = None, + secrets: dict[str, str] | None = None, + env_name: str | None = None, + include_metadata: bool = True, + discover_task_tools: bool = True, + task_tools_discovery_index: int | None = None, + ) -> None: + if num_tasks is not None and indices is not None: + raise ValueError("Provide num_tasks or indices, not both.") + + self._target = target + self._is_url = "://" in target + self._num_tasks = num_tasks + self._split = split + self._indices = indices + self._api_key = api_key + self._secrets = secrets + self._env_name = env_name + self._include_metadata = include_metadata + self._discover_task_tools = discover_task_tools + self._task_tools_discovery_index = task_tools_discovery_index + + # ── public surface ────────────────────────────────────────────── + + @cached_property + def train_dataset(self): + """A `datasets.Dataset` derived from the env's task list. + + Plugs directly into TRL's ``train_dataset=`` slot. Built lazily on first access. Has at minimum: + - `prompt`: empty user message (TRL appends the env's prompt). + - `task_index`: int passed to the adapter's `reset()`. + - per-task metadata columns (when `include_metadata=True`). + """ + from datasets import Dataset + + env = self._sdk_env + + # When the user asked for a specific subset (`num_tasks` cap or + # explicit `indices`), fetch only those — `list_tasks` returns + # the whole split (1376 entries for SETA, etc.) and is slow on + # the platform. Per-index `get_task` is fast and cheap. + if self._indices is not None: + indexes = list(self._indices) + task_specs = [_to_spec(env.get_task(self._split, i)) for i in indexes] + elif self._num_tasks is not None: + n_total = env.num_tasks(self._split) + n = min(self._num_tasks, n_total) + indexes = list(range(n)) + task_specs = [_to_spec(env.get_task(self._split, i)) for i in indexes] + else: + # No cap — fetch everything in one shot. + try: + tasks = env.list_tasks(self._split) + except Exception: # noqa: BLE001 + n = env.num_tasks(self._split) + tasks = [env.get_task(self._split, i) for i in range(n)] + task_specs = [_to_spec(t) for t in tasks] + indexes = list(range(len(task_specs))) + + rows: dict[str, list[Any]] = { + "prompt": [[{"role": "user", "content": ""}] for _ in indexes], + "task_index": indexes, + } + + if self._include_metadata and task_specs: + metadata_keys: set[str] = set() + for spec in task_specs: + if isinstance(spec, dict): + metadata_keys.update(spec.keys()) + # Never let a task-spec key overwrite our reserved row columns + # (e.g. an env that exposes a `prompt` task-spec field would + # otherwise replace our chat-format prompt with a raw string). + metadata_keys -= rows.keys() + for key in sorted(metadata_keys): + rows[key] = [s.get(key) if isinstance(s, dict) else None for s in task_specs] + + return Dataset.from_dict(rows) + + @cached_property + def environment_factory(self) -> Callable[[], _RolloutEnvironment]: + """Zero-arg callable that returns a fresh ``_RolloutEnvironment``. + + Plugs directly into TRL's ``environment_factory=`` slot. TRL calls this once per rollout at trainer + construction time, so each rollout has an isolated ORS session. Reuses the spec's already-discovered SDK env + + tool specs to skip per-env HTTP at trainer init. + """ + # Pre-fetch tool specs once at the spec level. ORS exposes shared tools on GET /tools and the full + # shared+task-specific set on GET /task_tools (session-scoped). GRPO inspects methods before reset(), so we + # must bind every tool the episode will see — use session.list_tools() when discover_task_tools=True. + env = self._sdk_env + tool_specs = self._discovered_tool_specs(env) + client = self._sdk_client + + # Each spec gets its own `_RolloutEnvironment` subclass so two specs + # for different envs (different tool sets) never clobber each other's + # bound methods on the shared parent class. + rollout_cls = type(f"_RolloutEnvironment_{id(self):x}", (_RolloutEnvironment,), {}) + + kwargs = { + "split": self._split, + "secrets": self._effective_secrets(), + "env_name": self._env_name, + "_client": client, + "_env": env, + "_tool_specs": tool_specs, + } + if self._is_url: + kwargs["base_url"] = self._target + else: + kwargs["name"] = self._target + if self._api_key: + kwargs["api_key"] = self._api_key + + kwargs = {k: v for k, v in kwargs.items() if v is not None} + + def _make() -> _RolloutEnvironment: + return rollout_cls(**kwargs) + + return _make + + @property + def reward_funcs(self) -> Callable[..., list[float]]: + """Default outcome-only reward function (last non-null reward per rollout). + + Plugs directly into TRL's ``reward_funcs=`` slot. Stable identity — module-level function, picklable for + multi-process workers. + """ + return _outcome_only_reward_func + + # ── internals ─────────────────────────────────────────────────── + + def _effective_secrets(self) -> dict[str, str] | None: + """Auto-forward ``OPENREWARD_API_KEY`` as the conventional ``api_key`` + per-session secret on platform mode (most envs need it).""" + if self._secrets is not None or self._is_url: + return self._secrets + key = self._api_key or os.environ.get("OPENREWARD_API_KEY") + return {"api_key": key} if key else None + + def _task_tools_probe_indices(self) -> list[int]: + """Pick task indices for ``session.list_tools()`` discovery (ORS ``/task_tools``).""" + if self._task_tools_discovery_index is not None: + return [self._task_tools_discovery_index] + if self._indices is not None: + return sorted(set(self._indices)) + return [0] + + def _discovered_tool_specs(self, env): + """Return ToolSpec list for binding on `_RolloutEnvironment`. + + Prefer ``session.list_tools()`` (ORS ``/task_tools``) so task-specific tools match what the OpenReward SDK + exposes during rollouts. Fall back to ``environment.list_tools()`` on failure or when disabled. + """ + shared = env.list_tools() + shared = _tool_specs_from_session_list_tools(shared) + if not self._discover_task_tools: + return shared + + try: + n = env.num_tasks(self._split) + except Exception as e: # noqa: BLE001 + logger.warning("OpenRewardSpec: num_tasks failed (%s); using shared tools only.", e) + return shared + + if n <= 0: + return shared + + probe_indices = self._task_tools_probe_indices() + bad = [idx for idx in probe_indices if idx < 0 or idx >= n] + if bad: + logger.warning( + "OpenRewardSpec: task tool probe index(es) %s out of range for split=%r (num_tasks=%s); ignoring them.", + bad, + self._split, + n, + ) + probe_indices = [idx for idx in probe_indices if 0 <= idx < n] + if not probe_indices: + logger.warning("OpenRewardSpec: no valid task indices for tool discovery; using shared tools only.") + return shared + + secrets = self._effective_secrets() + merged: list[Any] = [] + seen: dict[str, Any] = {} + any_probe_ok = False + + for idx in probe_indices: + try: + with env.session(split=self._split, index=idx, secrets=secrets) as sess: + specs = _tool_specs_from_session_list_tools(sess.list_tools()) + except Exception as e: # noqa: BLE001 + logger.warning( + "OpenRewardSpec: session tool discovery failed for task_index=%s (%s); skipping.", + idx, + e, + ) + continue + any_probe_ok = True + for spec in specs: + d = _spec_to_dict(spec) + name = d["name"] + if name not in seen: + seen[name] = spec + merged.append(spec) + elif _spec_to_dict(seen[name]) != d: + logger.warning( + "OpenRewardSpec: tool %r has differing schemas across probe tasks; keeping first.", + name, + ) + + if not any_probe_ok: + logger.warning("OpenRewardSpec: all task tool probes failed; using shared tools only.") + return shared + return merged + + @cached_property + def _sdk_client(self): + """The shared ``openreward.OpenReward`` client used by `dataset` and `factory`.""" + openreward = _import_openreward() + kwargs: dict[str, Any] = {} + if self._api_key: + kwargs["api_key"] = self._api_key + elif not self._is_url and "OPENREWARD_API_KEY" in os.environ: + kwargs["api_key"] = os.environ["OPENREWARD_API_KEY"] + if self._is_url: + kwargs["base_url"] = self._target + return openreward.OpenReward(**kwargs) + + @cached_property + def _sdk_env(self): + """The shared SDK ``Environment`` handle.""" + if self._is_url: + # Self-hosted single-env URL — pass any name; the SDK redirects. + # Fallback to "env" matches `_RolloutEnvironment.__init__`. + target = self._env_name or "env" + else: + target = self._target + return self._sdk_client.environments.get(target) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openreward/environment.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openreward/environment.py new file mode 100644 index 0000000000000000000000000000000000000000..7b969ee1c2c0b2a9ebacd6bb62f00d0ebff74fff --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/openreward/environment.py @@ -0,0 +1,404 @@ +# Copyright 2020-2026 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. + +"""TRL `environment_factory` adapter for any ORS-compliant server. + +Wraps the official ``openreward`` SDK so platform quirks (X-Secrets encoding, ephemeral session for discovery, +sticky-routing subdomain, SSE chunk reassembly, ping keepalive, …) are handled by code that ships with the spec. Our +job is only to expose the SDK's per-rollout session as a TRL-compatible class with dynamically-bound tool methods. + +Install: ``pip install trl[openreward]``. +""" + +from __future__ import annotations + +import logging +import os +import re +from typing import Any + + +logger = logging.getLogger(__name__) + + +def _import_openreward(): + """Lazy-import the openreward package with a friendly error message.""" + try: + import openreward + + return openreward + except ImportError as e: + raise ImportError( + "trl.experimental.openreward requires the `openreward` package. " + "Install with `pip install trl[openreward]`." + ) from e + + +# ── JSON Schema → Python type mapping (used by dynamic tool binding) ── + +_JSON_TYPE_TO_PY: dict[str, str] = { + "string": "str", + "integer": "int", + "number": "float", + "boolean": "bool", + "array": "list", + "object": "dict", +} + +_PY_TYPE_OBJECTS: dict[str, type] = { + "str": str, + "int": int, + "float": float, + "bool": bool, + "list": list, + "dict": dict, +} + +_PY_TYPE_FROM_VALUE: dict[type, str] = { + bool: "bool", + int: "int", + float: "float", + str: "str", + list: "list", + dict: "dict", +} + + +def _resolve_param_type(pdef: dict[str, Any]) -> str: + """Pick the best Python type name for one JSON-Schema property. + + Handles primitive ``"type"``, Pydantic's ``anyOf``/``oneOf`` form for ``Optional[T]``, and falls back to the type + of ``default``. Critical because transformers' tool-schema generator uses our Python annotations to build the + schema the model sees. + """ + t = pdef.get("type") + if isinstance(t, str) and t in _JSON_TYPE_TO_PY: + return _JSON_TYPE_TO_PY[t] + for key in ("anyOf", "oneOf"): + for opt in pdef.get(key) or []: + if isinstance(opt, dict): + inner = opt.get("type") + if isinstance(inner, str) and inner in _JSON_TYPE_TO_PY and inner != "null": + return _JSON_TYPE_TO_PY[inner] + if "default" in pdef and pdef["default"] is not None: + for value_type, name in _PY_TYPE_FROM_VALUE.items(): + if isinstance(pdef["default"], value_type): + return name + return "str" + + +# ──────────────────────────────────────────────────────────────────── + + +class _RolloutEnvironment: + """Per-rollout TRL adapter backed by the ``openreward`` SDK. + + **Internal class.** Users don't construct this directly; they create an :class:`OpenRewardSpec` and pass + ``spec.environment_factory`` to ``GRPOTrainer``. TRL's trainer then constructs one instance of this per rollout + slot. + + The tool surface is built once at construction by reading the env's tools and binding one Python method per ORS + tool — so swapping the URL or env name is the only thing needed to train against a different environment. + + Args: + name (`str`, *optional*): + openreward.ai catalog name (e.g. ``"Eigent/SETA"``). Mutually exclusive with `base_url`. Requires + ``OPENREWARD_API_KEY`` (env var or `api_key=`). + base_url (`str`, *optional*): + Direct URL of an ORS server (HF Space, local Docker, etc.). Mutually exclusive with `name`. + env_name (`str`, *optional*): + Name to look up on the server. Defaults to the canonical name parsed from `name`/`base_url`. + split (`str`, *optional*, defaults to `"train"`): + Split passed to ``env.session(split=, index=)``. + api_key (`str`, *optional*): + Override for ``OPENREWARD_API_KEY``. Only used with `name=`. + secrets (`dict[str, str]`, *optional*): + Per-session secrets. Forwarded to ``env.session(secrets=)``; the SDK encodes them and adds platform-domain + entries. + timeout (`float`, *optional*): + Reserved for future use. The SDK manages its own timeouts. + + Attributes: + reward (`float`): + Last non-null reward in the trajectory (outcome-only convention). + rewards (`list[float | None]`): + Per-step reward sequence in tool-call order. + metadata (`list[dict | None]`): + Per-step ``ToolOutput.metadata`` dicts. + finished (`bool`): + True after a tool returned ``finished: true``. + last_output (`str`): + Joined text of the most recent tool result. + """ + + def __init__( + self, + *, + name: str | None = None, + base_url: str | None = None, + env_name: str | None = None, + split: str = "train", + api_key: str | None = None, + secrets: dict[str, str] | None = None, + timeout: float | None = None, + _client: Any = None, + _env: Any = None, + _tool_specs: list[Any] | None = None, + ) -> None: + if (name is None) == (base_url is None): + raise ValueError("Provide exactly one of: name, base_url.") + + # Reuse a pre-built client/env when the spec has already discovered + # them (saves N HTTP calls at trainer init); otherwise build fresh. + if _client is None: + openreward = _import_openreward() + client_kwargs: dict[str, Any] = {} + if api_key: + client_kwargs["api_key"] = api_key + elif name and "OPENREWARD_API_KEY" in os.environ: + client_kwargs["api_key"] = os.environ["OPENREWARD_API_KEY"] + if base_url: + client_kwargs["base_url"] = base_url + self._client = openreward.OpenReward(**client_kwargs) + else: + self._client = _client + + if _env is None: + target = name if name is not None else env_name or "" + if base_url and not target: + # Self-hosted single-env URL — pass any name; SDK redirects. + target = "env" + self._env = self._client.environments.get(target) + else: + self._env = _env + + self._split = split + self._secrets = secrets + self._session_cm = None # the SDK context manager itself, retained for clean teardown + self._session = None # the entered Session object + + # Episode state — read by the trainer's reward_func. + self.reward: float = 0.0 + self.rewards: list[float | None] = [] + self.metadata: list[dict[str, Any] | None] = [] + self.finished: bool = False + self.last_output: str = "" + + # Bind one Python method per server-side tool. Pre-fetched specs + # come from the spec object; otherwise we ask the SDK ourselves. + specs = _tool_specs if _tool_specs is not None else self._env.list_tools() + for spec in specs: + _bind_tool_method(self.__class__, _spec_to_dict(spec)) + + # ── TRL contract ───────────────────────────────────────────────── + + def reset( + self, + *, + task_index: int = 0, + task_spec: dict[str, Any] | None = None, + **_: Any, + ) -> str: + """Open a fresh ORS session for this rollout. + + Closes any prior session, starts a new one via the SDK's ``env.session(...)`` context manager, fetches the + prompt, and returns its text (which TRL appends to the user message). + """ + self._teardown_session() + self.reward = 0.0 + self.rewards = [] + self.metadata = [] + self.finished = False + self.last_output = "" + + if task_spec is not None: + from openreward.api.environments.client import Task + + task = Task( + server_name=self._env.server, + environment_name=self._env.name, + task_spec=task_spec, + namespace=self._env.namespace, + ) + cm = self._env.session(task=task, secrets=self._secrets) + else: + cm = self._env.session(split=self._split, index=int(task_index), secrets=self._secrets) + + # Retain the context manager itself so `_teardown_session` can call + # its __exit__; calling __exit__ on the entered Session alone leaves + # the CM's exit logic (which deletes the env state + sid) unrun. + self._session_cm = cm + self._session = cm.__enter__() + prompt = self._session.get_prompt() + return _join_text_blocks(prompt) + + # Leading underscore so TRL's tool collector at grpo_trainer.py:502-506 + # excludes this from the model's tool surface. + def _close(self) -> None: + """Tear down the active session (best-effort).""" + self._teardown_session() + + # ── helpers ────────────────────────────────────────────────────── + + def _teardown_session(self) -> None: + if self._session_cm is None: + return + try: + # Exit the SDK's Session context manager — this deletes both + # the per-rollout env state and the sid on the server. + self._session_cm.__exit__(None, None, None) + except Exception as e: # noqa: BLE001 + logger.debug("session teardown failed: %s", e) + self._session_cm = None + self._session = None + + def _call_ors_tool(self, tool_name: str, tool_input: dict[str, Any]) -> str: + """Invoke a server-side tool and update episode state.""" + if self._session is None: + raise RuntimeError("Cannot call a tool before reset() opens a session.") + + try: + out = self._session.call_tool(tool_name, tool_input) + except Exception as e: # noqa: BLE001 + self.rewards.append(None) + self.metadata.append(None) + self.last_output = f"Error: {e}" + return self.last_output + + # `out` is `openreward.api.environments.types.ToolOutput` — a stable dataclass + # with `blocks: list`, `reward: Optional[float]`, `metadata: Optional[dict]`, `finished: bool`. + text = _join_text_blocks(out.blocks or []) or "(no output)" + + step_reward: float | None = None + if out.reward is not None: + try: + step_reward = float(out.reward) + except (TypeError, ValueError): + step_reward = None + self.rewards.append(step_reward) + if step_reward is not None: + self.reward = step_reward # last-non-null wins (outcome-only convention) + + self.metadata.append(out.metadata if isinstance(out.metadata, dict) else None) + self.finished = bool(out.finished) + self.last_output = text + return text + + +# ── dynamic tool binding ───────────────────────────────────────────── + + +_VALID_TOOL_NAME = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$") + + +def _bind_tool_method(cls: type, spec: dict[str, Any]) -> None: + """Generate a typed Python method for one ORS tool spec. + + Signature comes from the JSON Schema; docstring is Google-style so ``transformers.utils.get_json_schema`` (used by + vLLM) can produce a correct tool schema for the model. + + Untrusted text from the server (tool name, descriptions) is never spliced raw into the generated source — the name + is validated against a Python-identifier regex and the description / per-param descriptions are passed through + ``repr()`` before being interpolated, so a tool description containing triple quotes can't break binding. + """ + tool_name = spec["name"] + if not _VALID_TOOL_NAME.match(tool_name): + logger.warning("skipping tool with non-identifier name: %r", tool_name) + return + if tool_name in cls.__dict__: + # Already bound by an earlier instance — idempotent skip. + return + + description = spec.get("description") or f"Call the {tool_name} tool." + schema = spec.get("input_schema") or {} + properties: dict[str, dict[str, Any]] = schema.get("properties") or {} + required: set[str] = set(schema.get("required") or []) + + # Required params must come before optional ones in Python — sort. + required_props = [(n, p) for n, p in properties.items() if n in required] + optional_props = [(n, p) for n, p in properties.items() if n not in required] + + params_src: list[str] = [] + annotations: dict[str, type] = {} + args_doc_lines: list[str] = [] + for pname, pdef in required_props + optional_props: + if not _VALID_TOOL_NAME.match(pname): + logger.warning("skipping tool %r — non-identifier param name: %r", tool_name, pname) + return + py_type = _resolve_param_type(pdef) + annotations[pname] = _PY_TYPE_OBJECTS[py_type] + if pname in required: + params_src.append(f"{pname}: {py_type}") + else: + default = pdef.get("default", None) + params_src.append(f"{pname}: {py_type} = {default!r}") + pdesc = pdef.get("description") or pdef.get("title") or pname + args_doc_lines.append(f" {pname}: {pdesc}") + + # Build the docstring as a single repr-quoted string so triple-quotes / quotes / newlines in the description or + # arg text can never close out the generated docstring early. + docstring = description + (("\n\n Args:\n" + "\n".join(args_doc_lines)) if args_doc_lines else "") + src = ( + f"def {tool_name}(self, {', '.join(params_src)}) -> str:\n" + f" {docstring!r}\n" + f" _kwargs = dict(locals()); _kwargs.pop('self', None)\n" + f" return self._call_ors_tool({tool_name!r}, _kwargs)\n" + ) + ns: dict[str, Any] = {} + exec(src, ns) + fn = ns[tool_name] + fn.__qualname__ = f"{cls.__name__}.{tool_name}" + fn.__annotations__ = {**annotations, "return": str} + setattr(cls, tool_name, fn) + + +# ── small utilities ────────────────────────────────────────────────── + + +def _spec_to_dict(spec: Any) -> dict[str, Any]: + """Normalise SDK ``ToolSpec`` and dict shapes to the same dict form. + + ``openreward.api.environments.types.ToolSpec`` is a stable dataclass with ``name``, ``description``, + ``input_schema`` fields, so direct attribute access is safe. + """ + if isinstance(spec, dict): + return spec + return { + "name": spec.name, + "description": spec.description, + "input_schema": spec.input_schema or {}, + } + + +def _join_text_blocks(blocks: list[Any]) -> str: + """Concatenate the ``text`` field of every text block in order. + + Accepts both SDK ``TextBlock`` dataclasses and plain dicts. Both shapes expose a ``type`` discriminator (`"text"` + vs `"image"`); non-text blocks are skipped so e.g. ``ImageBlock`` doesn't trip up the join. + """ + if not blocks: + return "" + parts: list[str] = [] + for b in blocks: + if isinstance(b, dict): + if b.get("type") != "text": + continue + text = b.get("text") + else: + if b.type != "text": + continue + text = b.text + if text: + parts.append(str(text)) + return "\n".join(parts) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/orpo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/orpo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..88abd9e1826eae8a0d201b84a048614059b9e264 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/orpo/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .orpo_config import ORPOConfig +from .orpo_trainer import ORPOTrainer + + +__all__ = ["ORPOConfig", "ORPOTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/orpo/orpo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/orpo/orpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..78c98788824b7ce4fbfb8676dcb6fd89e488de2a --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/orpo/orpo_config.py @@ -0,0 +1,134 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Any + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class ORPOConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`experimental.orpo.ORPOTrainer`]. + + This class includes only the parameters that are specific to ORPO training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + 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: + max_length (`int` or `None`, *optional*, defaults to `1024`): + Maximum length of the sequences (prompt + completion) in the batch. This argument is required if you want + to use the default data collator. + max_completion_length (`int`, *optional*): + Maximum length of the completion. This argument is required if you want to use the default data collator + and your model is an encoder-decoder. + beta (`float`, *optional*, defaults to `0.1`): + Parameter controlling the relative ratio loss weight in the ORPO loss. In the + [paper](https://huggingface.co/papers/2403.07691), it is denoted by λ. In the + [code](https://github.com/xfactlab/orpo), it is denoted by `alpha`. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model. + padding_value (`int`, *optional*): + Padding value to use. If `None`, the padding value of the tokenizer is used. + generate_during_eval (`bool`, *optional*, defaults to `False`): + If `True`, generates and logs completions from the model to W&B or Comet during evaluation. + is_encoder_decoder (`bool`, *optional*): + 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. + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the model from a + string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`]. + dataset_num_proc (`int`, *optional*): + Number of processes to use for processing the dataset. + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `1e-6` instead of `5e-5`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=1e-6, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + max_length: int | None = field( + default=1024, + metadata={"help": "Maximum length of the sequences (prompt + completion) in the batch."}, + ) + max_completion_length: int | None = field( + default=None, + metadata={ + "help": "Maximum length of the completion. This argument is required if you want to use the default data " + "collator and your model is an encoder-decoder." + }, + ) + beta: float = field( + default=0.1, + metadata={ + "help": "Parameter controlling the relative ratio loss weight in the ORPO loss. In the paper, it is " + "denoted by λ." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the model."}, + ) + padding_value: int | None = field( + default=None, + metadata={"help": "Padding value to use. If `None`, the padding value of the tokenizer is used."}, + ) + generate_during_eval: bool = field( + default=False, + metadata={"help": "If `True`, generates and logs completions from the model to W&B during evaluation."}, + ) + is_encoder_decoder: bool | None = field( + default=None, + metadata={ + "help": "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." + }, + ) + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments to pass to `AutoModelForCausalLM.from_pretrained` when instantiating the model " + "from a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models that ship custom Python code from the Hub. Forwarded to " + "`AutoModelForCausalLM.from_pretrained`." + }, + ) + dataset_num_proc: int | None = field( + default=None, + metadata={"help": "Number of processes to use for processing the dataset."}, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/orpo/orpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/orpo/orpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..ac6d728273183d71265337a662dad0c3c75532ca --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/orpo/orpo_trainer.py @@ -0,0 +1,1041 @@ +# Copyright 2020-2026 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 random +import textwrap +from collections import defaultdict +from collections.abc import Callable +from contextlib import nullcontext +from pathlib import Path +from typing import Any, Literal + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +import torch.nn.functional as F +import transformers +from accelerate import PartialState, logging +from accelerate.utils import is_peft_model +from datasets import Dataset +from packaging.version import Version +from torch import autocast +from torch.utils.data import DataLoader +from transformers import ( + AutoModelForCausalLM, + BaseImageProcessor, + DataCollator, + FeatureExtractionMixin, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, + is_comet_available, + is_torch_xla_available, + is_wandb_available, +) +from transformers.trainer_utils import EvalLoopOutput +from transformers.utils import is_peft_available, is_torch_fx_proxy + +from ...data_utils import maybe_apply_chat_template, maybe_extract_prompt +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import disable_dropout_in_model, log_table_to_comet_experiment, selective_log_softmax +from ..utils import ( + DPODataCollatorWithPadding, + add_bos_token_if_needed, + add_eos_token_if_needed, + pad_to_length, + peft_module_casting_to_bf16, +) +from .orpo_config import ORPOConfig + + +if is_peft_available(): + from peft import PeftConfig, get_peft_model, prepare_model_for_kbit_training + + +if is_wandb_available(): + import wandb + +if is_torch_xla_available(): + import torch_xla.core.xla_model as xm + + +logger = logging.get_logger(__name__) + + +def log1mexp(x: torch.FloatTensor) -> torch.FloatTensor: + """Numerically stable computation of log(1-exp(x)).""" + # branch at -ln 2 ~ -0.693 to avoid cancellation + t = -0.6931471805599453 + return torch.where(x < t, torch.log1p(-torch.exp(x)), torch.log(-torch.expm1(x))) + + +class ORPOTrainer(_BaseTrainer): + r""" + Initialize ORPOTrainer. + + Args: + model ([`~transformers.PreTrainedModel`]): + The model to train, preferably an [`~transformers.AutoModelForSequenceClassification`]. + args ([`experimental.orpo.ORPOConfig`]): + The ORPO config arguments to use for training. + data_collator ([`~transformers.DataCollator`]): + The data collator to use for training. If None is specified, the default data collator + ([`experimental.utils.DPODataCollatorWithPadding`]) will be used which will pad the sequences to the + maximum length of the sequences in the batch, given a dataset of paired sequences. + train_dataset ([`~datasets.Dataset`]): + The dataset to use for training. + eval_dataset ([`~datasets.Dataset`]): + The dataset to use for evaluation. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. If provided, will be used to automatically process the inputs + for the model, and it will be saved along the model to make it easier to rerun an interrupted training or + reuse the fine-tuned model. + model_init (`Callable[[], transformers.PreTrainedModel]`): + The model initializer to use for training. If None is specified, the default model initializer will be + used. + callbacks (`list[transformers.TrainerCallback]`): + The callbacks to use for training. + optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): + The optimizer and scheduler to use for training. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`): + The function to use to preprocess the logits before computing the metrics. + peft_config ([`~peft.PeftConfig`], *optional*): + The PEFT configuration to use for training. If you pass a PEFT configuration, the model will be wrapped in + a PEFT model. + compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*): + The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to + metric values. + """ + + _tag_names = ["trl", "orpo"] + _name = "ORPO" + _paper = { + "title": "ORPO: Monolithic Preference Optimization without Reference Model", + "id": "2403.07691", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @article{hong2024orpo, + title = {{ORPO: Monolithic Preference Optimization without Reference Model}}, + author = {Jiwoo Hong and Noah Lee and James Thorne}, + year = 2024, + eprint = {arXiv:2403.07691} + }"""), + } + + def __init__( + self, + model: PreTrainedModel | nn.Module | str | None = None, + args: ORPOConfig | None = None, + data_collator: DataCollator | None = None, + train_dataset: Dataset | None = None, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + processing_class: PreTrainedTokenizerBase + | BaseImageProcessor + | FeatureExtractionMixin + | ProcessorMixin + | None = None, + model_init: Callable[[], PreTrainedModel] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + peft_config: "PeftConfig | None" = None, + compute_metrics: Callable[[EvalLoopOutput], dict] | None = None, + ): + if train_dataset is None: + raise ValueError("`train_dataset` is required") + + if args.model_init_kwargs is None: + model_init_kwargs = {} + elif not isinstance(model, str): + raise ValueError("You passed model_kwargs to the ORPOTrainer. But your model is already instantiated.") + else: + model_init_kwargs = args.model_init_kwargs + dtype = model_init_kwargs.get("dtype", "auto") + if dtype is not None: + # Convert to `torch.dtype` if an str is passed + if isinstance(dtype, str) and dtype != "auto": + dtype = getattr(torch, dtype) + if dtype != "auto" and not isinstance(dtype, torch.dtype): + raise ValueError( + f"Invalid `dtype` passed to the ORPOConfig. Expected a string with either `torch.dtype` or 'auto', but got {dtype}." + ) + model_init_kwargs["dtype"] = dtype + model_init_kwargs["device_map"] = model_init_kwargs.get("device_map", "auto") + + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + + if isinstance(model, str): + model = AutoModelForCausalLM.from_pretrained(model, **model_init_kwargs) + + # PEFT + # Initialize this variable to False. This helps tracking the case when `peft_module_casting_to_bf16` + # has been called in order to properly call autocast if needed. + self._peft_has_been_casted_to_bf16 = False + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first " + "merge and unload the existing adapter, save the resulting base model, and then pass that base " + "model along with the new `peft_config` to the trainer." + ) + + if getattr(model, "is_loaded_in_8bit", False) or getattr(model, "is_loaded_in_4bit", False): + _support_gc_kwargs = hasattr( + args, "gradient_checkpointing_kwargs" + ) and "gradient_checkpointing_kwargs" in list( + inspect.signature(prepare_model_for_kbit_training).parameters + ) + + prepare_model_kwargs = {"use_gradient_checkpointing": args.gradient_checkpointing} + + if _support_gc_kwargs: + prepare_model_kwargs["gradient_checkpointing_kwargs"] = args.gradient_checkpointing_kwargs + + model = prepare_model_for_kbit_training(model, **prepare_model_kwargs) + elif args.gradient_checkpointing: + # For backward compatibility with older versions of transformers + if hasattr(model, "enable_input_require_grads"): + model.enable_input_require_grads() + else: + + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + # get peft model with the given config + model = get_peft_model(model, peft_config) + if args.bf16 and getattr(model, "is_loaded_in_4bit", False): + peft_module_casting_to_bf16(model) + # If args.bf16 we need to explicitly call `generate` with torch amp autocast context manager + self._peft_has_been_casted_to_bf16 = True + + # For models that use gradient_checkpointing, we need to attach a hook that enables input + # to explicitly have `requires_grad=True`, otherwise training will either silently + # fail or completely fail. + elif args.gradient_checkpointing: + # For backward compatibility with older versions of transformers + if hasattr(model, "enable_input_require_grads"): + model.enable_input_require_grads() + else: + + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + if args.generate_during_eval and not (is_wandb_available() or is_comet_available()): + raise ValueError( + "`generate_during_eval=True` requires Weights and Biases or Comet to be installed." + " Please install `wandb` or `comet-ml` to resolve." + ) + + if model is not None: + self.is_encoder_decoder = model.config.is_encoder_decoder + elif args.is_encoder_decoder is None: + raise ValueError("When no model is provided, you need to pass the parameter is_encoder_decoder.") + else: + self.is_encoder_decoder = args.is_encoder_decoder + + if self.is_encoder_decoder: + self.decoder_start_token_id = model.config.decoder_start_token_id + self.pad_token_id = model.config.pad_token_id + + if processing_class is None: + raise ValueError("processing_class must be specified to tokenize a ORPO dataset.") + if args.max_length is None: + logger.warning( + "`max_length` is not set in the ORPOConfig's init" + " it will default to `512` by default, but you should do it yourself in the future.", + ) + max_length = 512 + else: + max_length = args.max_length + + if args.max_completion_length is None and self.is_encoder_decoder: + logger.warning( + "When using an encoder decoder architecture, you should set `max_completion_length` in the ORPOConfig's init" + " it will default to `128` by default, but you should do it yourself in the future.", + ) + self.max_completion_length = 128 + else: + self.max_completion_length = args.max_completion_length + + if data_collator is None: + data_collator = DPODataCollatorWithPadding( + pad_token_id=processing_class.pad_token_id, + is_encoder_decoder=self.is_encoder_decoder, + ) + + if args.remove_unused_columns: + args.remove_unused_columns = False + # warn users + logger.warning( + "When using DPODataCollatorWithPadding, you should set `remove_unused_columns=False` in your TrainingArguments" + " we have set it for you, but you should do it yourself in the future.", + ) + + self.use_dpo_data_collator = True + else: + self.use_dpo_data_collator = False + + # Disable dropout in the model and reference model + if args.disable_dropout: + disable_dropout_in_model(model) + + self.max_length = max_length + self.generate_during_eval = args.generate_during_eval + self.padding_value = args.padding_value if args.padding_value is not None else processing_class.pad_token_id + self.processing_class = processing_class + + self.beta = args.beta + self.aux_loss_enabled = getattr(model.config, "output_router_logits", False) + self.aux_loss_coef = getattr(model.config, "router_aux_loss_coef", 0.0) + if self.aux_loss_enabled and self.aux_loss_coef == 0.0: + logger.warning( + "You set `output_router_logits` to `True` in the model config, but `router_aux_loss_coef` is set to " + "`0.0`, meaning the auxiliary loss will not be used. Either set `router_aux_loss_coef` to a value " + "greater than `0.0`, or set `output_router_logits` to `False` if you don't want to use the auxiliary " + "loss.", + ) + + self._stored_metrics = defaultdict(lambda: defaultdict(list)) + + # Compute that only on the main process for faster data processing. + # see: https://github.com/huggingface/trl/pull/1255 + with PartialState().main_process_first(): + # Extract the prompt if needed, and apply the chat template if needed + train_dataset = train_dataset.map(maybe_extract_prompt, num_proc=args.dataset_num_proc) + train_dataset = train_dataset.map( + maybe_apply_chat_template, + fn_kwargs={"processing_class": processing_class}, + num_proc=args.dataset_num_proc, + ) + train_dataset = train_dataset.map(self.tokenize_row, num_proc=args.dataset_num_proc) + if eval_dataset is not None: + eval_dataset = eval_dataset.map(maybe_extract_prompt, num_proc=args.dataset_num_proc) + eval_dataset = eval_dataset.map( + maybe_apply_chat_template, + fn_kwargs={"processing_class": processing_class}, + num_proc=args.dataset_num_proc, + ) + eval_dataset = eval_dataset.map(self.tokenize_row, num_proc=args.dataset_num_proc) + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + model_init=model_init, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the + # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set + # self.model_accepts_loss_kwargs to False to enable scaling. + self.model_accepts_loss_kwargs = False + + # Add tags for models that have been loaded with the correct transformers version + if hasattr(self.model, "add_model_tags"): + self.model.add_model_tags(self._tag_names) + + if not hasattr(self, "accelerator"): + raise AttributeError( + "Your `Trainer` does not have an `accelerator` object. Consider upgrading `transformers`." + ) + + def build_tokenized_answer(self, prompt, answer): + """ + Llama tokenizer does satisfy `enc(a + b) = enc(a) + enc(b)`. It does ensure `enc(a + b) = enc(a) + enc(a + + b)[len(enc(a)):]`. Reference: + https://github.com/EleutherAI/lm-evaluation-harness/pull/531#issuecomment-1595586257 + """ + + full_tokenized = self.processing_class(prompt + answer, add_special_tokens=False) + prompt_input_ids = self.processing_class(prompt, add_special_tokens=False)["input_ids"] + + answer_input_ids = full_tokenized["input_ids"][len(prompt_input_ids) :] + answer_attention_mask = full_tokenized["attention_mask"][len(prompt_input_ids) :] + + # Concat tokens to form `enc(a) + enc(a + b)[len(enc(a)):]` + full_concat_input_ids = np.concatenate([prompt_input_ids, answer_input_ids]) + + # Prepare input tokens for token by token comparison + full_input_ids = np.array(full_tokenized["input_ids"]) + + if len(full_input_ids) != len(full_concat_input_ids): + raise ValueError("Prompt input ids and answer input ids should have the same length.") + + # On some tokenizers, like Llama-2 tokenizer, there are occasions where tokens + # can be merged together when tokenizing prompt+answer. This could result + # on the last token from the prompt being different when tokenized on its own + # vs when done as prompt+answer. + response_token_ids_start_idx = len(prompt_input_ids) + + # If tokenized prompt is different than both prompt+answer, then it means the + # last token has changed due to merging. + if prompt_input_ids != full_tokenized["input_ids"][:response_token_ids_start_idx]: + response_token_ids_start_idx -= 1 + + prompt_input_ids = full_tokenized["input_ids"][:response_token_ids_start_idx] + prompt_attention_mask = full_tokenized["attention_mask"][:response_token_ids_start_idx] + + if len(prompt_input_ids) != len(prompt_attention_mask): + raise ValueError("Prompt input ids and attention mask should have the same length.") + + answer_input_ids = full_tokenized["input_ids"][response_token_ids_start_idx:] + answer_attention_mask = full_tokenized["attention_mask"][response_token_ids_start_idx:] + + return dict( + prompt_input_ids=prompt_input_ids, + prompt_attention_mask=prompt_attention_mask, + input_ids=answer_input_ids, + attention_mask=answer_attention_mask, + ) + + def tokenize_row(self, feature, model: PreTrainedModel | nn.Module | None = None) -> dict: + """Tokenize a single row from a ORPO specific dataset. + + At this stage, we don't convert to PyTorch tensors yet; we just handle the truncation in case the prompt + + chosen or prompt + rejected responses is/are too long. First we truncate the prompt; if we're still too long, + we truncate the chosen/rejected. + + We also create the labels for the chosen/rejected responses, which are of length equal to the sum of the length + of the prompt and the chosen/rejected response, with `-100` for the prompt tokens. + """ + batch = {} + prompt = feature["prompt"] + chosen = feature["chosen"] + rejected = feature["rejected"] + + if not self.is_encoder_decoder: + # Check issues below for more details + # 1. https://github.com/huggingface/trl/issues/907 + # 2. https://github.com/EleutherAI/lm-evaluation-harness/pull/531#issuecomment-1595586257 + # 3. https://github.com/LianjiaTech/BELLE/issues/337 + + if not isinstance(prompt, str): + raise ValueError(f"prompt should be an str but got {type(prompt)}") + prompt_tokens = self.processing_class(prompt, add_special_tokens=False) + prompt_tokens = {f"prompt_{k}": v for k, v in prompt_tokens.items()} + + if not isinstance(chosen, str): + raise ValueError(f"chosen should be an str but got {type(chosen)}") + chosen_tokens = self.build_tokenized_answer(prompt, chosen) + + if not isinstance(rejected, str): + raise ValueError(f"rejected should be an str but got {type(rejected)}") + rejected_tokens = self.build_tokenized_answer(prompt, rejected) + + # Last prompt token might get merged by tokenizer and + # it should not be included for generation if that happens + prompt_len_input_ids = len(prompt_tokens["prompt_input_ids"]) + + chosen_prompt_len_input_ids = len(chosen_tokens["prompt_input_ids"]) + rejected_prompt_len_input_ids = len(rejected_tokens["prompt_input_ids"]) + prompt_len_input_ids = min(chosen_prompt_len_input_ids, rejected_prompt_len_input_ids) + + for k, v in prompt_tokens.items(): + prompt_tokens[k] = v[:prompt_len_input_ids] + + # Make sure prompts only have one different token at most an + # and length only differs by 1 at most + num_diff_tokens = sum( + a != b + for a, b in zip(chosen_tokens["prompt_input_ids"], rejected_tokens["prompt_input_ids"], strict=False) + ) + num_diff_len = abs(chosen_prompt_len_input_ids - rejected_prompt_len_input_ids) + if num_diff_tokens > 1 or num_diff_len > 1: + raise ValueError( + "Chosen and rejected prompt_input_ids might only differ on the " + "last token due to tokenizer merge ops." + ) + + # add BOS token to head of prompt. Avoid adding if it's already there + prompt_tokens, chosen_tokens, rejected_tokens = add_bos_token_if_needed( + self.processing_class.bos_token_id, + prompt_len_input_ids, + prompt_tokens, + chosen_prompt_len_input_ids, + chosen_tokens, + rejected_prompt_len_input_ids, + rejected_tokens, + ) + + # add EOS token to end of answer. Avoid adding if it's already there + chosen_tokens, rejected_tokens = add_eos_token_if_needed( + self.processing_class.eos_token_id, chosen_tokens, rejected_tokens + ) + + longer_response_length = max(len(chosen_tokens["input_ids"]), len(rejected_tokens["input_ids"])) + + # if combined sequence is too long, truncate the response + for answer_tokens in [chosen_tokens, rejected_tokens]: + if len(answer_tokens["prompt_input_ids"]) + longer_response_length > self.max_length: + for k in ["input_ids", "attention_mask"]: + answer_tokens[k] = answer_tokens[k][: self.max_length - longer_response_length] + + # Create labels + chosen_sequence_tokens = { + k: chosen_tokens[f"prompt_{k}"] + chosen_tokens[k] for k in ["input_ids", "attention_mask"] + } + rejected_sequence_tokens = { + k: rejected_tokens[f"prompt_{k}"] + rejected_tokens[k] for k in ["input_ids", "attention_mask"] + } + chosen_sequence_tokens["labels"] = chosen_sequence_tokens["input_ids"][:] + chosen_sequence_tokens["labels"][: len(chosen_tokens["prompt_input_ids"])] = [-100] * len( + chosen_tokens["prompt_input_ids"] + ) + rejected_sequence_tokens["labels"] = rejected_sequence_tokens["input_ids"][:] + rejected_sequence_tokens["labels"][: len(rejected_tokens["prompt_input_ids"])] = [-100] * len( + rejected_tokens["prompt_input_ids"] + ) + + for k, toks in { + "chosen_": chosen_sequence_tokens, + "rejected_": rejected_sequence_tokens, + "": prompt_tokens, + }.items(): + for type_key, tokens in toks.items(): + if type_key == "token_type_ids": + continue + batch[f"{k}{type_key}"] = tokens + + else: + chosen_tokens = self.processing_class( + chosen, truncation=True, max_length=self.max_completion_length, add_special_tokens=True + ) + rejected_tokens = self.processing_class( + rejected, truncation=True, max_length=self.max_completion_length, add_special_tokens=True + ) + prompt_tokens = self.processing_class(prompt, add_special_tokens=True) + + batch["chosen_labels"] = chosen_tokens["input_ids"] + batch["rejected_labels"] = rejected_tokens["input_ids"] + batch["prompt_input_ids"] = prompt_tokens["input_ids"] + batch["prompt_attention_mask"] = prompt_tokens["attention_mask"] + + if model is not None and hasattr(model, "prepare_decoder_input_ids_from_labels"): + batch["rejected_decoder_input_ids"] = model.prepare_decoder_input_ids_from_labels( + labels=torch.tensor(batch["rejected_labels"]) + ) + batch["chosen_decoder_input_ids"] = model.prepare_decoder_input_ids_from_labels( + labels=torch.tensor(batch["chosen_labels"]) + ) + + if is_torch_xla_available(): + # Pad the sequences to global max_length to avoid TorchXLA recompilation + for k in batch: + if "labels" in k or self.is_encoder_decoder: + pad_value = -100 + elif k.endswith("_input_ids"): + pad_value = self.padding_value + elif k.endswith("_attention_mask"): + pad_value = 0 + batch[k] = batch[k] + [pad_value] * (self.max_length - len(batch[k])) + return batch + + @staticmethod + def concatenated_inputs( + batch: dict[str, list | torch.LongTensor], + is_encoder_decoder: bool = False, + padding_value: int = 0, + device: torch.device | None = None, + ) -> dict[str, torch.LongTensor]: + """Concatenate the chosen and rejected inputs into a single tensor. + + Args: + batch: + A batch of data. Must contain the keys 'chosen_input_ids' and 'rejected_input_ids', which are tensors + of shape (batch_size, sequence_length). + is_encoder_decoder: + Whether the model is an encoder-decoder model. + padding_value: + The padding value to use for the concatenated inputs_ids. + device: + The device for the concatenated inputs. + + Returns: + A dictionary containing the concatenated inputs under the key 'concatenated_input_ids'. + """ + concatenated_batch = {} + + if is_encoder_decoder: + max_length = max(batch["chosen_labels"].shape[1], batch["rejected_labels"].shape[1]) + else: + max_length = max(batch["chosen_input_ids"].shape[1], batch["rejected_input_ids"].shape[1]) + + for k in batch: + if k.startswith("chosen") and isinstance(batch[k], torch.Tensor): + if "labels" in k or is_encoder_decoder: + pad_value = -100 + elif k.endswith("_input_ids"): + pad_value = padding_value + elif k.endswith("_attention_mask"): + pad_value = 0 + concatenated_key = k.replace("chosen", "concatenated") + concatenated_batch[concatenated_key] = pad_to_length(batch[k], max_length, pad_value=pad_value) + for k in batch: + if k.startswith("rejected") and isinstance(batch[k], torch.Tensor): + if "labels" in k or is_encoder_decoder: + pad_value = -100 + elif k.endswith("_input_ids"): + pad_value = padding_value + elif k.endswith("_attention_mask"): + pad_value = 0 + concatenated_key = k.replace("rejected", "concatenated") + concatenated_batch[concatenated_key] = torch.cat( + ( + concatenated_batch[concatenated_key], + pad_to_length(batch[k], max_length, pad_value=pad_value), + ), + dim=0, + ).to(device=device) + + if is_encoder_decoder: + concatenated_batch["concatenated_input_ids"] = batch["prompt_input_ids"].repeat(2, 1).to(device=device) + concatenated_batch["concatenated_attention_mask"] = ( + batch["prompt_attention_mask"].repeat(2, 1).to(device=device) + ) + + return concatenated_batch + + def odds_ratio_loss( + self, + policy_chosen_logps: torch.FloatTensor, + policy_rejected_logps: torch.FloatTensor, + ) -> tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]: + """Compute ORPO's odds ratio (OR) loss for a batch of policy and reference model log probabilities. + + Args: + policy_chosen_logps: + Log probabilities of the policy model for the chosen responses. Shape: (batch_size,) + policy_rejected_logps: + Log probabilities of the policy model for the rejected responses. Shape: (batch_size,) + + Returns: + A tuple of three tensors: (losses, chosen_rewards, rejected_rewards). The losses tensor contains the ORPO + loss for each example in the batch. The chosen_rewards and rejected_rewards tensors contain the rewards for + the chosen and rejected responses, respectively. The log odds ratio of the chosen responses over the + rejected responses ratio for logging purposes. The `log(sigmoid(log_odds_chosen))` for logging purposes. + """ + + # Derived from Eqs. (4) and (7) from https://huggingface.co/papers/2403.07691 by using log identities and exp(log(P(y|x)) = P(y|x) + policy_chosen_logps = policy_chosen_logps.float() + policy_rejected_logps = policy_rejected_logps.float() + log_odds = (policy_chosen_logps - policy_rejected_logps) - ( + log1mexp(policy_chosen_logps) - log1mexp(policy_rejected_logps) + ) + ratio = F.logsigmoid(log_odds) + losses = self.beta * ratio + + chosen_rewards = self.beta * (policy_chosen_logps.to(self.accelerator.device)).detach() + rejected_rewards = self.beta * (policy_rejected_logps.to(self.accelerator.device)).detach() + + return losses, chosen_rewards, rejected_rewards, torch.mean(ratio), torch.mean(log_odds) + + @staticmethod + def get_batch_logps( + logits: torch.FloatTensor, + labels: torch.LongTensor, + average_log_prob: bool = False, + is_encoder_decoder: bool = False, + ) -> torch.FloatTensor: + """Compute the log probabilities of the given labels under the given logits. + + Args: + logits: Logits of the model (unnormalized). Shape: (batch_size, sequence_length, vocab_size) + labels: + Labels for which to compute the log probabilities. Label tokens with a value of `-100` are ignored. + Shape: (batch_size, sequence_length) + average_log_prob: + If True, return the average log probability per (non-masked) token. Otherwise, return the sum of the + log probabilities of the (non-masked) tokens. + is_encoder_decoder: Whether the model is an encoder-decoder model. + + Returns: + A tensor of shape (batch_size,) containing the average/sum log probabilities of the given labels under the + given logits. + """ + if logits.shape[:-1] != labels.shape: + raise ValueError("Logits (batch and sequence length dim) and labels must have the same shape.") + + if not is_encoder_decoder: + labels = labels[:, 1:].clone() + logits = logits[:, :-1, :] + loss_mask = labels != -100 + + # dummy token; we'll ignore the losses on these tokens later + labels = torch.where(labels == -100, 0, labels) + + per_token_logps = selective_log_softmax(logits, labels) + + if average_log_prob: + return (per_token_logps * loss_mask).sum(-1) / loss_mask.sum(-1) + else: + return (per_token_logps * loss_mask).sum(-1) + + def concatenated_forward( + self, model: nn.Module, batch: dict[str, list | torch.LongTensor] + ) -> tuple[torch.FloatTensor, torch.FloatTensor, torch.FloatTensor, torch.FloatTensor]: + """Run the given model on the given batch of inputs, concatenating the chosen and rejected inputs together. + + We do this to avoid doing two forward passes, because it's faster for FSDP. + """ + concatenated_batch = self.concatenated_inputs( + batch, + is_encoder_decoder=self.is_encoder_decoder, + padding_value=self.padding_value, + device=self.accelerator.device, + ) + len_chosen = batch["chosen_labels"].shape[0] + + model_kwargs = ( + { + "decoder_input_ids": self._shift_right(concatenated_batch["concatenated_labels"]), + } + if self.is_encoder_decoder + else {} + ) + + if self.aux_loss_enabled: + model_kwargs["output_router_logits"] = True + + outputs = model( + concatenated_batch["concatenated_input_ids"], + attention_mask=concatenated_batch["concatenated_attention_mask"], + use_cache=False, + **model_kwargs, + ) + all_logits = outputs.logits + + def cross_entropy_loss(logits, labels): + if not self.is_encoder_decoder: + # Shift so that tokens < n predict n + logits = logits[..., :-1, :].contiguous() + labels = labels[..., 1:].contiguous() + # Flatten the tokens + loss_fct = nn.CrossEntropyLoss() + logits = logits.view(-1, logits.shape[-1]) + labels = labels.view(-1) + # Enable model parallelism + labels = labels.to(logits.device) + loss = loss_fct(logits, labels) + return loss + + if self.is_encoder_decoder: + labels = concatenated_batch["concatenated_labels"].clone() + else: + labels = concatenated_batch["concatenated_input_ids"].clone() + attention_mask = concatenated_batch["concatenated_attention_mask"] + labels = torch.where(attention_mask == 1, labels, -100) + # orpo chosen nll loss is computed over the full prompt and response + chosen_nll_loss = cross_entropy_loss(all_logits[:len_chosen], labels[:len_chosen]) + + all_logps = self.get_batch_logps( + all_logits, + concatenated_batch["concatenated_labels"], + average_log_prob=True, + is_encoder_decoder=self.is_encoder_decoder, + ) + + chosen_logps = all_logps[:len_chosen] + rejected_logps = all_logps[len_chosen:] + + if not self.is_encoder_decoder: + chosen_logits = all_logits[:len_chosen, :-1, :] + rejected_logits = all_logits[len_chosen:, :-1, :] + else: + chosen_logits = all_logits[:len_chosen] + rejected_logits = all_logits[len_chosen:] + + if self.aux_loss_enabled: + return (chosen_logps, rejected_logps, chosen_logits, rejected_logits, chosen_nll_loss, outputs.aux_loss) + + return (chosen_logps, rejected_logps, chosen_logits, rejected_logits, chosen_nll_loss) + + def get_batch_loss_metrics( + self, + model, + batch: dict[str, list | torch.LongTensor], + train_eval: Literal["train", "eval"] = "train", + ): + """Compute the ORPO loss and other metrics for the given batch of inputs for train or test.""" + metrics = {} + + forward_output = self.concatenated_forward(model, batch) + ( + policy_chosen_logps, + policy_rejected_logps, + policy_chosen_logits, + policy_rejected_logits, + policy_nll_loss, + ) = forward_output[:5] + if self.aux_loss_enabled: + aux_loss = forward_output[5] + + losses, chosen_rewards, rejected_rewards, log_odds_ratio, log_odds_chosen = self.odds_ratio_loss( + policy_chosen_logps, policy_rejected_logps + ) + # full ORPO loss + loss = policy_nll_loss - losses.mean() + + reward_accuracies = (chosen_rewards > rejected_rewards).float() + + prefix = "eval_" if train_eval == "eval" else "" + metrics[f"{prefix}rewards/chosen"] = self.accelerator.gather_for_metrics(chosen_rewards).mean() + metrics[f"{prefix}rewards/rejected"] = self.accelerator.gather_for_metrics(rejected_rewards).mean() + metrics[f"{prefix}rewards/accuracies"] = self.accelerator.gather_for_metrics(reward_accuracies).mean() + metrics[f"{prefix}rewards/margins"] = self.accelerator.gather_for_metrics( + chosen_rewards - rejected_rewards + ).mean() + metrics[f"{prefix}logps/rejected"] = self.accelerator.gather_for_metrics(policy_rejected_logps).detach().mean() + metrics[f"{prefix}logps/chosen"] = self.accelerator.gather_for_metrics(policy_chosen_logps).detach().mean() + metrics[f"{prefix}logits/rejected"] = self.accelerator.gather_for_metrics( + policy_rejected_logits.detach().mean() + ).mean() + metrics[f"{prefix}logits/chosen"] = self.accelerator.gather_for_metrics( + policy_chosen_logits.detach().mean() + ).mean() + metrics[f"{prefix}nll_loss"] = self.accelerator.gather_for_metrics(policy_nll_loss).detach().mean() + metrics[f"{prefix}log_odds_ratio"] = self.accelerator.gather_for_metrics(log_odds_ratio).detach().mean() + metrics[f"{prefix}log_odds_chosen"] = self.accelerator.gather_for_metrics(log_odds_chosen).detach().mean() + if is_torch_xla_available(): + xm.mark_step() # needed because .item() calls + for k, v in metrics.items(): + metrics[k] = v.item() + if self.aux_loss_enabled: + loss += self.aux_loss_coef * aux_loss + + return loss, metrics + + def compute_loss( + self, + model: PreTrainedModel | nn.Module, + inputs: dict[str, torch.Tensor | Any], + return_outputs=False, + num_items_in_batch=None, + ) -> torch.Tensor | tuple[torch.Tensor, dict[str, torch.Tensor]]: + compute_loss_context_manager = ( + autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext() + ) + + with compute_loss_context_manager: + loss, metrics = self.get_batch_loss_metrics(model, inputs, train_eval="train") + + # Make sure to move the loss to the device the original accumulating loss is at back in the `Trainer` class: + loss = loss.to(self.args.device) + + # force log the metrics + self.store_metrics(metrics, train_eval="train") + + if return_outputs: + return (loss, metrics) + return loss + + def generate_from_model(self, model, batch: dict[str, torch.LongTensor]) -> str: + """Generate samples from the model and reference model for the given batch of inputs.""" + + # If one uses `generate_during_eval` with peft + bf16, we need to explicitly call generate with + # the torch amp context manager as some hidden states are silently casted to full precision. + generate_context_manager = ( + autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext() + ) + + with generate_context_manager: + policy_output = model.generate( + input_ids=batch["prompt_input_ids"], + attention_mask=batch["prompt_attention_mask"], + max_length=self.max_length, + do_sample=True, + pad_token_id=self.processing_class.pad_token_id, + ) + + policy_output = pad_to_length(policy_output, self.max_length, self.processing_class.pad_token_id) + policy_output_decoded = self.processing_class.batch_decode(policy_output, skip_special_tokens=True) + + return policy_output_decoded + + def prediction_step( + self, + model: PreTrainedModel | nn.Module, + inputs: dict[str, torch.Tensor | Any], + prediction_loss_only: bool, + ignore_keys: list[str] | None = None, + ): + if not self.use_dpo_data_collator: + logger.warning( + "prediction_step is only implemented for DPODataCollatorWithPadding, and you passed a datacollator that is different than " + "DPODataCollatorWithPadding - you might see unexpected behavior. Alternatively, you can implement your own prediction_step method if you are using a custom data collator" + ) + if ignore_keys is None: + if hasattr(model, "config"): + ignore_keys = getattr(model.config, "keys_to_ignore_at_inference", []) + else: + ignore_keys = [] + + prediction_context_manager = ( + autocast(self.accelerator.device.type) if self._peft_has_been_casted_to_bf16 else nullcontext() + ) + + with torch.no_grad(), prediction_context_manager: + loss, metrics = self.get_batch_loss_metrics(model, inputs, train_eval="eval") + + # force log the metrics + self.store_metrics(metrics, train_eval="eval") + + if prediction_loss_only: + return (loss.detach(), None, None) + + # logits for the chosen and rejected samples from model + logits_dict = { + "eval_logits/chosen": metrics["eval_logits/chosen"], + "eval_logits/rejected": metrics["eval_logits/rejected"], + } + logits = [v for k, v in logits_dict.items() if k not in ignore_keys] + logits = torch.tensor(logits, device=self.accelerator.device) + labels = torch.zeros(logits.shape[0], device=self.accelerator.device) + + return (loss.detach(), logits, labels) + + def store_metrics(self, metrics: dict[str, float], train_eval: Literal["train", "eval"] = "train") -> None: + for key, value in metrics.items(): + self._stored_metrics[train_eval][key].append(value) + + def evaluation_loop( + self, + dataloader: DataLoader, + description: str, + prediction_loss_only: bool | None = None, + ignore_keys: list[str] | None = None, + metric_key_prefix: str = "eval", + ) -> EvalLoopOutput: + """ + Overriding built-in evaluation loop to store metrics for each batch. Prediction/evaluation loop, shared by + `Trainer.evaluate()` and `Trainer.predict()`. + + Works both with or without labels. + """ + + # Sample and save to game log if requested (for one batch to save time) + if self.generate_during_eval: + # Generate random indices within the range of the total number of samples + num_samples = len(dataloader.dataset) + random_indices = random.sample(range(num_samples), k=self.args.eval_batch_size) + + # Use dataloader.dataset.select to get the random batch without iterating over the DataLoader + random_batch_dataset = dataloader.dataset.select(random_indices) + random_batch = self.data_collator(random_batch_dataset) + random_batch = self._prepare_inputs(random_batch) + + policy_output_decoded = self.generate_from_model(self.model, random_batch) + + table = pd.DataFrame( + columns=["Prompt", "Policy"], + data=[ + [prompt, pol[len(prompt) :]] + for prompt, pol in zip(random_batch["prompt"], policy_output_decoded, strict=True) + ], + ) + if "wandb" in self.args.report_to: + wandb.log({"game_log": wandb.Table(data=table)}) + + if "comet_ml" in self.args.report_to: + log_table_to_comet_experiment( + name="game_log.csv", + table=table, + ) + + # Base evaluation + initial_output = super().evaluation_loop( + dataloader, description, prediction_loss_only, ignore_keys, metric_key_prefix + ) + + return initial_output + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + """ + Log `logs` on the various objects watching training, including stored metrics. + + Args: + logs (`dict[str, float]`): + The values to log. + start_time (`float`, *optional*): + Start time of the training. + """ + # logs either has 'loss' or 'eval_loss' + train_eval = "train" if "loss" in logs else "eval" + # Add averaged stored metrics to logs + for key, metrics in self._stored_metrics[train_eval].items(): + logs[key] = torch.tensor(metrics).mean().item() + del self._stored_metrics[train_eval] + return super().log(logs, start_time) + + def _shift_right(self, input_ids): + if self.decoder_start_token_id is None: + raise ValueError( + "model.config.decoder_start_token_id has to be defined. It is usually set to the pad_token_id." + ) + + # shift inputs to the right + if is_torch_fx_proxy(input_ids): + # Item assignment is not supported natively for proxies. + shifted_input_ids = torch.full(input_ids.shape[:-1] + (1,), self.decoder_start_token_id) + shifted_input_ids = torch.cat([shifted_input_ids, input_ids[..., :-1]], dim=-1) + else: + shifted_input_ids = input_ids.new_zeros(input_ids.shape) + shifted_input_ids[..., 1:] = input_ids[..., :-1].clone() + shifted_input_ids[..., 0] = self.decoder_start_token_id + + if self.pad_token_id is None: + raise ValueError("model.config.pad_token_id has to be defined.") + # replace possible -100 values in labels by `pad_token_id` + shifted_input_ids.masked_fill_(shifted_input_ids == -100, self.pad_token_id) + + return shifted_input_ids + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/papo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/papo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..62fb8105cb446c197570023e388299e1bd96bbc4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/papo/__init__.py @@ -0,0 +1,17 @@ +# Copyright 2020-2026 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. + + +from .papo_config import PAPOConfig +from .papo_trainer import PAPOTrainer diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/papo/papo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/papo/papo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..e142a94a9cdc3128456b6127436c3befd6bc2a93 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/papo/papo_config.py @@ -0,0 +1,73 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass +from typing import Literal + +from ...trainer.grpo_config import GRPOConfig + + +@dataclass +class PAPOConfig(GRPOConfig): + """ + Configuration class for PAPOTrainer. + + PAPO (Perception-Aware Policy Optimization) extends GRPO/DAPO for multimodal reasoning by adding an implicit + perception loss and double entropy regularization. + + Args: + perception_loss_weight (`float`, *optional*, defaults to `0.1`): + gamma Weight coefficient for the perception loss term. This encourages the model to be sensitive to visual + changes. + + mask_ratio (`float`, *optional*, defaults to `0.3`): + Ratio of the image to mask when computing perception loss. + + mask_type (`Literal["random", "patch", "grid"]`, *optional*, defaults to `"random"`): + Type of masking strategy to use. + + der_loss_weight1 (`float`, *optional*, defaults to `0.03`): + eta1 Weight coefficient for the Double Entropy Regularization (DER) term. This term encourages confident + predictions with original images (low entropy) and uncertain predictions with masked images (high entropy). + + der_loss_weight2 (`float`, *optional*, defaults to `0.03`): + eta2 Weight coefficient for the Double Entropy Regularization (DER) term. This term encourages confident + predictions with original images (low entropy) and uncertain predictions with masked images (high entropy). + + loss_type (`Literal["grpo", "dapo"]`, inherited from GRPOConfig): + Base loss type to use. Set to "grpo" for PAPO-G or "dapo" for PAPO-D. + """ + + perception_loss_weight: float = 0.1 + mask_ratio: float = 0.3 + mask_type: Literal["random", "patch", "grid"] = "random" + + # Added for Double Entropy Regularization + der_loss_weight1: float = 0.03 + der_loss_weight2: float = 0.03 + + def __post_init__(self): + super().__post_init__() + + # Validation + if not 0.0 <= self.mask_ratio <= 1.0: + raise ValueError(f"mask_ratio must be between 0 and 1, got {self.mask_ratio}") + + if self.der_loss_weight1 < 0 or self.der_loss_weight2 < 0: + raise ValueError( + f"der_loss_weight1 and der_loss_weight2 must be non-negative, got {self.der_loss_weight1} and {self.der_loss_weight2}" + ) + + if self.mask_type not in ["random", "patch", "grid"]: + raise ValueError(f"mask_type must be one of ['random', 'patch', 'grid'], got {self.mask_type}") diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/papo/papo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/papo/papo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..677fe926fd9f47288d217cc20e970b21f3c74b3a --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/papo/papo_trainer.py @@ -0,0 +1,354 @@ +# Copyright 2020-2026 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 random +import textwrap + +import torch +from datasets import Dataset, IterableDataset +from transformers import PreTrainedModel, PreTrainedTokenizerBase, ProcessorMixin + +from ...trainer.grpo_trainer import GRPOTrainer, RewardFunc +from ...trainer.utils import nanmax, nanmin +from .papo_config import PAPOConfig + + +class PAPOTrainer(GRPOTrainer): + """ + Trainer for Perception-Aware Policy Optimization (PAPO). + + PAPO extends GRPO/DAPO for multimodal reasoning by adding an implicit perception loss that encourages the model to + better utilize visual information. The key innovation is computing KL divergence between model outputs on original + vs. corrupted (masked) images. + + Two variants are supported: + - PAPO-G: PAPO + GRPO (use loss_type="grpo") + - PAPO-D: PAPO + DAPO (use loss_type="dapo") + + Example: + + ```python + from datasets import load_dataset + from trl.experimental.papo import PAPOTrainer, PAPOConfig + + dataset = load_dataset("your-vlm-dataset", split="train") + + + def reward_func(completions, **kwargs): + # Your reward function for multimodal reasoning + return [compute_reward(c) for c in completions] + + + # PAPO-G + config = PAPOConfig( + loss_type="grpo", # Use GRPO as base + perception_loss_weight=0.1, + mask_ratio=0.3, + ) + + # PAPO-G + config = PAPOConfig( + loss_type="dapo", # Use DAPO as base + perception_loss_weight=0.1, + mask_ratio=0.3, + ) + + trainer = PAPOTrainer( + model="Qwen/Qwen2-VL-2B-Instruct", + reward_funcs=reward_func, + args=config, + train_dataset=dataset, + ) + + trainer.train() + ``` + + Args: + model (`Union[str, PreTrainedModel]`): + Model to be trained (must be a vision-language model). + reward_funcs (`Union[RewardFunc, list[RewardFunc]]`): + Reward functions for computing rewards (same as GRPO). + args ([`PAPOConfig`], *optional*, defaults to `None`): + Configuration for this trainer. If `None`, a default configuration is used. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + Dataset to use for training. Must include "prompt" and "image" columns. + eval_dataset: Same requirements as train_dataset. + processing_class: Processing class (tokenizer/processor) for the model. + reward_processing_classes: Processing classes for reward models. + callbacks: Training callbacks. + optimizers: Optimizer and scheduler tuple. + peft_config: PEFT configuration if using parameter-efficient fine-tuning. + """ + + _tag_names = ["trl", "papo"] + _name = "PAPO" + _paper = { + "title": "Perception-Aware Policy Optimization for Multimodal Reasoning", + "id": "2507.06448", + # docstyle-ignore + "citation": textwrap.dedent( + """\ + @misc{wang2025perceptionawarepolicyoptimizationmultimodal, + title = {{Perception-Aware Policy Optimization for Multimodal Reasoning}}, + author = {Zhenhailong Wang and Xuehang Guo and Sofia Stoica and Haiyang Xu and Hongru Wang and Hyeonjeong Ha and Xiusi Chen and Yangyi Chen and Ming Yan and Fei Huang and Heng Ji}, + year = 2025, + url = {https://arxiv.org/abs/2507.06448}, + archivePrefix= {arXiv}, + eprint = {2507.06448}, + primaryClass = {cs.CL} + }""" + ), + } + + def __init__( + self, + model: str | PreTrainedModel, + reward_funcs: RewardFunc | list[RewardFunc], + args: PAPOConfig | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None, + callbacks=None, + optimizers=(None, None), + peft_config=None, + ): + # Initialize with default PAPO config if not provided + if args is None: + model_name = model if isinstance(model, str) else model.config._name_or_path + model_name = model_name.split("/")[-1] + args = PAPOConfig(f"{model_name}-PAPO") + + # Store PAPO-specific parameters + self.perception_loss_weight = args.perception_loss_weight + self.mask_ratio = args.mask_ratio + self.mask_type = args.mask_type + self.der_loss_weight1 = args.der_loss_weight1 + self.der_loss_weight2 = args.der_loss_weight2 + + # Initialize parent GRPO trainer + super().__init__( + model=model, + reward_funcs=reward_funcs, + args=args, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + reward_processing_classes=reward_processing_classes, + callbacks=callbacks, + optimizers=optimizers, + peft_config=peft_config, + ) + + def _mask_image(self, pixel_values: torch.Tensor, mask_ratio: float = None) -> torch.Tensor: + """ + Apply masking to image pixel values. + + Args: + pixel_values: Image tensor of shape (B, C, H, W) or (B, N, C, H, W) for multi-image + mask_ratio: Ratio of image to mask (defaults to self.mask_ratio) + + Returns: + Masked pixel values tensor + """ + if mask_ratio is None: + mask_ratio = self.mask_ratio + + masked_pixel_values = pixel_values.clone() + + if self.mask_type == "random": + # Random pixel masking + mask = torch.rand_like(pixel_values) > mask_ratio + masked_pixel_values = masked_pixel_values * mask + + elif self.mask_type == "patch": + # Patch-based masking (mask contiguous regions) + B = pixel_values.shape[0] + if pixel_values.ndim == 4: # (B, C, H, W) + C, H, W = pixel_values.shape[1:] + for i in range(B): + # Calculate patch size to mask + patch_h = int(H * mask_ratio**0.5) + patch_w = int(W * mask_ratio**0.5) + # Random starting position + start_h = random.randint(0, max(0, H - patch_h)) + start_w = random.randint(0, max(0, W - patch_w)) + # Apply mask + masked_pixel_values[i, :, start_h : start_h + patch_h, start_w : start_w + patch_w] = 0 + + elif pixel_values.ndim == 5: # (B, N, C, H, W) for multi-image + N, C, H, W = pixel_values.shape[1:] + for i in range(B): + for n in range(N): + patch_h = int(H * mask_ratio**0.5) + patch_w = int(W * mask_ratio**0.5) + start_h = random.randint(0, max(0, H - patch_h)) + start_w = random.randint(0, max(0, W - patch_w)) + masked_pixel_values[i, n, :, start_h : start_h + patch_h, start_w : start_w + patch_w] = 0 + + elif self.mask_type == "grid": + # Grid-based masking (mask regular grid cells) + if pixel_values.ndim == 4: + C, H, W = pixel_values.shape[1:] + grid_size = int((1 / mask_ratio) ** 0.5) + cell_h, cell_w = H // grid_size, W // grid_size + + for i in range(grid_size): + for j in range(grid_size): + if random.random() < mask_ratio: + masked_pixel_values[:, :, i * cell_h : (i + 1) * cell_h, j * cell_w : (j + 1) * cell_w] = 0 + + return masked_pixel_values + + def _compute_loss(self, model, inputs): + # >>> 1. GRPO loss + # Compute the per-token log probabilities for the model + prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"] + completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"] + input_ids = torch.cat([prompt_ids, completion_ids], dim=1) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens + + # Compute the per_token_logps and the entropy at each position in the completion + per_token_logps, entropies, _ = self._get_per_token_logps_and_entropies( + model, + input_ids, + attention_mask, + logits_to_keep, + compute_entropy=True, + pixel_values=inputs.get("pixel_values"), + image_grid_thw=inputs.get("image_grid_thw"), + num_images=inputs.get("num_images"), + pixel_attention_mask=inputs.get("pixel_attention_mask"), + image_sizes=inputs.get("image_sizes"), + ) + + if self.top_entropy_quantile < 1.0: + entropy_mask = self.get_high_entropy_mask(entropies, completion_mask, 1 - self.top_entropy_quantile) + else: + entropy_mask = None + + # Compute the KL divergence between the model and the reference model + if self.beta != 0.0: + ref_per_token_logps = inputs["ref_per_token_logps"] + per_token_kl = ( + torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1 + ) + + # Compute the loss + advantages = inputs["advantages"] + # When using num_iterations == 1 and steps_per_generation <= gradient_accumulation_steps + # old_per_token_logps == per_token_logps, so we can skip it's computation + # (see _generate_and_score_completions) and use per_token_logps.detach() instead. + old_per_token_logps = inputs.get("old_per_token_logps") + old_per_token_logps = per_token_logps.detach() if old_per_token_logps is None else old_per_token_logps + + log_ratio = per_token_logps - old_per_token_logps + if self.importance_sampling_level == "token": + log_importance_weights = log_ratio + elif self.importance_sampling_level == "sequence": + log_importance_weights = (log_ratio * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0) + log_importance_weights = log_importance_weights.unsqueeze(-1) + else: + raise ValueError( + f"Unknown importance sampling level: {self.importance_sampling_level}. Possible values are 'token' " + "and 'sequence'." + ) + # From here, log_importance_weights (and all subsequent tensors, coef_1, coef_2, etc.) shape depends on + # importance_sampling_level: "token" level: (B, T); "sequence" level: (B, 1) + + coef_1 = torch.exp(log_importance_weights) + coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high) + + # Two-sided clipping + if self.args.delta is not None: + coef_1 = torch.clamp(coef_1, max=self.args.delta) + + per_token_loss1 = coef_1 * advantages.unsqueeze(1) + per_token_loss2 = coef_2 * advantages.unsqueeze(1) + per_token_loss = -torch.min(per_token_loss1, per_token_loss2) + if entropy_mask is not None: + per_token_loss = per_token_loss * entropy_mask + if self.beta != 0.0: + per_token_loss = per_token_loss + self.beta * per_token_kl + + if self.loss_type == "grpo": + loss = ((per_token_loss * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0)).mean() + loss = loss / self.current_gradient_accumulation_steps + elif self.loss_type == "dapo": + normalizer = inputs["num_items_in_batch"] / self.accelerator.num_processes + loss = (per_token_loss * completion_mask).sum() / normalizer + else: + raise ValueError(f"Unknown loss type: {self.loss_type}") + # >>> 2. Implicit Perception Loss + inputs["pixel_values"] = self._mask_image(inputs["pixel_values"], self.mask_ratio) + mask_img_per_token_logps, mask_img_entropies, _ = self._get_per_token_logps_and_entropies( + model, + input_ids, + attention_mask, + logits_to_keep, + compute_entropy=True, + pixel_values=inputs.get("pixel_values"), + image_grid_thw=inputs.get("image_grid_thw"), + num_images=inputs.get("num_images"), + pixel_attention_mask=inputs.get("pixel_attention_mask"), + image_sizes=inputs.get("image_sizes"), + ) + perception_kl = ( + torch.exp(mask_img_per_token_logps - per_token_logps) - (mask_img_per_token_logps - per_token_logps) - 1 + ) + perception_kl = torch.clamp(perception_kl, min=0.0, max=0.2) + perception_loss = self.perception_loss_weight * perception_kl + + # >>> 3. Double Entropy Loss + der_loss = self.der_loss_weight1 * entropies + self.der_loss_weight2 * mask_img_entropies + + # PAPO Loss + loss = (loss - perception_loss + der_loss).mean() + # Log the metrics + mode = "train" if self.model.training else "eval" + + completion_token_count = completion_mask.sum().clamp(min=1.0) + + def masked_batch_mean(x): + if x.shape[1] == 1: # when importance_sampling_level == "sequence" + return x.mean() + else: + return (x * completion_mask).sum() / completion_token_count + + if self.beta != 0.0: + mean_kl = masked_batch_mean(per_token_kl) + self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item()) + + mean_entropy = masked_batch_mean(entropies) + self._metrics[mode]["entropy"].append(self.accelerator.gather(mean_entropy).nanmean().item()) + + # Compute the clipped probability ratios + is_low_clipped = (coef_1 < 1 - self.epsilon_low) & (advantages.unsqueeze(1) < 0) + is_high_clipped = (coef_1 > 1 + self.epsilon_high) & (advantages.unsqueeze(1) > 0) + is_region_clipped = is_low_clipped | is_high_clipped + + low_clip = masked_batch_mean(is_low_clipped.float()) + high_clip = masked_batch_mean(is_high_clipped.float()) + clip_ratio = masked_batch_mean(is_region_clipped.float()) + + gathered_low_clip = self.accelerator.gather(low_clip) + self._metrics[mode]["clip_ratio/low_mean"].append(gathered_low_clip.nanmean().item()) + self._metrics[mode]["clip_ratio/low_min"].append(nanmin(gathered_low_clip).item()) + gathered_high_clip = self.accelerator.gather(high_clip) + self._metrics[mode]["clip_ratio/high_mean"].append(gathered_high_clip.nanmean().item()) + self._metrics[mode]["clip_ratio/high_max"].append(nanmax(gathered_high_clip).item()) + gathered_clip_ratio = self.accelerator.gather(clip_ratio) + self._metrics[mode]["clip_ratio/region_mean"].append(gathered_clip_ratio.nanmean().item()) + return loss diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..09451e973bea4ae1432fe16276907644cd67466c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/__init__.py @@ -0,0 +1,30 @@ +# Copyright 2020-2026 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. + +from .modeling_value_head import ( + AutoModelForCausalLMWithValueHead, + AutoModelForSeq2SeqLMWithValueHead, + PreTrainedModelWrapper, +) +from .ppo_config import PPOConfig +from .ppo_trainer import PPOTrainer + + +__all__ = [ + "AutoModelForCausalLMWithValueHead", + "AutoModelForSeq2SeqLMWithValueHead", + "PreTrainedModelWrapper", + "PPOConfig", + "PPOTrainer", +] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/modeling_value_head.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/modeling_value_head.py new file mode 100644 index 0000000000000000000000000000000000000000..eacd2045b1910b98107929842098725b7f73aab4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/modeling_value_head.py @@ -0,0 +1,1020 @@ +# Copyright 2020-2026 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 logging +import os + +import torch +import torch.nn as nn +from accelerate import PartialState +from huggingface_hub import hf_hub_download +from huggingface_hub.utils import ( + EntryNotFoundError, + HFValidationError, + LocalEntryNotFoundError, + RepositoryNotFoundError, +) +from safetensors.torch import load_file as safe_load_file +from transformers import ( + AutoModelForCausalLM, + AutoModelForSeq2SeqLM, + PreTrainedModel, + is_torch_npu_available, + is_torch_xpu_available, +) +from transformers.utils import is_peft_available + + +if is_peft_available(): + from peft import ( + PeftConfig, + PeftModel, + PeftModelForCausalLM, + PeftModelForSeq2SeqLM, + PromptLearningConfig, + get_peft_model, + prepare_model_for_kbit_training, + ) + + +class PreTrainedModelWrapper(nn.Module): + """ + Wrapper for a [`~transformers.PreTrainedModel`] implemented as a standard PyTorch [`torch.nn.Module`]. + + This class provides a compatibility layer that preserves the key attributes and methods of the original + [`~transformers.PreTrainedModel`], while exposing a uniform interface consistent with PyTorch modules. It enables + seamless integration of pretrained Transformer models into custom training, evaluation, or inference workflows. + + Attributes: + pretrained_model ([`~transformers.PreTrainedModel`]): + The model to be wrapped. + parent_class ([`~transformers.PreTrainedModel`]): + The parent class of the model to be wrapped. + supported_args (`list`): + The list of arguments that are supported by the wrapper class. + """ + + transformers_parent_class = None + supported_args = None + supported_modules = ("v_head",) + supported_rm_modules = ("score",) + supported_pretrained_model_architectures = ( + (PreTrainedModel) + if not is_peft_available() + else (PreTrainedModel, PeftModelForCausalLM, PeftModelForSeq2SeqLM) + ) + + def __init__( + self, pretrained_model=None, score_module=None, supports_rm_adapter=False, rm_adapter_name=None, **kwargs + ): + super().__init__() + self.pretrained_model = pretrained_model + + self.config = pretrained_model.config + self.prepare_inputs_for_generation = pretrained_model.prepare_inputs_for_generation + self.is_loaded_in_8bit = getattr(pretrained_model, "is_loaded_in_8bit", False) + self.is_loaded_in_4bit = getattr(pretrained_model, "is_loaded_in_4bit", False) + self.is_sequential_parallel = False + + if hasattr(pretrained_model, "gradient_checkpointing_disable"): + self.gradient_checkpointing_disable = pretrained_model.gradient_checkpointing_disable + + if hasattr(pretrained_model, "gradient_checkpointing_enable"): + self.gradient_checkpointing_enable = pretrained_model.gradient_checkpointing_enable + + if hasattr(pretrained_model, "enable_input_require_grads"): + self.enable_input_require_grads = pretrained_model.enable_input_require_grads + + self.supports_rm_adapter = supports_rm_adapter + self.rm_adapter_name = rm_adapter_name + self.policy_adapter_name = "default" + if score_module is not None: + self.score = score_module + + @classmethod + def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs): + r""" + Instantiates a new model from a pretrained model from `transformers`. The pretrained model is loaded using the + `from_pretrained` method of the [`~transformers.PreTrainedModel`] class. The arguments that are specific to the + [`~transformers.PreTrainedModel`] class are passed along this method and filtered out from the `kwargs` + argument. + + Args: + pretrained_model_name_or_path (`str` or [`~transformers.PreTrainedModel`]): + The path to the pretrained model or its name. + *model_args (`list`, *optional*): + Additional positional arguments passed along to the underlying model's `from_pretrained` method. + **kwargs (`dict`, *optional*): + Additional keyword arguments passed along to the underlying model's `from_pretrained` method. We also + pre-process the kwargs to extract the arguments that are specific to the + [`~transformers.PreTrainedModel`] class and the arguments that are specific to trl models. The kwargs + also support `prepare_model_for_kbit_training` arguments from `peft` library. + """ + if kwargs is not None: + peft_config = kwargs.pop("peft_config", None) + reward_adapter = kwargs.pop("reward_adapter", None) + reward_adapter_name = kwargs.pop("reward_adapter_name", "reward_adapter") + is_trainable = kwargs.pop("is_trainable", False) + trl_model_args, pretrained_kwargs, peft_quantization_kwargs = cls._split_kwargs(kwargs) + token = pretrained_kwargs.get("token", None) + else: + peft_config = None + is_trainable = False + trl_model_args = {} + pretrained_kwargs = {} + peft_quantization_kwargs = {} + token = None + + if reward_adapter is not None and not isinstance(reward_adapter, str): + raise ValueError( + "The `reward_adapter` argument should be a string representing the name of local path or the Hub id to the Reward Modeling adapter." + ) + + is_peft_model = False + + current_device = cls._get_current_device() + if isinstance(pretrained_model_name_or_path, str): + quantization_config = pretrained_kwargs.get("quantization_config", None) + if quantization_config is not None: + is_loaded_in_8bit = getattr(quantization_config, "load_in_8bit", False) + is_loaded_in_4bit = getattr(quantization_config, "load_in_4bit", False) + else: + is_loaded_in_8bit = pretrained_kwargs["load_in_8bit"] if "load_in_8bit" in pretrained_kwargs else False + is_loaded_in_4bit = pretrained_kwargs["load_in_4bit"] if "load_in_4bit" in pretrained_kwargs else False + else: + is_loaded_in_8bit = getattr(pretrained_model_name_or_path, "is_loaded_in_8bit", False) + is_loaded_in_4bit = getattr(pretrained_model_name_or_path, "is_loaded_in_4bit", False) + + if (is_loaded_in_8bit or is_loaded_in_4bit) and "device_map" not in pretrained_kwargs: + # warn users + logging.warning( + "The `device_map` argument is not provided. We will override the device_map argument." + " to set the entire" + " model on the current device. If you want to set the model on multiple devices, please provide" + " a custom `device_map` argument." + ) + pretrained_kwargs["device_map"] = {"": current_device} + + if is_peft_available() and peft_config is not None and not isinstance(peft_config, PeftConfig): + raise ValueError("The `peft_config` argument should be an instance of `peft.PeftConfig` class.") + + # First, load the pre-trained model using the parent-class + # either `AutoModelForCausalLM` or `AutoModelForSeq2SeqLM` + if isinstance(pretrained_model_name_or_path, str): + if is_peft_available(): + try: + # If there is a trained peft adapter in the hub, load its config. + remote_adapter_config = hf_hub_download( + pretrained_model_name_or_path, + "adapter_config.json", + token=token, + ) + except (EntryNotFoundError, LocalEntryNotFoundError, HFValidationError, RepositoryNotFoundError): + remote_adapter_config = None + else: + remote_adapter_config = None + + local_adapter_present = os.path.exists(os.path.join(pretrained_model_name_or_path, "adapter_config.json")) + + if (local_adapter_present or remote_adapter_config is not None) and is_peft_available(): + if peft_config is not None: + logging.warning( + "`peft_config` argument ignored since a peft config file was found in " + f"{pretrained_model_name_or_path}" + ) + + # Load the trained peft adapter config + if local_adapter_present: + trained_adapter_config = PeftConfig.from_pretrained(pretrained_model_name_or_path) + else: + remote_adapter_dir = os.path.dirname(remote_adapter_config) + trained_adapter_config = PeftConfig.from_pretrained(remote_adapter_dir) + + # Load the pretrained base model + pretrained_model = cls.transformers_parent_class.from_pretrained( + trained_adapter_config.base_model_name_or_path, *model_args, **pretrained_kwargs + ) + + # Wrap the pretrained model with the trained peft adapter + pretrained_model = PeftModel.from_pretrained( + pretrained_model, pretrained_model_name_or_path, is_trainable=is_trainable, token=token + ) + logging.info("Trained peft adapter loaded") + else: + pretrained_model = cls.transformers_parent_class.from_pretrained( + pretrained_model_name_or_path, *model_args, **pretrained_kwargs + ) + + if peft_config is not None: + # Initialize a new peft adapter with the given config + if is_loaded_in_8bit or is_loaded_in_4bit: + pretrained_model = prepare_model_for_kbit_training( + pretrained_model, + **peft_quantization_kwargs, + ) + pretrained_model = get_peft_model(pretrained_model, peft_config) + logging.info("peft adapter initialised") + + elif isinstance(pretrained_model_name_or_path, cls.supported_pretrained_model_architectures): + pretrained_model = pretrained_model_name_or_path + + if peft_config is not None and isinstance(pretrained_model, PreTrainedModel): + # Initialize a new peft adapter with the given config + if is_loaded_in_8bit or is_loaded_in_4bit: + pretrained_model = prepare_model_for_kbit_training( + pretrained_model, + **peft_quantization_kwargs, + ) + pretrained_model = get_peft_model(pretrained_model, peft_config) + logging.info("peft adapter initialised") + else: + raise ValueError( + "pretrained_model_name_or_path should be a string or a PreTrainedModel, " + f"but is {type(pretrained_model_name_or_path)}" + ) + + if is_peft_available(): + if isinstance(pretrained_model, PeftModel): + is_peft_model = True + # for backward compatibility + if hasattr(pretrained_model, "active_peft_config") and isinstance( + pretrained_model.active_peft_config, PromptLearningConfig + ): + raise ValueError("PromptLearningConfig is not supported for PPO training.") + + # Add reward modeling adapter if specified + if not is_peft_model and reward_adapter is not None: + raise ValueError("reward_adapter can only be used with a PeftModel. ") + elif is_peft_model and reward_adapter is not None: + score_module = cls.add_and_load_reward_modeling_adapter( + pretrained_model, reward_adapter, reward_adapter_name, token=token + ) + multi_adapter_args = { + "score_module": score_module, + "supports_rm_adapter": True, + "rm_adapter_name": reward_adapter_name, + } + else: + multi_adapter_args = {"supports_rm_adapter": False} + + # Then, create the full model by instantiating the wrapper class + model = cls(pretrained_model, **multi_adapter_args, **trl_model_args) + + # if resume_training, load the state_dict again - this is ok since the + # state_dict is removed from the model after loading it. + is_resuming_training = True + if isinstance(pretrained_model_name_or_path, str): + safe_filename = os.path.join(pretrained_model_name_or_path, "model.safetensors") + filename = os.path.join(pretrained_model_name_or_path, "pytorch_model.bin") + + sharded_index_filename = os.path.join(pretrained_model_name_or_path, "pytorch_model.bin.index.json") + safe_sharded_index_filename = os.path.join(pretrained_model_name_or_path, "model.safetensors.index.json") + is_sharded = False + use_safe = os.path.exists(safe_filename) + + if not (os.path.exists(filename) or os.path.exists(safe_filename)): + # Try with `pytorch_model.bin` + filename, files_to_download, is_sharded, is_resuming_training = cls._get_checkpoint_from_hub( + pretrained_model, + pretrained_model_name_or_path, + sharded_index_filename, + token=token, + ) + # Try with safetensors + if filename is None and files_to_download is None: + safe_filename, files_to_download, is_sharded, is_resuming_training = cls._get_checkpoint_from_hub( + pretrained_model, + pretrained_model_name_or_path, + safe_sharded_index_filename, + token=token, + model_name="model.safetensors", + model_index_name="model.safetensors.index.json", + ) + use_safe = True + else: + use_safe = False + + loading_func = safe_load_file if use_safe else torch.load + load_kwargs = {} if use_safe else {"map_location": "cpu", "weights_only": True} + + if is_resuming_training: + if is_sharded: + # download each file and add it to the state_dict + state_dict = {} + + for shard_file in files_to_download: + filename = hf_hub_download( + pretrained_model_name_or_path, + shard_file, + token=token, + ) + state_dict.update(loading_func(filename, **load_kwargs)) + else: + state_dict = loading_func(filename if not use_safe else safe_filename, **load_kwargs) + + else: + state_dict = pretrained_model_name_or_path.state_dict() + + model.is_peft_model = is_peft_model + model.current_device = current_device + + if is_resuming_training: + model.post_init(state_dict=state_dict) + + return model + + @classmethod + def _get_checkpoint_from_hub( + cls, + pretrained_model, + pretrained_model_name_or_path, + index_filename, + token=None, + model_name="pytorch_model.bin", + model_index_name="pytorch_model.bin.index.json", + ): + files_to_download = None + filename = None + is_resuming_training = True + is_sharded = False + + try: + filename = hf_hub_download( + pretrained_model_name_or_path, + model_name, + token=token, + ) + # sharded + except (EntryNotFoundError, LocalEntryNotFoundError, HFValidationError, RepositoryNotFoundError): + if os.path.exists(index_filename): + index_file_name = index_filename + else: + try: + index_file_name = hf_hub_download( + pretrained_model_name_or_path, + model_index_name, + token=token, + ) + except (EntryNotFoundError, LocalEntryNotFoundError, HFValidationError, RepositoryNotFoundError): + # not continue training, do not have v_head weight + is_resuming_training = False + logging.warning( + f"A {type(pretrained_model)} model is loaded from '{pretrained_model_name_or_path}', " + f"and no v_head weight is found. This IS expected if you are not resuming PPO training." + ) + # load json + if is_resuming_training: + with open(index_file_name) as f: + index = json.load(f) + # check filename with `v_head` or any known extra module: + files_to_download = set() + for k, v in index["weight_map"].items(): + if any(module in k for module in cls.supported_modules): + files_to_download.add(v) + is_sharded = True + + return filename, files_to_download, is_sharded, is_resuming_training + + @classmethod + def _get_current_device(cls): + r""" + Get the current device. For GPU & XPU, we return the local process index using the `accelerate.PartialState` + object to handle corner cases when running scripts in distributed environments. + + Returns: + current_device (`int | str`): + The current device. + """ + state = PartialState() + if torch.cuda.is_available() or is_torch_xpu_available(): + return state.local_process_index + elif is_torch_npu_available(): + return f"npu:{state.local_process_index}" + else: + return "cpu" + + @classmethod + def _split_kwargs(cls, kwargs): + """ + Separate the kwargs from the arguments that we support inside `supported_args` and the ones that we don't. + """ + check_peft_kwargs = False + + if is_peft_available(): + from peft import prepare_model_for_kbit_training + + check_peft_kwargs = True + + supported_kwargs = {} + unsupported_kwargs = {} + peft_kwargs = {} + + for key, value in kwargs.items(): + if key in cls.supported_args: + supported_kwargs[key] = value + else: + unsupported_kwargs[key] = value + + if check_peft_kwargs: + if key in prepare_model_for_kbit_training.__code__.co_varnames: + peft_kwargs[key] = value + if key in unsupported_kwargs: + unsupported_kwargs.pop(key) + + return supported_kwargs, unsupported_kwargs, peft_kwargs + + @classmethod + def add_and_load_reward_modeling_adapter( + cls, pretrained_model, adapter_model_id, adapter_name="reward_model_adapter", token=None + ): + r""" + Add and load a reward modeling adapter. This method can only be used if the model is a `PeftModel` and if you + have initialized the model with the `reward_modeling_adapter_id` argument, pointing to the id of the reward + modeling adapter. The latest needs also to contain the score head in order to produce the reward. + """ + pretrained_model.load_adapter(adapter_model_id, adapter_name, is_trainable=False) + pretrained_model.train() + + filename = os.path.join(adapter_model_id, "adapter_model.bin") + safe_loading = False + if not os.path.exists(filename): + try: + local_filename = hf_hub_download( + adapter_model_id, + "adapter_model.bin", + token=token, + ) + except Exception: + filename = os.path.join(adapter_model_id, "adapter_model.safetensors") + safe_loading = True + if not os.path.exists(filename): + try: + local_filename = hf_hub_download( + adapter_model_id, + "adapter_model.safetensors", + token=token, + ) + except Exception as exc: + raise ValueError( + "Could not find adapter model in the Hub, make sure you have the correct adapter model id." + ) from exc + else: + local_filename = filename + else: + local_filename = filename + + loading_func = safe_load_file if safe_loading else torch.load + load_kwargs = {} if safe_loading else {"map_location": "cpu", "weights_only": True} + + adapter_state_dict = loading_func(local_filename, **load_kwargs) + + for score_name_candidate in cls.supported_rm_modules: + if any(score_name_candidate in name for name in adapter_state_dict.keys()): + score_name = score_name_candidate + # we have found the correct head name and can break + break + + score_dict = {} + + for name, param in adapter_state_dict.items(): + if score_name in name: + key_name = ".".join(name.split(".")[-1:]) + score_dict[key_name] = param.to(cls._get_current_device()) + + num_labels, hidden_dim = score_dict["weight"].shape + has_bias = any("bias" in name for name in adapter_state_dict.keys()) + + score = nn.Linear(hidden_dim, num_labels, bias=has_bias).to( + device=cls._get_current_device(), + dtype=pretrained_model.dtype, + ) + score.load_state_dict(score_dict) + for param in score.parameters(): + param.requires_grad = False + + return score + + def push_to_hub(self, *args, **kwargs): + r""" + Push the pretrained model to the hub. This method is a wrapper around + [`~transformers.PreTrainedModel.push_to_hub`]. Please refer to the documentation of + [`~transformers.PreTrainedModel.push_to_hub`] for more information. + + Args: + *args (`list`, *optional*): + Positional arguments passed along to the underlying model's `push_to_hub` method. + **kwargs (`dict`, *optional*): + Keyword arguments passed along to the underlying model's `push_to_hub` method. + """ + raise NotImplementedError + + def save_pretrained(self, *args, **kwargs): + r""" + Save the pretrained model to a directory. This method is a wrapper around + [`~transformers.PreTrainedModel.save_pretrained`]. Please refer to the documentation of + [`~transformers.PreTrainedModel.save_pretrained`] for more information. + + Args: + *args (`list`, *optional*): + Positional arguments passed along to the underlying model's `save_pretrained` method. + **kwargs (`dict`, *optional*): + Keyword arguments passed along to the underlying model's `save_pretrained` method. + """ + state_dict = kwargs.get("state_dict") + if state_dict is None: + state_dict = self.state_dict() + kwargs["state_dict"] = state_dict + + # if it is a peft model only save the `v_head` state_dict and + # pop the `state_dict` from the kwargs to avoid silent bugs with `peft` + if self.is_peft_model: + save_path = args[0] + save_path = os.path.join(save_path, "pytorch_model.bin") + torch.save(state_dict, save_path) + _ = kwargs.pop("state_dict", None) + + return self.pretrained_model.save_pretrained(*args, **kwargs) + + def state_dict(self, *args, **kwargs): + r""" + Return the state_dict of the pretrained model. + """ + raise NotImplementedError + + def post_init(self, *args, **kwargs): + r""" + Post initialization method. This method is called after the model is instantiated and loaded from a checkpoint. + It can be used to perform additional operations such as loading the state_dict. + """ + raise NotImplementedError + + def compute_reward_score(self, input_ids, attention_mask=None, **kwargs): + r""" + Computes the reward score for a given input. The method has first to enable the adapter and then compute the + reward score. After that the model disables the reward modeling adapter and enables the default ppo adapter + again. + """ + if not self.supports_rm_adapter: + raise ValueError("This model does not support reward modeling adapter.") + + # enable rm adapter + self.pretrained_model.set_adapter(self.rm_adapter_name) + self.pretrained_model.eval() + + with torch.no_grad(): + base_model_output = self.pretrained_model( + input_ids=input_ids, + attention_mask=attention_mask, + output_hidden_states=True, + return_dict=True, + **kwargs, + ) + + last_hidden_states = base_model_output.hidden_states[-1] + scores = self.score(last_hidden_states) + + self.pretrained_model.set_adapter(self.policy_adapter_name) + self.pretrained_model.eval() + + return scores + + +class ValueHead(nn.Module): + r""" + The ValueHead class implements a head for GPT2 that returns a scalar for each output token. + """ + + def __init__(self, config, **kwargs): + super().__init__() + if not hasattr(config, "summary_dropout_prob"): + summary_dropout_prob = kwargs.pop("summary_dropout_prob", 0.1) + else: + summary_dropout_prob = config.summary_dropout_prob + + self.dropout = nn.Dropout(summary_dropout_prob) if summary_dropout_prob else nn.Identity() + + # Determine hidden_size in priority order: + # 1. word_embed_proj_dim (OPT-350m): output projection dim, != internal hidden_size + # 2. hidden_size: standard attribute for most decoder-only and seq2seq models + # 3. text_config.hidden_size: multimodal configs (Gemma3, LLaVA,...) with no top-level hidden_size + # 4. decoder.hidden_size: EncoderDecoder compositions (e.g. BERT encoder + BERT decoder) + if hasattr(config, "word_embed_proj_dim"): + hidden_size = config.word_embed_proj_dim + elif hasattr(config, "hidden_size"): + hidden_size = config.hidden_size + elif hasattr(config, "text_config") and hasattr(config.text_config, "hidden_size"): + hidden_size = config.text_config.hidden_size + elif ( + getattr(config, "is_encoder_decoder", False) + and hasattr(config, "decoder") + and hasattr(config.decoder, "hidden_size") + ): + hidden_size = config.decoder.hidden_size + else: + raise ValueError( + "Cannot determine `hidden_size` from model config. " + "Please open an issue or pass a model whose config exposes one of: " + "`hidden_size`, `word_embed_proj_dim`, `text_config.hidden_size`, or `decoder.hidden_size`." + ) + self.summary = nn.Linear(hidden_size, 1) + + self.flatten = nn.Flatten() + + def forward(self, hidden_states): + output = self.dropout(hidden_states) + + # For now force upcast in fp32 if needed. Let's keep the + # output in fp32 for numerical stability. + if output.dtype != self.summary.weight.dtype: + output = output.to(self.summary.weight.dtype) + + output = self.summary(output) + return output + + +class AutoModelForCausalLMWithValueHead(PreTrainedModelWrapper): + """ + An autoregressive model with a value head in addition to the language model head. This class inherits from + [`experimental.ppo.PreTrainedModelWrapper`] and wraps a [`~transformers.PreTrainedModel`] class. The wrapper class + supports classic functions such as `from_pretrained`, `push_to_hub` and `generate`. To call a method of the wrapped + model, simply manipulate the `pretrained_model` attribute of this class. + + Class attributes: + - **transformers_parent_class** ([`~transformers.PreTrainedModel`]) -- The parent class of the wrapped model. + This + should be set to `transformers.AutoModelForCausalLM` for this class. + - **supported_args** (`tuple`) -- A tuple of strings that are used to identify the arguments that are supported + by the [`ValueHead`] class. Currently, the supported args are: + - **summary_dropout_prob** (`float`, `optional`, defaults to `None`) -- The dropout probability for the + [`ValueHead`] class. + - **v_head_initializer_range** (`float`, `optional`, defaults to `0.2`) -- The initializer range for the + [`ValueHead`] if a specific initialization strategy is selected. + - **v_head_init_strategy** (`str`, `optional`, defaults to `None`) -- The initialization strategy for the + [`ValueHead`]. Currently, the supported strategies are: + - **`None`** -- Initializes the weights of the [`ValueHead`] with a random distribution. This is the + default strategy. + - **"normal"** -- Initializes the weights of the [`ValueHead`] with a normal distribution. + """ + + transformers_parent_class = AutoModelForCausalLM + supported_args = ( + "summary_dropout_prob", + "v_head_initializer_range", + "v_head_init_strategy", + ) + + def __init__(self, pretrained_model, **kwargs): + """ + Initializes the model. + + Args: + pretrained_model ([`~transformers.PreTrainedModel`]): + The model to wrap. It should be a causal language model such as GPT2. or any model mapped inside the + `AutoModelForCausalLM` class. + kwargs (`dict`, `optional`): + Additional keyword arguments, that are passed to the [`ValueHead`] class. + """ + super().__init__(pretrained_model, **kwargs) + v_head_kwargs, _, _ = self._split_kwargs(kwargs) + self.v_head = ValueHead(self.pretrained_model.config, **v_head_kwargs) + self._init_weights(**v_head_kwargs) + + def _init_weights(self, **kwargs): + r""" + Initializes the weights of the value head. The default initialization strategy is random. Users can pass a + different initialization strategy by passing the `v_head_init_strategy` argument when calling + `.from_pretrained`. Supported strategies are: + - `normal`: initializes the weights with a normal distribution. + + Args: + **kwargs (`dict`, `optional`): + Additional keyword arguments, that are passed to the [`ValueHead`] class. These arguments can contain + the `v_head_init_strategy` argument as well as the `v_head_initializer_range` argument. + """ + initializer_range = kwargs.pop("v_head_initializer_range", 0.2) + # random init by default + init_strategy = kwargs.pop("v_head_init_strategy", None) + if init_strategy is None: + # do nothing + pass + elif init_strategy == "normal": + self.v_head.summary.weight.data.normal_(mean=0.0, std=initializer_range) + self.v_head.summary.bias.data.zero_() + + def forward( + self, + input_ids=None, + past_key_values=None, + attention_mask=None, + return_past_key_values=False, + **kwargs, + ): + r""" + Applies a forward pass to the wrapped model and returns the logits of the value head. + + Args: + input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): + Indices of input sequence tokens in the vocabulary. + past_key_values (`tuple(tuple(torch.FloatTensor))`, `optional`): + Contains pre-computed hidden-states (key and values in the attention blocks) as computed by the model + (see `past_key_values` input) to speed up sequential decoding. + attention_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, `optional`): + Mask to avoid performing attention on padding token indices. Mask values selected in ``[0, 1]``: + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + return_past_key_values (bool): A flag indicating if the computed hidden-states should be returned. + kwargs (`dict`, `optional`): + Additional keyword arguments, that are passed to the wrapped model. + """ + kwargs["output_hidden_states"] = True # this had already been set in the LORA / PEFT examples + kwargs["past_key_values"] = past_key_values + + if self.is_peft_model and self.pretrained_model.active_peft_config.peft_type == "PREFIX_TUNING": + kwargs.pop("past_key_values") + + base_model_output = self.pretrained_model( + input_ids=input_ids, + attention_mask=attention_mask, + **kwargs, + ) + + last_hidden_state = base_model_output.hidden_states[-1] + lm_logits = base_model_output.logits + loss = base_model_output.loss + + if last_hidden_state.device != self.v_head.summary.weight.device: + last_hidden_state = last_hidden_state.to(self.v_head.summary.weight.device) + + value = self.v_head(last_hidden_state).squeeze(-1) + + # force upcast in fp32 if logits are in half-precision + if lm_logits.dtype != torch.float32: + lm_logits = lm_logits.float() + + if return_past_key_values: + return (lm_logits, loss, value, base_model_output.past_key_values) + else: + return (lm_logits, loss, value) + + def generate(self, *args, **kwargs): + r""" + A simple wrapper around the `generate` method of the wrapped model. Please refer to the + [`generate`](https://huggingface.co/docs/transformers/internal/generation_utils) method of the wrapped model + for more information about the supported arguments. + + Args: + *args (`list`, *optional*): + Positional arguments passed to the `generate` method of the wrapped model. + **kwargs (`dict`, *optional*): + Keyword arguments passed to the `generate` method of the wrapped model. + """ + return self.pretrained_model.generate(*args, **kwargs) + + def state_dict(self, *args, **kwargs): + r""" + Returns the state dictionary of the model. We add the state dictionary of the value head to the state + dictionary of the wrapped model by prepending the key with `v_head.`. + """ + if not self.is_peft_model: + pretrained_model_state_dict = self.pretrained_model.state_dict(*args, **kwargs) + else: + # if it is a peft model, only save the v_head + pretrained_model_state_dict = {} + + v_head_state_dict = self.v_head.state_dict(*args, **kwargs) + for k, v in v_head_state_dict.items(): + pretrained_model_state_dict[f"v_head.{k}"] = v + return pretrained_model_state_dict + + def push_to_hub(self, *args, **kwargs): + self.pretrained_model.v_head = self.v_head + + return self.pretrained_model.push_to_hub(*args, **kwargs) + + def post_init(self, state_dict): + r""" + We add the state dictionary of the value head to the state dictionary of the wrapped model by prepending the + key with `v_head.`. This function removes the `v_head.` prefix from the keys of the value head state + dictionary. + """ + for k in list(state_dict.keys()): + if "v_head." in k: + state_dict[k.replace("v_head.", "")] = state_dict.pop(k) + self.v_head.load_state_dict(state_dict, strict=False) + del state_dict + + if hasattr(self.pretrained_model, "hf_device_map"): + if ( + "cpu" in self.pretrained_model.hf_device_map.values() + or "disk" in self.pretrained_model.hf_device_map.values() + ): + raise ValueError( + "The model is offloaded on CPU or disk - CPU & disk offloading is not supported for ValueHead models." + ) + + first_device = list(set(self.pretrained_model.hf_device_map.values()))[0] + if isinstance(first_device, int): + if is_torch_npu_available(): + first_device = f"npu:{first_device}" + elif is_torch_xpu_available(): + first_device = f"xpu:{first_device}" + else: + first_device = f"cuda:{first_device}" + self.v_head = self.v_head.to(first_device) + + def set_device_hook(module, input, outputs): + new_output = () + for output in outputs: + if isinstance(output, torch.Tensor): + new_output += (output.to(first_device),) + else: + new_output += (output,) + return new_output + + self.register_forward_hook(set_device_hook) + + self.is_sequential_parallel = True + + +class AutoModelForSeq2SeqLMWithValueHead(PreTrainedModelWrapper): + """ + A seq2seq model with a value head in addition to the language model head. This class inherits from + [`experimental.ppo.PreTrainedModelWrapper`] and wraps a [`~transformers.PreTrainedModel`] class. The wrapper class + supports classic functions such as `from_pretrained` and `push_to_hub` and also provides some additional + functionalities such as `generate`. + + Args: + pretrained_model ([`~transformers.PreTrainedModel`]): + The model to wrap. It should be a causal language model such as GPT2. or any model mapped inside the + [`~transformers.AutoModelForSeq2SeqLM`] class. + kwargs: + Additional keyword arguments passed along to the [`ValueHead`] class. + """ + + transformers_parent_class = AutoModelForSeq2SeqLM + lm_head_namings = ["lm_head", "embed_out", "output_projection"] + supported_args = ( + "summary_dropout_prob", + "v_head_initializer_range", + "v_head_init_strategy", + ) + + def __init__(self, pretrained_model, **kwargs): + super().__init__(pretrained_model, **kwargs) + v_head_kwargs, _, _ = self._split_kwargs(kwargs) + self.is_encoder_decoder = True + + if not self._has_lm_head(): + raise ValueError("The model does not have a language model head, please use a model that has one.") + + self.v_head = ValueHead(self.pretrained_model.config, **v_head_kwargs) + + self._init_weights(**v_head_kwargs) + + def _has_lm_head(self): + # check module names of all modules inside `pretrained_model` to find the language model head + for name, _module in self.pretrained_model.named_modules(): + if any(attribute in name for attribute in self.lm_head_namings): + return True + return False + + def post_init(self, state_dict): + r""" + We add the state dictionary of the value head to the state dictionary of the wrapped model by prepending the + key with `v_head.`. This function removes the `v_head.` prefix from the keys of the value head state + dictionary. + """ + for k in list(state_dict.keys()): + if "v_head." in k: + state_dict[k.replace("v_head.", "")] = state_dict.pop(k) + self.v_head.load_state_dict(state_dict, strict=False) + del state_dict + + if hasattr(self.pretrained_model, "hf_device_map"): + if ( + "cpu" in self.pretrained_model.hf_device_map.values() + or "disk" in self.pretrained_model.hf_device_map.values() + ): + raise ValueError( + "The model is offloaded on CPU or disk - CPU & disk offloading is not supported for ValueHead models." + ) + + # get the lm_head device + for name, module in self.pretrained_model.named_modules(): + if any(attribute in name for attribute in self.lm_head_namings): + lm_head_device = module.weight.device + break + + # put v_head on the same device as the lm_head to avoid issues + self.v_head = self.v_head.to(lm_head_device) + + def set_device_hook(module, input, outputs): + r""" + A hook that sets the device of the output of the model to the device of the first parameter of the + model. + + Args: + module (`nn.Module`): + The module to which the hook is attached. + input (`tuple`): + The input to the module. + outputs (`tuple`): + The output of the module. + """ + new_output = () + for output in outputs: + if isinstance(output, torch.Tensor): + new_output += (output.to(lm_head_device),) + else: + new_output += (output,) + return new_output + + self.register_forward_hook(set_device_hook) + self.is_sequential_parallel = True + + def state_dict(self, *args, **kwargs): + r""" + Returns the state dictionary of the model. We add the state dictionary of the value head to the state + dictionary of the wrapped model by prepending the key with `v_head.`. + """ + if not self.is_peft_model: + pretrained_model_state_dict = self.pretrained_model.state_dict(*args, **kwargs) + else: + # if it is a peft model, only save the v_head + pretrained_model_state_dict = {} + + v_head_state_dict = self.v_head.state_dict(*args, **kwargs) + for k, v in v_head_state_dict.items(): + pretrained_model_state_dict[f"v_head.{k}"] = v + return pretrained_model_state_dict + + def push_to_hub(self, *args, **kwargs): + self.pretrained_model.v_head = self.v_head + + return self.pretrained_model.push_to_hub(*args, **kwargs) + + def _init_weights(self, **kwargs): + r""" + We initialize the weights of the value head. + """ + initializer_range = kwargs.pop("v_head_initializer_range", 0.2) + # random init by default + init_strategy = kwargs.pop("v_head_init_strategy", None) + if init_strategy is None: + # do nothing + pass + elif init_strategy == "normal": + self.v_head.summary.weight.data.normal_(mean=0.0, std=initializer_range) + self.v_head.summary.bias.data.zero_() + + def forward( + self, + input_ids=None, + past_key_values=None, + attention_mask=None, + return_past_key_values=False, + **kwargs, + ): + kwargs["past_key_values"] = past_key_values + if self.is_peft_model and self.pretrained_model.active_peft_config.peft_type == "PREFIX_TUNING": + kwargs.pop("past_key_values") + + base_model_output = self.pretrained_model( + input_ids=input_ids, + attention_mask=attention_mask, + output_hidden_states=True, # We force the model to output hidden states + **kwargs, + ) + + last_hidden_state = base_model_output.decoder_hidden_states[-1] + lm_logits = base_model_output.logits + loss = base_model_output.loss + + value = self.v_head(last_hidden_state).squeeze(-1) + + # force upcast in fp32 if logits are in half-precision + if lm_logits.dtype != torch.float32: + lm_logits = lm_logits.float() + + if return_past_key_values: + return (lm_logits, loss, value, base_model_output.past_key_values) + else: + return (lm_logits, loss, value) + + def generate(self, *args, **kwargs): + r""" + We call `generate` on the wrapped model. + """ + return self.pretrained_model.generate(*args, **kwargs) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/ppo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/ppo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..b96ee394734982fd82cf6ba2ae87bc6ca7be206f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/ppo_config.py @@ -0,0 +1,280 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Literal + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class PPOConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`experimental.ppo.PPOTrainer`]. + + This class includes only the parameters that are specific to PPO training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + 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: + dataset_num_proc (`int`, *optional*): + Number of processes to use for processing the dataset. + num_mini_batches (`int`, *optional*, defaults to `1`): + Number of minibatches to split a batch into. + total_episodes (`int`, *optional*): + Total number of episodes in the dataset. + local_rollout_forward_batch_size (`int`, *optional*, defaults to `64`): + Per rank no grad forward pass in the rollout phase. + num_sample_generations (`int`, *optional*, defaults to `10`): + Number of debugging samples generations (i.e., `generate_completions` calls) throughout training. + response_length (`int`, *optional*, defaults to `53`): + Length of the response. + stop_token (`str`, *optional*): + Specifies the stop token to use for text generation. This parameter is mutually exclusive with + `stop_token_id`. + + - `None`: No stop token is applied, unless `stop_token_id` is specified. + - `'eos'`: Uses the tokenizer's `eos_token`. + + stop_token_id (`int`, *optional*): + Specifies the ID of the stop token to use for text generation. If `None`, no stop token ID is applied, + unless `stop_token` is specified. This parameter is mutually exclusive with `stop_token`. + temperature (`float`, *optional*, defaults to `0.7`): + Sampling temperature. + missing_eos_penalty (`float`, *optional*): + Penalty applied to the score when the model fails to generate an EOS token. This is useful to encourage to + generate completions shorter than the maximum length (`max_new_tokens`). The penalty must be a positive + value. + sft_model_path (`str`, *optional*, defaults to `"EleutherAI/pythia-160m"`): + Path to the SFT model. + world_size (`int`, *optional*): + Number of processes (GPUs) to use for the training. + num_total_batches (`int`, *optional*): + Number of total batches to train. + micro_batch_size (`int`, *optional*): + Micro batch size across devices (HF's `per_device_train_batch_size` * `world_size`). + local_batch_size (`int`, *optional*): + Batch size per GPU (HF's `per_device_train_batch_size` * `gradient_accumulation_steps`). + batch_size (`int`, *optional*): + Batch size across devices (HF's `per_device_train_batch_size` * `world_size` * + `gradient_accumulation_steps`). + local_mini_batch_size (`int`, *optional*): + Mini batch size per GPU. + mini_batch_size (`int`, *optional*): + Mini batch size across GPUs. + push_to_hub (`bool`, *optional*, defaults to `False`): + Whether to push the model to the Hub after training. + reward_model_path (`str`, *optional*, defaults to `"EleutherAI/pythia-160m"`): + Path to the reward model. + model_adapter_name (`str`, *optional*): + Name of the train target PEFT adapter, when using LoRA with multiple adapters. + ref_adapter_name (`str`, *optional*): + Name of the reference PEFT adapter, when using LoRA with multiple adapters. + num_ppo_epochs (`int`, *optional*, defaults to `4`): + Number of epochs to train. + whiten_rewards (`bool`, *optional*, defaults to `False`): + Whether to whiten the rewards. + kl_coef (`float`, *optional*, defaults to `0.05`): + KL coefficient. + kl_estimator (`Literal["k1", "k3"]`, *optional*, defaults to `"k1"`): + Which estimator for KL-Divergence to use from [Approximating KL + Divergence](http://joschu.net/blog/kl-approx.html). Defaults to "k1", a straightforward, unbiased + estimator. Can be set to "k3", an unbiased estimator with lower variance which "appears to be a strictly + better estimator". Cannot be set to "k2", as it is used for logging purposes. + cliprange (`float`, *optional*, defaults to `0.2`): + Clip range. + vf_coef (`float`, *optional*, defaults to `0.1`): + Value function coefficient. + cliprange_value (`float`, *optional*, defaults to `0.2`): + Clip range for the value function. + gamma (`float`, *optional*, defaults to `1.0`): + Discount factor. + lam (`float`, *optional*, defaults to `0.95`): + Lambda value for GAE. + ds3_gather_for_generation (`bool`, *optional*, defaults to `True`): + This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation, + improving generation speed. However, disabling this option allows training models that exceed the VRAM + capacity of a single GPU, albeit at the cost of slower generation. + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `3e-6` instead of `5e-5`. + """ + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=3e-6, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + dataset_num_proc: int | None = field( + default=None, + metadata={"help": "Number of processes to use for processing the dataset."}, + ) + num_mini_batches: int = field( + default=1, + metadata={"help": "Number of minibatches to split a batch into."}, + ) + total_episodes: int | None = field( + default=None, + metadata={"help": "Total number of episodes in the dataset."}, + ) + local_rollout_forward_batch_size: int = field( + default=64, + metadata={"help": "Per rank no grad forward pass in the rollout phase."}, + ) + num_sample_generations: int = field( + default=10, + metadata={ + "help": "Number of debugging samples generations (i.e., `generate_completions` calls) throughout training." + }, + ) + response_length: int = field( + default=53, + metadata={"help": "Length of the response."}, + ) + stop_token: Literal["eos"] | None = field( + default=None, + metadata={ + "help": "Specifies the stop token to use for text generation. This parameter is mutually exclusive with " + "`stop_token_id`." + }, + ) + stop_token_id: int | None = field( + default=None, + metadata={ + "help": "Specifies the ID of the stop token to use for text generation. If `None`, no stop token ID is " + "applied, unless `stop_token` is specified. This parameter is mutually exclusive with `stop_token`." + }, + ) + temperature: float = field( + default=0.7, + metadata={"help": "Sampling temperature."}, + ) + missing_eos_penalty: float | None = field( + default=None, + metadata={ + "help": "Penalty applied to the score when the model fails to generate an EOS token. This is useful to " + "encourage to generate completions shorter than the maximum length (`max_new_tokens`). The penalty must be " + "a positive value." + }, + ) + sft_model_path: str = field( + default="EleutherAI/pythia-160m", + metadata={"help": "Path to the SFT model."}, + ) + world_size: int | None = field( + default=None, + metadata={"help": "Number of processes (GPUs) to use for the training."}, + ) + num_total_batches: int | None = field( + default=None, + metadata={"help": "Number of total batches to train."}, + ) + micro_batch_size: int | None = field( + default=None, + metadata={"help": "Micro batch size across devices (HF's `per_device_train_batch_size` * `world_size`)."}, + ) + local_batch_size: int | None = field( + default=None, + metadata={"help": "Batch size per GPU (HF's `per_device_train_batch_size` * `gradient_accumulation_steps`)."}, + ) + batch_size: int | None = field( + default=None, + metadata={ + "help": "Batch size across devices (HF's `per_device_train_batch_size` * `world_size` * " + "`gradient_accumulation_steps`)." + }, + ) + local_mini_batch_size: int | None = field( + default=None, + metadata={"help": "Mini batch size per GPU."}, + ) + mini_batch_size: int | None = field( + default=None, + metadata={"help": "Mini batch size across GPUs."}, + ) + push_to_hub: bool = field( + default=False, + metadata={"help": "Whether to push the model to the Hub after training."}, + ) + reward_model_path: str = field( + default="EleutherAI/pythia-160m", + metadata={"help": "Path to the reward model."}, + ) + model_adapter_name: str | None = field( + default=None, + metadata={"help": "Name of the train target PEFT adapter, when using LoRA with multiple adapters."}, + ) + ref_adapter_name: str | None = field( + default=None, + metadata={"help": "Name of the reference PEFT adapter, when using LoRA with multiple adapters."}, + ) + num_ppo_epochs: int = field( + default=4, + metadata={"help": "Number of epochs to train."}, + ) + whiten_rewards: bool = field( + default=False, + metadata={"help": "Whether to whiten the rewards."}, + ) + kl_coef: float = field( + default=0.05, + metadata={"help": "KL coefficient."}, + ) + kl_estimator: Literal["k1", "k3"] = field( + default="k1", + metadata={ + "help": "Which estimator for KL-Divergence to use from Approximating KL Divergence " + "(http://joschu.net/blog/kl-approx.html). Defaults to 'k1', a straightforward, unbiased estimator. Can be " + "set to 'k3', an unbiased estimator with lower variance which 'appears to be a strictly better " + "estimator'. Cannot be set to 'k2', as it is used for logging purposes." + }, + ) + cliprange: float = field( + default=0.2, + metadata={"help": "Clip range."}, + ) + vf_coef: float = field( + default=0.1, + metadata={"help": "Value function coefficient."}, + ) + cliprange_value: float = field( + default=0.2, + metadata={"help": "Clip range for the value function."}, + ) + gamma: float = field( + default=1.0, + metadata={"help": "Discount factor."}, + ) + lam: float = field( + default=0.95, + metadata={"help": "Lambda value for GAE."}, + ) + ds3_gather_for_generation: bool = field( + default=True, + metadata={ + "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for " + "generation, improving generation speed. However, disabling this option allows training models that " + "exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation." + }, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/ppo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/ppo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..0d3e32f0a4639236d51ec63fd696ba83467742b0 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ppo/ppo_trainer.py @@ -0,0 +1,1037 @@ +# Copyright 2020-2026 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 gc +import math +import os +import textwrap +import time +from collections import defaultdict +from contextlib import contextmanager, nullcontext +from dataclasses import dataclass +from pathlib import Path + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +import transformers +from accelerate import Accelerator, logging +from accelerate.utils import gather_object +from datasets import Dataset +from packaging.version import Version +from torch.utils.data import DataLoader +from transformers import ( + BaseImageProcessor, + DataCollatorWithPadding, + FeatureExtractionMixin, + GenerationConfig, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, + TrainerControl, + TrainerState, +) +from transformers.integrations import get_reporting_integration_callbacks +from transformers.trainer import DEFAULT_CALLBACKS, DEFAULT_PROGRESS_CALLBACK +from transformers.trainer_callback import CallbackHandler, ExportableState, PrinterCallback +from transformers.utils import ModelOutput, is_peft_available, is_rich_available + +from ...models.utils import prepare_deepspeed, unwrap_model_for_generation +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import ( + disable_dropout_in_model, + log_table_to_comet_experiment, + pad, + selective_log_softmax, +) +from ..utils import ( + create_reference_model, + empty_cache, + first_true_indices, + get_reward, + peft_module_casting_to_bf16, +) +from .ppo_config import PPOConfig + + +if is_rich_available(): + from rich.console import Console + from rich.table import Table + + +logger = logging.get_logger(__name__) + +if is_peft_available(): + from peft import PeftConfig, PeftModel, get_peft_model + + +INVALID_LOGPROB = 1.0 + + +def generate( + lm_backbone: torch.nn.Module, queries: torch.Tensor, pad_token_id: int, generation_config: GenerationConfig +) -> tuple[torch.Tensor, torch.Tensor]: + """ + Generates sequences from the language model backbone in a way that does not affect padding tokens. + + Args: + lm_backbone (`torch.nn.Module`): + The language model backbone used for generation. + queries (`torch.Tensor`): + The tensor containing the input queries. + pad_token_id (`int`): + The token ID representing the pad token. + generation_config ([`~transformers.GenerationConfig`]): + The configuration for the generation process. + + Returns: + tuple: + - `generated_sequences` (`torch.Tensor`): + The concatenated tensor of input queries and generated sequences. + - `logits` (`torch.Tensor`): + The logits output from the generation process. + """ + context_length = queries.shape[1] + attention_mask = queries != pad_token_id + input_ids = torch.masked_fill(queries, ~attention_mask, 0) + output = lm_backbone.generate( + input_ids=input_ids, + attention_mask=attention_mask, + # position_ids=attention_mask.cumsum(1) - attention_mask.long(), # not needed: already adjusted in generations + # https://github.com/huggingface/transformers/blob/ac33aeeeee2a7a89b89c93c2962e6feb90daef0a/src/transformers/models/gpt2/modeling_gpt2.py#L1227-L1250 + generation_config=generation_config, + return_dict_in_generate=True, + output_scores=True, + ) + logits = torch.stack(output.scores, 1) + return torch.cat((queries, output.sequences[:, context_length:]), dim=1), logits + + +@torch.no_grad() +def batch_generation( + model: torch.nn.Module, + queries: torch.Tensor, + local_rollout_forward_batch_size: int, + pad_token_id: int, + generation_config: GenerationConfig, +): + query_responses = [] + logitss = [] + batch_size = queries.shape[0] + for i in range(0, batch_size, local_rollout_forward_batch_size): + query = queries[i : i + local_rollout_forward_batch_size] + query_response, logits = generate( + model, + query, + pad_token_id, + generation_config, + ) + query_responses.append(query_response) + logitss.append(logits) + + # padding tensors + padded_query_responses = pad(query_responses, padding_value=pad_token_id, padding_side="right") + padded_logitss = pad(logitss, padding_value=0, padding_side="right") + + # reshaping + padded_query_responses = padded_query_responses.view(-1, padded_query_responses.shape[-1])[:batch_size] + padded_logitss = padded_logitss.view(-1, *padded_logitss.shape[2:])[:batch_size] + + return padded_query_responses, padded_logitss + + +def exact_div(a, b, custom_error_message=""): + q = a // b + if a != q * b: + raise ValueError(f"{custom_error_message}, inexact division: {a} / {b} = {a / b}") + return q + + +def print_rich_table(df: pd.DataFrame) -> None: + if not is_rich_available(): + raise ImportError( + "The function `print_rich_table` requires the `rich` library. Please install it with `pip install rich`." + ) + console = Console() + table = Table(show_lines=True) + for column in df.columns: + table.add_column(column) + for _, row in df.iterrows(): + table.add_row(*row.astype(str).tolist()) + console.print(table) + + +def truncate_response(stop_token_id: int, pad_token_id: int, responses: torch.Tensor) -> torch.Tensor: + """ + Truncates the responses at the first occurrence of the stop token, filling the rest with pad tokens. + + Args: + stop_token_id (`int`): + The token ID representing the stop token where truncation occurs. + pad_token_id (`int`): + The token ID representing the pad token used to fill the truncated responses. + responses (`torch.Tensor`): + The tensor containing the responses to be truncated. + + Returns: + `torch.Tensor`: + The truncated responses tensor with pad tokens filled after the stop token. + """ + trunc_idxs = first_true_indices(responses == stop_token_id).unsqueeze(-1) + new_size = [1] * (len(responses.size()) - 1) + [responses.shape[1]] + idxs = torch.arange(responses.shape[1], device=responses.device).view(*new_size) + postprocessed_responses = torch.masked_fill(responses, idxs > trunc_idxs, pad_token_id) + return postprocessed_responses + + +def forward( + model: torch.nn.Module, + query_responses: torch.Tensor, + pad_token_id: int, +) -> ModelOutput: + """ + Performs a forward pass through the model with the given query responses and pad token ID. + + Args: + model (`torch.nn.Module`): + The model to perform the forward pass. + query_responses (`torch.Tensor`): + The tensor containing the query responses. + pad_token_id (`int`): + The token ID representing the pad token. + + Returns: + `ModelOutput`: + The output of the model, including hidden states. + """ + attention_mask = query_responses != pad_token_id + position_ids = attention_mask.cumsum(1) - attention_mask.long() + input_ids = torch.masked_fill(query_responses, ~attention_mask, 0) + return model( + input_ids=input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + return_dict=True, + output_hidden_states=True, + ) + + +@dataclass +class OnlineTrainerState(TrainerState): + """ + Training state for online/on-policy trainers. + + Extends [`~transformers.TrainerState`] with an `episode` counter to track the current rollout/episode. + + Args: + episode (`int`, defaults to 0): Zero-based episode index. + """ + + episode: int = 0 + + +def masked_mean(values: torch.Tensor, mask: torch.Tensor, axis: bool | None = None) -> torch.Tensor: + """Compute mean of tensor with a masked values.""" + if axis is not None: + return (values * mask).sum(axis=axis) / mask.sum(axis=axis) + else: + return (values * mask).sum() / mask.sum() + + +def masked_var(values: torch.Tensor, mask: torch.Tensor, unbiased: bool = True) -> torch.Tensor: + """Compute variance of tensor with masked values.""" + mean = masked_mean(values, mask) + centered_values = values - mean + variance = masked_mean(centered_values**2, mask) + if unbiased: + mask_sum = mask.sum() + if mask_sum == 0: + raise ValueError( + "The sum of the mask is zero, which can happen when `mini_batch_size=1`;" + "try increase the `mini_batch_size` or `gradient_accumulation_steps`" + ) + # note that if mask_sum == 1, then there is a division by zero issue + # to avoid it you just need to use a larger minibatch_size + bessel_correction = mask_sum / (mask_sum - 1) + variance = variance * bessel_correction + return variance + + +def masked_whiten(values: torch.Tensor, mask: torch.Tensor, shift_mean: bool = True) -> torch.Tensor: + """Whiten values with masked values.""" + mean, var = masked_mean(values, mask), masked_var(values, mask) + whitened = (values - mean) * torch.rsqrt(var + 1e-8) + if not shift_mean: + whitened += mean + return whitened + + +# taken from https://github.com/OpenLMLab/MOSS-RLHF/blob/40b91eb2f2b71b16919addede0341d2bef70825d/ppo/ppo_trainer.py#L29 +# we did this we can do a single `model = accelerator.prepare(model)` +class PolicyAndValueWrapper(nn.Module): + def __init__(self, policy, value_model) -> None: + super().__init__() + self.policy = policy + self.value_model = value_model + self.critic_backbone = getattr(value_model, value_model.base_model_prefix) + self.is_gradient_checkpointing = policy.is_gradient_checkpointing + + def gradient_checkpointing_enable(self, **kwargs): + self.policy.gradient_checkpointing_enable(**kwargs) + self.is_gradient_checkpointing = True + + def gradient_checkpointing_disable(self): + self.policy.gradient_checkpointing_disable() + self.is_gradient_checkpointing = False + + def forward(self, **kwargs): + output = self.critic_backbone(**kwargs) + logits = self.value_model.score(output.hidden_states[-1]) + return self.policy(**kwargs), logits + + +class PPOTrainer(_BaseTrainer): + """Trainer for Proximal Policy Optimization (PPO). + + For details on PPO, see the paper: [Proximal Policy Optimization + Algorithms](https://huggingface.co/papers/1707.06347). + + Args: + args ([`experimental.ppo.PPOConfig`]): + Training arguments. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`]): + Class to process the data. + model (`torch.nn.Module`): + Model to be trained. This is the policy model. + ref_model (`torch.nn.Module`, *optional*): + Reference model used to compute the KL divergence. If `None`, a copy of the policy model is created. + reward_model (`torch.nn.Module`): + Reward model used to compute the rewards. + train_dataset ([`~datasets.Dataset`]): + Dataset for training. + value_model (`torch.nn.Module`): + Value model used to predict the value of a state. + data_collator ([`~transformers.DataCollatorWithPadding`], *optional*): + Data collator to batch and pad samples from the dataset. If `None`, a default data collator is created + using the `processing_class`. + eval_dataset ([`~datasets.Dataset`] or `dict` of [`~datasets.Dataset`], *optional*): + Dataset for evaluation. + optimizers (`tuple` of `torch.optim.Optimizer` and `torch.optim.lr_scheduler.LambdaLR`, *optional*, defaults to `(None, None)`): + Tuple containing the optimizer and the learning rate scheduler to use for training. If `None`, the + optimizer and the learning rate scheduler are created using the + [`~transformers.Trainer.create_optimizer_and_scheduler`] method. + callbacks (`list` of [`~transformers.TrainerCallback`], *optional*): + Callbacks to use during training. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration to use PEFT for training. If `None`, PEFT is not used. If provided, the policy `model` + will be wrapped with the specified PEFT adapter. + """ + + _tag_names = ["trl", "ppo"] + _name = "PPO" + _paper = { + "title": "Fine-Tuning Language Models from Human Preferences", + "id": "1909.08593", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @article{mziegler2019fine-tuning, + title = {{Fine-Tuning Language Models from Human Preferences}}, + author = {Daniel M. Ziegler and Nisan Stiennon and Jeffrey Wu and Tom B. Brown and Alec Radford and Dario Amodei and Paul F. Christiano and Geoffrey Irving}, + year = 2019, + eprint = {arXiv:1909.08593} + }"""), + } + + def __init__( + self, + args: PPOConfig, + processing_class: PreTrainedTokenizerBase | BaseImageProcessor | FeatureExtractionMixin | ProcessorMixin, + model: nn.Module, + ref_model: nn.Module | None, + reward_model: nn.Module, + train_dataset: Dataset, + value_model: nn.Module, + data_collator: DataCollatorWithPadding | None = None, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + # less commonly used + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + callbacks: list[TrainerCallback] | None = None, + peft_config: "PeftConfig | None" = None, + ) -> None: + if train_dataset is None: + raise ValueError("`train_dataset` is required") + + if ref_model is model: + raise ValueError( + "`model` and `ref_model` cannot be the same object. If you want `ref_model` to be the " + "same as `model`, you must make a copy of it, or `None` if you use peft." + ) + + self.args = args + self.processing_class = processing_class + self.policy_model = model + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + # Define the collator if not provided + if data_collator is None: + data_collator = DataCollatorWithPadding(self.processing_class) + + # Handle stop token settings: update policy model's generation_config to use provided stop token + if args.stop_token and args.stop_token_id: + raise ValueError("You cannot set both `stop_token` and `stop_token_id`.") + elif args.stop_token: + if args.stop_token == "eos": + self.policy_model.generation_config.eos_token_id = self.stop_token_id = processing_class.eos_token_id + else: + raise ValueError( + f"Unknown `stop_token` {args.stop_token}. Allowed values are: `'eos'` and `None` (no stop token)." + ) + else: + self.policy_model.generation_config.eos_token_id = self.stop_token_id = args.stop_token_id # None or int + + # Check that the kl estimator is valid + if self.args.kl_estimator not in {"k1", "k3"}: + raise ValueError( + "kl_estimator must be either 'k1' (straightforward, unbiased) or 'k3' (lower variance, unbiased, " + "appears to be a strictly better estimator). See " + "[Approximating KL Divergence](http://joschu.net/blog/kl-approx.html) for details." + ) + + # PEFT + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if isinstance(self.policy_model, PeftModel): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first " + "merge and unload the existing adapter, save the resulting base model, and then pass that base " + "model along with the new `peft_config` to the trainer." + ) + + # get peft model with the given config + self.policy_model = get_peft_model(self.policy_model, peft_config) + if args.bf16 and getattr(self.policy_model, "is_loaded_in_4bit", False): + peft_module_casting_to_bf16(self.policy_model) + + self.is_peft_model = is_peft_available() and isinstance(self.policy_model, PeftModel) + self.model_adapter_name = args.model_adapter_name + self.ref_adapter_name = args.ref_adapter_name + + if ref_model: + self.ref_model = ref_model + elif self.is_peft_model: + self.ref_model = None + else: + self.ref_model = create_reference_model(self.policy_model) + + self.reward_model = reward_model + self.train_dataset = train_dataset + self.train_dataset_len = len(train_dataset) + self.value_model = value_model + self.data_collator = data_collator + self.eval_dataset = eval_dataset + self.optimizer, self.lr_scheduler = optimizers + self.optimizer_cls_and_kwargs = None # needed for transformers >= 4.47 + + ######### + # calculate various batch sizes + ######### + if args.total_episodes is None: # allow the users to define episodes in terms of epochs. + args.total_episodes = int(args.num_train_epochs * self.train_dataset_len) + accelerator = Accelerator(gradient_accumulation_steps=args.gradient_accumulation_steps) + self.accelerator = accelerator + args.world_size = accelerator.num_processes + args.local_batch_size = args.per_device_train_batch_size * args.gradient_accumulation_steps + args.micro_batch_size = int(args.per_device_train_batch_size * args.world_size) + args.batch_size = int(args.local_batch_size * args.world_size) + args.mini_batch_size = exact_div( + args.batch_size, args.num_mini_batches, "`batch_size` must be a multiple of `num_mini_batches`" + ) + args.local_mini_batch_size = exact_div( + args.local_batch_size, args.num_mini_batches, "`local_batch_size` must be a multiple of `num_mini_batches`" + ) + if args.whiten_rewards: + assert args.local_mini_batch_size >= 8, ( + f"Per-rank minibatch size {args.local_mini_batch_size} is insufficient for whitening" + ) + # `per_rank_rollout_batch_size` is our `args.local_batch_size` + # `per_rank_minibatch_size` is our `args.local_mini_batch_size` + args.num_total_batches = math.ceil( + args.total_episodes / args.batch_size + ) # we may train for more than `total_episodes` + self.local_seed = args.seed + accelerator.process_index * 100003 # Prime + if args.num_sample_generations > 0: + self.sample_generations_freq = max(1, args.num_total_batches // args.num_sample_generations) + self.local_dataloader_batch_size = args.local_batch_size + + ######### + # setup model, optimizer, and others + ######### + for module in [self.policy_model, self.ref_model, self.value_model, self.reward_model]: + if module is not None: + disable_dropout_in_model(module) + self.model = PolicyAndValueWrapper(self.policy_model, self.value_model) + self.model.config = self.policy_model.config # needed for pushing to hub + self.create_optimizer_and_scheduler( + num_training_steps=args.num_total_batches + ) # note that we are calling `self.lr_scheduler.step()` manually only at the batch level + + ######### + # trainer specifics + ######### + default_callbacks = DEFAULT_CALLBACKS + get_reporting_integration_callbacks(self.args.report_to) + self.callbacks = default_callbacks if callbacks is None else default_callbacks + callbacks + self.callback_handler = CallbackHandler( + self.callbacks, self.model, self.processing_class, self.optimizer, self.lr_scheduler + ) + self.add_callback(PrinterCallback if self.args.disable_tqdm else DEFAULT_PROGRESS_CALLBACK) + self.control = TrainerControl() + self.state = OnlineTrainerState( + is_local_process_zero=self.is_local_process_zero(), + is_world_process_zero=self.is_world_process_zero(), + stateful_callbacks=[ + cb for cb in self.callback_handler.callbacks + [self.control] if isinstance(cb, ExportableState) + ], + ) + self.current_flos = 0 + self.hp_search_backend = None + self.is_deepspeed_enabled = getattr(self.accelerator.state, "deepspeed_plugin", None) is not None + self.is_fsdp_enabled = getattr(self.accelerator.state, "fsdp_plugin", None) is not None + # Create distant repo and output directory if needed + self.hub_model_id = None + if self.args.push_to_hub: + self.init_hf_repo() + if self.args.should_save: + os.makedirs(self.args.output_dir, exist_ok=True) + + # Add tags for models that have been loaded with the correct transformers version + if hasattr(self.model, "add_model_tags"): + self.model.add_model_tags(self._tag_names) + + ######### + # setup dataloader + ######### + self.dataloader = DataLoader( + self.train_dataset, + batch_size=self.local_dataloader_batch_size, + shuffle=True, + collate_fn=self.data_collator, + drop_last=True, # needed; otherwise the last batch will be of ragged shape + ) + # sync random states for DataLoader(shuffle=True) before `accelerator.prepare` + # see https://gist.github.com/vwxyzjn/2581bff1e48e185e0b85b6dfe1def79c + torch.manual_seed(args.seed) + self.model, self.optimizer, self.dataloader = accelerator.prepare(self.model, self.optimizer, self.dataloader) + torch.manual_seed(self.local_seed) # reset the local seed again + + self.eval_dataloader = DataLoader( + self.eval_dataset, + batch_size=args.per_device_eval_batch_size, + collate_fn=self.data_collator, + drop_last=True, + ) # no need to shuffle eval dataset + self.eval_dataloader = accelerator.prepare(self.eval_dataloader) + + if self.is_deepspeed_enabled: + self.reward_model = prepare_deepspeed(self.reward_model, accelerator) + + if self.ref_model is None: + if not self.is_peft_model: + raise ValueError("No reference model and model is not a Peft model.") + else: + self.ref_model = prepare_deepspeed(self.ref_model, accelerator) + else: + if self.ref_model is None: + if not self.is_peft_model: + raise ValueError("No reference model and model is not a Peft model.") + else: + self.ref_model = self.ref_model.to(self.accelerator.device) + self.reward_model = self.reward_model.to(self.accelerator.device) + + def get_train_dataloader(self) -> DataLoader: + return self.dataloader + + def get_eval_dataloader(self) -> DataLoader: + return self.eval_dataloader + + @contextmanager + def null_ref_context(self): + """Context manager for handling null reference model (that is, peft adapter manipulation).""" + with ( + self.accelerator.unwrap_model(self.model.policy).disable_adapter() + if self.is_peft_model and not self.ref_adapter_name + else nullcontext() + ): + if self.ref_adapter_name: + self.model.policy.set_adapter(self.ref_adapter_name) + yield + if self.ref_adapter_name: + self.model.policy.set_adapter(self.model_adapter_name or "default") + + def save_model(self, output_dir: str | None = None, _internal_call: bool = False): + backup_model = self.model + if hasattr(self.model, "policy"): + self.model = self.model.policy # save only the policy for inference + if self.is_deepspeed_enabled: + backup_deepspeed = self.deepspeed + self.deepspeed = self.model + + super().save_model(output_dir, _internal_call) + + self.model = backup_model + if self.is_deepspeed_enabled: + self.deepspeed = backup_deepspeed + + def train(self): + args = self.args + accelerator = self.accelerator + optimizer = self.optimizer + model = self.model + ref_policy = self.ref_model + reward_model = self.reward_model + processing_class = self.processing_class + dataloader = self.dataloader + device = accelerator.device + + def repeat_generator(): + while True: + yield from dataloader + + iter_dataloader = iter(repeat_generator()) + generation_kwargs = { + "max_new_tokens": args.response_length, + "temperature": (args.temperature + 1e-7), + "top_k": 0.0, + "top_p": 1.0, + "do_sample": True, + } + generation_config = GenerationConfig(**generation_kwargs) + + accelerator.print("===training policy===") + start_time = time.time() + stats_shape = (args.num_ppo_epochs, args.num_mini_batches, args.gradient_accumulation_steps) + approxkl_stats = torch.zeros(stats_shape, device=device) + pg_clipfrac_stats = torch.zeros(stats_shape, device=device) + pg_loss_stats = torch.zeros(stats_shape, device=device) + vf_loss_stats = torch.zeros(stats_shape, device=device) + vf_clipfrac_stats = torch.zeros(stats_shape, device=device) + entropy_stats = torch.zeros(stats_shape, device=device) + ratio_stats = torch.zeros(stats_shape, device=device) + model.train() + + # trainer state initialization + self.state.global_step = 0 + self.state.episode = 0 + self.state.max_steps = args.num_total_batches + self.state.num_train_epochs = args.total_episodes / self.train_dataset_len + # Compute absolute values for logging, eval, and save if given as ratio + if args.logging_steps is not None: + if args.logging_steps < 1: + self.state.logging_steps = math.ceil(self.state.max_steps * args.logging_steps) + else: + self.state.logging_steps = args.logging_steps + if args.eval_steps is not None: + if args.eval_steps < 1: + self.state.eval_steps = math.ceil(self.state.max_steps * args.eval_steps) + else: + self.state.eval_steps = args.eval_steps + if args.save_steps is not None: + if args.save_steps < 1: + self.state.save_steps = math.ceil(self.state.max_steps * args.save_steps) + else: + self.state.save_steps = args.save_steps + self.control = self.callback_handler.on_train_begin(args, self.state, self.control) + + # backward compatibility + if self.is_deepspeed_enabled: + self.deepspeed = self.model + self.model_wrapped = self.model + + for update in range(1, args.num_total_batches + 1): + self.state.episode += 1 * args.batch_size + data = next(iter_dataloader) + with torch.no_grad(): + queries = data["input_ids"].to(device) + context_length = queries.shape[1] + responses = [] + postprocessed_responses = [] + logprobs = [] + ref_logprobs = [] + scores = [] + sequence_lengths = [] + values = [] + with ( + unwrap_model_for_generation( + self.model, + self.accelerator, + gather_deepspeed3_params=self.args.ds3_gather_for_generation, + generation_kwargs=generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762 + ) as unwrapped_model + ): + query_responses, logitss = batch_generation( + unwrapped_model.policy, + queries, + args.local_rollout_forward_batch_size, + processing_class.pad_token_id, + generation_config, + ) + + for i in range(0, queries.shape[0], args.local_rollout_forward_batch_size): + query = queries[i : i + args.local_rollout_forward_batch_size] + query_response = query_responses[i : i + args.local_rollout_forward_batch_size] + response = query_response[:, context_length:] + logits = logitss[i : i + args.local_rollout_forward_batch_size] + logprob = selective_log_softmax(logits, response) + del logits + empty_cache() + + if ref_policy is None: + with self.null_ref_context(): + ref_output = forward(model.policy, query_response, processing_class.pad_token_id) + else: + ref_output = forward(ref_policy, query_response, processing_class.pad_token_id) + ref_logits = ref_output.logits[:, context_length - 1 : -1] + ref_logits /= args.temperature + 1e-7 + ref_logprob = selective_log_softmax(ref_logits, response) + del ref_output, ref_logits + empty_cache() + + # Response Processing 1. truncate response after the first occurrence of `stop_token_id` + postprocessed_response = response + if self.stop_token_id is not None: # handle the edge case when stop_token_id exists but is 0 + postprocessed_response = truncate_response( + self.stop_token_id, processing_class.pad_token_id, response + ) + + # Response Processing 2. run reward model on the truncated responses + postprocessed_query_response = torch.cat((query, postprocessed_response), 1) + sequence_length = first_true_indices(postprocessed_response == processing_class.pad_token_id) - 1 + unwrapped_value_model = accelerator.unwrap_model(model).value_model + full_value, _, _ = get_reward( + unwrapped_value_model, query_response, processing_class.pad_token_id, context_length + ) + value = full_value[:, context_length - 1 : -1].squeeze(-1) + _, score, _ = get_reward( + reward_model, postprocessed_query_response, processing_class.pad_token_id, context_length + ) + + responses.append(response) + postprocessed_responses.append(postprocessed_response) + logprobs.append(logprob) + ref_logprobs.append(ref_logprob) + sequence_lengths.append(sequence_length) + scores.append(score) + values.append(value) + responses = torch.cat(responses, 0) + postprocessed_responses = torch.cat(postprocessed_responses, 0) + logprobs = torch.cat(logprobs, 0) + ref_logprobs = torch.cat(ref_logprobs, 0) + sequence_lengths = torch.cat(sequence_lengths, 0) + scores = torch.cat(scores, 0) + values = torch.cat(values, 0) + del (logprob, ref_logprob, full_value, value, score, unwrapped_model) + empty_cache() + gc.collect() + + # Response Processing 3. Filter completion. Ensure that the sample contains stop_token_id + # Completions not passing that filter will receive a lower score. + contain_eos_token = torch.any(postprocessed_responses == self.processing_class.eos_token_id, dim=-1) + if self.args.missing_eos_penalty is not None: + scores[~contain_eos_token] -= self.args.missing_eos_penalty + # accelerator.print(f"{scores=}, {(contain_eos_token.sum() / len(contain_eos_token))=}") + + # be very careful with `padding_mask_p1`; see https://excalidraw.com/#json=LWnzG4w2k5DjF_EOL_xPt,e2w3a-hFJ_gX5vOfeyXGTw + response_idxs = torch.arange(responses.shape[1], device=responses.device).repeat(responses.shape[0], 1) + padding_mask = response_idxs > sequence_lengths.unsqueeze(1) + logprobs = torch.masked_fill(logprobs, padding_mask, INVALID_LOGPROB) + ref_logprobs = torch.masked_fill(ref_logprobs, padding_mask, INVALID_LOGPROB) + sequence_lengths_p1 = sequence_lengths + 1 + padding_mask_p1 = response_idxs > (sequence_lengths_p1.unsqueeze(1)) + values = torch.masked_fill(values, padding_mask_p1, 0) + + # 4. compute rewards + # Formula used by http://joschu.net/blog/kl-approx.html for the k1 and k3 estimators + logr = ref_logprobs - logprobs + kl = -logr if args.kl_estimator == "k1" else (logr.exp() - 1) - logr # Else statement is k3 + non_score_reward = -args.kl_coef * kl + rewards = non_score_reward.clone() + actual_start = torch.arange(rewards.size(0), device=rewards.device) + actual_end = torch.where(sequence_lengths_p1 < rewards.size(1), sequence_lengths_p1, sequence_lengths) + rewards[actual_start, actual_end] += scores + + # 5. whiten rewards + if args.whiten_rewards: + rewards = masked_whiten(rewards, mask=~padding_mask_p1, shift_mean=False) + rewards = torch.masked_fill(rewards, padding_mask_p1, 0) + + # 6. compute advantages and returns + lastgaelam = 0 + advantages_reversed = [] + gen_length = responses.shape[1] + for t in reversed(range(gen_length)): + nextvalues = values[:, t + 1] if t < gen_length - 1 else 0.0 + delta = rewards[:, t] + args.gamma * nextvalues - values[:, t] + lastgaelam = delta + args.gamma * args.lam * lastgaelam + advantages_reversed.append(lastgaelam) + advantages = torch.stack(advantages_reversed[::-1], axis=1) + returns = advantages + values + advantages = masked_whiten(advantages, ~padding_mask) + advantages = torch.masked_fill(advantages, padding_mask, 0) + empty_cache() + + # Do multiple epochs of PPO training, with a fresh random shuffle in each epoch + for ppo_epoch_idx in range(args.num_ppo_epochs): + b_inds = np.random.permutation(args.local_batch_size) + minibatch_idx = 0 + for mini_batch_start in range(0, args.local_batch_size, args.local_mini_batch_size): + mini_batch_end = mini_batch_start + args.local_mini_batch_size + mini_batch_inds = b_inds[mini_batch_start:mini_batch_end] + gradient_accumulation_idx = 0 + for micro_batch_start in range(0, args.local_mini_batch_size, args.per_device_train_batch_size): + with accelerator.accumulate(model): + micro_batch_end = micro_batch_start + args.per_device_train_batch_size + micro_batch_inds = mini_batch_inds[micro_batch_start:micro_batch_end] + mb_advantage = advantages[micro_batch_inds] + mb_responses = responses[micro_batch_inds] + mb_query_responses = query_responses[micro_batch_inds] + mb_logprobs = logprobs[micro_batch_inds] + mb_return = returns[micro_batch_inds] + mb_values = values[micro_batch_inds] + + output, vpred_temp = forward(model, mb_query_responses, processing_class.pad_token_id) + logits = output.logits[:, context_length - 1 : -1] + logits /= args.temperature + 1e-7 + new_logprobs = selective_log_softmax(logits, mb_responses) + new_logprobs = torch.masked_fill( + new_logprobs, padding_mask[micro_batch_inds], INVALID_LOGPROB + ) + vpred = vpred_temp[:, context_length - 1 : -1].squeeze(-1) + vpred = torch.masked_fill(vpred, padding_mask_p1[micro_batch_inds], 0) + vpredclipped = torch.clamp( + vpred, + mb_values - args.cliprange_value, + mb_values + args.cliprange_value, + ) + vf_losses1 = torch.square(vpred - mb_return) + vf_losses2 = torch.square(vpredclipped - mb_return) + vf_loss_max = torch.max(vf_losses1, vf_losses2) + vf_loss = 0.5 * masked_mean(vf_loss_max, ~padding_mask_p1[micro_batch_inds]) + vf_clipfrac = masked_mean( + (vf_losses2 > vf_losses1).float(), ~padding_mask_p1[micro_batch_inds] + ) + logprobs_diff = new_logprobs - mb_logprobs + ratio = torch.exp(logprobs_diff) + pg_losses = -mb_advantage * ratio + pg_losses2 = -mb_advantage * torch.clamp(ratio, 1.0 - args.cliprange, 1.0 + args.cliprange) + pg_loss_max = torch.max(pg_losses, pg_losses2) + pg_loss = masked_mean(pg_loss_max, ~padding_mask[micro_batch_inds]) + loss = pg_loss + args.vf_coef * vf_loss + accelerator.backward(loss) + optimizer.step() + optimizer.zero_grad() + with torch.no_grad(): + pg_clipfrac = masked_mean( + (pg_losses2 > pg_losses).float(), ~padding_mask[micro_batch_inds] + ) + prob_dist = torch.nn.functional.softmax(logits, dim=-1) + entropy = torch.logsumexp(logits, dim=-1) - torch.sum(prob_dist * logits, dim=-1) + approxkl = 0.5 * (logprobs_diff**2).mean() + approxkl_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = approxkl + pg_clipfrac_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = ( + pg_clipfrac + ) + pg_loss_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = pg_loss + vf_loss_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = vf_loss + vf_clipfrac_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = ( + vf_clipfrac + ) + entropy_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = entropy.mean() + ratio_stats[ppo_epoch_idx, minibatch_idx, gradient_accumulation_idx] = ratio.mean() + gradient_accumulation_idx += 1 + minibatch_idx += 1 + # del everything and empty cache + # fmt: off + del ( + output, vpred_temp, logits, new_logprobs, vpred, vpredclipped, + vf_losses1, vf_losses2, vf_loss, vf_clipfrac, logprobs_diff, ratio, pg_losses, pg_losses2, pg_loss_max, + pg_loss, loss, pg_clipfrac, prob_dist, entropy, approxkl, mb_return, + mb_advantage, mb_values, mb_responses, mb_query_responses, mb_logprobs, + ) + # fmt: on + empty_cache() + with torch.no_grad(): + mean_kl = kl.sum(1).mean() + mean_entropy = (-logprobs).sum(1).mean() + mean_non_score_reward = non_score_reward.sum(1).mean() + rlhf_reward = mean_non_score_reward + scores.mean() + eps = int(self.state.episode / (time.time() - start_time)) + metrics = {} + metrics["eps"] = eps + metrics["objective/kl"] = self.accelerator.gather_for_metrics(mean_kl).mean().item() + metrics["objective/entropy"] = self.accelerator.gather_for_metrics(mean_entropy).mean().item() + metrics["objective/non_score_reward"] = ( + self.accelerator.gather_for_metrics(mean_non_score_reward).mean().item() + ) + metrics["objective/rlhf_reward"] = self.accelerator.gather_for_metrics(rlhf_reward).mean().item() + metrics["objective/scores"] = self.accelerator.gather_for_metrics(scores.mean()).mean().item() + metrics["policy/approxkl_avg"] = self.accelerator.gather_for_metrics(approxkl_stats).mean().item() + metrics["policy/clipfrac_avg"] = self.accelerator.gather_for_metrics(pg_clipfrac_stats).mean().item() + metrics["loss/policy_avg"] = self.accelerator.gather_for_metrics(pg_loss_stats).mean().item() + metrics["loss/value_avg"] = self.accelerator.gather_for_metrics(vf_loss_stats).mean().item() + metrics["val/clipfrac_avg"] = self.accelerator.gather_for_metrics(vf_clipfrac_stats).mean().item() + metrics["policy/entropy_avg"] = self.accelerator.gather_for_metrics(entropy_stats).mean().item() + metrics["val/ratio"] = self.accelerator.gather_for_metrics(ratio_stats).mean().item() + metrics["val/ratio_var"] = self.accelerator.gather_for_metrics(ratio_stats).var().item() + metrics["val/num_eos_tokens"] = (responses == processing_class.eos_token_id).sum().item() + metrics["lr"] = self.lr_scheduler.get_last_lr()[0] + metrics["episode"] = self.state.episode + self.state.epoch = self.state.episode / self.train_dataset_len # used by self.log + self.state.global_step += 1 + self.log(metrics) + + self.lr_scheduler.step() + self.control = self.callback_handler.on_step_end(args, self.state, self.control) + if self.control.should_save: + self._save_checkpoint(model, trial=None) + self.control = self.callback_handler.on_save(self.args, self.state, self.control) + del kl, mean_kl, mean_entropy, mean_non_score_reward, scores, metrics, non_score_reward + empty_cache() + gc.collect() + + if args.num_sample_generations > 0 and (update - 1) % self.sample_generations_freq == 0: + self.generate_completions(sampling=True) + empty_cache() + del ( + query_responses, + responses, + postprocessed_responses, + logprobs, + ref_logprobs, + values, + sequence_lengths, + contain_eos_token, + sequence_lengths_p1, + response_idxs, + padding_mask, + padding_mask_p1, + rewards, + actual_start, + actual_end, + advantages, + returns, + ) + empty_cache() + + # HF trainer specifics + self.control = self.callback_handler.on_train_end(args, self.state, self.control) + if self.control.should_save: + self._save_checkpoint(model, trial=None) + self.control = self.callback_handler.on_save(self.args, self.state, self.control) + + def generate_completions(self, sampling: bool = False): + if self.eval_dataset is None: + return # no eval set to sample from (pass eval_dataset and eval_strategy != "no" for sample generations) + args = self.args + processing_class = self.processing_class + generation_kwargs = { + "max_new_tokens": args.response_length, + "temperature": (0.01 + 1e-7), + "top_k": 0.0, + "top_p": 1.0, + "do_sample": True, + } + generation_config = GenerationConfig(**generation_kwargs) + + table = defaultdict(list) + with ( + unwrap_model_for_generation( + self.model, + self.accelerator, + gather_deepspeed3_params=self.args.ds3_gather_for_generation, + generation_kwargs=generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762 + ) as unwrapped_model + ): + for batch in self.eval_dataloader: + query = batch["input_ids"] + with torch.no_grad(): + context_length = query.shape[1] + query_response, _ = batch_generation( + unwrapped_model.policy, + query, + query.shape[0], + processing_class.pad_token_id, + generation_config, + ) + response = query_response[:, context_length:] + postprocessed_response = response + if self.stop_token_id is not None: # handle the edge case when stop_token_id exists but is 0 + postprocessed_response = truncate_response( + self.stop_token_id, processing_class.pad_token_id, response + ) + table["query"].extend( + gather_object(processing_class.batch_decode(query, skip_special_tokens=True)) + ) + table["model response"].extend( + gather_object(processing_class.batch_decode(postprocessed_response)) + ) + + postprocessed_query_response = torch.cat((query, postprocessed_response), 1) + _, score, _ = get_reward( + self.reward_model, postprocessed_query_response, processing_class.pad_token_id, context_length + ) + table["score"].extend(self.accelerator.gather_for_metrics(score).float().cpu().numpy()) + + if sampling: + break + df = pd.DataFrame(table) + + if self.accelerator.is_main_process: + if is_rich_available(): + print_rich_table(df.iloc[0 : 0 + 5]) + if "wandb" in args.report_to: + import wandb + + if wandb.run is not None: + wandb.log({"completions": wandb.Table(dataframe=df)}) + + if "comet_ml" in args.report_to: + log_table_to_comet_experiment( + name="completions.csv", + table=df, + ) + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/prm/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/prm/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..210c474aa459261c71906d4e1b11994a08dddd4c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/prm/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .prm_config import PRMConfig +from .prm_trainer import PRMTrainer + + +__all__ = ["PRMConfig", "PRMTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/prm/prm_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/prm/prm_config.py new file mode 100644 index 0000000000000000000000000000000000000000..b6150c01b2e4739e027ee3072080c5f057478841 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/prm/prm_config.py @@ -0,0 +1,88 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class PRMConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`experimental.prm.PRMTrainer`]. + + This class includes only the parameters that are specific to PRM training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + 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: + max_length (`int` or `None`, *optional*, defaults to `1024`): + Maximum length of the sequences (prompt + completion) used for truncation. + max_completion_length (`int`, *optional*): + Maximum length of the completion used for truncation. The completion is the concatenation of the steps. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model. + step_separator (`str`, *optional*, defaults to `"\n"`): + Separator used to separate each step of the reasoning process. + train_on_last_step_only (`bool`, *optional*, defaults to `False`): + Whether to train only on the last step. + dataset_num_proc (`int`, *optional*): + Number of processes to use for processing the dataset. + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `1e-5` instead of `5e-5`. + """ + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=1e-5, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + max_length: int | None = field( + default=1024, + metadata={"help": "Maximum length of the sequences (prompt + completion) used for truncation."}, + ) + max_completion_length: int | None = field( + default=None, + metadata={ + "help": "Maximum length of the completion used for truncation. The completion is the concatenation of the " + "steps." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the model and reference model."}, + ) + step_separator: str = field( + default="\n", + metadata={"help": "Separator used to separate each step of the reasoning process."}, + ) + train_on_last_step_only: bool = field( + default=False, + metadata={"help": "Whether to train only on the last step."}, + ) + dataset_num_proc: int | None = field( + default=None, + metadata={"help": "Number of processes to use for processing the dataset."}, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/prm/prm_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/prm/prm_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..78341a3b832b404791ccf1429129cf2dbbd1abfe --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/prm/prm_trainer.py @@ -0,0 +1,370 @@ +# Copyright 2020-2026 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 textwrap +from collections.abc import Callable +from itertools import chain +from pathlib import Path + +import numpy as np +import torch +import torch.nn as nn +import transformers +from accelerate import PartialState, logging +from accelerate.utils import is_peft_model +from datasets import Dataset, features +from packaging.version import Version +from transformers import ( + BaseImageProcessor, + DataCollator, + DataCollatorForTokenClassification, + FeatureExtractionMixin, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, +) +from transformers.trainer_utils import EvalPrediction +from transformers.utils import is_peft_available + +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import disable_dropout_in_model +from ..utils import prepare_peft_model +from .prm_config import PRMConfig + + +if is_peft_available(): + from peft import PeftConfig + +logger = logging.get_logger(__name__) + + +def compute_accuracy(eval_pred: EvalPrediction) -> dict[str, float]: + predictions, labels = eval_pred + if predictions.ndim == 3: + # Token classification task. Shapes are (batch_size, seq_len, num_labels) and (batch_size, seq_len) + # Used to compute the accuracy in the prm_trainer. + predictions = np.argmax(predictions, axis=2) + + # Flatten the predictions and labels to remove the ignored tokens. + predictions = np.array( + [ + p + for prediction, label in zip(predictions, labels, strict=True) + for (p, lbl) in zip(prediction, label, strict=True) + if lbl != -100 + ] + ) + labels = np.array([lbl for label in labels for lbl in label if lbl != -100]) + + else: + # Here, predictions is rewards_chosen and rewards_rejected. Shapes are (batch_size, 2) and (batch_size,) + # We want to see how much of the time rewards_chosen > rewards_rejected. + equal_mask = predictions[:, 0] == predictions[:, 1] + equal_predictions_count = int(equal_mask.sum()) + + if equal_predictions_count > 0: + # Before using the logger, the accelerate state must be initialized. It'susually the case when using this + # function inside a Trainer, but it may not be the case otherwise, in particular when unit testing. + PartialState() + + logger.warning( + f"There are {equal_predictions_count} out of {len(predictions[:, 0])} instances where the predictions " + "for both options are equal. These instances are ignored in the accuracy computation.", + ) + + # Filter out equal predictions + predictions = predictions[~equal_mask] + labels = labels[~equal_mask] + + # Use the remaining predictions for accuracy calculation + predictions = np.argmax(predictions, axis=1) + + accuracy = np.array(predictions == labels, dtype=float).mean().item() + return {"accuracy": accuracy} + + +class PRMTrainer(_BaseTrainer): + """ + Initialize PRMTrainer. + + Args: + model ([`~transformers.PreTrainedModel`]): + The model to train, preferably an `AutoModelForTokenClassification`. + args ([`experimental.prm.PRMConfig`]): + The arguments to use for training. + data_collator ([`~transformers.DataCollator`]): + The data collator to use for training. If None is specified, the default data collator + ([`~transformers.DataCollatorForTokenClassification`]) will be used which will pad the sequences to the + maximum length of the sequences in the batch, given a dataset of paired sequences. + train_dataset ([`~datasets.Dataset`]): + The dataset to use for training. + eval_dataset ([`~datasets.Dataset`]): + The dataset to use for evaluation. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. If provided, will be used to automatically process the inputs + for the model, and it will be saved along the model to make it easier to rerun an interrupted training or + reuse the fine-tuned model. + model_init (`Callable[[], transformers.PreTrainedModel]`): + The model initializer to use for training. If None is specified, the default model initializer will be + used. + compute_metrics (`Callable[[transformers.EvalPrediction], dict]`, *optional* defaults to `compute_accuracy`): + The metrics to use for evaluation. If no metrics are specified, the default metric (`compute_accuracy`) + will be used. + callbacks (`list[transformers.TrainerCallback]`): + The callbacks to use for training. + optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): + The optimizer and scheduler to use for training. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`): + The function to use to preprocess the logits before computing the metrics. + peft_config ([`~peft.PeftConfig`], *optional*): + The PEFT configuration to use for training. If you pass a PEFT configuration, the model will be wrapped in + a PEFT model. + """ + + _tag_names = ["trl", "prm"] + _name = "PRM" + _paper = { + "title": "Solving math word problems with process-and outcome-based feedback", + "id": "2211.14275", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @article{uesato2022solving, + title = {{Solving Math Word Problems With Process- and Outcome-Based Feedback}}, + author = {Uesato, Jonathan and Kushman, Nate and Kumar, Ramana and Song, Francis and Siegel, Noah and Wang, Lisa and Creswell, Antonia and Irving, Geoffrey and Higgins, Irina}, + year = 2022, + journal = {arXiv preprint arXiv:2211.14275} + }"""), + } + + def __init__( + self, + model: PreTrainedModel | nn.Module | None = None, + args: PRMConfig | None = None, + data_collator: DataCollator | None = None, + train_dataset: Dataset | None = None, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + processing_class: PreTrainedTokenizerBase + | BaseImageProcessor + | FeatureExtractionMixin + | ProcessorMixin + | None = None, + model_init: Callable[[], PreTrainedModel] | None = None, + compute_metrics: Callable[[EvalPrediction], dict] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = ( + None, + None, + ), + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + peft_config: "PeftConfig | None" = None, + ): + if train_dataset is None: + raise ValueError("`train_dataset` is required") + + # PEFT + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if peft_config is not None or is_peft_model(model): + model = prepare_peft_model(model, peft_config, args) + + # Disable dropout in the model + if args.disable_dropout: + disable_dropout_in_model(model) + + if compute_metrics is None: + compute_metrics = compute_accuracy + + if data_collator is None: + if processing_class is None: + raise ValueError( + "A processing_class must be specified when using the default DataCollatorForTokenClassification" + ) + data_collator = DataCollatorForTokenClassification(processing_class) + + if "input_ids" not in train_dataset.column_names: + with PartialState().main_process_first(): + fn_kwargs = { + "tokenizer": processing_class, + "step_separator": args.step_separator, + "max_length": args.max_length, + "max_completion_length": args.max_completion_length, + "train_on_last_step_only": args.train_on_last_step_only, + } + train_fn_kwargs = {**fn_kwargs, "is_eval": False} + train_dataset = train_dataset.map( + self.tokenize_row, + fn_kwargs=train_fn_kwargs, + num_proc=args.dataset_num_proc, + remove_columns=train_dataset.features, + desc="Tokenizing train dataset", + features=features.Features( # needed to avoid map to cast labels to bool + { + "labels": features.Sequence(features.Value("int64")), + "input_ids": features.Sequence(features.Value("int64")), + } + ), + ) + + eval_fn_kwargs = {**fn_kwargs, "is_eval": True} + if eval_dataset is not None: + eval_dataset = eval_dataset.map( + self.tokenize_row, + fn_kwargs=eval_fn_kwargs, + num_proc=args.dataset_num_proc, + remove_columns=eval_dataset.features, + desc="Tokenizing eval dataset", + features=features.Features( # needed to avoid map to cast labels to bool + { + "labels": features.Sequence(features.Value("int64")), + "input_ids": features.Sequence(features.Value("int64")), + } + ), + ) + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + model_init=model_init, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + # Add tags for models that have been loaded with the correct transformers version + if hasattr(self.model, "add_model_tags"): + self.model.add_model_tags(self._tag_names) + + @staticmethod + def tokenize_row( + features, + tokenizer, + step_separator, + max_length, + max_completion_length, + train_on_last_step_only, + is_eval, + ): + r""" + Tokenize a row of the dataset. + + Args: + features (`dict[str, str]`): + Row of the dataset, should contain the keys `"prompt"`, `"completions"`, and `"labels"`. + tokenizer ([`~transformers.PreTrainedTokenizerBase`]): + Tokenizer used to process the data. + step_separator (`str`): + Separator between steps in the completion. + max_length (`int` or `None`): + Maximum length of the sequences (prompt + completion). If `None`, the sequences are not truncated. + max_completion_length (`int` or `None`): + Maximum length of the completion sequences. If `None`, the completion sequences are not truncated. + train_on_last_step_only (`bool`): + Whether to train only on the last step. If `True`, the labels are `-100` for all tokens except the last + token of the completion. + is_eval (`bool`): + Whether the function is used to tokenize samples from a training or an evaluation dataset. Used only if + `train_on_last_step_only` is set to `True`. + + Returns: + `dict[str, list[int]]`: + Tokenized sequences with the keys `"input_ids"`, and `"labels". + + Example: + ```python + >>> from transformers import AutoTokenizer + + >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B") + >>> features = { + ... "prompt": "Which number is larger, 9.8 or 9.11?", + ... "completions": ["11 is greater than 8.", "Hence, 9.11 > 9.8."], + ... "labels": [True, False], + ... } + >>> PRMTrainer.tokenize_row( + ... features, tokenizer, "\n", max_completion_length=None, train_on_last_step_only=False, is_eval=False + ... ) + {'input_ids': [23085, 1372, 374, 8131, 11, 220, 24, 13, 23, 476, 220, 24, 13, 16, 16, 30, 16, 16, 374, 7046, 1091, 220, 23, 13, 198, 39, 763, 11, 220, 24, 13, 16, 16, 861, 220, 24, 13, 23, 13, 198], + 'labels': [-100, -100, -100, -100, -100, -100, -100, -100, 1, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, 0]} + ``` + """ + # Tokenize the prompt and completions + prompt_ids = tokenizer(features["prompt"], add_special_tokens=False)["input_ids"] + completions_ids = [ + tokenizer(completion, add_special_tokens=False)["input_ids"] for completion in features["completions"] + ] + if train_on_last_step_only and not is_eval: + labels = [-100] * (len(features["labels"]) - 1) + [int(features["labels"][-1])] + else: + labels = [int(label) for label in features["labels"]] + + # Get the ID of the separator token and add it to the completions + separator_ids = tokenizer.encode(step_separator, add_special_tokens=False) + completions_ids = [completion + separator_ids for completion in completions_ids] + + # Create the label + labels = [ + [-100] * (len(completion) - 1) + [label] for completion, label in zip(completions_ids, labels, strict=True) + ] + + # Join the completions and labels steps + completion_ids = list(chain(*completions_ids)) + labels = list(chain(*labels)) + + if tokenizer.bos_token_id is not None: + prompt_ids = [tokenizer.bos_token_id] + prompt_ids + + # Truncate completion sequences + if max_completion_length is not None: + completion_ids = completion_ids[:max_completion_length] + labels = labels[:max_completion_length] + + input_ids = prompt_ids + completion_ids + labels = [-100] * len(prompt_ids) + labels + + if max_length is not None: + input_ids = input_ids[:max_length] + labels = labels[:max_length] + + return {"input_ids": input_ids, "labels": labels} + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..85a7818ae5c8b83264ffec56a58c52f344fa5c26 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .sdft_config import SDFTConfig +from .sdft_trainer import SDFTTrainer + + +__all__ = ["SDFTConfig", "SDFTTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/loss_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/loss_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..5caa8c88713d2088c9c4c728dcea3e62236cf4e4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/loss_utils.py @@ -0,0 +1,135 @@ +# Copyright 2020-2026 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. + +"""Pure helper functions for self-distillation loss computation.""" + +import torch +import torch.nn.functional as F + +from ...trainer.utils import selective_log_softmax + + +def compute_divergence( + student_log_probs: torch.Tensor, + teacher_log_probs: torch.Tensor, + alpha: float, +) -> torch.Tensor: + if alpha == 0.0: + kl = F.kl_div(student_log_probs, teacher_log_probs, reduction="none", log_target=True) + elif alpha == 1.0: + kl = F.kl_div(teacher_log_probs, student_log_probs, reduction="none", log_target=True) + else: + alpha_t = torch.tensor(alpha, dtype=student_log_probs.dtype, device=student_log_probs.device) + mixture = torch.logsumexp( + torch.stack([student_log_probs + torch.log(1 - alpha_t), teacher_log_probs + torch.log(alpha_t)]), + dim=0, + ) + kl_teacher = F.kl_div(mixture, teacher_log_probs, reduction="none", log_target=True) + kl_student = F.kl_div(mixture, student_log_probs, reduction="none", log_target=True) + kl = torch.lerp(kl_student, kl_teacher, alpha) + return kl.sum(-1) + + +def add_tail_bucket(log_probs: torch.Tensor) -> torch.Tensor: + """Append a bucket holding the leftover probability mass to a top-k log-prob support. + + `log_probs` are true log-probabilities over a top-k subset, so they sum to the captured mass `P_topk <= 1`. This + appends one extra category equal to the tail mass `1 - P_topk`, yielding a distribution that sums to exactly 1. + """ + log_s = torch.logsumexp(log_probs, dim=-1, keepdim=True) + log_s = torch.clamp(log_s, max=-1e-7) + tail_log = torch.log(-torch.expm1(log_s)) + return torch.cat([log_probs, tail_log], dim=-1) + + +def apply_importance_sampling_clipping( + per_token_loss: torch.Tensor, + student_log_probs: torch.Tensor, + old_log_probs: torch.Tensor, + clip_coeff: float, +) -> torch.Tensor: + negative_approx_kl = (student_log_probs - old_log_probs).detach() + negative_approx_kl = torch.clamp(negative_approx_kl, min=-20.0, max=20.0) + ratio = torch.exp(negative_approx_kl).clamp(max=clip_coeff) + return per_token_loss * ratio + + +def compute_topk_self_distillation_loss( + student_logits: torch.Tensor, + teacher_logits: torch.Tensor, + *, + distillation_topk: int, + distillation_alpha: float, + distillation_add_tail: bool, +) -> torch.Tensor: + """Compute distillation loss on the student's top-k token support. + + The student's top-k logits define the support. The teacher distribution is projected onto the same token indices. + The selected support is then either renormalized or augmented with a tail bucket before the divergence is computed. + """ + student_logsumexp = torch.logsumexp(student_logits, dim=-1, keepdim=True) + topk_student_logits, topk_indices = torch.topk(student_logits, k=distillation_topk, dim=-1) + topk_student_log_probs = topk_student_logits - student_logsumexp + + teacher_logsumexp = torch.logsumexp(teacher_logits, dim=-1, keepdim=True) + topk_teacher_logits = torch.gather(teacher_logits, dim=-1, index=topk_indices) + topk_teacher_log_probs = topk_teacher_logits - teacher_logsumexp + + # Top-k log-probs sum to the captured mass P_topk <= 1; the rest (1 - P_topk) is the "tail". + if distillation_add_tail: + # Lump the tail into one bucket so the divergence approximates the full-vocab divergence. + topk_student_log_probs = add_tail_bucket(topk_student_log_probs) + topk_teacher_log_probs = add_tail_bucket(topk_teacher_log_probs) + else: + # Drop the tail and renormalize the top-k to sum to 1: divergence over the top-k conditional only. + topk_student_log_probs = topk_student_log_probs - torch.logsumexp(topk_student_log_probs, dim=-1, keepdim=True) + topk_teacher_log_probs = topk_teacher_log_probs - torch.logsumexp(topk_teacher_log_probs, dim=-1, keepdim=True) + + return compute_divergence(topk_student_log_probs, topk_teacher_log_probs, distillation_alpha) + + +def compute_full_logit_self_distillation_loss( + student_logits: torch.Tensor, + teacher_logits: torch.Tensor, + *, + distillation_alpha: float, +) -> torch.Tensor: + """Compute full-vocabulary self-distillation loss between student and teacher logits.""" + student_log_probs = torch.log_softmax(student_logits, dim=-1) + teacher_log_probs = torch.log_softmax(teacher_logits, dim=-1) + return compute_divergence(student_log_probs, teacher_log_probs, distillation_alpha) + + +def compute_sampled_token_self_distillation_loss( + student_logits: torch.Tensor, + teacher_logits: torch.Tensor, + completion_ids: torch.Tensor, + *, + distillation_alpha: float, +) -> torch.Tensor: + """Compute token-level self-distillation loss only on the sampled completion tokens. + + This path compares student and teacher log-probabilities on the realized completion tokens rather than over a + larger token support. + """ + if distillation_alpha != 1.0: + raise ValueError( + "Only reverse KL (alpha=1.0) is supported for token-level distillation when " + f"`distillation_mode='sampled_token'`, got alpha={distillation_alpha}" + ) + + student_per_token_logps = selective_log_softmax(student_logits, completion_ids) + teacher_per_token_logps = selective_log_softmax(teacher_logits, completion_ids) + log_ratio = student_per_token_logps - teacher_per_token_logps + return log_ratio.detach() * student_per_token_logps diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/sdft.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/sdft.py new file mode 100644 index 0000000000000000000000000000000000000000..817f5a7c4ed9b6bb4fef20fec264625eb3b66617 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/sdft.py @@ -0,0 +1,428 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# "peft", +# "trackio", +# "kernels", +# ] +# /// + +""" +Small-scale SDFT training with Qwen/Qwen3.5-0.8B. + +Expected dataset formats: + +1. Native TRL self-distillation format: + - `prompt` + - `privileged_context` containing only the extra teacher-only information + +2. Demonstration-based format: + - `prompt` + - `golden_response` + +Example: + +```bash +python trl/experimental/sdft/sdft.py \ + --model_name_or_path Qwen/Qwen3.5-0.8B \ + --dataset_name your-org/your-dataset \ + --output_dir outputs/sdft-qwen3.5-0.8b \ + --per_device_train_batch_size 1 \ + --gradient_accumulation_steps 16 \ + --learning_rate 2e-5 \ + --max_prompt_length 1024 \ + --max_completion_length 512 \ + --teacher_model_kind ema \ + --teacher_sync_steps 1 \ + --teacher_update_rate 0.01 \ + --eval_strategy steps \ + --eval_steps 50 \ + --report_to wandb +``` +""" + +import json +import os +import re +from dataclasses import dataclass, field +from string import Template +from typing import Any + +import torch +from datasets import DatasetDict, load_dataset, load_from_disk +from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig + +from trl import ( + LogCompletionsCallback, + ModelConfig, + ScriptArguments, + TrlParser, + get_kbit_device_map, + get_peft_config, + get_quantization_config, +) +from trl.data_utils import maybe_apply_chat_template +from trl.experimental.sdft import SDFTConfig, SDFTTrainer +from trl.models import unwrap_model_for_generation + + +DEFAULT_DEMONSTRATION_TEMPLATE = Template("""Example response: $output_text""") + + +@dataclass +class SDFTScriptArguments(ScriptArguments): + dataset_path: str | None = field( + default=None, + metadata={"help": "Optional local dataset path to load with `load_from_disk`. Overrides `dataset_name`."}, + ) + privileged_context_column: str = field( + default="privileged_context", + metadata={"help": "Column containing precomputed privileged context for SDFT."}, + ) + golden_response_column: str = field( + default="golden_response", + metadata={"help": "Column containing demonstration responses used to build privileged context."}, + ) + eval_num_prompts: int | None = field( + default=8, + metadata={"help": "Number of prompts to log during evaluation. Set to 0 to disable completion logging."}, + ) + demonstration_template: str = field( + default=DEFAULT_DEMONSTRATION_TEMPLATE.template, + metadata={"help": "Template used to build privileged context from demonstration content."}, + ) + tool_eval_num_examples: int | None = field( + default=None, + metadata={ + "help": "Optional number of eval examples to score for tool-use metrics. Defaults to the full eval split." + }, + ) + tool_eval_max_new_tokens: int = field( + default=256, + metadata={"help": "Maximum completion length for task evaluation generation."}, + ) + + +def _extract_prompt_text(prompt: Any) -> str: + if isinstance(prompt, str): + return prompt + if isinstance(prompt, list) and prompt and isinstance(prompt[0], dict): + for message in reversed(prompt): + if message.get("role") == "user": + content = message.get("content", "") + if isinstance(content, list): + return " ".join(part.get("text", "") for part in content if part.get("type") == "text") + return content + return str(prompt) + + +def _stringify_golden_response(response: Any) -> str: + if isinstance(response, str): + return response + if isinstance(response, list): + return "\n".join(_stringify_golden_response(item) for item in response) + return str(response) + + +def _build_privileged_context( + example: dict[str, Any], privileged_context_column: str, golden_response_column: str, template: Template +): + if privileged_context_column in example and example[privileged_context_column] is not None: + privileged_context = example[privileged_context_column] + elif golden_response_column in example: + privileged_context = template.safe_substitute( + orig_content=_extract_prompt_text(example["prompt"]), + output_text=_stringify_golden_response(example[golden_response_column]), + ) + elif "teacher_prompt" in example: + raise ValueError( + "Datasets for `trl.experimental.sdft` should provide `privileged_context` or `golden_response`, not " + "`teacher_prompt`." + ) + else: + raise ValueError("Dataset must contain either `privileged_context` or `golden_response` alongside `prompt`.") + + return { + "prompt": example["prompt"], + "privileged_context": privileged_context, + } + + +def _prepare_split(dataset, script_args: SDFTScriptArguments): + template = Template(script_args.demonstration_template) + return dataset.map( + lambda example: _build_privileged_context( + example, + privileged_context_column=script_args.privileged_context_column, + golden_response_column=script_args.golden_response_column, + template=template, + ), + remove_columns=dataset.column_names, + ) + + +def _can_prepare_privileged_context(dataset) -> bool: + columns = set(dataset.column_names) + return "prompt" in columns and ("privileged_context" in columns or "golden_response" in columns) + + +def _extract_action_and_input(text: str) -> tuple[str | None, str | None]: + action_match = re.search(r"Action:\s*([^\n]+)", text) + action_input_match = re.search(r"Action Input:\s*(.*)", text, flags=re.DOTALL) + action = action_match.group(1).strip() if action_match else None + action_input = action_input_match.group(1).strip() if action_input_match else None + return action, action_input + + +def _parse_json_object(text: str | None) -> tuple[bool, Any]: + if text is None: + return False, None + text = text.strip() + if text.startswith("```"): + text = re.sub(r"^```(?:json)?\s*", "", text) + text = re.sub(r"\s*```$", "", text) + try: + return True, json.loads(text) + except Exception: + return False, None + + +def _normalize_gold_answer(example: dict[str, Any]) -> tuple[str | None, Any]: + answers = example.get("golden_answer") or [] + if not answers: + return None, None + answer = answers[0] + action = answer.get("Action") + valid_json, action_input = _parse_json_object(answer.get("Action_Input")) + return action, action_input if valid_json else answer.get("Action_Input") + + +def _apply_prompt_template(tokenizer, prompt: Any) -> str: + return maybe_apply_chat_template({"prompt": prompt}, tokenizer)["prompt"] + + +def _run_tooluse_eval( + trainer: SDFTTrainer, + eval_dataset, + max_new_tokens: int, + num_examples: int | None = None, + metric_prefix: str = "tool_eval", +) -> dict[str, float]: + if num_examples is not None: + eval_dataset = eval_dataset.select(range(min(num_examples, len(eval_dataset)))) + + prompts = eval_dataset["prompt"] + prompt_texts = [_apply_prompt_template(trainer.processing_class, prompt) for prompt in prompts] + tokenized = trainer.processing_class( + text=prompt_texts, + return_tensors="pt", + padding=True, + padding_side="left", + truncation=True, + max_length=trainer.max_prompt_length, + add_special_tokens=False, + ) + tokenized = {key: value.to(trainer.accelerator.device) for key, value in tokenized.items()} + + with ( + unwrap_model_for_generation( + trainer.model_wrapped, + trainer.accelerator, + gather_deepspeed3_params=trainer.args.ds3_gather_for_generation, + ) as unwrapped_model, + torch.no_grad(), + ): + generated = unwrapped_model.generate( + **tokenized, + max_new_tokens=max_new_tokens, + do_sample=False, + pad_token_id=trainer.processing_class.pad_token_id, + eos_token_id=trainer.processing_class.eos_token_id, + ) + + prompt_length = tokenized["input_ids"].shape[1] + completions = trainer.processing_class.batch_decode(generated[:, prompt_length:], skip_special_tokens=True) + + action_correct = 0 + json_valid = 0 + full_match = 0 + parsed_action_present = 0 + records = [] + + for example, completion in zip(eval_dataset, completions, strict=True): + pred_action, pred_action_input_text = _extract_action_and_input(completion) + if pred_action is not None: + parsed_action_present += 1 + pred_json_valid, pred_action_input = _parse_json_object(pred_action_input_text) + if pred_json_valid: + json_valid += 1 + + gold_action, gold_action_input = _normalize_gold_answer(example) + is_action_correct = pred_action == gold_action and gold_action is not None + if is_action_correct: + action_correct += 1 + is_full_match = is_action_correct and pred_json_valid and pred_action_input == gold_action_input + if is_full_match: + full_match += 1 + + records.append( + { + "prompt": _extract_prompt_text(example["prompt"]), + "completion": completion, + "pred_action": pred_action, + "pred_action_input_text": pred_action_input_text, + "gold_action": gold_action, + "gold_action_input": gold_action_input, + "action_correct": is_action_correct, + "json_valid": pred_json_valid, + "full_match": is_full_match, + } + ) + + total = max(len(eval_dataset), 1) + metrics = { + f"{metric_prefix}/action_present_rate": parsed_action_present / total, + f"{metric_prefix}/valid_json_rate": json_valid / total, + f"{metric_prefix}/action_accuracy": action_correct / total, + f"{metric_prefix}/tool_call_accuracy": full_match / total, + } + + sample_path = os.path.join(trainer.args.output_dir, f"{metric_prefix}_samples.json") + os.makedirs(trainer.args.output_dir, exist_ok=True) + with open(sample_path, "w") as f: + json.dump(records[: min(20, len(records))], f, indent=2) + + return metrics + + +if __name__ == "__main__": + parser = TrlParser((SDFTScriptArguments, SDFTConfig, ModelConfig)) + script_args, training_args, model_args = parser.parse_args_and_config() + + if model_args.model_name_or_path is None: + raise ValueError("`model_name_or_path` is required.") + if model_args.dtype in ["auto", None]: + if training_args.bf16: + dtype = torch.bfloat16 + elif training_args.fp16: + dtype = torch.float16 + else: + dtype = "auto" + else: + dtype = getattr(torch, model_args.dtype) + model_kwargs = dict( + revision=model_args.model_revision, + attn_implementation=model_args.attn_implementation, + dtype=dtype, + ) + quantization_config = get_quantization_config(model_args) + if quantization_config is not None: + model_kwargs["device_map"] = get_kbit_device_map() + model_kwargs["quantization_config"] = quantization_config + + training_args.model_init_kwargs = model_kwargs + + tokenizer = AutoTokenizer.from_pretrained( + model_args.model_name_or_path, revision=model_args.model_revision, padding_side="left" + ) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + if script_args.dataset_path is not None: + dataset = load_from_disk(script_args.dataset_path) + else: + dataset = load_dataset( + script_args.dataset_name, + name=script_args.dataset_config, + streaming=script_args.dataset_streaming, + ) + + if not isinstance(dataset, DatasetDict): + raise ValueError("SDFT example expects a dataset with named splits.") + + train_dataset = _prepare_split(dataset[script_args.dataset_train_split], script_args) + raw_eval_dataset = dataset[script_args.dataset_test_split] if script_args.dataset_test_split in dataset else None + eval_dataset = None + if ( + training_args.eval_strategy != "no" + and raw_eval_dataset is not None + and _can_prepare_privileged_context(raw_eval_dataset) + ): + eval_dataset = _prepare_split(raw_eval_dataset, script_args) + + model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs) + model.config.use_cache = False if training_args.gradient_checkpointing else True + + trainer = SDFTTrainer( + model=model, + args=training_args, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=tokenizer, + peft_config=get_peft_config(model_args), + ) + + if eval_dataset is not None and script_args.eval_num_prompts: + generation_config = GenerationConfig( + max_new_tokens=training_args.max_completion_length, + do_sample=True, + temperature=training_args.temperature, + ) + trainer.add_callback( + LogCompletionsCallback(trainer, generation_config, num_prompts=script_args.eval_num_prompts) + ) + + pretrain_metrics = None + if raw_eval_dataset is not None and "golden_answer" in raw_eval_dataset.column_names: + pretrain_metrics = _run_tooluse_eval( + trainer, + raw_eval_dataset, + max_new_tokens=script_args.tool_eval_max_new_tokens, + num_examples=script_args.tool_eval_num_examples, + metric_prefix="tool_eval_before", + ) + trainer.log(pretrain_metrics) + trainer.log_metrics("eval", pretrain_metrics) + trainer.save_metrics("eval", pretrain_metrics) + + trainer.train() + + trainer.save_model(training_args.output_dir) + if eval_dataset is not None: + metrics = trainer.evaluate() + trainer.log_metrics("eval", metrics) + trainer.save_metrics("eval", metrics) + if raw_eval_dataset is not None and "golden_answer" in raw_eval_dataset.column_names: + post_metrics = _run_tooluse_eval( + trainer, + raw_eval_dataset, + max_new_tokens=script_args.tool_eval_max_new_tokens, + num_examples=script_args.tool_eval_num_examples, + metric_prefix="tool_eval_after", + ) + if pretrain_metrics is not None: + for key, value in pretrain_metrics.items(): + after_key = key.replace("tool_eval_before/", "tool_eval_after/") + if after_key in post_metrics: + delta_name = after_key.replace("tool_eval_after/", "tool_eval_delta/") + post_metrics[delta_name] = post_metrics[after_key] - value + trainer.log(post_metrics) + trainer.log_metrics("eval", post_metrics) + trainer.save_metrics("eval", post_metrics) + + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name or script_args.dataset_path) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/sdft_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/sdft_config.py new file mode 100644 index 0000000000000000000000000000000000000000..b21e3dbc60c782e385bdac882913691285ee19d8 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/sdft_config.py @@ -0,0 +1,472 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Any, Literal + +from transformers import TrainingArguments + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class SDFTConfig(_BaseConfig): + r""" + Configuration class for the [`SDFTTrainer`]. + + Parameters: + > Parameters that control the SDFT loss + + distillation_alpha (`float`, *optional*, defaults to `0.5`): + Divergence interpolation coefficient for SDFT top-k logit distillation. + distillation_mode (`Literal["sampled_token", "full_logits", "topk_logits"]`, *optional*, defaults to `"topk_logits"`): + Distillation objective mode. SDFT defaults to top-k logit distillation. + distillation_topk (`int`, *optional*, defaults to `100`): + Number of top tokens used by the default SDFT top-k logit objective. + distillation_is_clip (`float`, *optional*, defaults to `2.0`): + Clipping coefficient for importance sampling in self-distillation. `None` disables clipping. + distillation_add_tail (`bool`, *optional*, defaults to `False`): + Whether to add a tail bucket for non-top-k probability mass. + num_loss_tokens_to_skip (`int`, *optional*, defaults to `0`): + Number of initial completion tokens to exclude from the distillation loss. + + > Parameters that control the teacher + + teacher_model_kind (`str`, *optional*, defaults to `"base"`): + Semantic teacher choice for SDFT. `base` uses the initial student, `live` uses the current student, and + `ema` uses an exponentially averaged teacher. + teacher_update_rate (`float`, *optional*, defaults to `0.05`): + EMA update rate used when `teacher_model_kind="ema"`. A value of `1.0` reduces the update to a hard + overwrite, periodically resyncing the teacher to the current student weights. + teacher_sync_steps (`int`, *optional*, defaults to `1`): + Number of optimizer steps between teacher updates. + + > Parameters that control teacher-conditioned generation + + generate_from_teacher (`bool`, *optional*, defaults to `False`): + Whether on-policy generation should use the teacher-conditioned prompt instead of the student prompt. + teacher_prompt_template (`str`, *optional*, defaults to `"{prompt}\n\n{privileged_context}"`): + Template used to combine the student prompt and privileged context into the teacher prompt. + + > Parameters that control the model + + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` argument + of the `SDFTTrainer` is provided as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and [`~transformers.AutoProcessor.from_pretrained`], + for both the student and teacher. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the student and teacher models. + + > Parameters that control data preprocessing + + remove_unused_columns (`bool`, *optional*, defaults to `False`): + Whether to only keep the columns required by the trainer in the dataset. Keep this to `False` if you + provide extra columns (such as `privileged_context`) that the trainer needs. + max_prompt_length (`int`, *optional*, defaults to `512`): + Maximum prompt length. Longer prompts are truncated from the left. + shuffle_dataset (`bool`, *optional*, defaults to `True`): + Whether to shuffle the training dataset. + + > Parameters that control generation + + num_generations (`int`, *optional*, defaults to `8`): + Number of generations to sample. The effective batch size (num_processes * per_device_batch_size * + gradient_accumulation_steps) must be evenly divisible by this value. + num_generations_eval (`int`, *optional*): + Number of generations to sample during evaluation. This allows using fewer generations during evaluation to + save computation. If `None`, uses the value of `num_generations`. + max_completion_length (`int`, *optional*, defaults to `256`): + Maximum length of the generated completion. + temperature (`float`, *optional*, defaults to `1.0`): + Temperature for sampling. The higher the temperature, the more random the completions. + top_p (`float`, *optional*, defaults to `1.0`): + Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to 1.0 + to consider all tokens. + top_k (`int`, *optional*, defaults to `0`): + Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is + disabled and all tokens are considered. + min_p (`float`, *optional*): + Minimum token probability, which will be scaled by the probability of the most likely token. It must be a + value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range. + repetition_penalty (`float`, *optional*, defaults to `1.0`): + Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far. + Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model to repeat + tokens. + cache_implementation (`str`, *optional*): + Implementation of the cache method for faster generation when use_vllm is set to False. + generation_kwargs (`dict[str, Any]`, *optional*): + Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or `SamplingParams` (if + using vLLM) when sampling completions. This can be used to further customize the generation behavior, such + as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict with the other generation + parameters (like `min_p`, `top_p`, etc.), they will override them. + chat_template_kwargs (`dict[str, Any]`, *optional*): + Additional keyword arguments to pass to the `apply_chat_template` function when generating completions. + ds3_gather_for_generation (`bool`, *optional*, defaults to `True`): + This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation, + improving generation speed. However, disabling this option allows training models that exceed the VRAM + capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible + with vLLM generation. + + > Parameters that control generation acceleration powered by vLLM + + use_vllm (`bool`, *optional*, defaults to `False`): + Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation + instead of the default model.generate(). Requires `vllm` to be installed. + use_teacher_server (`bool`, *optional*, defaults to `False`): + Compute teacher logprobs from the running vLLM generation server instead of a local teacher forward. Only + supported for `teacher_model_kind='live'` with `use_vllm=True` and `vllm_mode='server'`, and + `distillation_mode` in {'sampled_token', 'topk_logits'} (the server returns the teacher's top-k logprobs, + not the full vocabulary; `topk_logits` distills over the teacher's own top-k support). + vllm_mode (`str`, *optional*, defaults to `"colocate"`): + Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or + `'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure a + TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same process + and share the training GPUs. This avoids the need for a separate server but may cause resource contention + with training. + vllm_model_impl (`str`, *optional*, defaults to `"vllm"`): + Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: Use the + `transformers` backend for model implementation. `vllm`: Use the `vllm` library for model implementation. + vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`): + Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but + waking the engine adds host–device transfer latency. + vllm_server_base_url (`str`, *optional*): + Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` and + `vllm_server_port` are ignored. + vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`): + Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided. + vllm_server_port (`int`, *optional*, defaults to `8000`): + Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided. + vllm_group_port (`int`, *optional*, defaults to `51216`): + Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port + is occupied, there is no need to change it. + vllm_server_timeout (`float`, *optional*, defaults to `240.0`): + Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the + timeout, a `ConnectionError` is raised. + vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`): + Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to + `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when + launching the vLLM server via the `--vllm_tensor_parallel_size` flag. + vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.3`): + Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to + `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when + launching the vLLM server via the `--vllm_gpu_memory_utilization` flag. + vllm_max_model_length (`int`, *optional*): + Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus + `max_completion_length`; if omitted, it is inferred from the model config. + + > Parameters that control the training + + num_iterations (`int`, *optional*, defaults to `1`): + Number of iterations per batch (denoted as μ in the algorithm). + generation_batch_size (`int`, *optional*): + Batch size to use for generation. If `None`, it defaults to the effective training batch size: + `per_device_train_batch_size * num_processes * steps_per_generation`. + steps_per_generation (`int`, *optional*): + Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`. + """ + + _VALID_DICT_FIELDS = TrainingArguments._VALID_DICT_FIELDS + ["model_init_kwargs"] + + model_init_kwargs: dict[str, Any] | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` argument of the `SDFTTrainer` is provided as a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`, for both the " + "student and teacher." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the student and teacher models."}, + ) + remove_unused_columns: bool = field( + default=False, + metadata={ + "help": "Whether to only keep the columns required by the trainer in the dataset. Keep this to `False` if you provide extra columns (such as `privileged_context`) that the trainer needs." + }, + ) + max_prompt_length: int | None = field( + default=512, + metadata={"help": "Maximum prompt length. Longer prompts are truncated from the left."}, + ) + num_generations: int = field( + default=8, + metadata={ + "help": "Number of generations to sample. The effective batch size (num_processes * per_device_batch_size * gradient_accumulation_steps) must be evenly divisible by this value." + }, + ) + num_generations_eval: int | None = field( + default=None, + metadata={ + "help": "Number of generations to sample during evaluation. This allows using fewer generations during evaluation to save computation. If `None`, uses the value of `num_generations`." + }, + ) + max_completion_length: int | None = field( + default=256, + metadata={"help": "Maximum length of the generated completion."}, + ) + ds3_gather_for_generation: bool = field( + default=True, + metadata={ + "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation, improving generation speed. However, disabling this option allows training models that exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible with vLLM generation." + }, + ) + shuffle_dataset: bool = field( + default=True, + metadata={"help": "Whether to shuffle the training dataset."}, + ) + generation_batch_size: int | None = field( + default=None, + metadata={ + "help": "Batch size to use for generation. If `None`, it defaults to the effective training batch size: `per_device_train_batch_size * num_processes * steps_per_generation`." + }, + ) + steps_per_generation: int | None = field( + default=None, + metadata={"help": "Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`."}, + ) + temperature: float = field( + default=1.0, + metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."}, + ) + top_p: float = field( + default=1.0, + metadata={ + "help": "Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to 1.0 to consider all tokens." + }, + ) + top_k: int = field( + default=0, + metadata={ + "help": "Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is disabled and all tokens are considered." + }, + ) + min_p: float | None = field( + default=None, + metadata={ + "help": "Minimum token probability, which will be scaled by the probability of the most likely token. It must be a value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range." + }, + ) + generation_kwargs: dict[str, Any] | None = field( + default=None, + metadata={ + "help": "Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or `SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them." + }, + ) + chat_template_kwargs: dict[str, Any] | None = field( + default=None, + metadata={ + "help": "Additional keyword arguments to pass to the `apply_chat_template` function when generating completions." + }, + ) + repetition_penalty: float = field( + default=1.0, + metadata={ + "help": "Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far. Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model to repeat tokens." + }, + ) + cache_implementation: str | None = field( + default=None, + metadata={"help": "Implementation of the cache method for faster generation when use_vllm is set to False."}, + ) + use_vllm: bool = field( + default=False, + metadata={ + "help": "Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation instead of the default model.generate(). Requires `vllm` to be installed." + }, + ) + use_teacher_server: bool = field( + default=False, + metadata={ + "help": "Compute teacher logprobs from the running vLLM generation server instead of a local teacher " + "forward. Only supported for `teacher_model_kind='live'` with `use_vllm=True` and `vllm_mode='server'`, " + "and `distillation_mode` in {'sampled_token', 'topk_logits'} (the server returns the teacher's top-k " + "logprobs, not the full vocabulary; `topk_logits` distills over the teacher's own top-k support)." + }, + ) + vllm_mode: str = field( + default="colocate", + metadata={ + "help": "Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or `'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same process and share the training GPUs. This avoids the need for a separate server but may cause resource contention with training." + }, + ) + vllm_model_impl: str = field( + default="vllm", + metadata={ + "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for model implementation." + }, + ) + vllm_enable_sleep_mode: bool = field( + default=False, + metadata={ + "help": "Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but waking the engine adds host–device transfer latency." + }, + ) + vllm_server_base_url: str | None = field( + default=None, + metadata={ + "help": "Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` and `vllm_server_port` are ignored." + }, + ) + vllm_server_host: str = field( + default="0.0.0.0", + metadata={"help": "Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."}, + ) + vllm_server_port: int = field( + default=8000, + metadata={"help": "Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."}, + ) + vllm_group_port: int = field( + default=51216, + metadata={ + "help": "Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port is occupied, there is no need to change it." + }, + ) + vllm_server_timeout: float = field( + default=240.0, + metadata={ + "help": "Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the timeout, a `ConnectionError` is raised." + }, + ) + vllm_tensor_parallel_size: int = field( + default=1, + metadata={ + "help": "Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when launching the vLLM server via the `--vllm_tensor_parallel_size` flag." + }, + ) + vllm_gpu_memory_utilization: float = field( + default=0.3, + metadata={ + "help": "Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when launching the vLLM server via the `--vllm_gpu_memory_utilization` flag." + }, + ) + vllm_max_model_length: int | None = field( + default=None, + metadata={ + "help": "Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus `max_completion_length`; if omitted, it is inferred from the model config." + }, + ) + num_iterations: int = field( + default=1, + metadata={"help": "Number of iterations per batch (denoted as μ in the algorithm)."}, + ) + teacher_model_kind: str = field( + default="base", + metadata={ + "help": "Semantic teacher choice for SDFT. `base` uses the initial student, `live` uses the current " + "student, and `ema` uses an exponentially averaged teacher." + }, + ) + teacher_update_rate: float = field( + default=0.05, + metadata={ + "help": 'EMA update rate used when `teacher_model_kind="ema"`. A value of `1.0` reduces the update ' + "to a hard overwrite, periodically resyncing the teacher to the current student weights." + }, + ) + teacher_sync_steps: int = field( + default=1, + metadata={"help": "Number of optimizer steps between teacher updates."}, + ) + distillation_alpha: float = field( + default=0.5, + metadata={"help": "Divergence interpolation coefficient for SDFT top-k logit distillation."}, + ) + distillation_mode: Literal["sampled_token", "full_logits", "topk_logits"] = field( + default="topk_logits", + metadata={"help": "Distillation objective mode. SDFT defaults to top-k logit distillation."}, + ) + distillation_topk: int | None = field( + default=100, + metadata={"help": "Number of top tokens used by the default SDFT top-k logit objective."}, + ) + distillation_is_clip: float | None = field( + default=2.0, + metadata={ + "help": "Clipping coefficient for importance sampling in self-distillation. `None` disables clipping." + }, + ) + distillation_add_tail: bool = field( + default=False, + metadata={"help": "Whether to add a tail bucket for non-top-k probability mass."}, + ) + generate_from_teacher: bool = field( + default=False, + metadata={ + "help": "Whether on-policy generation should use the teacher-conditioned prompt instead of the student prompt." + }, + ) + teacher_prompt_template: str = field( + default="{prompt}\n\n{privileged_context}", + metadata={ + "help": "Template used to combine the student prompt and privileged context into the teacher prompt." + }, + ) + num_loss_tokens_to_skip: int = field( + default=0, + metadata={"help": "Number of initial completion tokens to exclude from the distillation loss."}, + ) + + def __post_init__(self): + super().__post_init__() + if self.distillation_mode == "sampled_token" and self.distillation_alpha != 1.0: + raise ValueError( + "`distillation_mode='sampled_token'` only supports reverse KL, so it requires " + f"`distillation_alpha=1.0`, got {self.distillation_alpha}." + ) + num_processes = self.world_size + if self.generation_batch_size is None and self.steps_per_generation is None: + self.steps_per_generation = self.gradient_accumulation_steps + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + elif self.generation_batch_size is not None and self.steps_per_generation is None: + global_batch_size = self.per_device_train_batch_size * num_processes + if self.generation_batch_size % global_batch_size != 0: + raise ValueError( + f"generation_batch_size ({self.generation_batch_size}) must be divisible by the global batch size ({global_batch_size})." + ) + self.steps_per_generation = self.generation_batch_size // global_batch_size + elif self.generation_batch_size is None and self.steps_per_generation is not None: + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + else: + raise ValueError("'generation_batch_size' and 'steps_per_generation' can not both be configured") + + if self.generation_batch_size % self.num_generations != 0: + raise ValueError( + f"generation_batch_size ({self.generation_batch_size}) must be divisible by num_generations ({self.num_generations})." + ) + + if self.do_eval and self.eval_strategy != "no": + num_generations_eval = self.num_generations_eval or self.num_generations + if (self.per_device_eval_batch_size * num_processes) % num_generations_eval != 0: + raise ValueError( + f"The global eval batch size ({self.per_device_eval_batch_size} * {num_processes}) must be " + f"divisible by the number of generations used for evaluation ({num_generations_eval})." + ) + + if ( + "{prompt}" not in self.teacher_prompt_template + or "{privileged_context}" not in self.teacher_prompt_template + ): + raise ValueError( + "teacher_prompt_template must contain both `{prompt}` and `{privileged_context}` placeholders" + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/sdft_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/sdft_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..1f68ad8467b8345bf67e509b17d8ae1f064c8857 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/sdft_trainer.py @@ -0,0 +1,1311 @@ +# Copyright 2020-2026 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 textwrap +from collections import defaultdict +from contextlib import nullcontext +from dataclasses import dataclass +from functools import partial +from typing import Any + +import datasets +import torch +from accelerate.logging import get_logger +from accelerate.utils import is_peft_model +from datasets import Dataset, IterableDataset +from torch import nn +from torch.distributed.fsdp import FullyShardedDataParallel as FSDP +from torch.utils.data import DataLoader, Sampler +from transformers import ( + AutoProcessor, + GenerationConfig, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, +) +from transformers.trainer_utils import seed_worker +from transformers.utils import is_datasets_available, is_liger_kernel_available, is_peft_available + +from ...data_utils import is_conversational +from ...models import prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation +from ...models.utils import _ForwardRedirection +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import ( + RepeatSampler, + create_model_from_path, + disable_dropout_in_model, + get_config_model_id, + identity, + pad, + selective_log_softmax, + split_tensor_dict, + use_adapter, +) +from ..utils import prepare_peft_model +from .loss_utils import ( + add_tail_bucket, + apply_importance_sampling_clipping, + compute_divergence, + compute_full_logit_self_distillation_loss, + compute_sampled_token_self_distillation_loss, + compute_topk_self_distillation_loss, +) +from .sdft_config import SDFTConfig +from .teacher_sync import PEFTAdapterEMACallback, SyncTeacherModelCallback, is_pure_lora_training + + +if is_peft_available(): + from peft import PeftConfig + +if is_liger_kernel_available(): + from liger_kernel.chunked_loss import LigerFusedLinearJSDLoss + + +logger = get_logger(__name__) + + +TrainingBatch = dict[str, torch.Tensor | Any] + + +def build_teacher_request_inputs( + input_ids: torch.Tensor, + attention_mask: torch.Tensor, + prompt_attention_mask: torch.Tensor, +) -> tuple[list[list[int]], list[int], list[int]]: + """Trim padded batch tensors into per-sample (prompt+completion) sequences for teacher-server requests.""" + if input_ids.shape != attention_mask.shape: + raise ValueError( + f"input_ids and attention_mask must have the same shape, got {input_ids.shape} and {attention_mask.shape}." + ) + + input_ids_cpu = input_ids.detach().cpu() + attention_mask_cpu = attention_mask.detach().cpu().bool() + prompt_lengths = prompt_attention_mask.detach().cpu().sum(dim=1).to(torch.long) + + trimmed_input_ids: list[list[int]] = [] + prompt_lengths_list: list[int] = [] + completion_lengths_list: list[int] = [] + for row, mask, prompt_length in zip(input_ids_cpu, attention_mask_cpu, prompt_lengths, strict=True): + trimmed_row = row[mask] + prompt_len = int(prompt_length.item()) + if prompt_len < 0 or prompt_len > trimmed_row.numel(): + raise ValueError( + f"Invalid prompt length {prompt_len} for trimmed sequence of length {trimmed_row.numel()}." + ) + trimmed_input_ids.append(trimmed_row.tolist()) + prompt_lengths_list.append(prompt_len) + completion_lengths_list.append(int(trimmed_row.numel()) - prompt_len) + return trimmed_input_ids, prompt_lengths_list, completion_lengths_list + + +@dataclass +class DistillationLogits: + """Aligned logits and masks used to compute a self-distillation objective.""" + + completion_ids: torch.Tensor + loss_mask: torch.Tensor + student_logits: torch.Tensor + teacher_logits: torch.Tensor + + +def _extract_last_user_text(messages: list[dict[str, Any]]) -> str: + """Extract the text content from the last user message in a conversational prompt.""" + last_message = messages[-1] + if last_message.get("role") != "user": + raise ValueError( + f"Self-distillation teacher prompt construction expects the conversation to end with a user turn, " + f"but the last message has role '{last_message.get('role')}'. " + f"Prompts ending with assistant prefills or tool turns are not supported." + ) + content = last_message.get("content", "") + if isinstance(content, list): + return " ".join(part.get("text", "") for part in content if part.get("type") == "text") + return content + + +class DemonstrationTeacherContextBuilder: + """Builds student and teacher contexts from prompts plus privileged context""" + + def __init__(self, trainer): + self.trainer = trainer + + def _stringify_privileged_context(self, privileged_context: Any) -> str: + if privileged_context is None: + raise ValueError( + "`privileged_context` must not be None for self-distillation teacher prompt construction." + ) + if isinstance(privileged_context, str): + return privileged_context + if isinstance(privileged_context, list) and privileged_context and isinstance(privileged_context[0], dict): + chunks = [] + for message in privileged_context: + content = message.get("content", "") + if isinstance(content, list): + text = " ".join(part.get("text", "") for part in content if part.get("type") == "text") + else: + text = str(content) + if text: + chunks.append(text) + return "\n".join(chunks) + return str(privileged_context) + + def _compose_teacher_prompt(self, prompt: Any, privileged_context: Any) -> Any: + privileged_text = self._stringify_privileged_context(privileged_context) + if isinstance(prompt, list): + system_messages = prompt[:-1] + prompt_text = _extract_last_user_text(prompt) + teacher_text = self.trainer.args.teacher_prompt_template.format( + prompt=prompt_text, + privileged_context=privileged_text, + ) + return system_messages + [{"role": "user", "content": teacher_text}] + return self.trainer.args.teacher_prompt_template.format(prompt=prompt, privileged_context=privileged_text) + + def select_generation_prompts(self, prompts: list[Any], privileged_contexts: list[Any]) -> list[Any]: + return [ + self._compose_teacher_prompt(prompt, privileged_context) + for prompt, privileged_context in zip(prompts, privileged_contexts, strict=True) + ] + + def build( + self, + prompts: list[Any], + privileged_contexts: list[Any], + completion_ids: torch.Tensor, + completion_mask: torch.Tensor, + ) -> dict[str, torch.Tensor]: + teacher_prompts = [ + self._compose_teacher_prompt(prompt, privileged_context) + for prompt, privileged_context in zip(prompts, privileged_contexts, strict=True) + ] + teacher_prompt_ids_list = self.trainer._tokenize_prompts(teacher_prompts) + device = completion_ids.device + teacher_prompt_ids = [torch.tensor(ids) for ids in teacher_prompt_ids_list] + teacher_prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in teacher_prompt_ids] + teacher_prompt_ids = pad( + teacher_prompt_ids, padding_value=self.trainer._tokenizer.pad_token_id, padding_side="left" + ).to(device=device) + teacher_prompt_mask = pad(teacher_prompt_mask, padding_value=0, padding_side="left").to(device=device) + teacher_input_ids = torch.cat([teacher_prompt_ids, completion_ids], dim=1) + teacher_attention_mask = torch.cat([teacher_prompt_mask, completion_mask], dim=1) + return { + "teacher_input_ids": teacher_input_ids, + "teacher_attention_mask": teacher_attention_mask, + } + + +class SDFTTrainer(_BaseTrainer): + """Trainer for SDFT-style on-policy self-distillation with explicit teacher prompts.""" + + _tag_names = ["trl", "sdft"] + _name = "SDFT" + config_cls = SDFTConfig + # docstyle-ignore + _paper = { + "title": "Self-Distillation Enables Continual Learning", + "id": "2601.19897", + "citation": textwrap.dedent("""\ + @article{shenfeld2026selfdistillation, + title = {{Self-Distillation Enables Continual Learning}}, + author = {Idan Shenfeld and Mehul Damani and Jonas H\\"ubotter and Pulkit Agrawal}, + year = 2026, + eprint = {arXiv:2601.19897} + }"""), + } + + def __init__( + self, + model: str | PreTrainedModel | nn.Module, + args: SDFTConfig | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + peft_config: PeftConfig | None = None, + ): + if isinstance(train_dataset, IterableDataset): + raise NotImplementedError("Iterable datasets are not yet supported in SDFTTrainer.") + if isinstance(eval_dataset, IterableDataset) or ( + isinstance(eval_dataset, dict) and any(isinstance(ds, IterableDataset) for ds in eval_dataset.values()) + ): + raise NotImplementedError("Iterable eval datasets are not yet supported in SDFTTrainer.") + + self.num_loss_tokens_to_skip = args.num_loss_tokens_to_skip + self.teacher_context_builder = DemonstrationTeacherContextBuilder(self) + + if train_dataset is None: + raise ValueError("`train_dataset` is required") + + if isinstance(model, str): + model_init_kwargs = args.model_init_kwargs or {} + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + model = create_model_from_path(model, **model_init_kwargs) + elif args.model_init_kwargs is not None: + logger.warning( + "You passed `model_init_kwargs` to the self-distillation config, but `model` is already " + "instantiated. The `model_init_kwargs` will be ignored." + ) + + self.model_kwarg_keys = ( + inspect.signature(model.forward).parameters.keys() + if not hasattr(model, "get_base_model") + else inspect.signature(model.get_base_model().forward).parameters.keys() + ) + + if peft_config is None and getattr(model, "peft_config", None) is not None: + logger.warning( + "The provided self-distillation student model already contains a PEFT adapter. " + "This setup is accepted but not directly supported. In particular, `teacher_model_kind='base'` " + "may refer to the underlying base weights rather than the exact initially loaded student state " + "including its adapter. For unambiguous teacher behavior, start from a merged/non-adapter model " + "or manage separate adapters explicitly." + ) + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config`. Pass either a base " + "model with `peft_config`, or a pre-wrapped PEFT model." + ) + if peft_config is not None or (is_peft_available() and getattr(model, "peft_config", None) is not None): + model = prepare_peft_model(model, peft_config, args) + + if processing_class is None: + processing_class = AutoProcessor.from_pretrained( + get_config_model_id(model.config), + truncation_side="left", + padding_side="left", + trust_remote_code=args.trust_remote_code, + ) + + if isinstance(processing_class, ProcessorMixin): + self._tokenizer = processing_class.tokenizer + elif isinstance(processing_class, PreTrainedTokenizerBase): + self._tokenizer = processing_class + else: + raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`") + + if self._tokenizer.pad_token is None: + self._tokenizer.pad_token = self._tokenizer.eos_token + + self.max_prompt_length = args.max_prompt_length + self.max_completion_length = args.max_completion_length + self.num_generations = args.num_generations + self.num_generations_eval = args.num_generations_eval or args.num_generations + self.num_iterations = args.num_iterations + self.shuffle_dataset = args.shuffle_dataset + self.temperature = args.temperature + self.generate_from_teacher = args.generate_from_teacher + self.use_vllm = args.use_vllm + self.chat_template_kwargs = args.chat_template_kwargs or {} + self._step = 0 + self._buffered_inputs = None + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + + self.generation_kwargs = { + "max_new_tokens": self.max_completion_length, + "do_sample": True, + "pad_token_id": self._tokenizer.pad_token_id, + "bos_token_id": self._tokenizer.bos_token_id, + "eos_token_id": self._tokenizer.eos_token_id, + "temperature": args.temperature, + "top_p": args.top_p, + "top_k": args.top_k, + "min_p": args.min_p, + "repetition_penalty": args.repetition_penalty, + "cache_implementation": args.cache_implementation, + } + if args.generation_kwargs is not None: + self.generation_kwargs.update(args.generation_kwargs) + self.generation_config = GenerationConfig(**self.generation_kwargs, disable_compile=True) + + if hasattr(model, "warnings_issued"): + model.warnings_issued["estimate_tokens"] = True + + # Teacher logprobs from the running vLLM generation server (reuses the synced student weights) instead of a + # local teacher forward. MVP: `live` teacher only — the generation server holds the current student weights. + self.use_teacher_server = args.use_teacher_server + if self.use_teacher_server: + if not (args.use_vllm and args.vllm_mode == "server"): + raise ValueError( + "`use_teacher_server=True` requires `use_vllm=True` and `vllm_mode='server'`: teacher logprobs are " + "served by the same vLLM server used for generation." + ) + if args.teacher_model_kind != "live": + raise ValueError( + "`use_teacher_server=True` only supports `teacher_model_kind='live'` (the generation server holds " + f"the current student weights), got {args.teacher_model_kind!r}." + ) + if args.distillation_mode not in ("sampled_token", "topk_logits"): + raise ValueError( + "`use_teacher_server=True` only supports `distillation_mode` in {'sampled_token', 'topk_logits'}, " + f"got {args.distillation_mode!r}. The server returns the teacher's top-k logprobs, not the full " + "vocabulary, so `full_logits` is unavailable. Note `topk_logits` distills over the teacher's own " + "top-k support (the server cannot score the student's top-k indices)." + ) + if args.use_liger_kernel: + raise ValueError( + "`use_teacher_server=True` is incompatible with `use_liger_kernel`: the server returns top-k " + "logprobs while the Liger fused loss needs full-vocabulary hidden states." + ) + # Liger fused JSD loss for `full_logits`: same generalized JSD as `compute_divergence`, so alpha maps to beta. + self.use_liger_loss = False + if args.use_liger_kernel: + if not is_liger_kernel_available(): + raise ImportError( + "Liger is required to use `use_liger_kernel` as the self-distillation loss. Run " + "`pip install liger-kernel`." + ) + if args.distillation_mode != "full_logits": + raise ValueError( + "`use_liger_kernel` only supports `distillation_mode='full_logits'`, got " + f"{args.distillation_mode!r}. The fused JSD kernel operates on the full vocabulary and cannot " + "express the top-k support or sampled-token objectives." + ) + if args.distillation_is_clip is not None: + raise ValueError( + "`use_liger_kernel` is incompatible with `distillation_is_clip`: the fused kernel does not expose " + "per-token losses for importance-sampling clipping." + ) + self.liger_jsd_loss = LigerFusedLinearJSDLoss( + beta=args.distillation_alpha, + ignore_index=-100, + temperature=args.temperature, + compiled=False, + weight_hard_loss=0.0, + weight_soft_loss=1.0, + ) + self._forward_redirection = _ForwardRedirection() + self.use_liger_loss = True + + super().__init__( + model=model, + args=args, + data_collator=identity, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + callbacks=callbacks, + optimizers=optimizers, + compute_loss_func="non-None value to disable scaling", + ) + + self._last_loaded_step = -1 if self.use_vllm else 0 + if self.use_vllm: + from ...generation.vllm_generation import VLLMGeneration + + self.vllm_generation = VLLMGeneration( + model=self.model, + accelerator=self.accelerator, + processing_class=self.processing_class, + mode=args.vllm_mode, + server_base_url=args.vllm_server_base_url, + server_host=args.vllm_server_host, + server_port=args.vllm_server_port, + group_port=args.vllm_group_port, + server_timeout=args.vllm_server_timeout, + tensor_parallel_size=args.vllm_tensor_parallel_size, + gpu_memory_utilization=args.vllm_gpu_memory_utilization, + max_model_length=args.vllm_max_model_length, + max_num_seqs=args.per_device_train_batch_size + * args.vllm_tensor_parallel_size + * args.steps_per_generation, + enable_sleep_mode=args.vllm_enable_sleep_mode, + model_impl=args.vllm_model_impl, + repetition_penalty=args.repetition_penalty, + temperature=self.temperature, + top_p=args.top_p, + top_k=args.top_k, + min_p=args.min_p, + max_completion_length=self.max_completion_length, + logprobs=None, + generation_kwargs=args.generation_kwargs, + ) + + # Per-rank read-only client to the same generation server for teacher scoring (weights are synced there by + # `VLLMGeneration`; scoring needs no weight-update communicator). Mirrors the distillation trainer's + # `teacher_client`. + self.teacher_client = None + if self.use_teacher_server: + from ...generation.vllm_client import VLLMClient + + base_url = args.vllm_server_base_url or f"http://{args.vllm_server_host}:{args.vllm_server_port}" + self.teacher_client = VLLMClient(base_url=base_url, connection_timeout=args.vllm_server_timeout) + + if args.disable_dropout: + disable_dropout_in_model(self.model) + + if hasattr(self.model, "add_model_tags"): + self.model.add_model_tags(self._tag_names) + + self._setup_teacher_model() + self.model_accepts_loss_kwargs = False + + def _set_signature_columns_if_needed(self): + if self._signature_columns is None: + self._signature_columns = ["prompt", "privileged_context"] + + def _dispatch_self_distillation_callback(self, event_name: str, **payload) -> None: + for callback in self.callback_handler.callbacks: + callback_fn = getattr(callback, event_name, None) + if callback_fn is not None: + callback_fn( + args=self.args, + state=self.state, + control=self.control, + model=self.model, + processing_class=self.processing_class, + **payload, + ) + + def _setup_teacher_model(self) -> None: + """Prepare teacher state according to the semantic teacher choice. + + Resolve `teacher_model_kind` × PEFT state into the effective teacher: + + - `"live"` (any model): + Teacher is the student. No divergence, no callback. + - `"base"` + PEFT model: + Teacher reuses `self.model`; the base weights are recovered downstream by disabling the adapter via + `use_adapter` during teacher forward. + - `"base"` + non-PEFT model: + Teacher is a frozen deepcopy of the initial student (falls through to the copy branch below). + - `"ema"` + pure-LoRA training: + Teacher reuses `self.model`; a dedicated `"teacher"` LoRA adapter is attached and updated by + `PEFTAdapterEMACallback`. Teacher forward switches to that adapter downstream. + - `"ema"` (otherwise): + Teacher is a frozen deepcopy synchronized each step by `SyncTeacherModelCallback`. + + Must be called after `super().__init__` so that `self.callback_handler` is available. + """ + + teacher_model_kind = self.args.teacher_model_kind + + if teacher_model_kind == "live": + self.teacher_model = self.model + return + + if teacher_model_kind == "base" and is_peft_model(self.model): + self.teacher_model = self.model + return + + if self._use_peft_ema_teacher_adapter(): + # Must run after super().__init__ so self.callback_handler exists. + self.add_callback( + PEFTAdapterEMACallback( + model=self.model, + teacher_adapter_name="teacher", + update_rate=self.args.teacher_update_rate, + sync_steps=self.args.teacher_sync_steps, + accelerator=self.accelerator, + ) + ) + self.teacher_model = self.model + return + + if is_peft_model(self.model): + raise ValueError( + "`teacher_model_kind='ema'` with a non-pure-LoRA PEFT model is not supported: the separate EMA " + "teacher cannot be parameter-matched to the PEFT student. Use pure-LoRA training, a non-PEFT model, " + "or `teacher_model_kind` in {'live', 'base'}." + ) + + # Build the teacher from the model path (like the GRPO/DPO reference model) rather than deep-copying the + # student: under ZeRO-3 the student params are already sharded, so a deep copy would clone empty shards. + model_init_kwargs = self.args.model_init_kwargs or {} + if self.args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", self.args.trust_remote_code) + self.teacher_model = create_model_from_path(get_config_model_id(self.model.config), **model_init_kwargs) + self.teacher_model.requires_grad_(False) + self.teacher_model.eval() + if self.is_deepspeed_enabled: + self.teacher_model = prepare_deepspeed(self.teacher_model, self.accelerator) + elif self.is_fsdp_enabled: + self.teacher_model = prepare_fsdp(self.teacher_model, self.accelerator) + else: + self.teacher_model = self.accelerator.prepare_model(self.teacher_model, evaluation_mode=True) + + if teacher_model_kind == "ema": + self.add_callback(SyncTeacherModelCallback(teacher_model=self.teacher_model, accelerator=self.accelerator)) + + def _use_peft_ema_teacher_adapter(self) -> bool: + return self.args.teacher_model_kind == "ema" and is_pure_lora_training(self.model, self.accelerator) + + def get_train_dataloader(self): + if self.train_dataset is None: + raise ValueError("Trainer: training requires a train_dataset.") + + train_dataset = self.train_dataset + data_collator = self.data_collator + if is_datasets_available() and isinstance(train_dataset, datasets.Dataset): + train_dataset = self._remove_unused_columns(train_dataset, description="training") + else: + data_collator = self._get_collator_with_removed_columns(data_collator, description="training") + + dataloader_params = { + "batch_size": self._train_batch_size * self.args.steps_per_generation, + "collate_fn": data_collator, + "num_workers": self.args.dataloader_num_workers, + "pin_memory": self.args.dataloader_pin_memory, + "persistent_workers": self.args.dataloader_persistent_workers, + } + if not isinstance(train_dataset, torch.utils.data.IterableDataset): + dataloader_params["sampler"] = self._get_train_sampler() + dataloader_params["drop_last"] = self.args.dataloader_drop_last + dataloader_params["worker_init_fn"] = partial( + seed_worker, num_workers=self.args.dataloader_num_workers, rank=self.args.process_index + ) + dataloader_params["prefetch_factor"] = self.args.dataloader_prefetch_factor + return self.accelerator.prepare(DataLoader(train_dataset, **dataloader_params)) + + def _get_train_sampler(self, dataset=None) -> Sampler: + if dataset is None: + dataset = self.train_dataset + return RepeatSampler( + data_source=dataset, + mini_repeat_count=self.num_generations, + batch_size=self.args.generation_batch_size // self.num_generations, + repeat_count=self.num_iterations * self.args.steps_per_generation, + shuffle=self.shuffle_dataset, + seed=self.args.seed, + ) + + def _get_eval_sampler(self, eval_dataset) -> Sampler: + return RepeatSampler( + data_source=eval_dataset, + mini_repeat_count=self.num_generations_eval, + seed=self.args.seed, + ) + + def training_step(self, model, inputs, num_items_in_batch): + # Gather spans forward+backward: the fused JSD computes the lm_head grad in backward. + with self._get_liger_zero3_lm_head_gather_ctx(model): + output = super().training_step(model, inputs, num_items_in_batch) + self._step += 1 + return output + + def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys=None): + if not isinstance(inputs, dict): + inputs = self._prepare_inputs(inputs) + with torch.no_grad(): + with self.compute_loss_context_manager(): + loss = self.compute_loss(model, inputs) + return loss.detach(), None, None + + def _prepare_inputs(self, generation_batch): + """Return the per-step training batch, regenerating rollouts and buffering them for reuse in train mode. + + In train mode, rollouts are generated once every `steps_per_generation * num_iterations` steps and split into + per-step slices reused until the next regeneration. In eval mode, every batch is freshly prepared. + """ + mode = "train" if self.model.training else "eval" + if mode == "train": + generate_every = self.args.steps_per_generation * self.num_iterations + if self._step % generate_every == 0 or self._buffered_inputs is None: + buffered_batch = self._prepare_training_batch(generation_batch) + self._buffered_inputs = split_tensor_dict(buffered_batch, self.args.steps_per_generation) + self._dispatch_self_distillation_callback( + "on_generation_batch_built", + generate_every=generate_every, + steps_per_generation=self.args.steps_per_generation, + ) + return self._buffered_inputs[self._step % self.args.steps_per_generation] + return self._prepare_training_batch(generation_batch) + + def _prepare_training_batch(self, inputs: list[dict[str, Any]]) -> TrainingBatch: + """Sample student rollouts and construct teacher prompts""" + batch = self.sample_rollouts(inputs) + mode = "train" if self.model.training else "eval" + self._record_completion_metrics(mode, batch) + prompts = [example["prompt"] for example in inputs] + privileged_contexts = [example.get("privileged_context") for example in inputs] + teacher_batch = self.teacher_context_builder.build( + prompts, + privileged_contexts, + batch["completion_ids"], + batch["completion_mask"], + ) + batch.update( + { + "teacher_input_ids": teacher_batch["teacher_input_ids"], + "teacher_attention_mask": teacher_batch["teacher_attention_mask"], + } + ) + + self._dispatch_self_distillation_callback( + "on_self_distillation_batch_prepared", + old_per_token_logps=batch.get("old_per_token_logps"), + prompt_ids=batch["prompt_ids"], + completion_ids=batch["completion_ids"], + teacher_input_ids=batch["teacher_input_ids"], + teacher_attention_mask=batch["teacher_attention_mask"], + ) + return batch + + def sample_rollouts(self, inputs: list[dict[str, Any]]) -> TrainingBatch: + """Generate completions for a batch of prompts and assemble the training batch.""" + prompts = [example["prompt"] for example in inputs] + privileged_contexts = [example.get("privileged_context") for example in inputs] + + student_prompt_ids_list = self._tokenize_prompts(prompts) + if self.generate_from_teacher: + generation_prompts = self.teacher_context_builder.select_generation_prompts(prompts, privileged_contexts) + generation_prompt_ids_list = self._tokenize_prompts(generation_prompts) + else: + generation_prompts = prompts + generation_prompt_ids_list = student_prompt_ids_list + + self._dispatch_self_distillation_callback( + "on_generation_prompts_selected", + generation_prompts=generation_prompts, + generation_prompt_text=None, + ) + + _, completion_ids_list = self._generate(generation_prompt_ids_list) + device = self.accelerator.device + prompt_ids = [torch.tensor(ids) for ids in student_prompt_ids_list] + prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids] + prompt_ids = pad(prompt_ids, padding_value=self._tokenizer.pad_token_id, padding_side="left").to(device=device) + prompt_mask = pad(prompt_mask, padding_value=0, padding_side="left").to(device=device) + + completion_ids = [torch.tensor(ids) for ids in completion_ids_list] + completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids] + completion_ids = pad(completion_ids, padding_value=self._tokenizer.pad_token_id, padding_side="right").to( + device=device + ) + completion_mask = pad(completion_mask, padding_value=0, padding_side="right").to(device=device) + + old_per_token_logps = None + if not self.generate_from_teacher: + old_per_token_logps = self._compute_rollout_logps( + prompt_ids=prompt_ids, + prompt_mask=prompt_mask, + completion_ids=completion_ids, + completion_mask=completion_mask, + ) + batch: TrainingBatch = { + "prompt_ids": prompt_ids, + "prompt_mask": prompt_mask, + "completion_ids": completion_ids, + "completion_mask": completion_mask, + "raw_completion_lengths": torch.tensor( + [len(ids) for ids in completion_ids_list], device=device, dtype=torch.long + ), + } + if old_per_token_logps is not None: + batch["old_per_token_logps"] = old_per_token_logps + return batch + + def _get_completion_ids_list(self, batch: TrainingBatch) -> list[list[int]]: + raw_completion_lengths = batch["raw_completion_lengths"].detach().cpu().tolist() + return [ + ids[:length].tolist() + for ids, length in zip(batch["completion_ids"].detach().cpu(), raw_completion_lengths, strict=True) + ] + + def _tokenize_prompts(self, prompts: list[Any]) -> list[list[int]]: + if is_conversational({"prompt": prompts[0]}): + tokenized = self.processing_class.apply_chat_template( + conversation=prompts, + add_generation_prompt=True, + tokenize=True, + return_dict=True, + **self.chat_template_kwargs, + ) + prompt_ids = tokenized["input_ids"] + else: + prompt_ids = self.processing_class(text=prompts)["input_ids"] + if self.max_prompt_length is not None: + prompt_ids = [ids[-self.max_prompt_length :] for ids in prompt_ids] + return prompt_ids + + def _generate(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]: + if self.use_vllm: + return self._generate_vllm(prompt_ids) + return self._generate_transformers(prompt_ids) + + def _generate_vllm(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]: + if self.state.global_step != self._last_loaded_step: + self.vllm_generation.sync_weights() + self._last_loaded_step = self.state.global_step + + mode = "train" if self.model.training else "eval" + num_generations = self.num_generations if mode == "train" else self.num_generations_eval + prompt_ids_out, completion_ids_list, _, _ = self.vllm_generation.generate( + prompts=prompt_ids, + images=None, + num_generations=num_generations, + ) + return prompt_ids_out, completion_ids_list + + def _generate_transformers(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]: + device = self.accelerator.device + prompt_tensors = [torch.tensor(ids) for ids in prompt_ids] + padded_ids = pad(prompt_tensors, padding_value=self._tokenizer.pad_token_id, padding_side="left").to( + device=device + ) + attention_mask = pad([torch.ones_like(t) for t in prompt_tensors], padding_value=0, padding_side="left").to( + device=device + ) + generate_inputs: dict[str, torch.Tensor | Any] = {"input_ids": padded_ids, "attention_mask": attention_mask} + + with ( + unwrap_model_for_generation( + self.model_wrapped, + self.accelerator, + gather_deepspeed3_params=self.args.ds3_gather_for_generation, + generation_kwargs=self.generation_kwargs, + ) as unwrapped_model, + torch.no_grad(), + FSDP.summon_full_params(self.model_wrapped, recurse=False) if self.is_fsdp_enabled else nullcontext(), + ): + prompt_completion_ids = unwrapped_model.generate( + **generate_inputs, generation_config=self.generation_config + ) + + prompt_length = generate_inputs["input_ids"].size(1) + completion_ids = prompt_completion_ids[:, prompt_length:] + is_eos = completion_ids == self._tokenizer.eos_token_id + eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device) + eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)] + seq_idx = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1) + completion_mask = (seq_idx <= eos_idx.unsqueeze(1)).int() + completion_ids_list = [ + c[m].tolist() for c, m in zip(completion_ids.cpu(), completion_mask.bool().cpu(), strict=True) + ] + return prompt_ids, completion_ids_list + + def _compute_rollout_logps( + self, + prompt_ids: torch.Tensor, + prompt_mask: torch.Tensor, + completion_ids: torch.Tensor, + completion_mask: torch.Tensor, + ) -> torch.Tensor | None: + generate_every = self.args.steps_per_generation * self.num_iterations + old_per_token_logps = None + + if self.args.gradient_accumulation_steps % generate_every != 0: + prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + logits_to_keep = completion_ids.size(1) + with torch.no_grad(): + logits = self._forward_logits( + self.model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + ) + old_per_token_logps = selective_log_softmax(logits, completion_ids) + + return old_per_token_logps + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + if return_outputs: + raise ValueError("The SDFTTrainer does not support returning outputs") + + if self.use_teacher_server: + loss = self._compute_server_distillation_loss(model, inputs) + elif self.use_liger_loss: + loss = self._compute_liger_loss(model, inputs) + else: + distillation_logits = self._compute_teacher_student_logits(model, self.teacher_model, inputs) + loss = self._compute_self_distillation_loss(model, inputs, distillation_logits) + accumulation_scale = self.current_gradient_accumulation_steps if self.model.training else 1.0 + return loss / accumulation_scale + + def _compute_self_distillation_loss( + self, + model, + inputs: TrainingBatch, + distillation_logits: DistillationLogits, + ) -> torch.Tensor: + """Compute the per-token distillation loss and aggregate by normalizing over sequence length. + + Dispatches between three objectives based on `distillation_mode`: + + - `"topk_logits"`: top-k approximation of the divergence, optionally with a tail bucket for the remaining + probability mass (`distillation_add_tail`). + - `"full_logits"`: full-vocab divergence. + - `"sampled_token"`: token-level (reverse-KL) distillation on sampled `completion_ids`. + + When `distillation_is_clip` is set and `old_per_token_logps` are available, the loss is corrected by a clipped + importance-sampling ratio between the current student and the student at rollout time. + """ + if distillation_logits.loss_mask.sum() == 0: + mode = "train" if model.training else "eval" + self._log_self_distillation_metric(mode, 0.0) + # Keep the zero loss attached to the student graph so backward produces zero gradients instead of stopping. + return distillation_logits.student_logits.sum() * 0.0 + + if self.args.distillation_mode == "topk_logits": + if self.args.distillation_topk is None: + raise ValueError("`distillation_mode='topk_logits'` requires `distillation_topk` to be set.") + per_token_loss = compute_topk_self_distillation_loss( + distillation_logits.student_logits, + distillation_logits.teacher_logits, + distillation_topk=self.args.distillation_topk, + distillation_alpha=self.args.distillation_alpha, + distillation_add_tail=self.args.distillation_add_tail, + ) + elif self.args.distillation_mode == "full_logits": + per_token_loss = compute_full_logit_self_distillation_loss( + distillation_logits.student_logits, + distillation_logits.teacher_logits, + distillation_alpha=self.args.distillation_alpha, + ) + elif self.args.distillation_mode == "sampled_token": + per_token_loss = compute_sampled_token_self_distillation_loss( + distillation_logits.student_logits, + distillation_logits.teacher_logits, + distillation_logits.completion_ids, + distillation_alpha=self.args.distillation_alpha, + ) + else: + raise ValueError( + "distillation_mode must be one of: 'sampled_token', 'full_logits', 'topk_logits', " + f"got {self.args.distillation_mode!r}" + ) + + old_per_token_logps = inputs.get("old_per_token_logps") + if self.args.distillation_is_clip is not None and old_per_token_logps is not None: + student_per_token_logps = selective_log_softmax( + distillation_logits.student_logits, + distillation_logits.completion_ids, + ) + per_token_loss = apply_importance_sampling_clipping( + per_token_loss, + student_per_token_logps, + old_per_token_logps, + self.args.distillation_is_clip, + ) + + loss = (per_token_loss * distillation_logits.loss_mask).sum(-1) / distillation_logits.loss_mask.sum(-1).clamp( + min=1.0 + ) + loss = loss.mean() + + mode = "train" if model.training else "eval" + mean_distill_loss = ( + per_token_loss * distillation_logits.loss_mask + ).sum() / distillation_logits.loss_mask.sum().clamp(min=1.0) + self._log_self_distillation_metric( + mode, + self.accelerator.gather(mean_distill_loss).mean().item(), + ) + return loss + + def _compute_server_distillation_loss(self, model, inputs: TrainingBatch) -> torch.Tensor: + """Distillation loss with teacher logprobs served by the vLLM generation server (`teacher_model_kind='live'`). + + The student is forwarded locally (grad) for its logits; the teacher logprobs are fetched from the server (no + local teacher forward). `sampled_token` distills the realized token (reverse KL); `topk_logits` distills over + the teacher's own top-k support (the server cannot score the student's top-k indices). + """ + # Buffered batches are reused across optimizer steps (`num_iterations > 1`), so the server weights can lag the + # live student; re-sync before scoring. + if self.state.global_step != self._last_loaded_step: + self.vllm_generation.sync_weights() + # Only the main process pushes weights to the server, so hold every rank here until the push completes; + # otherwise non-main ranks could score against half-updated weights. + self.accelerator.wait_for_everyone() + self._last_loaded_step = self.state.global_step + + completion_ids = inputs["completion_ids"] + completion_mask = inputs["completion_mask"] + logits_to_keep = completion_ids.size(1) + + # SDFT skips the first few completion tokens in the distillation loss to suppress teacher-prompt artifacts. + loss_mask = completion_mask + if self.num_loss_tokens_to_skip > 0: + token_positions = torch.arange(completion_mask.size(1), device=completion_mask.device).unsqueeze(0) + loss_mask = completion_mask * (token_positions >= self.num_loss_tokens_to_skip).long() + + student_input_ids = torch.cat([inputs["prompt_ids"], completion_ids], dim=1) + student_attention_mask = torch.cat([inputs["prompt_mask"], completion_mask], dim=1) + student_logits = self._forward_logits( + model=model, + input_ids=student_input_ids, + attention_mask=student_attention_mask, + logits_to_keep=logits_to_keep, + ) + + mode = "train" if model.training else "eval" + teacher = self._get_teacher_token_logprobs_from_server(inputs, logits_to_keep) + # Padding positions come back as `-inf`; the masked-out positions are neutralized to finite values below so the + # divergence does not leak `+inf` through them (mirrors the distillation trainer). + required = loss_mask.bool() + student_per_token_logps = selective_log_softmax(student_logits, completion_ids) + + teacher_per_token_logps = teacher["actual_logprobs"] + if (required & ~torch.isfinite(teacher_per_token_logps)).any(): + raise ValueError("Teacher server returned no logprob for a required completion token.") + teacher_per_token_logps = torch.where( + required, teacher_per_token_logps, torch.zeros_like(teacher_per_token_logps) + ) + + # Diagnostic for disagreement between local student scores and server teacher scores on realized tokens. + # Sudden jumps can indicate stale server weights or numerical drift. + abs_diff = ((student_per_token_logps.detach() - teacher_per_token_logps).abs() * loss_mask).sum() / ( + loss_mask.sum().clamp(min=1.0) + ) + self._metrics[mode]["self_distillation/server_logprob_abs_diff"].append( + self.accelerator.gather(abs_diff).mean().item() + ) + + if self.args.distillation_mode == "sampled_token": + # Reverse-KL token-level objective, matching `compute_sampled_token_self_distillation_loss`. + per_token_loss = (student_per_token_logps - teacher_per_token_logps).detach() * student_per_token_logps + else: + teacher_topk_logps = teacher["topk_logprobs"] + teacher_topk_ids = teacher["topk_token_ids"] + # Project the student onto the teacher's top-k support, then renormalize (or add a tail bucket) before the + # divergence, matching `compute_topk_self_distillation_loss` on the teacher's support. + keep = required.unsqueeze(-1) + student_topk_logps = torch.gather( + torch.log_softmax(student_logits, dim=-1), dim=-1, index=teacher_topk_ids + ) + student_topk_logps = torch.where(keep, student_topk_logps, torch.zeros_like(student_topk_logps)) + teacher_topk_logps = torch.where(keep, teacher_topk_logps, torch.zeros_like(teacher_topk_logps)) + if self.args.distillation_add_tail: + student_topk_logps = add_tail_bucket(student_topk_logps) + teacher_topk_logps = add_tail_bucket(teacher_topk_logps) + else: + student_topk_logps = student_topk_logps - torch.logsumexp(student_topk_logps, dim=-1, keepdim=True) + teacher_topk_logps = teacher_topk_logps - torch.logsumexp(teacher_topk_logps, dim=-1, keepdim=True) + per_token_loss = compute_divergence(student_topk_logps, teacher_topk_logps, self.args.distillation_alpha) + + old_per_token_logps = inputs.get("old_per_token_logps") + if self.args.distillation_is_clip is not None and old_per_token_logps is not None: + per_token_loss = apply_importance_sampling_clipping( + per_token_loss, student_per_token_logps, old_per_token_logps, self.args.distillation_is_clip + ) + + loss = (per_token_loss * loss_mask).sum(-1) / loss_mask.sum(-1).clamp(min=1.0) + loss = loss.mean() + mean_distill_loss = (per_token_loss * loss_mask).sum() / loss_mask.sum().clamp(min=1.0) + self._log_self_distillation_metric(mode, self.accelerator.gather(mean_distill_loss).mean().item()) + return loss + + def _get_teacher_token_logprobs_from_server( + self, inputs: TrainingBatch, logits_to_keep: int + ) -> dict[str, torch.Tensor]: + """Per-token teacher logprobs from the vLLM server. + + Returns a dict with `actual_logprobs` (`(B, T)`, the realized-token logprob for reverse KL) and `topk_logprobs` + / `topk_token_ids` (`(B, T, K)`, the teacher's top-k support for top-k logit distillation). Completions are + right-padded, so server values fill the leading positions of each row and the trailing padding keeps the `-inf` + / `0` sentinels (neutralized by the caller). + """ + import numpy as np + + teacher_input_ids = inputs["teacher_input_ids"] + teacher_attention_mask = inputs["teacher_attention_mask"] + device = teacher_input_ids.device + batch_size = teacher_input_ids.size(0) + prompt_attention_mask = teacher_attention_mask[:, : teacher_attention_mask.size(1) - logits_to_keep] + if self.args.distillation_mode == "topk_logits" and self.args.distillation_topk is None: + raise ValueError("`distillation_mode='topk_logits'` requires `distillation_topk` to be set.") + top_logprobs = self.args.distillation_topk if self.args.distillation_mode == "topk_logits" else 1 + + sequences, prompt_lengths, _ = build_teacher_request_inputs( + teacher_input_ids, teacher_attention_mask, prompt_attention_mask + ) + result = self.teacher_client.get_sequence_logprobs( + sequences=sequences, + prompt_lengths=prompt_lengths, + top_logprobs=top_logprobs, + temperature=self.temperature, + ) + + actual = np.full((batch_size, logits_to_keep), float("-inf"), dtype=np.float32) + topk = np.full((batch_size, logits_to_keep, top_logprobs), float("-inf"), dtype=np.float32) + topk_ids = np.zeros((batch_size, logits_to_keep, top_logprobs), dtype=np.int64) + for i in range(batch_size): + seq_actual = result["actual_logprobs"][i] + n = min(len(seq_actual), logits_to_keep) + if n: + actual[i, :n] = np.array(seq_actual, dtype=np.float32)[:n, 0] + topk[i, :n] = np.array(result["logprobs"][i], dtype=np.float32)[:n] + topk_ids[i, :n] = np.array(result["logprob_token_ids"][i], dtype=np.int64)[:n] + return { + "actual_logprobs": torch.from_numpy(actual).to(device), + "topk_logprobs": torch.from_numpy(topk).to(device), + "topk_token_ids": torch.from_numpy(topk_ids).to(device), + } + + def _compute_teacher_student_logits( + self, + model, + teacher_model, + inputs: TrainingBatch, + ) -> DistillationLogits: + """Compute the per-token logits of the student and teacher over the completion tokens. + + The student is forwarded on its own input (original prompt plus the sampled completion) while the teacher is + forwarded on its input (prompt, privileged context, and the same completion). Both sets of logits are aligned + to the completion tokens so they can be compared position-by-position in the distillation loss. + + The teacher forward runs under `torch.no_grad()` and the context resolved by + `_get_teacher_context_for_self_distillation`, which routes it to the correct weights. + """ + prompt_ids = inputs["prompt_ids"] + prompt_mask = inputs["prompt_mask"] + completion_ids = inputs["completion_ids"] + completion_mask = inputs["completion_mask"] + logits_to_keep = completion_ids.size(1) + + # SDFT skips the first few completion tokens in the distillation loss to suppress teacher-prompt artifacts. + loss_mask = completion_mask + if self.num_loss_tokens_to_skip > 0: + token_positions = torch.arange(completion_mask.size(1), device=completion_mask.device).unsqueeze(0) + loss_mask = completion_mask * (token_positions >= self.num_loss_tokens_to_skip).long() + + student_input_ids = torch.cat([prompt_ids, completion_ids], dim=1) + student_attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + student_logits = self._forward_logits( + model=model, + input_ids=student_input_ids, + attention_mask=student_attention_mask, + logits_to_keep=logits_to_keep, + ) + + with torch.no_grad(), self._get_teacher_context_for_self_distillation(): + teacher_logits = self._forward_logits( + model=teacher_model, + input_ids=inputs["teacher_input_ids"], + attention_mask=inputs["teacher_attention_mask"], + logits_to_keep=logits_to_keep, + ) + + return DistillationLogits( + completion_ids=completion_ids, + loss_mask=loss_mask, + student_logits=student_logits, + teacher_logits=teacher_logits, + ) + + def _forward_logits( + self, + model, + input_ids: torch.Tensor, + attention_mask: torch.Tensor, + logits_to_keep: int, + ) -> torch.Tensor: + """Forward the model and return temperature-scaled logits aligned to the completion tokens.""" + model_inputs = { + "input_ids": input_ids, + "attention_mask": attention_mask, + "use_cache": False, + } + if "logits_to_keep" in self.model_kwarg_keys: + model_inputs["logits_to_keep"] = logits_to_keep + 1 + + logits = model(**model_inputs).logits + logits = logits[:, :-1, :] + logits = logits[:, -logits_to_keep:, :] + return logits / self.temperature + + def _compute_liger_loss(self, model, inputs: TrainingBatch) -> torch.Tensor: + """`full_logits` distillation via the Liger fused JSD kernel: forwards the base models for hidden states and + fuses the lm_head projection with the divergence, never materializing the full-vocab logits. + + Each model is forwarded through its own wrapper via `_forward_redirection` so FSDP2/DeepSpeed materialize the + sharded params during the unwrapped base forward. The fused kernel needs both lm_head weights live at once, so + the frozen teacher weight is captured while the teacher is materialized and handed to the student pass. + """ + logits_to_keep = inputs["completion_ids"].size(1) + completion_mask = inputs["completion_mask"] + loss_mask = completion_mask + if self.num_loss_tokens_to_skip > 0: + token_positions = torch.arange(completion_mask.size(1), device=completion_mask.device).unsqueeze(0) + loss_mask = completion_mask * (token_positions >= self.num_loss_tokens_to_skip).long() + + unwrapped_student = self.accelerator.unwrap_model(model) + unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model) + + with torch.no_grad(), self._get_teacher_context_for_self_distillation(): + teacher_hidden, teacher_weight, teacher_bias = self._forward_redirection( + self.teacher_model, + unwrapped_teacher, + self._liger_teacher_side, + unwrapped_teacher, + inputs, + logits_to_keep, + ) + + return self._forward_redirection( + model, + unwrapped_student, + self._liger_student_loss, + unwrapped_student, + inputs, + logits_to_keep, + loss_mask, + teacher_hidden, + teacher_weight, + teacher_bias, + ) + + def _liger_teacher_side(self, teacher, inputs: TrainingBatch, logits_to_keep: int): + """Teacher hidden states + frozen lm_head weight, captured while the teacher params are materialized.""" + hidden = teacher.get_decoder()( + input_ids=inputs["teacher_input_ids"], + attention_mask=inputs["teacher_attention_mask"], + use_cache=False, + ).last_hidden_state + hidden = hidden[:, :-1][:, -logits_to_keep:] + head = teacher.get_output_embeddings() + # Clone so the weight survives re-sharding once this forward context exits. + weight = head.weight.detach().clone() + bias = head.bias.detach().clone() if head.bias is not None else None + return hidden, weight, bias + + def _liger_student_loss( + self, + student, + inputs: TrainingBatch, + logits_to_keep, + loss_mask, + teacher_hidden, + teacher_weight, + teacher_bias, + ): + student_input_ids = torch.cat([inputs["prompt_ids"], inputs["completion_ids"]], dim=1) + student_attention_mask = torch.cat([inputs["prompt_mask"], inputs["completion_mask"]], dim=1) + student_hidden = student.get_decoder()( + input_ids=student_input_ids, + attention_mask=student_attention_mask, + use_cache=False, + ).last_hidden_state + # Align hidden states to the completion-predicting positions, matching `_forward_logits`. + student_hidden = student_hidden[:, :-1][:, -logits_to_keep:] + + # `ignore_index` masks non-response positions; the token values only feed the disabled hard-CE term. + completion_ids = inputs["completion_ids"] + true_labels = torch.where(loss_mask.bool(), completion_ids, torch.full_like(completion_ids, -100)) + + student_head = student.get_output_embeddings() + # Per-sequence then batch mean (grpo), matching the non-Liger path: the fused kernel reduces by total tokens + # (bnpo), so we call it per sequence and average. + seq_losses = [ + self.liger_jsd_loss( + student_input=student_hidden[i], + student_weight=student_head.weight, + teacher_input=teacher_hidden[i], + teacher_weight=teacher_weight, + true_labels=true_labels[i], + student_bias=student_head.bias, + teacher_bias=teacher_bias, + ) + for i in range(student_hidden.size(0)) + ] + loss = torch.stack(seq_losses).mean() + + mode = "train" if student.training else "eval" + self._log_self_distillation_metric(mode, self.accelerator.gather(loss.detach()).mean().item()) + return loss + + def _get_liger_zero3_lm_head_gather_ctx(self, model): + """Gather the sharded student/teacher lm_head weights for the fused matmul under ZeRO-3. Liger reads + `lm_head.weight` by attribute, so the gather hook never fires; the decoder forward gathers itself. No-op + outside ZeRO-3.""" + if not self.use_liger_loss: + return nullcontext() + + deepspeed_plugin = self.accelerator.state.deepspeed_plugin + if deepspeed_plugin is None or deepspeed_plugin.zero_stage != 3: + return nullcontext() + + import deepspeed + + unwrapped_student = self.accelerator.unwrap_model(model) + unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model) + student_head = unwrapped_student.get_output_embeddings() + teacher_head = unwrapped_teacher.get_output_embeddings() + params = [student_head.weight, teacher_head.weight] + if student_head.bias is not None: + params.append(student_head.bias) + if teacher_head.bias is not None: + params.append(teacher_head.bias) + return deepspeed.zero.GatheredParameters(params, modifier_rank=None) + + def _get_teacher_context_for_self_distillation(self): + """Return the context manager that routes the teacher forward to the correct weights. + + For non-PEFT models this is a no-op. For PEFT models: + + - `teacher_model_kind == "base"`: disable the student adapter so the teacher forward uses the base weights. + - `teacher_model_kind == "ema"` under pure-LoRA training: switch to the `"teacher"` LoRA adapter. + - otherwise: no-op; the teacher is a separate deepcopy. + """ + teacher_model_kind = self.args.teacher_model_kind + if not is_peft_model(self.model): + return nullcontext() + + target_model = self.accelerator.unwrap_model(self.teacher_model) + + if teacher_model_kind == "base": + return use_adapter(target_model, adapter_name=None) + if teacher_model_kind == "ema" and self._use_peft_ema_teacher_adapter(): + return use_adapter(target_model, adapter_name="teacher") + return nullcontext() + + def _record_completion_metrics(self, mode: str, batch: TrainingBatch) -> None: + device = self.accelerator.device + completion_ids_list = self._get_completion_ids_list(batch) + agg_completion_lengths = self.accelerator.gather(batch["raw_completion_lengths"]) + self._metrics[mode]["completions/mean_length"].append(agg_completion_lengths.float().mean().item()) + self._metrics[mode]["completions/min_length"].append(agg_completion_lengths.float().min().item()) + self._metrics[mode]["completions/max_length"].append(agg_completion_lengths.float().max().item()) + + eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id] + is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device) + agg_is_truncated = self.accelerator.gather(is_truncated) + self._metrics[mode]["completions/clipped_ratio"].append(agg_is_truncated.float().mean().item()) + term_completion_lengths = agg_completion_lengths[~agg_is_truncated] + if len(term_completion_lengths) == 0: + term_completion_lengths = torch.zeros(1, device=device) + self._metrics[mode]["completions/mean_terminated_length"].append(term_completion_lengths.float().mean().item()) + self._metrics[mode]["completions/min_terminated_length"].append(term_completion_lengths.float().min().item()) + self._metrics[mode]["completions/max_terminated_length"].append(term_completion_lengths.float().max().item()) + + def _log_self_distillation_metric(self, mode: str, value: float) -> None: + metric_prefix = self._name.lower().replace(" ", "_") + self._metrics[mode]["self_distillation/distillation_loss"].append(value) + self._metrics[mode][f"{metric_prefix}/distillation_loss"].append(value) + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + metrics = {k: sum(v) / len(v) for k, v in self._metrics[mode].items() if v} + if mode == "eval": + metrics = {f"eval_{k}": v for k, v in metrics.items()} + logs = {**logs, **metrics} + super().log(logs, start_time) + self._metrics[mode].clear() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/teacher_sync.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/teacher_sync.py new file mode 100644 index 0000000000000000000000000000000000000000..8fb0f751a0bb5f4ae69ce9d201b29c09263bf21c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdft/teacher_sync.py @@ -0,0 +1,184 @@ +# Copyright 2020-2026 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 logging + +import torch +from accelerate.utils import is_peft_model +from transformers import ( + TrainerCallback, + TrainerControl, + TrainerState, + TrainingArguments, +) + +from ...trainer.callbacks import SyncRefModelCallback + + +logger = logging.getLogger(__name__) + + +def is_pure_lora_training(model, accelerator=None) -> bool: + """Return `True` when the active adapter is LoRA and every trainable parameter is a LoRA parameter.""" + if not is_peft_model(model): + return False + + if accelerator is not None: + model = accelerator.unwrap_model(model) + + adapter_name = model.active_adapter + if adapter_name is None: + adapter_name = "default" + adapter_config = model.peft_config.get(adapter_name) + peft_type = adapter_config.peft_type + if peft_type is None or str(peft_type).split(".")[-1] != "LORA": + return False + + for name, param in model.named_parameters(): + if param.requires_grad and "lora_" not in name: + return False + return True + + +class SyncTeacherModelCallback(SyncRefModelCallback): + """Synchronize an EMA teacher model with the student model on each configured sync step.""" + + def __init__(self, teacher_model, accelerator=None): + super().__init__(ref_model=teacher_model, accelerator=accelerator) + + def on_step_end(self, args, state, control, **kwargs): + model = kwargs["model"] + if self.ref_model is not None and state.global_step % args.teacher_sync_steps == 0: + if self.accelerator: + model = self.accelerator.unwrap_model(model) + self.sync_target_model(model, self.ref_model, args.teacher_update_rate) + + +class PEFTAdapterEMACallback(TrainerCallback): + """ + Callback that maintains an EMA copy of PEFT adapter weights for use as a teacher model in self-distillation. + + The callback creates a secondary adapter ("teacher") with zero-initialized weights and maintains shadow weights + that are updated via exponential moving average: `teacher_weight = (1-α) * teacher_weight + α * student_weight` + + Usage: + ```python + trainer.add_callback( + PEFTAdapterEMACallback( + model=model, + teacher_adapter_name="teacher", + update_rate=0.05, + ) + ) + ``` + """ + + def __init__( + self, + model, + teacher_adapter_name: str = "teacher", + update_rate: float = 0.05, + sync_steps: int = 1, + accelerator=None, + ): + self.model = model + self.teacher_adapter_name = teacher_adapter_name + self.update_rate = update_rate + self.sync_steps = sync_steps + self.accelerator = accelerator + self.shadow_weights: dict[str, torch.Tensor] | None = None + self.teacher_adapter_config = None + self._initialized = False + + def _get_student_state_dict(self): + """Get student adapter state dict using PEFT keys (without adapter name).""" + from peft import get_peft_model_state_dict + + if self.accelerator is not None: + model = self.accelerator.unwrap_model(self.model) + else: + model = self.model + return get_peft_model_state_dict(model) + + def _initialize_teacher_adapter(self): + """Create teacher adapter with zero weights initialized from student adapter.""" + from peft import get_peft_model_state_dict, set_peft_model_state_dict + + if self._initialized: + return + + if self.accelerator is not None: + model = self.accelerator.unwrap_model(self.model) + else: + model = self.model + + adapter_name = model.active_adapter + if adapter_name is None: + adapter_name = "default" + + self.teacher_adapter_config = model.peft_config.get(adapter_name) + + student_state = get_peft_model_state_dict(model) + + teacher_state = {k: torch.zeros_like(v) for k, v in student_state.items()} + + model.add_adapter(self.teacher_adapter_name, self.teacher_adapter_config) + + model.set_adapter(self.teacher_adapter_name) + set_peft_model_state_dict(model, teacher_state, adapter_name=self.teacher_adapter_name) + + model.set_adapter(adapter_name) + + self.shadow_weights = {k: v.clone().zero_() for k, v in teacher_state.items()} + + self._initialized = True + logger.info(f"Initialized PEFT adapter EMA teacher with adapter name: {self.teacher_adapter_name}") + + @torch.no_grad() + def on_step_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs): + if state.global_step % self.sync_steps != 0: + return + + if not self._initialized: + self._initialize_teacher_adapter() + + if self.shadow_weights is None: + return + + if self.accelerator is None and "accelerator" in kwargs: + self.accelerator = kwargs["accelerator"] + + student_state = self._get_student_state_dict() + + for key, student_param in student_state.items(): + if key in self.shadow_weights: + shadow = self.shadow_weights[key] + shadow.data = (1 - self.update_rate) * shadow.data + self.update_rate * student_param.data + + from peft import set_peft_model_state_dict + + if self.accelerator is not None: + unwrapped_model = self.accelerator.unwrap_model(self.model) + else: + unwrapped_model = self.model + + original_adapter = unwrapped_model.active_adapter + unwrapped_model.set_adapter(self.teacher_adapter_name) + set_peft_model_state_dict(unwrapped_model, self.shadow_weights, adapter_name=self.teacher_adapter_name) + unwrapped_model.set_adapter(original_adapter) + + def on_train_begin(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs): + if self.accelerator is None and "accelerator" in kwargs: + self.accelerator = kwargs["accelerator"] + self._initialize_teacher_adapter() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f50a54cf7c8d3dcc907361da9caa07e53cd21d9f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .sdpo_config import SDPOConfig +from .sdpo_trainer import SDPOTrainer + + +__all__ = ["SDPOConfig", "SDPOTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/loss_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/loss_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..5caa8c88713d2088c9c4c728dcea3e62236cf4e4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/loss_utils.py @@ -0,0 +1,135 @@ +# Copyright 2020-2026 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. + +"""Pure helper functions for self-distillation loss computation.""" + +import torch +import torch.nn.functional as F + +from ...trainer.utils import selective_log_softmax + + +def compute_divergence( + student_log_probs: torch.Tensor, + teacher_log_probs: torch.Tensor, + alpha: float, +) -> torch.Tensor: + if alpha == 0.0: + kl = F.kl_div(student_log_probs, teacher_log_probs, reduction="none", log_target=True) + elif alpha == 1.0: + kl = F.kl_div(teacher_log_probs, student_log_probs, reduction="none", log_target=True) + else: + alpha_t = torch.tensor(alpha, dtype=student_log_probs.dtype, device=student_log_probs.device) + mixture = torch.logsumexp( + torch.stack([student_log_probs + torch.log(1 - alpha_t), teacher_log_probs + torch.log(alpha_t)]), + dim=0, + ) + kl_teacher = F.kl_div(mixture, teacher_log_probs, reduction="none", log_target=True) + kl_student = F.kl_div(mixture, student_log_probs, reduction="none", log_target=True) + kl = torch.lerp(kl_student, kl_teacher, alpha) + return kl.sum(-1) + + +def add_tail_bucket(log_probs: torch.Tensor) -> torch.Tensor: + """Append a bucket holding the leftover probability mass to a top-k log-prob support. + + `log_probs` are true log-probabilities over a top-k subset, so they sum to the captured mass `P_topk <= 1`. This + appends one extra category equal to the tail mass `1 - P_topk`, yielding a distribution that sums to exactly 1. + """ + log_s = torch.logsumexp(log_probs, dim=-1, keepdim=True) + log_s = torch.clamp(log_s, max=-1e-7) + tail_log = torch.log(-torch.expm1(log_s)) + return torch.cat([log_probs, tail_log], dim=-1) + + +def apply_importance_sampling_clipping( + per_token_loss: torch.Tensor, + student_log_probs: torch.Tensor, + old_log_probs: torch.Tensor, + clip_coeff: float, +) -> torch.Tensor: + negative_approx_kl = (student_log_probs - old_log_probs).detach() + negative_approx_kl = torch.clamp(negative_approx_kl, min=-20.0, max=20.0) + ratio = torch.exp(negative_approx_kl).clamp(max=clip_coeff) + return per_token_loss * ratio + + +def compute_topk_self_distillation_loss( + student_logits: torch.Tensor, + teacher_logits: torch.Tensor, + *, + distillation_topk: int, + distillation_alpha: float, + distillation_add_tail: bool, +) -> torch.Tensor: + """Compute distillation loss on the student's top-k token support. + + The student's top-k logits define the support. The teacher distribution is projected onto the same token indices. + The selected support is then either renormalized or augmented with a tail bucket before the divergence is computed. + """ + student_logsumexp = torch.logsumexp(student_logits, dim=-1, keepdim=True) + topk_student_logits, topk_indices = torch.topk(student_logits, k=distillation_topk, dim=-1) + topk_student_log_probs = topk_student_logits - student_logsumexp + + teacher_logsumexp = torch.logsumexp(teacher_logits, dim=-1, keepdim=True) + topk_teacher_logits = torch.gather(teacher_logits, dim=-1, index=topk_indices) + topk_teacher_log_probs = topk_teacher_logits - teacher_logsumexp + + # Top-k log-probs sum to the captured mass P_topk <= 1; the rest (1 - P_topk) is the "tail". + if distillation_add_tail: + # Lump the tail into one bucket so the divergence approximates the full-vocab divergence. + topk_student_log_probs = add_tail_bucket(topk_student_log_probs) + topk_teacher_log_probs = add_tail_bucket(topk_teacher_log_probs) + else: + # Drop the tail and renormalize the top-k to sum to 1: divergence over the top-k conditional only. + topk_student_log_probs = topk_student_log_probs - torch.logsumexp(topk_student_log_probs, dim=-1, keepdim=True) + topk_teacher_log_probs = topk_teacher_log_probs - torch.logsumexp(topk_teacher_log_probs, dim=-1, keepdim=True) + + return compute_divergence(topk_student_log_probs, topk_teacher_log_probs, distillation_alpha) + + +def compute_full_logit_self_distillation_loss( + student_logits: torch.Tensor, + teacher_logits: torch.Tensor, + *, + distillation_alpha: float, +) -> torch.Tensor: + """Compute full-vocabulary self-distillation loss between student and teacher logits.""" + student_log_probs = torch.log_softmax(student_logits, dim=-1) + teacher_log_probs = torch.log_softmax(teacher_logits, dim=-1) + return compute_divergence(student_log_probs, teacher_log_probs, distillation_alpha) + + +def compute_sampled_token_self_distillation_loss( + student_logits: torch.Tensor, + teacher_logits: torch.Tensor, + completion_ids: torch.Tensor, + *, + distillation_alpha: float, +) -> torch.Tensor: + """Compute token-level self-distillation loss only on the sampled completion tokens. + + This path compares student and teacher log-probabilities on the realized completion tokens rather than over a + larger token support. + """ + if distillation_alpha != 1.0: + raise ValueError( + "Only reverse KL (alpha=1.0) is supported for token-level distillation when " + f"`distillation_mode='sampled_token'`, got alpha={distillation_alpha}" + ) + + student_per_token_logps = selective_log_softmax(student_logits, completion_ids) + teacher_per_token_logps = selective_log_softmax(teacher_logits, completion_ids) + log_ratio = student_per_token_logps - teacher_per_token_logps + return log_ratio.detach() * student_per_token_logps diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/sdpo.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/sdpo.py new file mode 100644 index 0000000000000000000000000000000000000000..a49c6a8f547afb230017e322b47f72d88bac2bd8 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/sdpo.py @@ -0,0 +1,390 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# "peft", +# "math-verify", +# "latex2sympy2_extended", +# "trackio", +# "kernels", +# ] +# /// + +""" +Usage: + +```bash +python trl/experimental/sdpo/sdpo.py \ + --model_name_or_path Qwen/Qwen2.5-Math-1.5B-Instruct \ + --dataset_name openai/gsm8k \ + --dataset_config main \ + --output_dir outputs/sdpo-qwen35-2b-gsm8k \ + --learning_rate 5e-5 \ + --dtype bfloat16 \ + --bf16 true \ + --max_completion_length 128 \ + --use_peft \ + --lora_target_modules q_proj k_proj v_proj o_proj gate_proj up_proj down_proj \ + --per_device_train_batch_size 1 \ + --gradient_accumulation_steps 2 \ + --num_generations 8 \ + --generation_batch_size 32 \ + --distillation_alpha 1.0 \ + --distillation_mode sampled_token \ + --distillation_weight 0.5 \ + --report_to none \ + --eval_strategy steps \ + --eval_steps 1000 \ + --save_strategy no \ + --eval_num_prompts 0 \ + --accuracy_eval_num_examples 64 \ + --max_train_examples 256 \ + --max_eval_examples 128 +``` + +This example uses verifiable math rewards and reports answer accuracy before and after training. If your dataset +already contains textual environment feedback, pass the column name via `--feedback_column`; it will be forwarded as +`privileged_context` for SDPO reprompting. +""" + +import re +from dataclasses import dataclass, field +from typing import Any + +import torch +from datasets import DatasetDict, load_dataset, load_from_disk +from transformers import AutoTokenizer, GenerationConfig + +from trl import ( + LogCompletionsCallback, + ModelConfig, + ScriptArguments, + TrlParser, + get_kbit_device_map, + get_peft_config, + get_quantization_config, +) +from trl.data_utils import maybe_apply_chat_template +from trl.experimental.sdpo import SDPOConfig, SDPOTrainer + + +SYSTEM_PROMPT = ( + "A conversation between user and assistant. The user asks a question, and the assistant solves it. The assistant " + "first thinks about the reasoning process in the mind and then provides the user with the answer. The reasoning " + "must be enclosed within tags, and the final answer must be on its own line in the format " + "`#### `." +) + + +@dataclass +class SDPOScriptArguments(ScriptArguments): + dataset_path: str | None = field( + default=None, + metadata={"help": "Optional local dataset path to load with `load_from_disk`. Overrides `dataset_name`."}, + ) + feedback_column: str | None = field( + default=None, + metadata={ + "help": "Optional dataset column containing textual environment feedback to pass as `privileged_context`." + }, + ) + eval_num_prompts: int | None = field( + default=8, + metadata={"help": "Number of prompts to log during evaluation. Set to 0 to disable completion logging."}, + ) + accuracy_eval_num_examples: int | None = field( + default=128, + metadata={"help": "Optional number of eval examples to score for answer accuracy. Defaults to 128."}, + ) + accuracy_eval_max_new_tokens: int = field( + default=128, + metadata={"help": "Maximum completion length for answer-accuracy evaluation generation."}, + ) + feedback_from_solution: str | None = field( + default=None, + metadata={ + "help": "Optional synthesized feedback source when the dataset has no feedback column. Supported: " + "`final_answer`, `full_solution`." + }, + ) + max_train_examples: int | None = field( + default=None, + metadata={"help": "Optional cap on the number of training examples loaded from the selected train split."}, + ) + max_eval_examples: int | None = field( + default=None, + metadata={"help": "Optional cap on the number of evaluation examples loaded from the selected eval split."}, + ) + dataset_shuffle_seed: int = field( + default=42, + metadata={"help": "Random seed used before applying `max_train_examples` or `max_eval_examples`."}, + ) + + +@dataclass +class ExampleSDPOConfig(SDPOConfig): + scale_rewards: str = field( + default="group", + metadata={"help": "Reward normalization mode. Supported: `group`, `batch`, `none`."}, + ) + + +def _make_solution_feedback(final_answer: str, worked_solution: str, feedback_from_solution: str | None) -> str | None: + if feedback_from_solution is None: + return None + if feedback_from_solution == "final_answer": + return ( + "Your previous answer was incorrect. The correct final answer is:\n\n" + f"#### {final_answer}\n\n" + "Revise your reasoning and end with the same final answer format." + ) + if feedback_from_solution == "full_solution": + return ( + "Your previous answer was incorrect. Here is a correct worked solution:\n\n" + f"{worked_solution}\n\n" + "Use it to solve the original question correctly." + ) + raise ValueError("feedback_from_solution must be one of: `final_answer`, `full_solution`.") + + +def _make_conversation( + example: dict[str, Any], feedback_column: str | None, feedback_from_solution: str | None +) -> dict[str, Any]: + prompt = example.get("prompt") + if prompt is None and "problem" in example: + prompt = [ + {"role": "system", "content": SYSTEM_PROMPT}, + {"role": "user", "content": example["problem"]}, + ] + if prompt is None and "question" in example: + prompt = [ + {"role": "system", "content": SYSTEM_PROMPT}, + {"role": "user", "content": example["question"]}, + ] + + if prompt is None: + raise ValueError("Each example must provide one of: `prompt`, `problem`, or `question`.") + + output = {"prompt": prompt} + + solution = None + if "solution" in example: + solution = example["solution"] + elif "answer" in example: + solution = _normalize_gsm8k_answer(example["answer"]) + + if solution is not None: + output["solution"] = solution + + if feedback_column is not None and feedback_column in example: + output["privileged_context"] = example[feedback_column] + elif "privileged_context" in example: + output["privileged_context"] = example["privileged_context"] + elif solution is not None: + worked_solution = example.get("solution") + if worked_solution is None and "answer" in example: + worked_solution = example["answer"].strip() + if worked_solution is None: + worked_solution = f"#### {solution}" + synthesized_feedback = _make_solution_feedback(solution, worked_solution, feedback_from_solution) + if synthesized_feedback is not None: + output["privileged_context"] = synthesized_feedback + + return output + + +def _normalize_gsm8k_answer(answer_text: str) -> str: + if "####" not in answer_text: + return answer_text.strip() + return answer_text.split("####", 1)[1].strip().replace(",", "") + + +def _extract_predicted_answer(completion_text: str) -> str | None: + match = re.search(r"####\s*([^\n]+)", completion_text) + if match: + return match.group(1).strip().replace(",", "") + + matches = re.findall(r"(-?\$?[0-9][0-9,]*(?:\.[0-9]+)?)", completion_text) + if not matches: + return None + return matches[-1].replace("$", "").replace(",", "").strip() + + +def _gsm8k_accuracy_reward(completions, solution, **kwargs) -> list[float]: + rewards = [] + for completion, gold in zip(completions, solution, strict=True): + content = completion[0]["content"] if isinstance(completion, list) else completion + pred = _extract_predicted_answer(content) + rewards.append(1.0 if pred is not None and pred == gold else 0.0) + return rewards + + +def _gsm8k_soft_format_reward(completions, **kwargs) -> list[float]: + pattern = r".*?\s*####\s*[^\n]+" + rewards = [] + for completion in completions: + content = completion[0]["content"] if isinstance(completion, list) else completion + rewards.append(0.25 if re.match(pattern, content, flags=re.DOTALL) else 0.0) + return rewards + + +def _run_accuracy_eval( + trainer: SDPOTrainer, eval_dataset, max_new_tokens: int, num_examples: int | None, metric_prefix: str = "math_eval" +) -> dict[str, float]: + if num_examples is not None: + eval_dataset = eval_dataset.select(range(min(num_examples, len(eval_dataset)))) + + prompts = eval_dataset["prompt"] + prompt_texts = [ + maybe_apply_chat_template({"prompt": prompt}, trainer.processing_class)["prompt"] for prompt in prompts + ] + tokenized = trainer.processing_class( + text=prompt_texts, + return_tensors="pt", + padding=True, + padding_side="left", + truncation=True, + max_length=trainer.max_prompt_length, + add_special_tokens=False, + ) + tokenized = {key: value.to(trainer.accelerator.device) for key, value in tokenized.items()} + model = trainer.accelerator.unwrap_model(trainer.model) + was_training = model.training + model.eval() + with torch.no_grad(): + generated = model.generate( + **tokenized, + max_new_tokens=max_new_tokens, + do_sample=False, + pad_token_id=trainer.processing_class.pad_token_id, + eos_token_id=trainer.processing_class.eos_token_id, + ) + if was_training: + model.train() + + prompt_length = tokenized["input_ids"].shape[1] + completions = trainer.processing_class.batch_decode(generated[:, prompt_length:], skip_special_tokens=True) + completion_messages = [[{"role": "assistant", "content": completion}] for completion in completions] + rewards = _gsm8k_accuracy_reward(completion_messages, solution=eval_dataset["solution"]) + total = max(len(rewards), 1) + return { + f"{metric_prefix}/accuracy": sum(rewards) / total, + f"{metric_prefix}/num_scored": float(len(rewards)), + } + + +if __name__ == "__main__": + parser = TrlParser((SDPOScriptArguments, ExampleSDPOConfig, ModelConfig)) + script_args, training_args, model_args = parser.parse_args_and_config() + + dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype) + training_args.model_init_kwargs = dict( + revision=model_args.model_revision, + attn_implementation=model_args.attn_implementation, + dtype=dtype, + ) + quantization_config = get_quantization_config(model_args) + if quantization_config is not None: + training_args.model_init_kwargs["device_map"] = get_kbit_device_map() + training_args.model_init_kwargs["quantization_config"] = quantization_config + + if script_args.dataset_path is not None: + dataset = load_from_disk(script_args.dataset_path) + else: + dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config) + + if not isinstance(dataset, DatasetDict): + raise ValueError("SDPO example expects a dataset with named splits.") + + train_split = dataset[script_args.dataset_train_split] + if script_args.max_train_examples is not None: + train_split = train_split.shuffle(seed=script_args.dataset_shuffle_seed).select( + range(min(script_args.max_train_examples, len(train_split))) + ) + + train_dataset = train_split.map( + lambda example: _make_conversation(example, script_args.feedback_column, script_args.feedback_from_solution), + remove_columns=train_split.column_names, + ) + eval_dataset = None + if training_args.eval_strategy != "no": + eval_split = dataset[script_args.dataset_test_split] + if script_args.max_eval_examples is not None: + eval_split = eval_split.shuffle(seed=script_args.dataset_shuffle_seed).select( + range(min(script_args.max_eval_examples, len(eval_split))) + ) + + eval_dataset = eval_split.map( + lambda example: _make_conversation( + example, script_args.feedback_column, script_args.feedback_from_solution + ), + remove_columns=eval_split.column_names, + ) + + reward_funcs = [_gsm8k_soft_format_reward, _gsm8k_accuracy_reward] + + tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + trainer = SDPOTrainer( + model=model_args.model_name_or_path, + args=training_args, + reward_funcs=reward_funcs, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + peft_config=get_peft_config(model_args), + processing_class=tokenizer, + ) + + if eval_dataset is not None and script_args.eval_num_prompts: + generation_config = GenerationConfig( + max_new_tokens=training_args.max_completion_length, + do_sample=True, + temperature=training_args.temperature, + ) + trainer.add_callback( + LogCompletionsCallback(trainer, generation_config, num_prompts=script_args.eval_num_prompts) + ) + + if eval_dataset is not None: + pre_metrics = _run_accuracy_eval( + trainer, + eval_dataset, + max_new_tokens=script_args.accuracy_eval_max_new_tokens, + num_examples=script_args.accuracy_eval_num_examples, + ) + trainer.log_metrics("eval", {f"before_{k}": v for k, v in pre_metrics.items()}) + trainer.save_metrics("eval", {f"before_{k}": v for k, v in pre_metrics.items()}) + + trainer.train() + + trainer.save_model(training_args.output_dir) + if eval_dataset is not None: + post_metrics = _run_accuracy_eval( + trainer, + eval_dataset, + max_new_tokens=script_args.accuracy_eval_max_new_tokens, + num_examples=script_args.accuracy_eval_num_examples, + ) + after_metrics = {f"after_{k}": v for k, v in post_metrics.items()} + delta_metrics = { + f"delta_{k.split('/', 1)[1]}": after_metrics[f"after_{k}"] - pre_metrics[k] for k in pre_metrics + } + trainer.log_metrics("eval", after_metrics | delta_metrics) + trainer.save_metrics("eval", after_metrics | delta_metrics) + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name or script_args.dataset_path) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/sdpo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/sdpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..1981a6c4d6c82a39f68634a21aee2a712cd0d71a --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/sdpo_config.py @@ -0,0 +1,644 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Any, Literal + +from transformers import TrainingArguments + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class SDPOConfig(_BaseConfig): + r""" + Configuration class for the [`SDPOTrainer`]. + + Parameters: + > Parameters that control the online policy objective + + beta (`float`, *optional*, defaults to `0.0`): + KL coefficient. If `0.0` (default), the reference model is not loaded, reducing memory usage and improving + training speed. [DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement + learning](https://huggingface.co/papers/2501.12948) use a value of `0.001`. + epsilon (`float`, *optional*, defaults to `0.2`): + Epsilon value for clipping. + epsilon_high (`float`, *optional*): + Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the lower-bound + specified in argument `epsilon`. Paper DAPO recommends `0.28`. + importance_sampling_level (`str`, *optional*, defaults to `"token"`): + Controls whether importance sampling ratios are computed at the `'token'` or `'sequence'` level. `'token'` + keeps the raw per-token log-probability ratios (one weight per token). `'sequence'` averages the + log-probability ratios across valid tokens to produce a single ratio per sequence. The GSPO paper shows + that sequence-level sampling often yields more stable training and better alignment with sequence-level + rewards. + reward_weights (`list[float]`, *optional*): + Weights for each reward function. Must match the number of reward functions. If `None`, all rewards are + weighted equally with weight `1.0`. + scale_rewards (`str` or `bool`, *optional*, defaults to `"group"`): + Specifies the scaling strategy for rewards. Supported values are: `True` or `'group'` (default): rewards + are scaled by the standard deviation within each group, ensuring unit variance within a group. `'batch'`: + rewards are scaled by the standard deviation across the entire batch, as recommended in the PPO Lite paper. + `False` or `'none'`: no scaling is applied. The Dr. GRPO paper recommends not scaling rewards, as scaling + by the standard deviation introduces a question-level difficulty bias. + + > Parameters that control the SDPO loss + + distillation_weight (`float`, *optional*, defaults to `1.0`): + Convex combination weight between the policy and self-distillation objectives. The loss is `(1 - + distillation_weight) * policy_loss + distillation_weight * distillation_loss`. Must be in `[0, 1]`. `1.0` + (default) trains purely on self-distillation, `0.0` falls back to the standard GRPO-style policy gradient, + and intermediate values blend both. + distillation_alpha (`float`, *optional*, defaults to `1.0`): + Divergence interpolation coefficient. Sampled-token SDPO requires the official reverse-KL setting + `distillation_alpha=1.0`. + distillation_mode (`Literal["sampled_token", "full_logits", "topk_logits"]`, *optional*, defaults to `"sampled_token"`): + Distillation objective mode. `sampled_token` is the default SDPO mode and requires + `distillation_alpha=1.0`. + distillation_topk (`int`, *optional*): + Top-k approximation for logit-level SDPO. Must be set when `distillation_mode=topk_logits` and left unset + otherwise. + distillation_is_clip (`float`, *optional*, defaults to `2.0`): + Clipping coefficient for importance sampling in self-distillation. `None` disables clipping. + distillation_add_tail (`bool`, *optional*, defaults to `False`): + Whether to add a tail bucket for non-top-k probability mass. + + > Parameters that control the teacher + + teacher_model_kind (`str`, *optional*, defaults to `"ema"`): + Semantic teacher choice. `base` uses the initial student, `live` uses the current student, and `ema` uses + an exponentially averaged teacher. + teacher_update_rate (`float`, *optional*, defaults to `0.05`): + Teacher update rate used for EMA teacher synchronization. + teacher_sync_steps (`int`, *optional*, defaults to `1`): + How often to synchronize the EMA teacher model. + + > Parameters that control reprompting + + use_successful_as_teacher (`bool`, *optional*, defaults to `True`): + Use successful rollouts as implicit feedback for self-distillation. + success_reward_threshold (`float`, *optional*, defaults to `1.0`): + Minimum reward for a rollout to be considered a successful demonstration. + dont_reprompt_on_self_success (`bool`, *optional*, defaults to `True`): + Skip reprompting when model generates correct response. + max_reprompt_len (`int`, *optional*, defaults to `10240`): + Maximum length for reprompting in self-distillation. + reprompt_template (`str`, *optional*, defaults to `"{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n"`): + Template for reprompting the teacher with a successful demonstration. + solution_template (`str`, *optional*, defaults to `"\nCorrect solution: + \n\n{successful_previous_attempt}\n\n"`): Template for formatting the successful demonstration text. + feedback_template (`str`, *optional*, defaults to `"\nThe following is feedback from your unsuccessful earlier attempt: + \n\n{feedback_raw}\n\n"`): Template for formatting environment feedback for reprompting. + include_environment_feedback (`bool`, *optional*, defaults to `False`): + Whether to include environment feedback in teacher reprompts when available. + environment_feedback_only_without_solution (`bool`, *optional*, defaults to `False`): + Whether to use feedback only when no successful solution is available. + remove_thinking_from_demonstration (`bool`, *optional*, defaults to `False`): + Whether to remove ... blocks from the demonstration text. + + > Parameters that control diagnostics + + diagnostics_warning_interval (`int`, *optional*, defaults to `10`): + Emit repeated trainer diagnostics every N consecutive degenerate steps. Set to 0 to disable. + diagnostics_flat_tolerance (`float`, *optional*, defaults to `1e-8`): + Tolerance used to decide whether reward variance or reprompt activity is effectively zero. + + > Parameters that control the model + + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` argument + of the `SDPOTrainer` is provided as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and [`~transformers.AutoProcessor.from_pretrained`]. + Also applied to reward-model and reward-tokenizer loads. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model. This is useful for training with a reference model, as it prevents + the model from generating different logprobs for the same input. + + > Parameters that control data preprocessing + + remove_unused_columns (`bool`, *optional*, defaults to `False`): + Whether to only keep the column 'prompt' in the dataset. If you use a custom reward function that requires + any column other than 'prompts' and 'completions', you should keep this to `False`. + max_prompt_length (`int`, *optional*, defaults to `512`): + Maximum prompt length. Longer prompts are truncated from the left. + shuffle_dataset (`bool`, *optional*, defaults to `True`): + Whether to shuffle the training dataset. + + > Parameters that control generation + + num_generations (`int`, *optional*, defaults to `8`): + Number of generations to sample. The effective batch size (num_processes * per_device_batch_size * + gradient_accumulation_steps) must be evenly divisible by this value. + num_generations_eval (`int`, *optional*): + Number of generations to sample during evaluation. This allows using fewer generations during evaluation to + save computation. If `None`, uses the value of `num_generations`. + max_completion_length (`int`, *optional*, defaults to `256`): + Maximum length of the generated completion. + temperature (`float`, *optional*, defaults to `1.0`): + Temperature for sampling. The higher the temperature, the more random the completions. + top_p (`float`, *optional*, defaults to `1.0`): + Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to 1.0 + to consider all tokens. + top_k (`int`, *optional*, defaults to `0`): + Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is + disabled and all tokens are considered. + min_p (`float`, *optional*): + Minimum token probability, which will be scaled by the probability of the most likely token. It must be a + value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range. + repetition_penalty (`float`, *optional*, defaults to `1.0`): + Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far. + Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model to repeat + tokens. + cache_implementation (`str`, *optional*): + Implementation of the cache method for faster generation when use_vllm is set to False. + generation_kwargs (`dict[str, Any]`, *optional*): + Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or `SamplingParams` (if + using vLLM) when sampling completions. This can be used to further customize the generation behavior, such + as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict with the other generation + parameters (like `min_p`, `top_p`, etc.), they will override them. + chat_template_kwargs (`dict[str, Any]`, *optional*): + Additional keyword arguments to pass to the `apply_chat_template` function when generating completions. + ds3_gather_for_generation (`bool`, *optional*, defaults to `True`): + This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation, + improving generation speed. However, disabling this option allows training models that exceed the VRAM + capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible + with vLLM generation. + + > Parameters that control generation acceleration powered by vLLM + + use_vllm (`bool`, *optional*, defaults to `False`): + Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation + instead of the default model.generate(). Requires `vllm` to be installed. + use_teacher_server (`bool`, *optional*, defaults to `False`): + Compute teacher logprobs from the running vLLM generation server instead of a local teacher forward. Only + supported for `teacher_model_kind='live'` with `use_vllm=True`, `vllm_mode='server'`, + `distillation_weight=1.0` (pure distillation), and `distillation_mode` in {'sampled_token', 'topk_logits'} + (the server returns the teacher's top-k logprobs, not the full vocabulary; `topk_logits` distills over the + teacher's own top-k support). + vllm_mode (`str`, *optional*, defaults to `"colocate"`): + Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or + `'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure a + TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same process + and share the training GPUs. This avoids the need for a separate server but may cause resource contention + with training. + vllm_model_impl (`str`, *optional*, defaults to `"vllm"`): + Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: Use the + `transformers` backend for model implementation. `vllm`: Use the `vllm` library for model implementation. + vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`): + Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but + waking the engine adds host–device transfer latency. + vllm_server_base_url (`str`, *optional*): + Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` and + `vllm_server_port` are ignored. + vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`): + Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided. + vllm_server_port (`int`, *optional*, defaults to `8000`): + Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided. + vllm_group_port (`int`, *optional*, defaults to `51216`): + Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port + is occupied, there is no need to change it. + vllm_server_timeout (`float`, *optional*, defaults to `240.0`): + Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the + timeout, a `ConnectionError` is raised. + vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`): + Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to + `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when + launching the vLLM server via the `--vllm_tensor_parallel_size` flag. + vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.3`): + Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to + `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when + launching the vLLM server via the `--vllm_gpu_memory_utilization` flag. + vllm_max_model_length (`int`, *optional*): + Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus + `max_completion_length`; if omitted, it is inferred from the model config. + + > Parameters that control the training + + loss_type (`str`, *optional*, defaults to `"dapo"`): + Specifies the loss formulation to use. Supported values are 'grpo', 'bnpo', 'dr_grpo', and 'dapo'. 'grpo': + Aggregates token-level losses by normalizing over sequence length. Not recommended due to length bias—this + approach tends to prefer shorter completions with positive advantages and longer ones with negative + advantages. 'dapo' (default): Aggregates token-level losses by normalizing with the number of active tokens + in the global accumulated batch. This method was introduced in the DAPO paper to eliminate length bias. + 'dr_grpo': Aggregates token-level losses by normalizing with a global constant. This method was introduced + in the Dr. GRPO paper to eliminate length bias. The value of the constant corresponds to + `max_completion_length`. 'bnpo': Aggregates token-level losses by normalizing with the number of active + tokens in the local batch. Note that normalization is performed over the local batch only, so results may + slightly vary depending on the local batch size, despite a constant effective batch size. When using + `per_device_train_batch_size==1`, the loss is equivalent to the GRPO loss. + num_iterations (`int`, *optional*, defaults to `1`): + Number of iterations per batch (denoted as μ in the algorithm). + generation_batch_size (`int`, *optional*): + Batch size to use for generation. If `None`, it defaults to the effective training batch size: + `per_device_train_batch_size * num_processes * steps_per_generation`. + steps_per_generation (`int`, *optional*): + Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`. + mask_truncated_completions (`bool`, *optional*, defaults to `False`): + When enabled, truncated completions are excluded from the loss calculation, preventing them from being + incorrectly penalized and introducing noise during training. According to the DAPO paper, this is a good + practice for training stability. + """ + + _VALID_DICT_FIELDS = TrainingArguments._VALID_DICT_FIELDS + ["model_init_kwargs"] + + model_init_kwargs: dict[str, Any] | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` argument of the `SDPOTrainer` is provided as a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`. Also applied to " + "reward-model and reward-tokenizer loads." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={ + "help": "Whether to disable dropout in the model. This is useful for training with a reference model, as it prevents the model from generating different logprobs for the same input." + }, + ) + remove_unused_columns: bool = field( + default=False, + metadata={ + "help": "Whether to only keep the column 'prompt' in the dataset. If you use a custom reward function that requires any column other than 'prompts' and 'completions', you should keep this to `False`." + }, + ) + max_prompt_length: int | None = field( + default=512, + metadata={"help": "Maximum prompt length. Longer prompts are truncated from the left."}, + ) + num_generations: int = field( + default=8, + metadata={ + "help": "Number of generations to sample. The effective batch size (num_processes * per_device_batch_size * gradient_accumulation_steps) must be evenly divisible by this value." + }, + ) + num_generations_eval: int | None = field( + default=None, + metadata={ + "help": "Number of generations to sample during evaluation. This allows using fewer generations during evaluation to save computation. If `None`, uses the value of `num_generations`." + }, + ) + max_completion_length: int | None = field( + default=256, + metadata={"help": "Maximum length of the generated completion."}, + ) + ds3_gather_for_generation: bool = field( + default=True, + metadata={ + "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation, improving generation speed. However, disabling this option allows training models that exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible with vLLM generation." + }, + ) + shuffle_dataset: bool = field( + default=True, + metadata={"help": "Whether to shuffle the training dataset."}, + ) + generation_batch_size: int | None = field( + default=None, + metadata={ + "help": "Batch size to use for generation. If `None`, it defaults to the effective training batch size: `per_device_train_batch_size * num_processes * steps_per_generation`." + }, + ) + steps_per_generation: int | None = field( + default=None, + metadata={"help": "Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`."}, + ) + temperature: float = field( + default=1.0, + metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."}, + ) + top_p: float = field( + default=1.0, + metadata={ + "help": "Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to 1.0 to consider all tokens." + }, + ) + top_k: int = field( + default=0, + metadata={ + "help": "Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is disabled and all tokens are considered." + }, + ) + min_p: float | None = field( + default=None, + metadata={ + "help": "Minimum token probability, which will be scaled by the probability of the most likely token. It must be a value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range." + }, + ) + generation_kwargs: dict[str, Any] | None = field( + default=None, + metadata={ + "help": "Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or `SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them." + }, + ) + chat_template_kwargs: dict[str, Any] | None = field( + default=None, + metadata={ + "help": "Additional keyword arguments to pass to the `apply_chat_template` function when generating completions." + }, + ) + repetition_penalty: float = field( + default=1.0, + metadata={ + "help": "Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far. Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model to repeat tokens." + }, + ) + cache_implementation: str | None = field( + default=None, + metadata={"help": "Implementation of the cache method for faster generation when use_vllm is set to False."}, + ) + use_vllm: bool = field( + default=False, + metadata={ + "help": "Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation instead of the default model.generate(). Requires `vllm` to be installed." + }, + ) + use_teacher_server: bool = field( + default=False, + metadata={ + "help": "Compute teacher logprobs from the running vLLM generation server instead of a local teacher " + "forward. Only supported for `teacher_model_kind='live'` with `use_vllm=True`, `vllm_mode='server'`, " + "`distillation_weight=1.0` (pure distillation), and `distillation_mode` in {'sampled_token', " + "'topk_logits'} (the server returns the teacher's top-k logprobs, not the full vocabulary; `topk_logits` " + "distills over the teacher's own top-k support)." + }, + ) + vllm_mode: str = field( + default="colocate", + metadata={ + "help": "Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or `'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same process and share the training GPUs. This avoids the need for a separate server but may cause resource contention with training." + }, + ) + vllm_model_impl: str = field( + default="vllm", + metadata={ + "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for model implementation." + }, + ) + vllm_enable_sleep_mode: bool = field( + default=False, + metadata={ + "help": "Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but waking the engine adds host–device transfer latency." + }, + ) + vllm_server_base_url: str | None = field( + default=None, + metadata={ + "help": "Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` and `vllm_server_port` are ignored." + }, + ) + vllm_server_host: str = field( + default="0.0.0.0", + metadata={"help": "Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."}, + ) + vllm_server_port: int = field( + default=8000, + metadata={"help": "Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."}, + ) + vllm_group_port: int = field( + default=51216, + metadata={ + "help": "Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port is occupied, there is no need to change it." + }, + ) + vllm_server_timeout: float = field( + default=240.0, + metadata={ + "help": "Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the timeout, a `ConnectionError` is raised." + }, + ) + vllm_tensor_parallel_size: int = field( + default=1, + metadata={ + "help": "Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when launching the vLLM server via the `--vllm_tensor_parallel_size` flag." + }, + ) + vllm_gpu_memory_utilization: float = field( + default=0.3, + metadata={ + "help": "Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when launching the vLLM server via the `--vllm_gpu_memory_utilization` flag." + }, + ) + vllm_max_model_length: int | None = field( + default=None, + metadata={ + "help": "Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus `max_completion_length`; if omitted, it is inferred from the model config." + }, + ) + num_iterations: int = field( + default=1, + metadata={"help": "Number of iterations per batch (denoted as μ in the algorithm)."}, + ) + loss_type: str = field( + default="dapo", + metadata={ + "help": "Specifies the loss formulation to use. Supported values are 'grpo', 'bnpo', 'dr_grpo', and 'dapo'. 'grpo': Aggregates token-level losses by normalizing over sequence length. Not recommended due to length bias—this approach tends to prefer shorter completions with positive advantages and longer ones with negative advantages. 'dapo' (default): Aggregates token-level losses by normalizing with the number of active tokens in the global accumulated batch. This method was introduced in the DAPO paper to eliminate length bias. 'dr_grpo': Aggregates token-level losses by normalizing with a global constant. This method was introduced in the Dr. GRPO paper to eliminate length bias. The value of the constant corresponds to `max_completion_length`. 'bnpo': Aggregates token-level losses by normalizing with the number of active tokens in the local batch. Note that normalization is performed over the local batch only, so results may slightly vary depending on the local batch size, despite a constant effective batch size. When using `per_device_train_batch_size==1`, the loss is equivalent to the GRPO loss." + }, + ) + mask_truncated_completions: bool = field( + default=False, + metadata={ + "help": "When enabled, truncated completions are excluded from the loss calculation, preventing them from being incorrectly penalized and introducing noise during training. According to the DAPO paper, this is a good practice for training stability." + }, + ) + dont_reprompt_on_self_success: bool = field( + default=True, + metadata={"help": "Skip reprompting when model generates correct response."}, + ) + beta: float = field( + default=0.0, + metadata={ + "help": "KL coefficient. If `0.0` (default), the reference model is not loaded, reducing memory usage and improving training speed. [DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning](https://huggingface.co/papers/2501.12948) use a value of `0.001`." + }, + ) + epsilon: float = field( + default=0.2, + metadata={"help": "Epsilon value for clipping."}, + ) + epsilon_high: float | None = field( + default=None, + metadata={ + "help": "Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the lower-bound specified in argument `epsilon`. Paper DAPO recommends `0.28`." + }, + ) + importance_sampling_level: str = field( + default="token", + metadata={ + "help": "Controls whether importance sampling ratios are computed at the `'token'` or `'sequence'` level. `'token'` keeps the raw per-token log-probability ratios (one weight per token). `'sequence'` averages the log-probability ratios across valid tokens to produce a single ratio per sequence. The GSPO paper shows that sequence-level sampling often yields more stable training and better alignment with sequence-level rewards." + }, + ) + reward_weights: list[float] | None = field( + default=None, + metadata={ + "help": "Weights for each reward function. Must match the number of reward functions. If `None`, all rewards are weighted equally with weight `1.0`." + }, + ) + scale_rewards: str | bool = field( + default="group", + metadata={ + "help": "Specifies the scaling strategy for rewards. Supported values are: `True` or `'group'` (default): rewards are scaled by the standard deviation within each group, ensuring unit variance within a group. `'batch'`: rewards are scaled by the standard deviation across the entire batch, as recommended in the PPO Lite paper. `False` or `'none'`: no scaling is applied. The Dr. GRPO paper recommends not scaling rewards, as scaling by the standard deviation introduces a question-level difficulty bias." + }, + ) + distillation_alpha: float = field( + default=1.0, + metadata={ + "help": "Divergence interpolation coefficient. Sampled-token SDPO requires the official reverse-KL setting " + "`distillation_alpha=1.0`." + }, + ) + distillation_mode: Literal["sampled_token", "full_logits", "topk_logits"] = field( + default="sampled_token", + metadata={ + "help": "Distillation objective mode. `sampled_token` is the default SDPO mode and requires " + "`distillation_alpha=1.0`." + }, + ) + distillation_topk: int | None = field( + default=None, + metadata={ + "help": "Top-k approximation for logit-level SDPO. Must be set when `distillation_mode=topk_logits` and left " + "unset otherwise." + }, + ) + distillation_is_clip: float | None = field( + default=2.0, + metadata={ + "help": "Clipping coefficient for importance sampling in self-distillation. `None` disables clipping." + }, + ) + distillation_add_tail: bool = field( + default=False, + metadata={"help": "Whether to add a tail bucket for non-top-k probability mass."}, + ) + distillation_weight: float = field( + default=1.0, + metadata={ + "help": "Convex combination weight between the policy and self-distillation objectives. The loss is " + "`(1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss`. Must be in `[0, 1]`. " + "`1.0` (default) trains purely on self-distillation, `0.0` falls back to the standard GRPO-style policy " + "gradient, and intermediate values blend both." + }, + ) + teacher_model_kind: str = field( + default="ema", + metadata={ + "help": "Semantic teacher choice. `base` uses the initial student, `live` uses the current student, " + "and `ema` uses an exponentially averaged teacher." + }, + ) + teacher_update_rate: float = field( + default=0.05, + metadata={"help": "Teacher update rate used for EMA teacher synchronization."}, + ) + teacher_sync_steps: int = field( + default=1, + metadata={"help": "How often to synchronize the EMA teacher model."}, + ) + max_reprompt_len: int = field( + default=10240, + metadata={"help": "Maximum length for reprompting in self-distillation."}, + ) + use_successful_as_teacher: bool = field( + default=True, + metadata={"help": "Use successful rollouts as implicit feedback for self-distillation."}, + ) + success_reward_threshold: float = field( + default=1.0, + metadata={"help": "Minimum reward for a rollout to be considered a successful demonstration."}, + ) + reprompt_template: str = field( + default="{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n", + metadata={"help": "Template for reprompting the teacher with a successful demonstration."}, + ) + solution_template: str = field( + default="\nCorrect solution:\n\n{successful_previous_attempt}\n\n", + metadata={"help": "Template for formatting the successful demonstration text."}, + ) + feedback_template: str = field( + default="\nThe following is feedback from your unsuccessful earlier attempt:\n\n{feedback_raw}\n\n", + metadata={"help": "Template for formatting environment feedback for reprompting."}, + ) + include_environment_feedback: bool = field( + default=False, + metadata={"help": "Whether to include environment feedback in teacher reprompts when available."}, + ) + environment_feedback_only_without_solution: bool = field( + default=False, + metadata={"help": "Whether to use feedback only when no successful solution is available."}, + ) + remove_thinking_from_demonstration: bool = field( + default=False, + metadata={"help": "Whether to remove ... blocks from the demonstration text."}, + ) + diagnostics_warning_interval: int = field( + default=10, + metadata={ + "help": "Emit repeated trainer diagnostics every N consecutive degenerate steps. Set to 0 to disable." + }, + ) + diagnostics_flat_tolerance: float = field( + default=1e-8, + metadata={ + "help": "Tolerance used to decide whether reward variance or reprompt activity is effectively zero." + }, + ) + + def __post_init__(self): + super().__post_init__() + if not 0.0 <= self.distillation_weight <= 1.0: + raise ValueError(f"`distillation_weight` must be in [0, 1], got {self.distillation_weight}.") + if self.distillation_mode == "sampled_token" and self.distillation_alpha != 1.0: + raise ValueError( + "`distillation_mode='sampled_token'` only supports reverse KL, so it requires " + f"`distillation_alpha=1.0`, got {self.distillation_alpha}." + ) + num_processes = self.world_size + if self.generation_batch_size is None and self.steps_per_generation is None: + self.steps_per_generation = self.gradient_accumulation_steps + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + elif self.generation_batch_size is not None and self.steps_per_generation is None: + global_batch_size = self.per_device_train_batch_size * num_processes + if self.generation_batch_size % global_batch_size != 0: + raise ValueError( + f"generation_batch_size ({self.generation_batch_size}) must be divisible by the global batch size ({global_batch_size})." + ) + self.steps_per_generation = self.generation_batch_size // global_batch_size + elif self.generation_batch_size is None and self.steps_per_generation is not None: + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + else: + raise ValueError("'generation_batch_size' and 'steps_per_generation' can not both be configured") + + if self.generation_batch_size % self.num_generations != 0: + raise ValueError( + f"generation_batch_size ({self.generation_batch_size}) must be divisible by num_generations ({self.num_generations})." + ) + + if self.do_eval and self.eval_strategy != "no": + num_generations_eval = self.num_generations_eval or self.num_generations + if (self.per_device_eval_batch_size * num_processes) % num_generations_eval != 0: + raise ValueError( + f"The global eval batch size ({self.per_device_eval_batch_size} * {num_processes}) must be " + f"divisible by the number of generations used for evaluation ({num_generations_eval})." + ) + + self.scale_rewards = {True: "group", False: "none"}.get(self.scale_rewards, self.scale_rewards) + + if self.epsilon_high is None: + self.epsilon_high = self.epsilon diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/sdpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/sdpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..9a7c10184930cfb03bf4d1cb9447e3205a5f729c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/sdpo_trainer.py @@ -0,0 +1,1772 @@ +# Copyright 2020-2026 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 re +import textwrap +from collections import defaultdict +from contextlib import nullcontext +from dataclasses import dataclass +from functools import partial +from typing import Any + +import datasets +import torch +from accelerate.utils import gather_object, is_peft_model +from datasets import Dataset, IterableDataset +from torch import nn +from torch.distributed.fsdp import FullyShardedDataParallel as FSDP +from torch.utils.data import DataLoader, Sampler +from transformers import ( + AutoModelForSequenceClassification, + AutoProcessor, + AutoTokenizer, + GenerationConfig, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, +) +from transformers.trainer_utils import seed_worker +from transformers.utils import is_datasets_available, is_liger_kernel_available, is_peft_available, logging + +from ...data_utils import apply_chat_template, is_conversational +from ...models import prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation +from ...models.utils import _ForwardRedirection +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import ( + RepeatSampler, + create_model_from_path, + disable_dropout_in_model, + get_config_model_id, + identity, + pad, + selective_log_softmax, + split_tensor_dict, + use_adapter, +) +from ..utils import prepare_peft_model +from .loss_utils import ( + add_tail_bucket, + apply_importance_sampling_clipping, + compute_divergence, + compute_full_logit_self_distillation_loss, + compute_sampled_token_self_distillation_loss, + compute_topk_self_distillation_loss, +) +from .sdpo_config import SDPOConfig +from .teacher_sync import PEFTAdapterEMACallback, SyncTeacherModelCallback, is_pure_lora_training + + +logger = logging.get_logger(__name__) + + +if is_peft_available(): + from peft import PeftConfig + +if is_liger_kernel_available(): + from liger_kernel.chunked_loss import LigerFusedLinearJSDLoss + + +TrainingBatch = dict[str, torch.Tensor | Any] + + +def build_teacher_request_inputs( + input_ids: torch.Tensor, + attention_mask: torch.Tensor, + prompt_attention_mask: torch.Tensor, +) -> tuple[list[list[int]], list[int], list[int]]: + """Trim padded batch tensors into per-sample (prompt+completion) sequences for teacher-server requests.""" + if input_ids.shape != attention_mask.shape: + raise ValueError( + f"input_ids and attention_mask must have the same shape, got {input_ids.shape} and {attention_mask.shape}." + ) + + input_ids_cpu = input_ids.detach().cpu() + attention_mask_cpu = attention_mask.detach().cpu().bool() + prompt_lengths = prompt_attention_mask.detach().cpu().sum(dim=1).to(torch.long) + + trimmed_input_ids: list[list[int]] = [] + prompt_lengths_list: list[int] = [] + completion_lengths_list: list[int] = [] + for row, mask, prompt_length in zip(input_ids_cpu, attention_mask_cpu, prompt_lengths, strict=True): + trimmed_row = row[mask] + prompt_len = int(prompt_length.item()) + if prompt_len < 0 or prompt_len > trimmed_row.numel(): + raise ValueError( + f"Invalid prompt length {prompt_len} for trimmed sequence of length {trimmed_row.numel()}." + ) + trimmed_input_ids.append(trimmed_row.tolist()) + prompt_lengths_list.append(prompt_len) + completion_lengths_list.append(int(trimmed_row.numel()) - prompt_len) + return trimmed_input_ids, prompt_lengths_list, completion_lengths_list + + +@dataclass +class DistillationLogits: + """Aligned logits and masks used to compute a self-distillation objective.""" + + completion_ids: torch.Tensor + completion_mask: torch.Tensor + loss_mask: torch.Tensor + student_logits: torch.Tensor + teacher_logits: torch.Tensor + + +def _extract_last_user_text(messages: list[dict[str, Any]]) -> str: + """Extract the text content from the last user message in a conversational prompt.""" + last_message = messages[-1] + if last_message.get("role") != "user": + raise ValueError( + f"Self-distillation teacher prompt construction expects the conversation to end with a user turn, " + f"but the last message has role '{last_message.get('role')}'. " + f"Prompts ending with assistant prefills or tool turns are not supported." + ) + content = last_message.get("content", "") + if isinstance(content, list): + return " ".join(part.get("text", "") for part in content if part.get("type") == "text") + return content + + +class SuccessfulRolloutTeacherContextBuilder: + """Builds teacher contexts from successful rollouts""" + + def __init__(self, trainer): + self.trainer = trainer + self.last_metrics: dict[str, float] = {} + + def _build_reprompt_text(self, prompt_text: str, solution_text: str, feedback_text: str) -> str: + return self.trainer.args.reprompt_template.format( + prompt=prompt_text, + solution=solution_text, + feedback=feedback_text, + ) + + def _tokenize_teacher_messages( + self, teacher_messages_list: list[str | list[dict[str, Any]]] + ) -> dict[str, torch.Tensor]: + device = self.trainer.accelerator.device + teacher_prompt_ids_list = self.trainer._tokenize_prompts_untruncated(teacher_messages_list) + teacher_prompt_ids = [ + torch.as_tensor(ids[-self.trainer.args.max_reprompt_len :], device=device) + for ids in teacher_prompt_ids_list + ] + teacher_prompt_mask = [torch.ones(len(ids), dtype=torch.long, device=device) for ids in teacher_prompt_ids] + return { + "prompt_ids": pad( + teacher_prompt_ids, padding_value=self.trainer._tokenizer.pad_token_id, padding_side="left" + ), + "prompt_mask": pad(teacher_prompt_mask, padding_value=0, padding_side="left"), + } + + def build( + self, + output: dict[str, torch.Tensor | Any], + prompts: list[Any], + rewards: torch.Tensor, + feedbacks: list[Any] | None = None, + ) -> dict[str, torch.Tensor]: + device = self.trainer.accelerator.device + mode = "train" if self.trainer.model.training else "eval" + num_generations = self.trainer.num_generations if mode == "train" else self.trainer.num_generations_eval + completion_ids = output["completion_ids"] + completion_mask = output["completion_mask"] + + num_local = len(prompts) + process_start = self.trainer.accelerator.process_index * num_local + process_slice = slice(process_start, process_start + num_local) + + # Rewards arrive already locally sliced (per-process) from the rollout mixin; re-gather them so + # the mining loop can find successful rollouts across all processes within each generation group. + all_rewards = self.trainer.accelerator.gather(rewards) + # Completion tensors are padded to the local max length per rank; align shapes before gathering. + # Use separate variables so the original completion_ids/completion_mask stay unpadded for the + # teacher concat (they must match the student's sequence length for logits_to_keep alignment). + padded_completion_ids = self.trainer.accelerator.pad_across_processes( + completion_ids, dim=1, pad_index=self.trainer._tokenizer.pad_token_id + ) + all_completion_ids = self.trainer.accelerator.gather(padded_completion_ids) + all_prompts = gather_object(prompts) + total_samples = all_rewards.shape[0] + all_feedbacks = gather_object(feedbacks) if feedbacks is not None else [None] * total_samples + + threshold = self.trainer.args.success_reward_threshold + dont_reprompt_self = self.trainer.args.dont_reprompt_on_self_success + feedback_only_without_solution = self.trainer.args.environment_feedback_only_without_solution + self_distillation_mask = torch.zeros(total_samples, device=device) + num_with_solution = 0 + num_with_feedback_available = 0 + num_with_feedback_used = 0 + success_group_count = 0 + successful_demo_indices: list[int | None] = [None] * total_samples + use_feedback_flags: list[bool] = [False] * total_samples + has_solution_flags: list[bool] = [False] * total_samples + + for i in range(total_samples): + group_start = (i // num_generations) * num_generations + group_end = group_start + num_generations + + successful = [] + if self.trainer.args.use_successful_as_teacher: + for j in range(group_start, group_end): + if dont_reprompt_self and j == i: + continue + if all_rewards[j].item() >= threshold: + successful.append(j) + + if i % num_generations == 0: + # Count groups with any successful rollout, ignoring self-exclusion which only + # affects per-sample teacher assignment, not whether the group has successes. + group_has_success = any(all_rewards[j].item() >= threshold for j in range(group_start, group_end)) + if group_has_success: + success_group_count += 1 + + raw_feedback = all_feedbacks[i] + has_feedback = isinstance(raw_feedback, str) and raw_feedback.strip() != "" + if has_feedback: + num_with_feedback_available += 1 + + has_solution = len(successful) > 0 + has_solution_flags[i] = has_solution + if has_solution: + successful_demo_indices[i] = successful[0] + use_feedback = ( + self.trainer.args.include_environment_feedback + and has_feedback + and (not feedback_only_without_solution or not has_solution) + ) + use_feedback_flags[i] = use_feedback + if use_feedback: + num_with_feedback_used += 1 + if has_solution or use_feedback: + self_distillation_mask[i] = 1.0 + if has_solution: + num_with_solution += 1 + + local_teacher_messages = [] + local_self_distillation_mask = self_distillation_mask[process_slice] + for global_idx in range(process_start, process_start + num_local): + original_prompt = all_prompts[global_idx] + raw_feedback = all_feedbacks[global_idx] + has_solution = has_solution_flags[global_idx] + use_feedback = use_feedback_flags[global_idx] + + if not has_solution and not use_feedback: + local_teacher_messages.append(original_prompt) + continue + + solution_text = "" + if has_solution: + demo_idx = successful_demo_indices[global_idx] + if demo_idx is None: + raise RuntimeError("Expected a successful demonstration index for an active SDPO teacher prompt.") + demo_ids = all_completion_ids[demo_idx] + demo_ids = demo_ids[demo_ids != self.trainer._tokenizer.pad_token_id] + demo_text = self.trainer.processing_class.decode(demo_ids, skip_special_tokens=True) + + if self.trainer.args.remove_thinking_from_demonstration: + demo_text = re.sub(r".*?", "", demo_text, flags=re.DOTALL).strip() + + solution_text = self.trainer.args.solution_template.format(successful_previous_attempt=demo_text) + + feedback_text = "" + if use_feedback: + feedback_text = self.trainer.args.feedback_template.format(feedback_raw=raw_feedback) + + if isinstance(original_prompt, list): + system_messages = original_prompt[:-1] + prompt_text = _extract_last_user_text(original_prompt) + reprompt_text = self._build_reprompt_text(prompt_text, solution_text, feedback_text) + local_teacher_messages.append(system_messages + [{"role": "user", "content": reprompt_text}]) + else: + local_teacher_messages.append(self._build_reprompt_text(original_prompt, solution_text, feedback_text)) + + teacher_batch = self._tokenize_teacher_messages(local_teacher_messages) + teacher_input_ids = torch.cat([teacher_batch["prompt_ids"], completion_ids], dim=1) + teacher_attention_mask = torch.cat([teacher_batch["prompt_mask"], completion_mask], dim=1) + + batch_size = total_samples if total_samples > 0 else 1 + num_groups = max(1, total_samples // max(1, num_generations)) + self.last_metrics = { + "self_distillation/success_group_fraction": success_group_count / num_groups, + "self_distillation/success_sample_fraction": num_with_solution / batch_size, + "self_distillation/feedback_available_fraction": num_with_feedback_available / batch_size, + "self_distillation/feedback_used_fraction": num_with_feedback_used / batch_size, + "self_distillation/reprompt_sample_fraction": self_distillation_mask.float().mean().item(), + } + + return { + "teacher_input_ids": teacher_input_ids, + "teacher_attention_mask": teacher_attention_mask, + "self_distillation_mask": local_self_distillation_mask, + } + + +class SDPOTrainer(_BaseTrainer): + """ + Trainer for Self-Distillation Policy Optimization (SDPO). + + SDPO augments on-policy optimization with self-distillation from the model's own high-reward trajectories. It + converts tokenized feedback into a dense learning signal without any external teacher or explicit reward model. + SDPO treats the current model conditioned on feedback as a self-teacher and distills its feedback-informed + next-token predictions back into the policy. + """ + + config_cls = SDPOConfig + _tag_names = ["trl", "sdpo"] + _name = "SDPO" + # docstyle-ignore + _paper = { + "title": "Reinforcement Learning via Self-Distillation", + "id": "2601.20802", + "citation": textwrap.dedent("""\ + @article{hubotter2026sdpo, + title = {{Reinforcement Learning via Self-Distillation}}, + author = {Jonas H\\"ubotter and Frederike L\\"ubeck and Lejs Behric and Anton Baumann and Marco Bagatella and Daniel Marta and Ido Hakimi and Idan Shenfeld and Thomas Kleine Buening and Carlos Guestrin and Andreas Krause}, + year = 2026, + eprint = {arXiv:2601.20802} + }"""), + } + + def __init__( + self, + model: str | PreTrainedModel | nn.Module, + reward_funcs: Any | list[Any] | None = None, + args: SDPOConfig | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + peft_config=None, + ): + if reward_funcs is None or (isinstance(reward_funcs, list) and len(reward_funcs) == 0): + raise ValueError("`reward_funcs` is required for SDPOTrainer because SDPO must score rollouts.") + if train_dataset is None: + raise ValueError("`train_dataset` is required") + + if isinstance(model, str): + model_init_kwargs = args.model_init_kwargs or {} + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + model = create_model_from_path(model, **model_init_kwargs) + elif args.model_init_kwargs is not None: + logger.warning( + "You passed `model_init_kwargs` to the self-distillation config, but `model` is already " + "instantiated. The `model_init_kwargs` will be ignored." + ) + + self.model_kwarg_keys = ( + inspect.signature(model.forward).parameters.keys() + if not hasattr(model, "get_base_model") + else inspect.signature(model.get_base_model().forward).parameters.keys() + ) + + if peft_config is None and getattr(model, "peft_config", None) is not None: + logger.warning( + "The provided self-distillation student model already contains a PEFT adapter. " + "This setup is accepted but not directly supported. In particular, `teacher_model_kind='base'` " + "may refer to the underlying base weights rather than the exact initially loaded student state " + "including its adapter. For unambiguous teacher behavior, start from a merged/non-adapter model " + "or manage separate adapters explicitly." + ) + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config`. Pass either a base " + "model with `peft_config`, or a pre-wrapped PEFT model." + ) + if peft_config is not None or (is_peft_available() and getattr(model, "peft_config", None) is not None): + model = prepare_peft_model(model, peft_config, args) + + if processing_class is None: + processing_class = AutoProcessor.from_pretrained( + get_config_model_id(model.config), + truncation_side="left", + padding_side="left", + trust_remote_code=args.trust_remote_code, + ) + + if isinstance(processing_class, ProcessorMixin): + self._tokenizer = processing_class.tokenizer + elif isinstance(processing_class, PreTrainedTokenizerBase): + self._tokenizer = processing_class + else: + raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`") + + if self._tokenizer.pad_token is None: + self._tokenizer.pad_token = self._tokenizer.eos_token + + self.max_prompt_length = args.max_prompt_length + self.max_completion_length = args.max_completion_length + self.num_generations = args.num_generations + self.num_generations_eval = args.num_generations_eval or args.num_generations + self.num_iterations = args.num_iterations + self.shuffle_dataset = args.shuffle_dataset + self.loss_type = args.loss_type + self.mask_truncated_completions = args.mask_truncated_completions + self.temperature = args.temperature + self.use_vllm = args.use_vllm + self.chat_template_kwargs = args.chat_template_kwargs or {} + self._step = 0 + self._buffered_inputs = None + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + self._diagnostic_counters = { + "train": defaultdict(int), + "eval": defaultdict(int), + } + + self.generation_kwargs = { + "max_new_tokens": self.max_completion_length, + "do_sample": True, + "pad_token_id": self._tokenizer.pad_token_id, + "bos_token_id": self._tokenizer.bos_token_id, + "eos_token_id": self._tokenizer.eos_token_id, + "temperature": args.temperature, + "top_p": args.top_p, + "top_k": args.top_k, + "min_p": args.min_p, + "repetition_penalty": args.repetition_penalty, + "cache_implementation": args.cache_implementation, + } + if args.generation_kwargs is not None: + self.generation_kwargs.update(args.generation_kwargs) + self.generation_config = GenerationConfig(**self.generation_kwargs, disable_compile=True) + + if hasattr(model, "warnings_issued"): + model.warnings_issued["estimate_tokens"] = True + + # Teacher logprobs from the running vLLM generation server (reuses the synced student weights) instead of a + # local teacher forward. MVP: `live` teacher only — the generation server holds the current student weights. + self.use_teacher_server = args.use_teacher_server + if self.use_teacher_server: + if not (args.use_vllm and args.vllm_mode == "server"): + raise ValueError( + "`use_teacher_server=True` requires `use_vllm=True` and `vllm_mode='server'`: teacher logprobs are " + "served by the same vLLM server used for generation." + ) + if args.teacher_model_kind != "live": + raise ValueError( + "`use_teacher_server=True` only supports `teacher_model_kind='live'` (the generation server holds " + f"the current student weights), got {args.teacher_model_kind!r}." + ) + if args.distillation_weight != 1.0: + raise ValueError( + "`use_teacher_server=True` only supports pure self-distillation with `distillation_weight=1.0`, " + f"got {args.distillation_weight}. A convex blend with the policy loss needs the full-vocabulary " + "logits, which the server does not return." + ) + if args.distillation_mode not in ("sampled_token", "topk_logits"): + raise ValueError( + "`use_teacher_server=True` only supports `distillation_mode` in {'sampled_token', 'topk_logits'}, " + f"got {args.distillation_mode!r}. The server returns the teacher's top-k logprobs, not the full " + "vocabulary, so `full_logits` is unavailable. Note `topk_logits` distills over the teacher's own " + "top-k support (the server cannot score the student's top-k indices)." + ) + if args.use_liger_kernel: + raise ValueError( + "`use_teacher_server=True` is incompatible with `use_liger_kernel`: the server returns top-k " + "logprobs while the Liger fused loss needs full-vocabulary hidden states." + ) + # Liger fused JSD loss for `full_logits`: same generalized JSD as `compute_divergence`, so alpha maps to beta. + self.use_liger_loss = False + if args.use_liger_kernel: + if not is_liger_kernel_available(): + raise ImportError( + "Liger is required to use `use_liger_kernel` as the self-distillation loss. Run " + "`pip install liger-kernel`." + ) + if args.distillation_weight != 1.0: + raise ValueError( + "`use_liger_kernel` only supports pure self-distillation with `distillation_weight=1.0`, got " + f"{args.distillation_weight}. A convex blend with the policy loss needs the policy-gradient term, " + "so the fused distillation kernel offers no benefit there." + ) + if args.distillation_mode != "full_logits": + raise ValueError( + "`use_liger_kernel` only supports `distillation_mode='full_logits'`, got " + f"{args.distillation_mode!r}. The fused JSD kernel operates on the full vocabulary and cannot " + "express the top-k support or sampled-token objectives." + ) + if args.distillation_is_clip is not None: + raise ValueError( + "`use_liger_kernel` is incompatible with `distillation_is_clip`: the fused kernel does not expose " + "per-token losses for importance-sampling clipping." + ) + if args.loss_type != "bnpo": + logger.warning( + "The Liger fused loss reduces with a token-level mean (equivalent to `loss_type='bnpo'`); the " + f"configured `loss_type={args.loss_type!r}` is ignored on the Liger path." + ) + self.liger_jsd_loss = LigerFusedLinearJSDLoss( + beta=args.distillation_alpha, + ignore_index=-100, + temperature=args.temperature, + compiled=False, + weight_hard_loss=0.0, + weight_soft_loss=1.0, + ) + self._forward_redirection = _ForwardRedirection() + self.use_liger_loss = True + + super().__init__( + model=model, + args=args, + data_collator=identity, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + callbacks=callbacks, + optimizers=optimizers, + compute_loss_func="non-None value to disable scaling", + ) + + self._last_loaded_step = -1 if self.use_vllm else 0 + if self.use_vllm: + from ...generation.vllm_generation import VLLMGeneration + + self.vllm_generation = VLLMGeneration( + model=self.model, + accelerator=self.accelerator, + processing_class=self.processing_class, + mode=args.vllm_mode, + server_base_url=args.vllm_server_base_url, + server_host=args.vllm_server_host, + server_port=args.vllm_server_port, + group_port=args.vllm_group_port, + server_timeout=args.vllm_server_timeout, + tensor_parallel_size=args.vllm_tensor_parallel_size, + gpu_memory_utilization=args.vllm_gpu_memory_utilization, + max_model_length=args.vllm_max_model_length, + max_num_seqs=args.per_device_train_batch_size + * args.vllm_tensor_parallel_size + * args.steps_per_generation, + enable_sleep_mode=args.vllm_enable_sleep_mode, + model_impl=args.vllm_model_impl, + repetition_penalty=args.repetition_penalty, + temperature=self.temperature, + top_p=args.top_p, + top_k=args.top_k, + min_p=args.min_p, + max_completion_length=self.max_completion_length, + logprobs=None, + generation_kwargs=args.generation_kwargs, + ) + + # Per-rank read-only client to the same generation server for teacher scoring (weights are synced there by + # `VLLMGeneration`; scoring needs no weight-update communicator). Mirrors the distillation trainer's + # `teacher_client`. + self.teacher_client = None + if self.use_teacher_server: + from ...generation.vllm_client import VLLMClient + + base_url = args.vllm_server_base_url or f"http://{args.vllm_server_host}:{args.vllm_server_port}" + self.teacher_client = VLLMClient(base_url=base_url, connection_timeout=args.vllm_server_timeout) + + if args.disable_dropout: + disable_dropout_in_model(self.model) + + if hasattr(self.model, "add_model_tags"): + self.model.add_model_tags(self._tag_names) + + self._setup_teacher_model() + self.model_accepts_loss_kwargs = False + + self.importance_sampling_level = args.importance_sampling_level + self.scale_rewards = args.scale_rewards + self.epsilon_low = args.epsilon + self.epsilon_high = args.epsilon_high + self.beta = args.beta + + if not isinstance(reward_funcs, list): + reward_funcs = [reward_funcs] + self.reward_func_names = [] + for i, reward_func in enumerate(reward_funcs): + if isinstance(reward_func, str): + reward_model_init_kwargs = args.model_init_kwargs or {} + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + reward_model_init_kwargs["device_map"] = None + reward_model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + reward_funcs[i] = AutoModelForSequenceClassification.from_pretrained( + reward_func, + num_labels=1, + **reward_model_init_kwargs, + ) + if isinstance(reward_funcs[i], nn.Module): + self.reward_func_names.append(get_config_model_id(reward_funcs[i].config).split("/")[-1]) + else: + self.reward_func_names.append(reward_funcs[i].__name__) + self.reward_funcs = reward_funcs + + if args.reward_weights is not None: + if len(args.reward_weights) != len(self.reward_funcs): + raise ValueError("Number of reward weights must match number of reward functions") + self.reward_weights = torch.tensor(args.reward_weights, dtype=torch.float32) + else: + self.reward_weights = torch.ones(len(self.reward_funcs), dtype=torch.float32) + + if reward_processing_classes is None: + reward_processing_classes = [None] * len(self.reward_funcs) + elif not isinstance(reward_processing_classes, list): + reward_processing_classes = [reward_processing_classes] + if len(reward_processing_classes) != len(self.reward_funcs): + raise ValueError("Number of reward processing classes must match number of reward functions") + + for i, (reward_processing_class, reward_func) in enumerate( + zip(reward_processing_classes, self.reward_funcs, strict=True) + ): + if isinstance(reward_func, PreTrainedModel): + if reward_processing_class is None: + reward_processing_class = AutoTokenizer.from_pretrained( + get_config_model_id(reward_func.config), trust_remote_code=args.trust_remote_code + ) + if reward_processing_class.pad_token_id is None: + reward_processing_class.pad_token = reward_processing_class.eos_token + reward_func.config.pad_token_id = reward_processing_class.pad_token_id + reward_processing_classes[i] = reward_processing_class + self.reward_processing_classes = reward_processing_classes + + for i, reward_func in enumerate(self.reward_funcs): + if isinstance(reward_func, nn.Module): + if self.is_deepspeed_enabled: + self.reward_funcs[i] = prepare_deepspeed(reward_func, self.accelerator) + elif self.is_fsdp_enabled: + self.reward_funcs[i] = prepare_fsdp(reward_func, self.accelerator) + else: + self.reward_funcs[i] = self.accelerator.prepare_model(reward_func, evaluation_mode=True) + + self.teacher_context_builder = SuccessfulRolloutTeacherContextBuilder(self) + + def _set_signature_columns_if_needed(self): + if self._signature_columns is None: + self._signature_columns = ["prompt", "privileged_context"] + + def _dispatch_self_distillation_callback(self, event_name: str, **payload) -> None: + for callback in self.callback_handler.callbacks: + callback_fn = getattr(callback, event_name, None) + if callback_fn is not None: + callback_fn( + args=self.args, + state=self.state, + control=self.control, + model=self.model, + processing_class=self.processing_class, + **payload, + ) + + def _setup_teacher_model(self) -> None: + """Prepare teacher state according to the semantic teacher choice. + + Resolve `teacher_model_kind` × PEFT state into the effective teacher: + + - `"live"` (any model): + Teacher is the student. No divergence, no callback. + - `"base"` + PEFT model: + Teacher reuses `self.model`; the base weights are recovered downstream by disabling the adapter via + `use_adapter` during teacher forward. + - `"base"` + non-PEFT model: + Teacher is a frozen deepcopy of the initial student (falls through to the copy branch below). + - `"ema"` + pure-LoRA training: + Teacher reuses `self.model`; a dedicated `"teacher"` LoRA adapter is attached and updated by + `PEFTAdapterEMACallback`. Teacher forward switches to that adapter downstream. + - `"ema"` (otherwise): + Teacher is a frozen deepcopy synchronized each step by `SyncTeacherModelCallback`. + + Must be called after `super().__init__` so that `self.callback_handler` is available. + """ + + teacher_model_kind = self.args.teacher_model_kind + + if teacher_model_kind == "live": + self.teacher_model = self.model + return + + if teacher_model_kind == "base" and is_peft_model(self.model): + self.teacher_model = self.model + return + + if self._use_peft_ema_teacher_adapter(): + # Must run after super().__init__ so self.callback_handler exists. + self.add_callback( + PEFTAdapterEMACallback( + model=self.model, + teacher_adapter_name="teacher", + update_rate=self.args.teacher_update_rate, + sync_steps=self.args.teacher_sync_steps, + accelerator=self.accelerator, + ) + ) + self.teacher_model = self.model + return + + if is_peft_model(self.model): + raise ValueError( + "`teacher_model_kind='ema'` with a non-pure-LoRA PEFT model is not supported: the separate EMA " + "teacher cannot be parameter-matched to the PEFT student. Use pure-LoRA training, a non-PEFT model, " + "or `teacher_model_kind` in {'live', 'base'}." + ) + + # Build the teacher from the model path (like the GRPO/DPO reference model) rather than deep-copying the + # student: under ZeRO-3 the student params are already sharded, so a deep copy would clone empty shards. + model_init_kwargs = self.args.model_init_kwargs or {} + if self.args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", self.args.trust_remote_code) + self.teacher_model = create_model_from_path(get_config_model_id(self.model.config), **model_init_kwargs) + self.teacher_model.requires_grad_(False) + self.teacher_model.eval() + if self.is_deepspeed_enabled: + self.teacher_model = prepare_deepspeed(self.teacher_model, self.accelerator) + elif self.is_fsdp_enabled: + self.teacher_model = prepare_fsdp(self.teacher_model, self.accelerator) + else: + self.teacher_model = self.accelerator.prepare_model(self.teacher_model, evaluation_mode=True) + + if teacher_model_kind == "ema": + self.add_callback(SyncTeacherModelCallback(teacher_model=self.teacher_model, accelerator=self.accelerator)) + + def _use_peft_ema_teacher_adapter(self) -> bool: + return self.args.teacher_model_kind == "ema" and is_pure_lora_training(self.model, self.accelerator) + + def get_train_dataloader(self): + if self.train_dataset is None: + raise ValueError("Trainer: training requires a train_dataset.") + + train_dataset = self.train_dataset + data_collator = self.data_collator + if is_datasets_available() and isinstance(train_dataset, datasets.Dataset): + train_dataset = self._remove_unused_columns(train_dataset, description="training") + else: + data_collator = self._get_collator_with_removed_columns(data_collator, description="training") + + dataloader_params = { + "batch_size": self._train_batch_size * self.args.steps_per_generation, + "collate_fn": data_collator, + "num_workers": self.args.dataloader_num_workers, + "pin_memory": self.args.dataloader_pin_memory, + "persistent_workers": self.args.dataloader_persistent_workers, + } + if not isinstance(train_dataset, torch.utils.data.IterableDataset): + dataloader_params["sampler"] = self._get_train_sampler() + dataloader_params["drop_last"] = self.args.dataloader_drop_last + dataloader_params["worker_init_fn"] = partial( + seed_worker, num_workers=self.args.dataloader_num_workers, rank=self.args.process_index + ) + dataloader_params["prefetch_factor"] = self.args.dataloader_prefetch_factor + return self.accelerator.prepare(DataLoader(train_dataset, **dataloader_params)) + + def _get_train_sampler(self, dataset=None) -> Sampler: + if dataset is None: + dataset = self.train_dataset + return RepeatSampler( + data_source=dataset, + mini_repeat_count=self.num_generations, + batch_size=self.args.generation_batch_size // self.num_generations, + repeat_count=self.num_iterations * self.args.steps_per_generation, + shuffle=self.shuffle_dataset, + seed=self.args.seed, + ) + + def _get_eval_sampler(self, eval_dataset) -> Sampler: + return RepeatSampler( + data_source=eval_dataset, + mini_repeat_count=self.num_generations_eval, + seed=self.args.seed, + ) + + def training_step(self, model, inputs, num_items_in_batch): + # Gather spans forward+backward: the fused JSD computes the lm_head grad in backward. + with self._get_liger_zero3_lm_head_gather_ctx(model): + output = super().training_step(model, inputs, num_items_in_batch) + self._step += 1 + return output + + def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys=None): + if not isinstance(inputs, dict): + inputs = self._prepare_inputs(inputs) + with torch.no_grad(): + with self.compute_loss_context_manager(): + loss = self.compute_loss(model, inputs) + return loss.detach(), None, None + + def _prepare_inputs(self, generation_batch): + """Return the per-step training batch, regenerating rollouts and buffering them for reuse in train mode. + + In train mode, rollouts are generated once every `steps_per_generation * num_iterations` steps and split into + per-step slices reused until the next regeneration. In eval mode, every batch is freshly prepared. + """ + mode = "train" if self.model.training else "eval" + if mode == "train": + generate_every = self.args.steps_per_generation * self.num_iterations + if self._step % generate_every == 0 or self._buffered_inputs is None: + buffered_batch = self._prepare_training_batch(generation_batch) + self._buffered_inputs = split_tensor_dict(buffered_batch, self.args.steps_per_generation) + self._dispatch_self_distillation_callback( + "on_generation_batch_built", + generate_every=generate_every, + steps_per_generation=self.args.steps_per_generation, + ) + return self._buffered_inputs[self._step % self.args.steps_per_generation] + return self._prepare_training_batch(generation_batch) + + def _prepare_training_batch(self, inputs: list[dict[str, Any]]) -> TrainingBatch: + """Sample student rollouts, calculate advantage and construct teacher prompts""" + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + + # Generate student rollouts and decode completions for reward functions + batch = self.sample_rollouts(inputs) + prompts = [example["prompt"] for example in inputs] + privileged_contexts = [example.get("privileged_context") for example in inputs] + completion_ids_list = self._get_completion_ids_list(batch) + if is_conversational({"prompt": prompts[0]}): + completions_text = self.processing_class.batch_decode(batch["completion_ids"], skip_special_tokens=True) + completions = [[{"role": "assistant", "content": content}] for content in completions_text] + else: + completions = self.processing_class.batch_decode(batch["completion_ids"], skip_special_tokens=True) + + # Compute rewards over the globally gathered rollout batch + rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list) + if rewards_per_func.numel() == 0: + rewards = torch.zeros(self.accelerator.num_processes * len(prompts), device=device) + else: + rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1) + + # Normalize rewards within generation groups to produce local policy advantages + num_generations = self.num_generations if mode == "train" else self.num_generations_eval + mean_grouped_rewards = rewards.view(-1, num_generations).mean(dim=1).repeat_interleave(num_generations, dim=0) + if self.scale_rewards == "batch": + std_rewards = rewards.std().expand_as(rewards) if rewards.numel() > 1 else torch.zeros_like(rewards) + group_std_rewards = rewards.view(-1, num_generations).std(dim=1) + elif self.scale_rewards == "none": + std_rewards = torch.ones_like(rewards) + group_std_rewards = torch.ones(rewards.numel() // num_generations, device=device, dtype=rewards.dtype) + else: + group_std_rewards = rewards.view(-1, num_generations).std(dim=1) + std_rewards = group_std_rewards.repeat_interleave(num_generations, dim=0) + advantages = (rewards - mean_grouped_rewards) / (std_rewards + 1e-4) + local_batch_size = batch["completion_ids"].size(0) + process_start = self.accelerator.process_index * local_batch_size + process_slice = slice(process_start, process_start + local_batch_size) + local_rewards = rewards[process_slice] + local_advantages = advantages[process_slice] + + self._record_reward_diagnostics(mode, rewards, rewards_per_func, group_std_rewards) + self._record_completion_metrics(mode, batch) + + batch["rewards"] = local_rewards + batch["advantages"] = local_advantages + teacher_context = self.teacher_context_builder.build( + batch, + prompts, + batch["rewards"], + feedbacks=privileged_contexts, + ) + + for key, value in self.teacher_context_builder.last_metrics.items(): + self._metrics[mode][key].append(value) + self._warn_on_inactive_self_distillation(mode) + + self._dispatch_self_distillation_callback( + "on_teacher_context_built", + teacher_input_ids=teacher_context["teacher_input_ids"], + teacher_attention_mask=teacher_context["teacher_attention_mask"], + completion_mask=batch["completion_mask"], + self_distillation_mask=teacher_context["self_distillation_mask"], + ) + + batch.update( + { + "teacher_input_ids": teacher_context["teacher_input_ids"], + "teacher_attention_mask": teacher_context["teacher_attention_mask"], + "self_distillation_mask": teacher_context["self_distillation_mask"], + } + ) + + self._dispatch_self_distillation_callback( + "on_self_distillation_batch_prepared", + old_per_token_logps=batch.get("old_per_token_logps"), + prompt_ids=batch["prompt_ids"], + completion_ids=batch["completion_ids"], + teacher_input_ids=batch["teacher_input_ids"], + teacher_attention_mask=batch["teacher_attention_mask"], + self_distillation_mask=batch.get("self_distillation_mask"), + ) + return batch + + def sample_rollouts(self, inputs: list[dict[str, Any]]) -> TrainingBatch: + """Generate completions for a batch of prompts and assemble the training batch.""" + prompts = [example["prompt"] for example in inputs] + prompt_ids = self._tokenize_prompts(prompts) + self._dispatch_self_distillation_callback( + "on_generation_prompts_selected", + generation_prompts=prompts, + generation_prompt_text=None, + ) + + prompt_ids_list, completion_ids_list = self._generate(prompt_ids) + device = self.accelerator.device + prompt_ids = [torch.tensor(ids) for ids in prompt_ids_list] + prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids] + prompt_ids = pad(prompt_ids, padding_value=self._tokenizer.pad_token_id, padding_side="left").to(device=device) + prompt_mask = pad(prompt_mask, padding_value=0, padding_side="left").to(device=device) + + completion_ids = [torch.tensor(ids) for ids in completion_ids_list] + completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids] + completion_ids = pad(completion_ids, padding_value=self._tokenizer.pad_token_id, padding_side="right").to( + device=device + ) + completion_mask = pad(completion_mask, padding_value=0, padding_side="right").to(device=device) + + if self.mask_truncated_completions: + eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id] + is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device) + completion_mask = completion_mask * (~is_truncated).unsqueeze(1).int() + + old_per_token_logps = self._compute_rollout_logps( + prompt_ids=prompt_ids, + prompt_mask=prompt_mask, + completion_ids=completion_ids, + completion_mask=completion_mask, + ) + batch: TrainingBatch = { + "prompt_ids": prompt_ids, + "prompt_mask": prompt_mask, + "completion_ids": completion_ids, + "completion_mask": completion_mask, + "raw_completion_lengths": torch.tensor( + [len(ids) for ids in completion_ids_list], device=device, dtype=torch.long + ), + } + if old_per_token_logps is not None: + batch["old_per_token_logps"] = old_per_token_logps + return batch + + def _get_completion_ids_list(self, batch: TrainingBatch) -> list[list[int]]: + raw_completion_lengths = batch["raw_completion_lengths"].detach().cpu().tolist() + return [ + ids[:length].tolist() + for ids, length in zip(batch["completion_ids"].detach().cpu(), raw_completion_lengths, strict=True) + ] + + def _tokenize_prompts_untruncated(self, prompts: list[Any]) -> list[list[int]]: + if is_conversational({"prompt": prompts[0]}): + tokenized = self.processing_class.apply_chat_template( + conversation=prompts, + add_generation_prompt=True, + tokenize=True, + return_dict=True, + **self.chat_template_kwargs, + ) + prompt_ids = tokenized["input_ids"] + else: + prompt_ids = self.processing_class(text=prompts)["input_ids"] + return prompt_ids + + def _tokenize_prompts(self, prompts: list[Any]) -> list[list[int]]: + prompt_ids = self._tokenize_prompts_untruncated(prompts) + if self.max_prompt_length is not None: + prompt_ids = [ids[-self.max_prompt_length :] for ids in prompt_ids] + return prompt_ids + + def _generate(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]: + if self.use_vllm: + return self._generate_vllm(prompt_ids) + return self._generate_transformers(prompt_ids) + + def _generate_vllm(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]: + if self.state.global_step != self._last_loaded_step: + self.vllm_generation.sync_weights() + self._last_loaded_step = self.state.global_step + + mode = "train" if self.model.training else "eval" + num_generations = self.num_generations if mode == "train" else self.num_generations_eval + prompt_ids_out, completion_ids_list, _, _ = self.vllm_generation.generate( + prompts=prompt_ids, + images=None, + num_generations=num_generations, + ) + return prompt_ids_out, completion_ids_list + + def _generate_transformers(self, prompt_ids: list[list[int]]) -> tuple[list[list[int]], list[list[int]]]: + device = self.accelerator.device + prompt_tensors = [torch.tensor(ids) for ids in prompt_ids] + padded_ids = pad(prompt_tensors, padding_value=self._tokenizer.pad_token_id, padding_side="left").to( + device=device + ) + attention_mask = pad([torch.ones_like(t) for t in prompt_tensors], padding_value=0, padding_side="left").to( + device=device + ) + generate_inputs: dict[str, torch.Tensor | Any] = {"input_ids": padded_ids, "attention_mask": attention_mask} + + with ( + unwrap_model_for_generation( + self.model_wrapped, + self.accelerator, + gather_deepspeed3_params=self.args.ds3_gather_for_generation, + generation_kwargs=self.generation_kwargs, + ) as unwrapped_model, + torch.no_grad(), + FSDP.summon_full_params(self.model_wrapped, recurse=False) if self.is_fsdp_enabled else nullcontext(), + ): + prompt_completion_ids = unwrapped_model.generate( + **generate_inputs, generation_config=self.generation_config + ) + + prompt_length = generate_inputs["input_ids"].size(1) + completion_ids = prompt_completion_ids[:, prompt_length:] + is_eos = completion_ids == self._tokenizer.eos_token_id + eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device) + eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)] + seq_idx = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1) + completion_mask = (seq_idx <= eos_idx.unsqueeze(1)).int() + completion_ids_list = [ + c[m].tolist() for c, m in zip(completion_ids.cpu(), completion_mask.bool().cpu(), strict=True) + ] + return prompt_ids, completion_ids_list + + def _compute_rollout_logps( + self, + prompt_ids: torch.Tensor, + prompt_mask: torch.Tensor, + completion_ids: torch.Tensor, + completion_mask: torch.Tensor, + ) -> torch.Tensor | None: + generate_every = self.args.steps_per_generation * self.num_iterations + old_per_token_logps = None + + if self.args.gradient_accumulation_steps % generate_every != 0: + prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + logits_to_keep = completion_ids.size(1) + with torch.no_grad(): + logits = self._forward_logits( + self.model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + ) + old_per_token_logps = selective_log_softmax(logits, completion_ids) + + return old_per_token_logps + + def _calculate_rewards(self, inputs, prompts, completions, completion_ids_list): + device = self.accelerator.device + if len(self.reward_funcs) == 0: + return torch.zeros((len(prompts), 0), device=device) + + rewards_per_func = torch.zeros(len(prompts), len(self.reward_funcs), device=device) + keys = [key for key in inputs[0] if key not in ["prompt", "completion", "completion_ids"]] + reward_kwargs = {key: [example[key] for example in inputs] for key in keys} + reward_kwargs["trainer_state"] = self.state + + for i, (reward_func, reward_processing_class) in enumerate( + zip(self.reward_funcs, self.reward_processing_classes, strict=True) + ): + if isinstance(reward_func, nn.Module): + if is_conversational(inputs[0]): + messages = [{"messages": p + c} for p, c in zip(prompts, completions, strict=True)] + texts = [ + apply_chat_template(x, reward_processing_class, **self.chat_template_kwargs)["text"] + for x in messages + ] + else: + texts = [p + c for p, c in zip(prompts, completions, strict=True)] + reward_inputs = reward_processing_class( + text=texts, + return_tensors="pt", + padding=True, + padding_side="right", + add_special_tokens=False, + ) + reward_inputs = _BaseTrainer._prepare_inputs(self, reward_inputs) + with torch.inference_mode(): + rewards_per_func[:, i] = reward_func(**reward_inputs).logits[:, 0] + else: + output_reward_func = reward_func( + prompts=prompts, + completions=completions, + completion_ids=completion_ids_list, + **reward_kwargs, + ) + output_reward_func = [reward if reward is not None else torch.nan for reward in output_reward_func] + rewards_per_func[:, i] = torch.tensor(output_reward_func, dtype=torch.float32, device=device) + + return self.accelerator.gather(rewards_per_func) + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + if return_outputs: + raise ValueError("The SDPOTrainer does not support returning outputs") + + if self.args.distillation_weight == 1.0: + if self.use_teacher_server: + loss = self._compute_server_distillation_loss(model, inputs) + elif self.use_liger_loss: + accumulation_scale = self.current_gradient_accumulation_steps if self.model.training else 1.0 + return self._compute_liger_loss(model, inputs) / accumulation_scale + else: + distillation_logits = self._compute_teacher_student_logits(model, self.teacher_model, inputs) + loss = self._compute_self_distillation_loss(model, inputs, distillation_logits) + elif self.args.distillation_weight == 0.0: + student_input_ids = torch.cat([inputs["prompt_ids"], inputs["completion_ids"]], dim=1) + student_attention_mask = torch.cat([inputs["prompt_mask"], inputs["completion_mask"]], dim=1) + student_logits = self._forward_logits( + model=model, + input_ids=student_input_ids, + attention_mask=student_attention_mask, + logits_to_keep=inputs["completion_ids"].size(1), + ) + loss = self._compute_policy_loss(inputs, student_logits) + else: + distillation_logits = self._compute_teacher_student_logits(model, self.teacher_model, inputs) + policy_loss = self._compute_policy_loss(inputs, distillation_logits.student_logits) + distillation_loss = self._compute_self_distillation_loss(model, inputs, distillation_logits) + loss = ( + 1 - self.args.distillation_weight + ) * policy_loss + self.args.distillation_weight * distillation_loss + + accumulation_scale = self.current_gradient_accumulation_steps if self.model.training else 1.0 + return loss / accumulation_scale + + def _compute_policy_loss( + self, + inputs, + student_logits, + ) -> torch.Tensor: + completion_ids = inputs["completion_ids"] + completion_mask = inputs["completion_mask"] + per_token_logps = selective_log_softmax(student_logits, completion_ids) + old_per_token_logps = inputs.get("old_per_token_logps") + old_per_token_logps = per_token_logps.detach() if old_per_token_logps is None else old_per_token_logps + advantages = inputs["advantages"] + if advantages.dim() == 1: + advantages = advantages.unsqueeze(1) + log_ratio = per_token_logps - old_per_token_logps + if self.importance_sampling_level == "sequence": + log_ratio = (log_ratio * completion_mask).sum(-1, keepdim=True) / completion_mask.sum( + -1, keepdim=True + ).clamp(min=1.0) + coef_1 = torch.exp(log_ratio) + coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high) + per_token_loss = -torch.min(coef_1 * advantages, coef_2 * advantages) + + if self.loss_type == "grpo": + loss = (per_token_loss * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0) + loss = loss.mean() + elif self.loss_type == "bnpo": + loss = (per_token_loss * completion_mask).sum() / completion_mask.sum().clamp(min=1.0) + elif self.loss_type == "dr_grpo": + loss = (per_token_loss * completion_mask).sum() / (per_token_loss.size(0) * self.max_completion_length) + elif self.loss_type == "dapo": + loss = (per_token_loss * completion_mask).sum() / completion_mask.sum().clamp(min=1.0) + else: + raise ValueError(f"Unsupported loss_type: {self.loss_type}") + + mode = "train" if self.model.training else "eval" + self._metrics[mode]["self_distillation/policy_loss"].append( + self.accelerator.gather(loss.detach()).mean().item() + ) + + return loss + + def _compute_self_distillation_loss( + self, + model, + inputs: TrainingBatch, + distillation_logits: DistillationLogits, + ) -> torch.Tensor: + """Compute the per-token distillation loss and aggregate by normalizing over sequence length. + + Dispatches between three objectives based on `distillation_mode`: + + - `"topk_logits"`: top-k approximation of the divergence, optionally with a tail bucket for the remaining + probability mass (`distillation_add_tail`). + - `"full_logits"`: full-vocab divergence. + - `"sampled_token"`: token-level (reverse-KL) distillation on sampled `completion_ids`. + + When `distillation_is_clip` is set and `old_per_token_logps` are available, the loss is corrected by a clipped + importance-sampling ratio between the current student and the student at rollout time. + """ + if distillation_logits.loss_mask.sum() == 0: + mode = "train" if model.training else "eval" + self._log_self_distillation_metric(mode, 0.0) + # Keep the zero loss attached to the student graph so backward produces zero gradients instead of stopping. + return distillation_logits.student_logits.sum() * 0.0 + + if self.args.distillation_mode == "topk_logits": + if self.args.distillation_topk is None: + raise ValueError("`distillation_mode='topk_logits'` requires `distillation_topk` to be set.") + per_token_loss = compute_topk_self_distillation_loss( + distillation_logits.student_logits, + distillation_logits.teacher_logits, + distillation_topk=self.args.distillation_topk, + distillation_alpha=self.args.distillation_alpha, + distillation_add_tail=self.args.distillation_add_tail, + ) + elif self.args.distillation_mode == "full_logits": + per_token_loss = compute_full_logit_self_distillation_loss( + distillation_logits.student_logits, + distillation_logits.teacher_logits, + distillation_alpha=self.args.distillation_alpha, + ) + elif self.args.distillation_mode == "sampled_token": + per_token_loss = compute_sampled_token_self_distillation_loss( + distillation_logits.student_logits, + distillation_logits.teacher_logits, + distillation_logits.completion_ids, + distillation_alpha=self.args.distillation_alpha, + ) + else: + raise ValueError( + "distillation_mode must be one of: 'sampled_token', 'full_logits', 'topk_logits', " + f"got {self.args.distillation_mode!r}" + ) + + old_per_token_logps = inputs.get("old_per_token_logps") + if self.args.distillation_is_clip is not None and old_per_token_logps is not None: + student_per_token_logps = selective_log_softmax( + distillation_logits.student_logits, + distillation_logits.completion_ids, + ) + per_token_loss = apply_importance_sampling_clipping( + per_token_loss, + student_per_token_logps, + old_per_token_logps, + self.args.distillation_is_clip, + ) + + loss = (per_token_loss * distillation_logits.loss_mask).sum(-1) / distillation_logits.loss_mask.sum(-1).clamp( + min=1.0 + ) + loss = loss.mean() + + mode = "train" if model.training else "eval" + mean_distill_loss = ( + per_token_loss * distillation_logits.loss_mask + ).sum() / distillation_logits.loss_mask.sum().clamp(min=1.0) + self._log_self_distillation_metric( + mode, + self.accelerator.gather(mean_distill_loss).mean().item(), + ) + return loss + + def _compute_server_distillation_loss(self, model, inputs: TrainingBatch) -> torch.Tensor: + """Distillation loss with teacher logprobs served by the vLLM generation server (`teacher_model_kind='live'`). + + The student is forwarded locally (grad) for its logits; the teacher logprobs are fetched from the server (no + local teacher forward). `sampled_token` distills the realized token (reverse KL); `topk_logits` distills over + the teacher's own top-k support (the server cannot score the student's top-k indices). + """ + # Buffered batches are reused across optimizer steps (`num_iterations > 1`), so the server weights can lag the + # live student; re-sync before scoring. + if self.state.global_step != self._last_loaded_step: + self.vllm_generation.sync_weights() + # Only the main process pushes weights to the server, so hold every rank here until the push completes; + # otherwise non-main ranks could score against half-updated weights. + self.accelerator.wait_for_everyone() + self._last_loaded_step = self.state.global_step + + completion_ids = inputs["completion_ids"] + completion_mask = inputs["completion_mask"] + logits_to_keep = completion_ids.size(1) + + self_distillation_mask = inputs.get("self_distillation_mask") + if self_distillation_mask is None: + loss_mask = completion_mask + else: + loss_mask = completion_mask * self_distillation_mask.unsqueeze(1) + + student_input_ids = torch.cat([inputs["prompt_ids"], completion_ids], dim=1) + student_attention_mask = torch.cat([inputs["prompt_mask"], completion_mask], dim=1) + student_logits = self._forward_logits( + model=model, + input_ids=student_input_ids, + attention_mask=student_attention_mask, + logits_to_keep=logits_to_keep, + ) + + mode = "train" if model.training else "eval" + teacher = self._get_teacher_token_logprobs_from_server(inputs, logits_to_keep) + # Padding positions come back as `-inf`; the masked-out positions are neutralized to finite values below so the + # divergence does not leak `+inf` through them (mirrors the distillation trainer). + required = loss_mask.bool() + student_per_token_logps = selective_log_softmax(student_logits, completion_ids) + + teacher_per_token_logps = teacher["actual_logprobs"] + if (required & ~torch.isfinite(teacher_per_token_logps)).any(): + raise ValueError("Teacher server returned no logprob for a required completion token.") + teacher_per_token_logps = torch.where( + required, teacher_per_token_logps, torch.zeros_like(teacher_per_token_logps) + ) + + # Diagnostic for disagreement between local student scores and server teacher scores on realized tokens. + # Sudden jumps can indicate stale server weights or numerical drift. + abs_diff = ((student_per_token_logps.detach() - teacher_per_token_logps).abs() * loss_mask).sum() / ( + loss_mask.sum().clamp(min=1.0) + ) + self._metrics[mode]["self_distillation/server_logprob_abs_diff"].append( + self.accelerator.gather(abs_diff).mean().item() + ) + + if self.args.distillation_mode == "sampled_token": + # Reverse-KL token-level objective, matching `compute_sampled_token_self_distillation_loss`. + per_token_loss = (student_per_token_logps - teacher_per_token_logps).detach() * student_per_token_logps + else: + teacher_topk_logps = teacher["topk_logprobs"] + teacher_topk_ids = teacher["topk_token_ids"] + # Project the student onto the teacher's top-k support, then renormalize (or add a tail bucket) before the + # divergence, matching `compute_topk_self_distillation_loss` on the teacher's support. + keep = required.unsqueeze(-1) + student_topk_logps = torch.gather( + torch.log_softmax(student_logits, dim=-1), dim=-1, index=teacher_topk_ids + ) + student_topk_logps = torch.where(keep, student_topk_logps, torch.zeros_like(student_topk_logps)) + teacher_topk_logps = torch.where(keep, teacher_topk_logps, torch.zeros_like(teacher_topk_logps)) + if self.args.distillation_add_tail: + student_topk_logps = add_tail_bucket(student_topk_logps) + teacher_topk_logps = add_tail_bucket(teacher_topk_logps) + else: + student_topk_logps = student_topk_logps - torch.logsumexp(student_topk_logps, dim=-1, keepdim=True) + teacher_topk_logps = teacher_topk_logps - torch.logsumexp(teacher_topk_logps, dim=-1, keepdim=True) + per_token_loss = compute_divergence(student_topk_logps, teacher_topk_logps, self.args.distillation_alpha) + + old_per_token_logps = inputs.get("old_per_token_logps") + if self.args.distillation_is_clip is not None and old_per_token_logps is not None: + per_token_loss = apply_importance_sampling_clipping( + per_token_loss, student_per_token_logps, old_per_token_logps, self.args.distillation_is_clip + ) + + loss = (per_token_loss * loss_mask).sum(-1) / loss_mask.sum(-1).clamp(min=1.0) + loss = loss.mean() + mean_distill_loss = (per_token_loss * loss_mask).sum() / loss_mask.sum().clamp(min=1.0) + self._log_self_distillation_metric(mode, self.accelerator.gather(mean_distill_loss).mean().item()) + return loss + + def _get_teacher_token_logprobs_from_server( + self, inputs: TrainingBatch, logits_to_keep: int + ) -> dict[str, torch.Tensor]: + """Per-token teacher logprobs from the vLLM server. + + Returns a dict with `actual_logprobs` (`(B, T)`, the realized-token logprob for reverse KL) and `topk_logprobs` + / `topk_token_ids` (`(B, T, K)`, the teacher's top-k support for top-k logit distillation). Completions are + right-padded, so server values fill the leading positions of each row and the trailing padding keeps the `-inf` + / `0` sentinels (neutralized by the caller). + """ + import numpy as np + + teacher_input_ids = inputs["teacher_input_ids"] + teacher_attention_mask = inputs["teacher_attention_mask"] + device = teacher_input_ids.device + batch_size = teacher_input_ids.size(0) + prompt_attention_mask = teacher_attention_mask[:, : teacher_attention_mask.size(1) - logits_to_keep] + if self.args.distillation_mode == "topk_logits" and self.args.distillation_topk is None: + raise ValueError("`distillation_mode='topk_logits'` requires `distillation_topk` to be set.") + top_logprobs = self.args.distillation_topk if self.args.distillation_mode == "topk_logits" else 1 + + sequences, prompt_lengths, _ = build_teacher_request_inputs( + teacher_input_ids, teacher_attention_mask, prompt_attention_mask + ) + result = self.teacher_client.get_sequence_logprobs( + sequences=sequences, + prompt_lengths=prompt_lengths, + top_logprobs=top_logprobs, + temperature=self.temperature, + ) + + actual = np.full((batch_size, logits_to_keep), float("-inf"), dtype=np.float32) + topk = np.full((batch_size, logits_to_keep, top_logprobs), float("-inf"), dtype=np.float32) + topk_ids = np.zeros((batch_size, logits_to_keep, top_logprobs), dtype=np.int64) + for i in range(batch_size): + seq_actual = result["actual_logprobs"][i] + n = min(len(seq_actual), logits_to_keep) + if n: + actual[i, :n] = np.array(seq_actual, dtype=np.float32)[:n, 0] + topk[i, :n] = np.array(result["logprobs"][i], dtype=np.float32)[:n] + topk_ids[i, :n] = np.array(result["logprob_token_ids"][i], dtype=np.int64)[:n] + return { + "actual_logprobs": torch.from_numpy(actual).to(device), + "topk_logprobs": torch.from_numpy(topk).to(device), + "topk_token_ids": torch.from_numpy(topk_ids).to(device), + } + + def _compute_teacher_student_logits( + self, + model, + teacher_model, + inputs: TrainingBatch, + ) -> DistillationLogits: + """Compute the per-token logits of the student and teacher over the completion tokens. + + The student is forwarded on its own input (original prompt plus the sampled completion) while the teacher is + forwarded on its input (prompt, privileged context, and the same completion). Both sets of logits are aligned + to the completion tokens so they can be compared position-by-position in the distillation loss. + + The teacher forward runs under `torch.no_grad()` and the context resolved by + `_get_teacher_context_for_self_distillation`, which routes it to the correct weights. + """ + prompt_ids = inputs["prompt_ids"] + prompt_mask = inputs["prompt_mask"] + completion_ids = inputs["completion_ids"] + completion_mask = inputs["completion_mask"] + logits_to_keep = completion_ids.size(1) + + self_distillation_mask = inputs.get("self_distillation_mask") + if self_distillation_mask is None: + loss_mask = completion_mask + else: + loss_mask = completion_mask * self_distillation_mask.unsqueeze(1) + student_input_ids = torch.cat([prompt_ids, completion_ids], dim=1) + student_attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + student_logits = self._forward_logits( + model=model, + input_ids=student_input_ids, + attention_mask=student_attention_mask, + logits_to_keep=logits_to_keep, + ) + + with torch.no_grad(), self._get_teacher_context_for_self_distillation(): + teacher_logits = self._forward_logits( + model=teacher_model, + input_ids=inputs["teacher_input_ids"], + attention_mask=inputs["teacher_attention_mask"], + logits_to_keep=logits_to_keep, + ) + + return DistillationLogits( + completion_ids=completion_ids, + completion_mask=completion_mask, + loss_mask=loss_mask, + student_logits=student_logits, + teacher_logits=teacher_logits, + ) + + def _forward_logits( + self, + model, + input_ids: torch.Tensor, + attention_mask: torch.Tensor, + logits_to_keep: int, + ) -> torch.Tensor: + """Forward the model and return temperature-scaled logits aligned to the completion tokens.""" + model_inputs = { + "input_ids": input_ids, + "attention_mask": attention_mask, + "use_cache": False, + } + if "logits_to_keep" in self.model_kwarg_keys: + model_inputs["logits_to_keep"] = logits_to_keep + 1 + + logits = model(**model_inputs).logits + logits = logits[:, :-1, :] + logits = logits[:, -logits_to_keep:, :] + return logits / self.temperature + + def _compute_liger_loss(self, model, inputs: TrainingBatch) -> torch.Tensor: + """`full_logits` distillation via the Liger fused JSD kernel: forwards the base models for hidden states and + fuses the lm_head projection with the divergence, never materializing the full-vocab logits. + + Each model is forwarded through its own wrapper via `_forward_redirection` so FSDP2/DeepSpeed materialize the + sharded params during the unwrapped base forward. The fused kernel needs both lm_head weights live at once, so + the frozen teacher weight is captured while the teacher is materialized and handed to the student pass. + """ + logits_to_keep = inputs["completion_ids"].size(1) + self_distillation_mask = inputs.get("self_distillation_mask") + if self_distillation_mask is None: + loss_mask = inputs["completion_mask"] + else: + loss_mask = inputs["completion_mask"] * self_distillation_mask.unsqueeze(1) + + unwrapped_student = self.accelerator.unwrap_model(model) + unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model) + + with torch.no_grad(), self._get_teacher_context_for_self_distillation(): + teacher_hidden, teacher_weight, teacher_bias = self._forward_redirection( + self.teacher_model, + unwrapped_teacher, + self._liger_teacher_side, + unwrapped_teacher, + inputs, + logits_to_keep, + ) + + return self._forward_redirection( + model, + unwrapped_student, + self._liger_student_loss, + unwrapped_student, + inputs, + logits_to_keep, + loss_mask, + teacher_hidden, + teacher_weight, + teacher_bias, + ) + + def _liger_teacher_side(self, teacher, inputs: TrainingBatch, logits_to_keep: int): + """Teacher hidden states + frozen lm_head weight, captured while the teacher params are materialized.""" + hidden = teacher.get_decoder()( + input_ids=inputs["teacher_input_ids"], + attention_mask=inputs["teacher_attention_mask"], + use_cache=False, + ).last_hidden_state + hidden = hidden[:, :-1][:, -logits_to_keep:] + head = teacher.get_output_embeddings() + # Clone so the weight survives re-sharding once this forward context exits. + weight = head.weight.detach().clone() + bias = head.bias.detach().clone() if head.bias is not None else None + return hidden, weight, bias + + def _liger_student_loss( + self, + student, + inputs: TrainingBatch, + logits_to_keep, + loss_mask, + teacher_hidden, + teacher_weight, + teacher_bias, + ): + student_input_ids = torch.cat([inputs["prompt_ids"], inputs["completion_ids"]], dim=1) + student_attention_mask = torch.cat([inputs["prompt_mask"], inputs["completion_mask"]], dim=1) + student_hidden = student.get_decoder()( + input_ids=student_input_ids, + attention_mask=student_attention_mask, + use_cache=False, + ).last_hidden_state + # Align hidden states to the completion-predicting positions, matching `_forward_logits`. + student_hidden = student_hidden[:, :-1][:, -logits_to_keep:] + + # `ignore_index` masks non-response positions; the token values only feed the disabled hard-CE term. + completion_ids = inputs["completion_ids"] + true_labels = torch.where(loss_mask.bool(), completion_ids, torch.full_like(completion_ids, -100)) + + student_head = student.get_output_embeddings() + # Per-sequence then batch mean (grpo), matching the non-Liger path: the fused kernel reduces by total tokens + # (bnpo), so we call it per sequence and average. + seq_losses = [ + self.liger_jsd_loss( + student_input=student_hidden[i], + student_weight=student_head.weight, + teacher_input=teacher_hidden[i], + teacher_weight=teacher_weight, + true_labels=true_labels[i], + student_bias=student_head.bias, + teacher_bias=teacher_bias, + ) + for i in range(student_hidden.size(0)) + ] + loss = torch.stack(seq_losses).mean() + + mode = "train" if student.training else "eval" + self._log_self_distillation_metric(mode, self.accelerator.gather(loss.detach()).mean().item()) + return loss + + def _get_liger_zero3_lm_head_gather_ctx(self, model): + """Gather the sharded student/teacher lm_head weights for the fused matmul under ZeRO-3. Liger reads + `lm_head.weight` by attribute, so the gather hook never fires; the decoder forward gathers itself. No-op + outside ZeRO-3.""" + if not self.use_liger_loss: + return nullcontext() + + deepspeed_plugin = self.accelerator.state.deepspeed_plugin + if deepspeed_plugin is None or deepspeed_plugin.zero_stage != 3: + return nullcontext() + + import deepspeed + + unwrapped_student = self.accelerator.unwrap_model(model) + unwrapped_teacher = self.accelerator.unwrap_model(self.teacher_model) + student_head = unwrapped_student.get_output_embeddings() + teacher_head = unwrapped_teacher.get_output_embeddings() + params = [student_head.weight, teacher_head.weight] + if student_head.bias is not None: + params.append(student_head.bias) + if teacher_head.bias is not None: + params.append(teacher_head.bias) + return deepspeed.zero.GatheredParameters(params, modifier_rank=None) + + def _get_teacher_context_for_self_distillation(self): + """Return the context manager that routes the teacher forward to the correct weights. + + For non-PEFT models this is a no-op. For PEFT models: + + - `teacher_model_kind == "base"`: disable the student adapter so the teacher forward uses the base weights. + - `teacher_model_kind == "ema"` under pure-LoRA training: switch to the `"teacher"` LoRA adapter. + - otherwise: no-op; the teacher is a separate deepcopy. + """ + teacher_model_kind = self.args.teacher_model_kind + if not is_peft_model(self.model): + return nullcontext() + + target_model = self.accelerator.unwrap_model(self.teacher_model) + + if teacher_model_kind == "base": + return use_adapter(target_model, adapter_name=None) + if teacher_model_kind == "ema" and self._use_peft_ema_teacher_adapter(): + return use_adapter(target_model, adapter_name="teacher") + return nullcontext() + + def _record_completion_metrics(self, mode: str, batch: TrainingBatch) -> None: + device = self.accelerator.device + completion_ids_list = self._get_completion_ids_list(batch) + agg_completion_lengths = self.accelerator.gather(batch["raw_completion_lengths"]) + self._metrics[mode]["completions/mean_length"].append(agg_completion_lengths.float().mean().item()) + self._metrics[mode]["completions/min_length"].append(agg_completion_lengths.float().min().item()) + self._metrics[mode]["completions/max_length"].append(agg_completion_lengths.float().max().item()) + + eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id] + is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device) + agg_is_truncated = self.accelerator.gather(is_truncated) + self._metrics[mode]["completions/clipped_ratio"].append(agg_is_truncated.float().mean().item()) + term_completion_lengths = agg_completion_lengths[~agg_is_truncated] + if len(term_completion_lengths) == 0: + term_completion_lengths = torch.zeros(1, device=device) + self._metrics[mode]["completions/mean_terminated_length"].append(term_completion_lengths.float().mean().item()) + self._metrics[mode]["completions/min_terminated_length"].append(term_completion_lengths.float().min().item()) + self._metrics[mode]["completions/max_terminated_length"].append(term_completion_lengths.float().max().item()) + + def _log_self_distillation_metric(self, mode: str, value: float) -> None: + metric_prefix = self._name.lower().replace(" ", "_") + self._metrics[mode]["self_distillation/distillation_loss"].append(value) + self._metrics[mode][f"{metric_prefix}/distillation_loss"].append(value) + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + # Average the metrics + metrics = {} + for key, val in self._metrics[mode].items(): + # Filter out NaN values before averaging. A reward function that returns None for all samples + # in a batch produces NaN for that batch's metric. With logging_steps > 1, a naive sum()/len() + # would let a single NaN contaminate valid data from other batches. Only return None when no + # valid values remain (e.g. JSON loggers crash on float NaN). + valid = [v for v in val if not math.isnan(v)] + metrics[key] = sum(valid) / len(valid) if valid else None + + # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs` + # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() + + def _record_reward_diagnostics( + self, + mode: str, + rewards: torch.Tensor, + rewards_per_func: torch.Tensor, + group_std_rewards: torch.Tensor, + ) -> None: + tolerance = self.args.diagnostics_flat_tolerance + + reward_mean = rewards.mean() if rewards.numel() > 0 else torch.tensor(0.0, device=self.accelerator.device) + reward_std = rewards.std() if rewards.numel() > 1 else torch.tensor(0.0, device=self.accelerator.device) + reward_min = rewards.min() if rewards.numel() > 0 else torch.tensor(0.0, device=self.accelerator.device) + reward_max = rewards.max() if rewards.numel() > 0 else torch.tensor(0.0, device=self.accelerator.device) + flat_group_fraction = ( + (group_std_rewards <= tolerance).float().mean() + if group_std_rewards.numel() > 0 + else torch.tensor(1.0, device=self.accelerator.device) + ) + + self._metrics[mode]["self_distillation/reward_mean"].append(self.accelerator.gather(reward_mean).mean().item()) + self._metrics[mode]["self_distillation/reward_std"].append(self.accelerator.gather(reward_std).mean().item()) + self._metrics[mode]["self_distillation/reward_min"].append(self.accelerator.gather(reward_min).min().item()) + self._metrics[mode]["self_distillation/reward_max"].append(self.accelerator.gather(reward_max).max().item()) + self._metrics[mode]["self_distillation/group_reward_std_mean"].append( + self.accelerator.gather(group_std_rewards.mean() if group_std_rewards.numel() > 0 else reward_std) + .mean() + .item() + ) + self._metrics[mode]["self_distillation/flat_group_fraction"].append( + self.accelerator.gather(flat_group_fraction).mean().item() + ) + + if rewards_per_func.numel() > 0: + reward_func_means = rewards_per_func.nanmean(dim=0) + gathered_means = self.accelerator.gather(reward_func_means).view(-1, reward_func_means.numel()).mean(dim=0) + for reward_name, reward_func_mean in zip(self.reward_func_names, gathered_means.tolist(), strict=True): + self._metrics[mode][f"self_distillation/rewards/{reward_name}"].append(reward_func_mean) + + reward_is_flat = reward_std.item() <= tolerance + grouped_rewards_are_flat = flat_group_fraction.item() >= 1.0 - tolerance + if reward_is_flat and grouped_rewards_are_flat: + self._warn_on_degenerate_diagnostics( + mode=mode, + counter_key="flat_rewards", + message=( + "Observed flat SDPO rewards across all sampled generations. " + "Policy advantages will collapse to zero, and SDPO will not learn. " + "Check reward density, reward shaping, or `success_reward_threshold`." + ), + ) + else: + self._diagnostic_counters[mode]["flat_rewards"] = 0 + + def _warn_on_inactive_self_distillation(self, mode: str) -> None: + metrics = self.teacher_context_builder.last_metrics + tolerance = self.args.diagnostics_flat_tolerance + + reprompt_fraction = metrics.get("self_distillation/reprompt_sample_fraction", 0.0) + success_fraction = metrics.get("self_distillation/success_group_fraction", 0.0) + + if reprompt_fraction <= tolerance: + self._warn_on_degenerate_diagnostics( + mode=mode, + counter_key="inactive_self_distillation", + message=( + "SDPO self-distillation is inactive because no reprompted samples were constructed. " + "This usually means no rollout exceeded `success_reward_threshold` and no usable privileged " + "feedback was available." + ), + ) + else: + self._diagnostic_counters[mode]["inactive_self_distillation"] = 0 + + if success_fraction <= tolerance: + self._warn_on_degenerate_diagnostics( + mode=mode, + counter_key="no_successful_rollouts", + message=( + "SDPO did not find any successful rollouts in the current generation groups. " + "If this persists, reduce task difficulty, adjust reward shaping, or lower " + "`success_reward_threshold`." + ), + ) + else: + self._diagnostic_counters[mode]["no_successful_rollouts"] = 0 + + def _warn_on_degenerate_diagnostics(self, mode: str, counter_key: str, message: str) -> None: + interval = self.args.diagnostics_warning_interval + if interval == 0: + return + + self._diagnostic_counters[mode][counter_key] += 1 + count = self._diagnostic_counters[mode][counter_key] + if count == 1 or count % interval == 0: + logger.warning("%s Consecutive degenerate steps: %s.", message, count) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/teacher_sync.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/teacher_sync.py new file mode 100644 index 0000000000000000000000000000000000000000..8fb0f751a0bb5f4ae69ce9d201b29c09263bf21c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/sdpo/teacher_sync.py @@ -0,0 +1,184 @@ +# Copyright 2020-2026 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 logging + +import torch +from accelerate.utils import is_peft_model +from transformers import ( + TrainerCallback, + TrainerControl, + TrainerState, + TrainingArguments, +) + +from ...trainer.callbacks import SyncRefModelCallback + + +logger = logging.getLogger(__name__) + + +def is_pure_lora_training(model, accelerator=None) -> bool: + """Return `True` when the active adapter is LoRA and every trainable parameter is a LoRA parameter.""" + if not is_peft_model(model): + return False + + if accelerator is not None: + model = accelerator.unwrap_model(model) + + adapter_name = model.active_adapter + if adapter_name is None: + adapter_name = "default" + adapter_config = model.peft_config.get(adapter_name) + peft_type = adapter_config.peft_type + if peft_type is None or str(peft_type).split(".")[-1] != "LORA": + return False + + for name, param in model.named_parameters(): + if param.requires_grad and "lora_" not in name: + return False + return True + + +class SyncTeacherModelCallback(SyncRefModelCallback): + """Synchronize an EMA teacher model with the student model on each configured sync step.""" + + def __init__(self, teacher_model, accelerator=None): + super().__init__(ref_model=teacher_model, accelerator=accelerator) + + def on_step_end(self, args, state, control, **kwargs): + model = kwargs["model"] + if self.ref_model is not None and state.global_step % args.teacher_sync_steps == 0: + if self.accelerator: + model = self.accelerator.unwrap_model(model) + self.sync_target_model(model, self.ref_model, args.teacher_update_rate) + + +class PEFTAdapterEMACallback(TrainerCallback): + """ + Callback that maintains an EMA copy of PEFT adapter weights for use as a teacher model in self-distillation. + + The callback creates a secondary adapter ("teacher") with zero-initialized weights and maintains shadow weights + that are updated via exponential moving average: `teacher_weight = (1-α) * teacher_weight + α * student_weight` + + Usage: + ```python + trainer.add_callback( + PEFTAdapterEMACallback( + model=model, + teacher_adapter_name="teacher", + update_rate=0.05, + ) + ) + ``` + """ + + def __init__( + self, + model, + teacher_adapter_name: str = "teacher", + update_rate: float = 0.05, + sync_steps: int = 1, + accelerator=None, + ): + self.model = model + self.teacher_adapter_name = teacher_adapter_name + self.update_rate = update_rate + self.sync_steps = sync_steps + self.accelerator = accelerator + self.shadow_weights: dict[str, torch.Tensor] | None = None + self.teacher_adapter_config = None + self._initialized = False + + def _get_student_state_dict(self): + """Get student adapter state dict using PEFT keys (without adapter name).""" + from peft import get_peft_model_state_dict + + if self.accelerator is not None: + model = self.accelerator.unwrap_model(self.model) + else: + model = self.model + return get_peft_model_state_dict(model) + + def _initialize_teacher_adapter(self): + """Create teacher adapter with zero weights initialized from student adapter.""" + from peft import get_peft_model_state_dict, set_peft_model_state_dict + + if self._initialized: + return + + if self.accelerator is not None: + model = self.accelerator.unwrap_model(self.model) + else: + model = self.model + + adapter_name = model.active_adapter + if adapter_name is None: + adapter_name = "default" + + self.teacher_adapter_config = model.peft_config.get(adapter_name) + + student_state = get_peft_model_state_dict(model) + + teacher_state = {k: torch.zeros_like(v) for k, v in student_state.items()} + + model.add_adapter(self.teacher_adapter_name, self.teacher_adapter_config) + + model.set_adapter(self.teacher_adapter_name) + set_peft_model_state_dict(model, teacher_state, adapter_name=self.teacher_adapter_name) + + model.set_adapter(adapter_name) + + self.shadow_weights = {k: v.clone().zero_() for k, v in teacher_state.items()} + + self._initialized = True + logger.info(f"Initialized PEFT adapter EMA teacher with adapter name: {self.teacher_adapter_name}") + + @torch.no_grad() + def on_step_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs): + if state.global_step % self.sync_steps != 0: + return + + if not self._initialized: + self._initialize_teacher_adapter() + + if self.shadow_weights is None: + return + + if self.accelerator is None and "accelerator" in kwargs: + self.accelerator = kwargs["accelerator"] + + student_state = self._get_student_state_dict() + + for key, student_param in student_state.items(): + if key in self.shadow_weights: + shadow = self.shadow_weights[key] + shadow.data = (1 - self.update_rate) * shadow.data + self.update_rate * student_param.data + + from peft import set_peft_model_state_dict + + if self.accelerator is not None: + unwrapped_model = self.accelerator.unwrap_model(self.model) + else: + unwrapped_model = self.model + + original_adapter = unwrapped_model.active_adapter + unwrapped_model.set_adapter(self.teacher_adapter_name) + set_peft_model_state_dict(unwrapped_model, self.shadow_weights, adapter_name=self.teacher_adapter_name) + unwrapped_model.set_adapter(original_adapter) + + def on_train_begin(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs): + if self.accelerator is None and "accelerator" in kwargs: + self.accelerator = kwargs["accelerator"] + self._initialize_teacher_adapter() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d62e42ef96cc9cd6e4ff4de23ce39460420e34b7 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .ssd_config import SSDConfig +from .ssd_trainer import SSDTrainer + + +__all__ = ["SSDConfig", "SSDTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd.py new file mode 100644 index 0000000000000000000000000000000000000000..dc24ccb055012451a6fba1ca0ce42a5c51b592eb --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd.py @@ -0,0 +1,166 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# "peft", +# "trackio", +# "kernels", +# ] +# /// + +""" +Simple Self-Distillation (SSD) training for code generation. + +Implements the method from "Embarrassingly Simple Self-Distillation Improves Code Generation" (Zhang et al., 2026): +sample completions from the model at a training-time temperature and truncation, then fine-tune on those raw, +unverified samples with standard cross-entropy loss. No reward model, verifier, teacher, or RL needed. + +The dataset only requires a ``prompt`` column containing coding problem prompts. + +Example: + +```bash +python trl/experimental/ssd/ssd.py \ + --model_name_or_path Qwen/Qwen3-4B-Instruct-2507 \ + --dataset_name microsoft/rStar-Coder \ + --dataset_config seed_sft \ + --prompt_column question \ + --output_dir outputs/ssd-qwen3-4b \ + --per_device_train_batch_size 1 \ + --gradient_accumulation_steps 32 \ + --learning_rate 5e-6 \ + --lr_scheduler_type cosine \ + --max_prompt_length 1024 \ + --max_completion_length 65536 \ + --temperature 1.6 \ + --top_k 20 \ + --top_p 0.8 \ + --num_train_epochs 1 \ + --bf16 \ + --report_to trackio +``` +""" + +from dataclasses import dataclass, field + +import torch +from datasets import DatasetDict, load_dataset, load_from_disk +from transformers import AutoModelForCausalLM, AutoTokenizer + +from trl import ( + ModelConfig, + ScriptArguments, + TrlParser, + get_kbit_device_map, + get_peft_config, + get_quantization_config, +) +from trl.experimental.ssd import SSDConfig, SSDTrainer + + +@dataclass +class SSDScriptArguments(ScriptArguments): + dataset_path: str | None = field( + default=None, + metadata={"help": "Optional local dataset path to load with `load_from_disk`. Overrides `dataset_name`."}, + ) + prompt_column: str = field( + default="prompt", + metadata={"help": "Column containing the problem prompts."}, + ) + + +if __name__ == "__main__": + parser = TrlParser((SSDScriptArguments, SSDConfig, ModelConfig)) + script_args, training_args, model_args = parser.parse_args_and_config() + + if model_args.model_name_or_path is None: + raise ValueError("`model_name_or_path` is required.") + + if model_args.dtype in ["auto", None]: + if training_args.bf16: + dtype = torch.bfloat16 + elif training_args.fp16: + dtype = torch.float16 + else: + dtype = "auto" + else: + dtype = getattr(torch, model_args.dtype) + model_kwargs = dict( + revision=model_args.model_revision, + attn_implementation=model_args.attn_implementation, + dtype=dtype, + ) + quantization_config = get_quantization_config(model_args) + if quantization_config is not None: + model_kwargs["device_map"] = get_kbit_device_map() + model_kwargs["quantization_config"] = quantization_config + + training_args.model_init_kwargs = model_kwargs + + tokenizer = AutoTokenizer.from_pretrained( + model_args.model_name_or_path, revision=model_args.model_revision, padding_side="left" + ) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + # Load dataset + if script_args.dataset_path is not None: + dataset = load_from_disk(script_args.dataset_path) + else: + dataset = load_dataset( + script_args.dataset_name, + name=script_args.dataset_config, + streaming=script_args.dataset_streaming, + ) + + # Ensure the dataset has a `prompt` column + def _prepare_split(ds): + if script_args.prompt_column != "prompt" and script_args.prompt_column in ds.column_names: + ds = ds.rename_column(script_args.prompt_column, "prompt") + return ds.select_columns(["prompt"]) + + if isinstance(dataset, DatasetDict): + train_dataset = _prepare_split(dataset[script_args.dataset_train_split]) + eval_dataset = None + if script_args.dataset_test_split in dataset: + eval_dataset = _prepare_split(dataset[script_args.dataset_test_split]) + else: + train_dataset = _prepare_split(dataset) + eval_dataset = None + + model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs) + model.config.use_cache = False if training_args.gradient_checkpointing else True + + trainer = SSDTrainer( + model=model, + args=training_args, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=tokenizer, + peft_config=get_peft_config(model_args), + ) + + trainer.train() + + trainer.save_model(training_args.output_dir) + if eval_dataset is not None: + metrics = trainer.evaluate() + trainer.log_metrics("eval", metrics) + trainer.save_metrics("eval", metrics) + + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name or script_args.dataset_path) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd_config.py new file mode 100644 index 0000000000000000000000000000000000000000..7a52b9c65a2293194cd132347564e374a39c526d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd_config.py @@ -0,0 +1,263 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Any + +from transformers import TrainingArguments + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class SSDConfig(_BaseConfig): + r""" + Configuration class for [`SSDTrainer`]. + + Implements Simple Self-Distillation (SSD) from [*Embarrassingly Simple Self-Distillation Improves Code + Generation*](https://huggingface.co/papers/2604.01193). SSD samples completions from the model at a training-time + temperature and truncation configuration, then fine-tunes on those raw, unverified samples with standard + cross-entropy loss. + + The `temperature`, `top_k`, and `top_p` parameters control the training-time sampling configuration (T_train, + rho_train in the paper). The evaluation-time configuration (T_eval, rho_eval) is set independently at inference + time. + + Parameters: + > Parameters that control generation and rollout reuse + + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments used when the `model` argument is passed as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and [`~transformers.AutoProcessor.from_pretrained`]. + max_prompt_length (`int` or `None`, *optional*, defaults to `512`): + Maximum prompt length. Longer prompts are truncated from the left. + max_completion_length (`int` or `None`, *optional*, defaults to `256`): + Maximum generated completion length. + generation_batch_size (`int` or `None`, *optional*): + Global batch size used for generation. Mutually exclusive with `steps_per_generation`. + steps_per_generation (`int` or `None`, *optional*): + Number of optimizer steps that reuse one generated batch. Mutually exclusive with `generation_batch_size`. + + > Parameters that control sampling + + temperature (`float`, *optional*, defaults to `1.0`): + Sampling temperature (T_train in the paper). + top_k (`int`, *optional*, defaults to `0`): + Top-k sampling parameter. `0` disables top-k filtering. + top_p (`float`, *optional*, defaults to `1.0`): + Top-p (nucleus) sampling parameter. + min_p (`float` or `None`, *optional*): + Minimum token probability for sampling. + repetition_penalty (`float`, *optional*, defaults to `1.0`): + Repetition penalty used during generation. + generation_kwargs (`dict[str, Any]` or `None`, *optional*): + Extra generation kwargs passed to `GenerationConfig`. + + > Parameters that control vLLM generation + + use_vllm (`bool`, *optional*, defaults to `False`): + Whether to use vLLM for generation instead of the training model. + vllm_mode (`str`, *optional*, defaults to `"colocate"`): + vLLM mode: `"colocate"` (shared GPU) or `"server"` (separate vLLM server). + vllm_model_impl (`str`, *optional*, defaults to `"vllm"`): + Model implementation for vLLM: `"vllm"`, `"transformers"`, or `"auto"`. + vllm_server_base_url (`str` or `None`, *optional*): + Base URL for the vLLM server. If provided, `vllm_server_host` and `vllm_server_port` are ignored. + vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`): + Host of the vLLM server (server mode only). + vllm_server_port (`int`, *optional*, defaults to `8000`): + Port of the vLLM server (server mode only). + vllm_server_timeout (`float`, *optional*, defaults to `240.0`): + Timeout in seconds to wait for the vLLM server. + vllm_group_port (`int`, *optional*, defaults to `51216`): + Port for the weight update group (server mode only). + vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`): + Tensor parallel size for colocated vLLM. + vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.3`): + GPU memory utilization ratio for colocated vLLM. + vllm_max_model_length (`int` or `None`, *optional*): + Model context length for vLLM. Inferred from model config if not set. + vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`): + Whether to enable sleep mode for colocated vLLM engine. + + > Parameters that control training behavior + + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model during training. + filter_empty (`bool`, *optional*, defaults to `True`): + Whether to filter out empty or single-line stub completions from the generated data. + num_iterations (`int`, *optional*, defaults to `1`): + Number of optimization iterations per generated batch. + shuffle_dataset (`bool`, *optional*, defaults to `True`): + Whether to shuffle the training dataset. + ds3_gather_for_generation (`bool`, *optional*, defaults to `True`): + Whether to gather ZeRO-3 weights for generation. + cache_implementation (`str` or `None`, *optional*): + Cache implementation used by transformers generation. + chat_template_kwargs (`dict[str, Any]` or `None`, *optional*): + Extra kwargs forwarded to chat template application. + """ + + _VALID_DICT_FIELDS = TrainingArguments._VALID_DICT_FIELDS + ["model_init_kwargs"] + + model_init_kwargs: dict[str, Any] | None = field( + default=None, + metadata={"help": "Keyword arguments for model initialization when `model` is passed as a string."}, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`." + }, + ) + max_prompt_length: int | None = field( + default=512, + metadata={"help": "Maximum prompt length. Longer prompts are truncated from the left."}, + ) + max_completion_length: int | None = field( + default=256, + metadata={"help": "Maximum generated completion length."}, + ) + generation_batch_size: int | None = field( + default=None, + metadata={"help": "Global batch size used for generation. Mutually exclusive with `steps_per_generation`."}, + ) + steps_per_generation: int | None = field( + default=None, + metadata={"help": "Number of optimizer steps that reuse one generated batch."}, + ) + temperature: float = field( + default=1.0, + metadata={"help": "Sampling temperature (T_train in the paper)."}, + ) + top_k: int = field( + default=0, + metadata={"help": "Top-k sampling parameter. `0` disables top-k filtering."}, + ) + top_p: float = field( + default=1.0, + metadata={"help": "Top-p (nucleus) sampling parameter."}, + ) + min_p: float | None = field( + default=None, + metadata={"help": "Minimum token probability for sampling."}, + ) + repetition_penalty: float = field( + default=1.0, + metadata={"help": "Repetition penalty used during generation."}, + ) + generation_kwargs: dict[str, Any] | None = field( + default=None, + metadata={"help": "Extra generation kwargs passed to `GenerationConfig`."}, + ) + cache_implementation: str | None = field( + default=None, + metadata={"help": "Cache implementation used by transformers generation."}, + ) + chat_template_kwargs: dict[str, Any] | None = field( + default=None, + metadata={"help": "Extra kwargs forwarded to chat template application."}, + ) + use_vllm: bool = field( + default=False, + metadata={"help": "Whether to use vLLM for generation."}, + ) + vllm_mode: str = field( + default="colocate", + metadata={"help": "vLLM mode: 'colocate' (shared GPU) or 'server' (separate vLLM server)."}, + ) + vllm_model_impl: str = field( + default="vllm", + metadata={"help": "Model implementation for vLLM: 'vllm', 'transformers', or 'auto'."}, + ) + vllm_server_base_url: str | None = field( + default=None, + metadata={ + "help": "Base URL for the vLLM server. If provided, vllm_server_host and vllm_server_port are ignored." + }, + ) + vllm_server_host: str = field( + default="0.0.0.0", + metadata={"help": "Host of the vLLM server (server mode only)."}, + ) + vllm_server_port: int = field( + default=8000, + metadata={"help": "Port of the vLLM server (server mode only)."}, + ) + vllm_server_timeout: float = field( + default=240.0, + metadata={"help": "Timeout in seconds to wait for the vLLM server."}, + ) + vllm_group_port: int = field( + default=51216, + metadata={"help": "Port for the weight update group (server mode only)."}, + ) + vllm_tensor_parallel_size: int = field( + default=1, + metadata={"help": "Tensor parallel size for colocated vLLM."}, + ) + vllm_gpu_memory_utilization: float = field( + default=0.3, + metadata={"help": "GPU memory utilization ratio for colocated vLLM."}, + ) + vllm_max_model_length: int | None = field( + default=None, + metadata={"help": "Model context length for vLLM. Inferred from model config if not set."}, + ) + vllm_enable_sleep_mode: bool = field( + default=False, + metadata={"help": "Whether to enable sleep mode for colocated vLLM engine."}, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the model during training."}, + ) + filter_empty: bool = field( + default=True, + metadata={"help": "Whether to filter out empty or single-line stub completions."}, + ) + num_iterations: int = field( + default=1, + metadata={"help": "Number of optimization iterations per generated batch."}, + ) + shuffle_dataset: bool = field( + default=True, + metadata={"help": "Whether to shuffle the training dataset."}, + ) + ds3_gather_for_generation: bool = field( + default=True, + metadata={"help": "Whether to gather ZeRO-3 weights for generation."}, + ) + + def __post_init__(self): + super().__post_init__() + + num_processes = self.world_size + if self.generation_batch_size is None and self.steps_per_generation is None: + self.steps_per_generation = self.gradient_accumulation_steps + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + elif self.generation_batch_size is not None and self.steps_per_generation is None: + global_batch_size = self.per_device_train_batch_size * num_processes + if self.generation_batch_size % global_batch_size != 0: + raise ValueError( + f"generation_batch_size ({self.generation_batch_size}) must be divisible by the global batch size ({global_batch_size})." + ) + self.steps_per_generation = self.generation_batch_size // global_batch_size + elif self.generation_batch_size is None and self.steps_per_generation is not None: + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + else: + raise ValueError("'generation_batch_size' and 'steps_per_generation' can not both be configured") diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd_eval.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..cb3f6d24995cad889062c4b2bc3889b978a61a37 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd_eval.py @@ -0,0 +1,260 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# "vllm", +# "huggingface_hub", +# "livecodebench @ git+https://github.com/LiveCodeBench/LiveCodeBench.git", +# ] +# /// + +""" +LiveCodeBench v6 evaluation script. + +Generates completions with vLLM at a configurable decoding setting and scores them with LiveCodeBench's official +``codegen_metrics`` (pass@k via sandboxed test execution). The default decoding configuration matches Table 3 of +*Embarrassingly Simple Self-Distillation Improves Code Generation* (Zhang et al., 2026), making this script suitable +for evaluating SSD-trained checkpoints alongside their base models. + +Example — evaluate the base Qwen3-4B-Instruct-2507 on the v6 delta (the new problems released in v6): + +```bash +python trl/experimental/ssd/ssd_eval.py \\ + --model_name_or_path Qwen/Qwen3-4B-Instruct-2507 \\ + --temperature 1.1 \\ + --top_k 20 \\ + --top_p 0.8 \\ + --n 1 \\ + --output_file outputs/qwen3_4b_base_lcb_v6.json +``` + +Evaluate an SSD-trained checkpoint with the same decoding configuration: + +```bash +python trl/experimental/ssd/ssd_eval.py \\ + --model_name_or_path outputs/ssd-qwen3-4b-instruct \\ + --temperature 1.1 \\ + --top_k 20 \\ + --top_p 0.8 \\ + --n 5 \\ + --output_file outputs/qwen3_4b_ssd_lcb_v6.json +``` +""" + +# ruff: noqa: T201 + +from __future__ import annotations + +import json +import re +from dataclasses import dataclass, field +from datetime import datetime + +from huggingface_hub import hf_hub_download +from lcb_runner.benchmarks.code_generation import CodeGenerationProblem +from lcb_runner.evaluation.compute_code_generation_metrics import codegen_metrics +from transformers import AutoTokenizer +from vllm import LLM, SamplingParams + +from trl import TrlParser + + +# LiveCodeBench stores new problems added in each release version in a separate JSONL file: +# ``test.jsonl`` = v1, ``test2.jsonl`` = v2, …, ``test6.jsonl`` = v6 (the delta added in release v6). +# The paper's "LCB v6" refers to exactly this delta. +LCB_REPO = "livecodebench/code_generation_lite" +LCB_V6_FILE = "test6.jsonl" + + +SYSTEM_MESSAGE = ( + "You are an expert Python programmer. You will be given a question (problem specification) and will " + "generate a correct Python program that matches the specification and passes all tests." +) +FORMATTING_WITHOUT_STARTER = ( + "Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on " + "the sample inputs). Enclose your code within delimiters as follows. Ensure that when the python " + "program runs, it reads the inputs, runs the algorithm and writes output to STDOUT." +) +FORMATTING_WITH_STARTER = ( + "You will use the following starter code to write the solution to the problem and enclose your code " + "within delimiters." +) + +CODE_FENCE_RE = re.compile(r"```(?:python)?\s*\n(.*?)```", re.DOTALL) + + +@dataclass +class SSDEvalArguments: + model_name_or_path: str = field(metadata={"help": "Model path or Hub repo id to evaluate."}) + output_file: str = field(metadata={"help": "Path to write generations + metrics JSON."}) + temperature: float = field(default=1.1, metadata={"help": "Evaluation-time sampling temperature (T_eval)."}) + top_k: int = field(default=20, metadata={"help": "Evaluation-time top-k truncation."}) + top_p: float = field(default=0.8, metadata={"help": "Evaluation-time top-p (nucleus) truncation."}) + n: int = field(default=1, metadata={"help": "Number of samples per problem (pass@1 uses 1, pass@5 uses 5)."}) + max_tokens: int = field(default=32768, metadata={"help": "Maximum tokens to generate per completion."}) + max_model_len: int = field(default=65536, metadata={"help": "vLLM max model length."}) + gpu_memory_utilization: float = field(default=0.9, metadata={"help": "vLLM GPU memory ratio."}) + tensor_parallel_size: int = field(default=1, metadata={"help": "vLLM tensor parallel size."}) + dtype: str = field(default="bfloat16", metadata={"help": "vLLM model dtype."}) + start_date: str | None = field( + default=None, metadata={"help": "Keep only problems with contest_date >= YYYY-MM-DD."} + ) + end_date: str | None = field( + default=None, metadata={"help": "Keep only problems with contest_date <= YYYY-MM-DD."} + ) + max_problems: int | None = field( + default=None, metadata={"help": "Evaluate at most N problems (useful for quick smoke tests)."} + ) + difficulty: str | None = field( + default=None, metadata={"help": "Filter to a single difficulty: 'easy', 'medium', or 'hard'."} + ) + timeout: int = field(default=6, metadata={"help": "Per-test execution timeout in seconds."}) + num_process_evaluate: int = field(default=8, metadata={"help": "Parallel processes for sandboxed evaluation."}) + seed: int = field(default=0, metadata={"help": "vLLM sampling seed."}) + + +def _build_prompt(tokenizer, question_content: str, starter_code: str) -> str: + """Build the LCB prompt and apply the model's chat template.""" + body = f"### Question:\n{question_content}\n\n" + if starter_code: + body += f"### Format: {FORMATTING_WITH_STARTER}\n" + body += f"```python\n{starter_code}\n```\n\n" + else: + body += f"### Format: {FORMATTING_WITHOUT_STARTER}\n" + body += "```python\n# YOUR CODE HERE\n```\n\n" + body += "### Answer: (use the provided format with backticks)\n\n" + messages = [ + {"role": "system", "content": SYSTEM_MESSAGE}, + {"role": "user", "content": body}, + ] + return tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) + + +def _extract_code(text: str) -> str: + """Extract the first Python code fence from a model completion.""" + match = CODE_FENCE_RE.search(text) + if match: + return match.group(1).strip() + # Fallback: if the model returned bare code without a fence, return the whole thing. + return text.strip() + + +def _load_lcb_v6_problems(args: SSDEvalArguments): + """Load LiveCodeBench v6 problems, filter by date/difficulty/count, and return as a list.""" + jsonl_path = hf_hub_download(repo_id=LCB_REPO, filename=LCB_V6_FILE, repo_type="dataset") + with open(jsonl_path) as f: + problems = [CodeGenerationProblem(**json.loads(line)) for line in f] + + if args.start_date is not None: + start = datetime.fromisoformat(args.start_date) + problems = [p for p in problems if p.contest_date >= start] + if args.end_date is not None: + end = datetime.fromisoformat(args.end_date) + problems = [p for p in problems if p.contest_date <= end] + if args.difficulty is not None: + problems = [p for p in problems if p.difficulty.value == args.difficulty] + if args.max_problems is not None: + problems = problems[: args.max_problems] + + return problems + + +def main(): + parser = TrlParser(SSDEvalArguments) + (args,) = parser.parse_args_and_config() + + problems = _load_lcb_v6_problems(args) + print(f"Evaluating {len(problems)} problems from LiveCodeBench v6") + + tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path) + prompts = [_build_prompt(tokenizer, p.question_content, p.starter_code) for p in problems] + + llm = LLM( + model=args.model_name_or_path, + dtype=args.dtype, + tensor_parallel_size=args.tensor_parallel_size, + max_model_len=args.max_model_len, + gpu_memory_utilization=args.gpu_memory_utilization, + ) + sampling_params = SamplingParams( + n=args.n, + temperature=args.temperature, + top_k=args.top_k, + top_p=args.top_p, + max_tokens=args.max_tokens, + seed=args.seed, + ) + outputs = llm.generate(prompts, sampling_params) + + generations_list = [] + for out in outputs: + code_list = [_extract_code(o.text) for o in out.outputs] + generations_list.append(code_list) + + samples_list = [p.get_evaluation_sample() for p in problems] + k_list = [1] if args.n == 1 else [1, args.n] + metrics, results, _metadata = codegen_metrics( + samples_list, + generations_list, + k_list=k_list, + num_process_evaluate=args.num_process_evaluate, + timeout=args.timeout, + ) + + # Break down pass@1 by difficulty for easier comparison with the paper's tables. `codegen_metrics` + # returns a nested `detail` dict keyed by problem index. + per_problem_pass1 = metrics["detail"]["pass@1"] + per_difficulty = {} + for difficulty in ("easy", "medium", "hard"): + idxs = [i for i, p in enumerate(problems) if p.difficulty.value == difficulty] + if not idxs: + continue + per_difficulty[difficulty] = { + "num_problems": len(idxs), + "pass@1": sum(per_problem_pass1[i] for i in idxs) / len(idxs), + } + + summary = { + "model": args.model_name_or_path, + "num_problems": len(problems), + "temperature": args.temperature, + "top_k": args.top_k, + "top_p": args.top_p, + "n": args.n, + "metrics": {k: float(v) for k, v in metrics.items() if k != "detail"}, + "per_difficulty": per_difficulty, + } + + detail = [ + { + "question_id": p.question_id, + "difficulty": p.difficulty.value, + "code_list": code_list, + "pass@1": per_problem_pass1[i], + } + for i, (p, code_list) in enumerate(zip(problems, generations_list, strict=False)) + ] + + with open(args.output_file, "w") as f: + json.dump({"summary": summary, "detail": detail}, f, indent=2) + + print("\n=== Summary ===") + print(json.dumps(summary, indent=2)) + print(f"\nFull results written to {args.output_file}") + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..3a7f83c3f171719fcdeb56d5f85bf6e5f99e97d5 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/ssd/ssd_trainer.py @@ -0,0 +1,532 @@ +# Copyright 2020-2026 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. + +"""Trainer for Simple Self-Distillation (SSD). + +Implements the method from *Embarrassingly Simple Self-Distillation Improves Code Generation* (Zhang et al., 2026): +sample completions from the frozen model at a training-time temperature and truncation configuration, then fine-tune on +those raw, unverified samples with standard cross-entropy loss. No reward model, verifier, teacher model, or +reinforcement learning is needed. +""" + +from __future__ import annotations + +import inspect +import math +import textwrap +from collections import defaultdict +from functools import partial +from typing import Any + +import datasets +import torch +from accelerate.logging import get_logger +from accelerate.utils import is_peft_model +from datasets import Dataset, IterableDataset +from torch import nn +from torch.utils.data import DataLoader, Sampler +from transformers import ( + AutoProcessor, + GenerationConfig, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, +) +from transformers.trainer_utils import seed_worker +from transformers.utils import is_datasets_available, is_peft_available + +from ...data_utils import maybe_apply_chat_template +from ...models import unwrap_model_for_generation +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import ( + RepeatSampler, + create_model_from_path, + disable_dropout_in_model, + get_config_model_id, + identity, + pad, + selective_log_softmax, + split_tensor_dict, +) +from ..utils import prepare_peft_model +from .ssd_config import SSDConfig + + +if is_peft_available(): + from peft import PeftConfig + + +logger = get_logger(__name__) + + +class SSDTrainer(_BaseTrainer): + """Trainer for SSD-style on-policy self-distillation with cross-entropy loss. + + SSD generates completions from the model at a specified training-time temperature and truncation configuration, + then fine-tunes on those raw, unverified samples using standard cross-entropy loss. The dataset only requires a + ``prompt`` column. + """ + + _tag_names = ["trl", "ssd"] + _name = "SSD" + config_cls = SSDConfig + # docstyle-ignore + _paper = { + "title": "Embarrassingly Simple Self-Distillation Improves Code Generation", + "id": "2604.01193", + "citation": textwrap.dedent("""\ + @article{zhang2026ssd, + title = {{Embarrassingly Simple Self-Distillation Improves Code Generation}}, + author = {Ruixiang Zhang and Richard He Bai and Huangjie Zheng and Navdeep Jaitly and Ronan Collobert and Yizhe Zhang}, + year = 2026, + eprint = {arXiv:2604.01193} + }"""), + } + + def __init__( + self, + model: str | PreTrainedModel | nn.Module, + args: SSDConfig | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + peft_config: PeftConfig | None = None, + ): + if train_dataset is None: + raise ValueError("`train_dataset` is required") + if isinstance(train_dataset, IterableDataset): + raise NotImplementedError("Iterable datasets are not yet supported in SSDTrainer.") + if isinstance(eval_dataset, IterableDataset) or ( + isinstance(eval_dataset, dict) and any(isinstance(ds, IterableDataset) for ds in eval_dataset.values()) + ): + raise NotImplementedError("Iterable eval datasets are not yet supported in SSDTrainer.") + if args is None: + model_name = model if isinstance(model, str) else get_config_model_id(model.config) + model_name = model_name.split("/")[-1] + args = SSDConfig(f"{model_name}-SSD") + if isinstance(model, str): + model_init_kwargs = args.model_init_kwargs or {} + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + model = create_model_from_path(model, **model_init_kwargs) + elif args.model_init_kwargs is not None: + logger.warning( + "You passed `model_init_kwargs` to `SSDConfig`, but `model` is already instantiated. " + "The `model_init_kwargs` will be ignored." + ) + + self.model_kwarg_keys = ( + inspect.signature(model.forward).parameters.keys() + if not hasattr(model, "get_base_model") + else inspect.signature(model.get_base_model().forward).parameters.keys() + ) + + # PEFT + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to SSDTrainer. Pass either a base " + "model with `peft_config`, or a pre-wrapped PEFT model." + ) + if peft_config is not None or (is_peft_available() and getattr(model, "peft_config", None) is not None): + model = prepare_peft_model(model, peft_config, args) + + if processing_class is None: + processing_class = AutoProcessor.from_pretrained( + get_config_model_id(model.config), + truncation_side="left", + padding_side="left", + trust_remote_code=args.trust_remote_code, + ) + + if isinstance(processing_class, ProcessorMixin): + self._tokenizer = processing_class.tokenizer + elif isinstance(processing_class, PreTrainedTokenizerBase): + self._tokenizer = processing_class + else: + raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`") + + if self._tokenizer.pad_token is None: + self._tokenizer.pad_token = self._tokenizer.eos_token + + self.max_prompt_length = args.max_prompt_length + self.max_completion_length = args.max_completion_length + # SSD always samples a single completion per prompt (N=1 in the paper). + self.num_generations = 1 + self.num_iterations = args.num_iterations + self.temperature = args.temperature + self.shuffle_dataset = args.shuffle_dataset + self.filter_empty = args.filter_empty + self.use_vllm = args.use_vllm + self.chat_template_kwargs = args.chat_template_kwargs or {} + self._step = 0 + self._buffered_inputs = None + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + + generation_kwargs = { + "max_new_tokens": self.max_completion_length, + "do_sample": True, + "pad_token_id": self._tokenizer.pad_token_id, + "bos_token_id": self._tokenizer.bos_token_id, + "eos_token_id": self._tokenizer.eos_token_id, + "temperature": args.temperature, + "top_p": args.top_p, + "top_k": args.top_k, + "min_p": args.min_p, + "repetition_penalty": args.repetition_penalty, + "cache_implementation": args.cache_implementation, + } + if args.generation_kwargs is not None: + generation_kwargs.update(args.generation_kwargs) + self.generation_config = GenerationConfig(**generation_kwargs, disable_compile=True) + + if hasattr(model, "warnings_issued"): + model.warnings_issued["estimate_tokens"] = True + + super().__init__( + model=model, + args=args, + data_collator=identity, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + callbacks=callbacks, + optimizers=optimizers, + compute_loss_func="non-None value to disable scaling", + ) + + if args.disable_dropout: + disable_dropout_in_model(self.model) + + self.model.add_model_tags(self._tag_names) + + self.model_accepts_loss_kwargs = False + + if self.use_vllm: + from ...generation.vllm_generation import VLLMGeneration + + self.vllm_generation = VLLMGeneration( + model=self.model, + accelerator=self.accelerator, + processing_class=self.processing_class, + mode=args.vllm_mode, + server_base_url=args.vllm_server_base_url, + server_host=args.vllm_server_host, + server_port=args.vllm_server_port, + group_port=args.vllm_group_port, + server_timeout=args.vllm_server_timeout, + tensor_parallel_size=args.vllm_tensor_parallel_size, + gpu_memory_utilization=args.vllm_gpu_memory_utilization, + max_model_length=args.vllm_max_model_length, + max_num_seqs=args.per_device_train_batch_size + * args.vllm_tensor_parallel_size + * args.steps_per_generation, + enable_sleep_mode=args.vllm_enable_sleep_mode, + model_impl=args.vllm_model_impl, + repetition_penalty=args.repetition_penalty, + temperature=self.temperature, + top_p=args.top_p, + top_k=args.top_k, + min_p=args.min_p, + max_completion_length=self.max_completion_length, + logprobs=None, + generation_kwargs=args.generation_kwargs, + ) + self._last_loaded_step = -1 + + def _set_signature_columns_if_needed(self): + if self._signature_columns is None: + self._signature_columns = ["prompt"] + + def _apply_prompt_template(self, prompts): + return [ + maybe_apply_chat_template({"prompt": prompt}, self.processing_class, **self.chat_template_kwargs)["prompt"] + for prompt in prompts + ] + + # ------------------------------------------------------------------ + # DataLoader + # ------------------------------------------------------------------ + + def get_train_dataloader(self): + if self.train_dataset is None: + raise ValueError("Trainer: training requires a train_dataset.") + + train_dataset = self.train_dataset + data_collator = self.data_collator + if is_datasets_available() and isinstance(train_dataset, datasets.Dataset): + train_dataset = self._remove_unused_columns(train_dataset, description="training") + else: + data_collator = self._get_collator_with_removed_columns(data_collator, description="training") + + dataloader_params = { + "batch_size": self._train_batch_size * self.args.steps_per_generation, + "collate_fn": data_collator, + "num_workers": self.args.dataloader_num_workers, + "pin_memory": self.args.dataloader_pin_memory, + "persistent_workers": self.args.dataloader_persistent_workers, + } + if not isinstance(train_dataset, torch.utils.data.IterableDataset): + dataloader_params["sampler"] = self._get_train_sampler() + dataloader_params["drop_last"] = self.args.dataloader_drop_last + dataloader_params["worker_init_fn"] = partial( + seed_worker, num_workers=self.args.dataloader_num_workers, rank=self.args.process_index + ) + dataloader_params["prefetch_factor"] = self.args.dataloader_prefetch_factor + return self.accelerator.prepare(DataLoader(train_dataset, **dataloader_params)) + + def _get_train_sampler(self, dataset=None) -> Sampler: + if dataset is None: + dataset = self.train_dataset + return RepeatSampler( + data_source=dataset, + mini_repeat_count=self.num_generations, + batch_size=self.args.generation_batch_size // self.num_generations, + repeat_count=self.num_iterations * self.args.steps_per_generation, + shuffle=self.shuffle_dataset, + seed=self.args.seed, + ) + + def _get_eval_sampler(self, eval_dataset) -> Sampler: + return RepeatSampler( + data_source=eval_dataset, + mini_repeat_count=self.num_generations, + seed=self.args.seed, + ) + + # ------------------------------------------------------------------ + # Training step management + # ------------------------------------------------------------------ + + def training_step(self, model, inputs, num_items_in_batch): + output = super().training_step(model, inputs, num_items_in_batch) + self._step += 1 + return output + + def _prepare_inputs(self, generation_batch): + mode = "train" if self.model.training else "eval" + if mode == "train": + generate_every = self.args.steps_per_generation * self.num_iterations + if self._step % generate_every == 0 or self._buffered_inputs is None: + generation_batch = self._build_buffered_batch(generation_batch) + self._buffered_inputs = split_tensor_dict(generation_batch, self.args.steps_per_generation) + return self._buffered_inputs[self._step % self.args.steps_per_generation] + return self._build_buffered_batch(generation_batch) + + # ------------------------------------------------------------------ + # Generation + # ------------------------------------------------------------------ + + def _generate_completion_ids(self, prompts: list[Any]) -> tuple[torch.Tensor, torch.Tensor]: + """Generate completions from the model at the configured training-time temperature and truncation.""" + if self.use_vllm: + return self._generate_completion_ids_vllm(prompts) + return self._generate_completion_ids_transformers(prompts) + + def _generate_completion_ids_vllm(self, prompts: list[Any]) -> tuple[torch.Tensor, torch.Tensor]: + """Generate completions using vLLM.""" + if self.state.global_step != self._last_loaded_step: + self.vllm_generation.sync_weights() + self._last_loaded_step = self.state.global_step + + prompts_text = self._apply_prompt_template(prompts) + tokenized = self.processing_class( + text=prompts_text, + return_tensors=None, + padding=False, + max_length=self.max_prompt_length, + truncation=True, + add_special_tokens=False, + ) + prompt_ids = tokenized["input_ids"] + + _, completion_ids_list, _, _ = self.vllm_generation.generate( + prompts=prompt_ids, + images=None, + num_generations=self.num_generations, + ) + + device = self.accelerator.device + completion_ids = [torch.tensor(ids, device=device) for ids in completion_ids_list] + completion_mask = [torch.ones(len(ids), dtype=torch.long, device=device) for ids in completion_ids_list] + return ( + pad(completion_ids, padding_value=self._tokenizer.pad_token_id, padding_side="right"), + pad(completion_mask, padding_value=0, padding_side="right"), + ) + + def _generate_completion_ids_transformers(self, prompts: list[Any]) -> tuple[torch.Tensor, torch.Tensor]: + """Generate completions using the training model with transformers.""" + generate_inputs = self.processing_class( + text=self._apply_prompt_template(prompts), + return_tensors="pt", + padding=True, + padding_side="left", + max_length=self.max_prompt_length, + truncation=True, + add_special_tokens=False, + ) + # Use the base Trainer tensor preparation instead of re-entering the buffered outer training hook. + generate_inputs = _BaseTrainer._prepare_inputs(self, generate_inputs) + + with ( + unwrap_model_for_generation( + self.model_wrapped, + self.accelerator, + gather_deepspeed3_params=self.args.ds3_gather_for_generation, + ) as unwrapped_model, + torch.no_grad(), + ): + prompt_completion_ids = unwrapped_model.generate( + **generate_inputs, generation_config=self.generation_config + ) + + prompt_length = generate_inputs["input_ids"].size(1) + completion_ids = prompt_completion_ids[:, prompt_length:] + is_eos = completion_ids == self._tokenizer.eos_token_id + eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=completion_ids.device) + eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)] + seq_idx = torch.arange(is_eos.size(1), device=completion_ids.device).expand(is_eos.size(0), -1) + completion_mask = (seq_idx <= eos_idx.unsqueeze(1)).long() + + completion_ids_list = [c[m].tolist() for c, m in zip(completion_ids, completion_mask.bool(), strict=True)] + completion_ids = [torch.tensor(ids, device=self.accelerator.device) for ids in completion_ids_list] + completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids] + return ( + pad(completion_ids, padding_value=self._tokenizer.pad_token_id, padding_side="right"), + pad(completion_mask, padding_value=0, padding_side="right"), + ) + + # ------------------------------------------------------------------ + # Batch construction + # ------------------------------------------------------------------ + + def _build_buffered_batch(self, inputs: list[dict[str, Any]]) -> dict[str, torch.Tensor | Any]: + """Generate completions and build the training batch.""" + prompts = [example["prompt"] for example in inputs] + completion_ids, completion_mask = self._generate_completion_ids(prompts) + + # Optionally filter empty or single-line stub completions (the paper applies minimal syntactic filtering) + if self.filter_empty: + completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + keep = torch.ones(len(completions_text), dtype=torch.bool, device=completion_ids.device) + for i, text in enumerate(completions_text): + stripped = text.strip() + if len(stripped) == 0 or stripped.count("\n") == 0 and len(stripped) < 10: + keep[i] = False + completion_mask = completion_mask * keep.unsqueeze(1).long() + + # Tokenize prompts for the training forward pass + prompt_text = self._apply_prompt_template(prompts) + prompt_inputs = self.processing_class( + text=prompt_text, + return_tensors="pt", + padding=True, + padding_side="left", + max_length=self.max_prompt_length, + truncation=True, + add_special_tokens=False, + ) + prompt_inputs = _BaseTrainer._prepare_inputs(self, prompt_inputs) + prompt_ids = prompt_inputs["input_ids"] + prompt_mask = prompt_inputs["attention_mask"] + + # Log completion statistics + mode = "train" if self.model.training else "eval" + completion_lengths = completion_mask.sum(dim=1).float() + agg_lengths = self.accelerator.gather(completion_lengths) + self._metrics[mode]["completions/mean_length"].append(agg_lengths.mean().item()) + self._metrics[mode]["completions/min_length"].append(agg_lengths.min().item()) + self._metrics[mode]["completions/max_length"].append(agg_lengths.max().item()) + active_ratio = (completion_mask.sum(dim=1) > 0).float().mean() + self._metrics[mode]["ssd/active_sample_ratio"].append(self.accelerator.gather(active_ratio).mean().item()) + + return { + "prompt_ids": prompt_ids, + "prompt_mask": prompt_mask, + "completion_ids": completion_ids, + "completion_mask": completion_mask, + } + + # ------------------------------------------------------------------ + # Loss computation + # ------------------------------------------------------------------ + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + if return_outputs: + raise ValueError("The SSDTrainer does not support returning outputs") + + prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"] + completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"] + input_ids = torch.cat([prompt_ids, completion_ids], dim=1) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + logits_to_keep = completion_ids.size(1) + + # Forward pass + model_inputs = {"input_ids": input_ids, "attention_mask": attention_mask, "use_cache": False} + if "logits_to_keep" in self.model_kwarg_keys: + model_inputs["logits_to_keep"] = logits_to_keep + 1 + logits = model(**model_inputs).logits + logits = logits[:, :-1, :] + logits = logits[:, -logits_to_keep:, :] + + # Standard cross-entropy loss: -log p(y_t | x, y None: + mode = "train" if self.model.training else "eval" + metrics = {} + for key, val in self._metrics[mode].items(): + valid = [v for v in val if not math.isnan(v)] + metrics[key] = sum(valid) / len(valid) if valid else None + + # When called in evaluation, the keys in `logs` start with "eval_". We need to add the prefix "eval_" to the + # keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e07ec04eb1b9f4d8a0cfeef4b64460f3c991c1fc --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .tpo_config import TPOConfig +from .tpo_trainer import TPOTrainer + + +__all__ = ["TPOConfig", "TPOTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/tpo.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/tpo.py new file mode 100644 index 0000000000000000000000000000000000000000..dfb01e860287cefda57ee2d9ee9156bdad0663f2 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/tpo.py @@ -0,0 +1,211 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl[peft]", +# "trackio", +# "kernels", +# ] +# /// + +""" +Triple Preference Optimization (TPO) training. + +TPO requires a *triple-preference* dataset where each example contains a `chosen`, a `rejected` and a `reference` +(gold) completion for the same prompt. Two dataset paths are supported out of the box: + +- Use the published + [`tpo-alignment/triple-preference-ultrafeedback-40K`](https://huggingface.co/datasets/tpo-alignment/triple-preference-ultrafeedback-40K) + dataset directly. It already has the `prompt` / `reference` / `chosen` / `rejected` schema. +- Pass `--dataset_name openbmb/UltraFeedback` and the script automatically builds the triple-preference dataset as + described in the TPO paper (Saeidi et al., 2025): the response with the highest `overall_score` becomes `reference`, + the second-highest becomes `chosen`, and the lowest becomes `rejected`. + +In both cases, if the dataset is in standard (plain-string) format it is auto-wrapped into the conversational format so +that the model's chat template is applied — this matches how Instruct models like `Qwen/Qwen3-0.6B` are trained. + +Usage: + +Full training: + +```bash +python trl/experimental/tpo/tpo.py \ + --dataset_name tpo-alignment/triple-preference-ultrafeedback-40K \ + --model_name_or_path Qwen/Qwen3-0.6B \ + --per_device_train_batch_size 2 \ + --max_steps 1000 \ + --learning_rate 5e-7 \ + --gradient_accumulation_steps 8 \ + --beta 0.01 \ + --tpo_alpha 1.0 \ + --output_dir Qwen3-0.6B-TPO \ + --no_remove_unused_columns +``` + +TPO-L (length-normalized variant with target reward margin): + +```bash +python trl/experimental/tpo/tpo.py \ + --dataset_name tpo-alignment/triple-preference-ultrafeedback-40K \ + --model_name_or_path Qwen/Qwen3-0.6B \ + --per_device_train_batch_size 2 \ + --max_steps 1000 \ + --learning_rate 5e-7 \ + --gradient_accumulation_steps 8 \ + --beta 0.01 \ + --tpo_alpha 1.0 \ + --loss_type tpo-l \ + --tpo_l_gamma 0.5 \ + --output_dir Qwen3-0.6B-TPO-L \ + --no_remove_unused_columns +``` + +LoRA: + +```bash +python trl/experimental/tpo/tpo.py \ + --dataset_name tpo-alignment/triple-preference-ultrafeedback-40K \ + --model_name_or_path Qwen/Qwen3-0.6B \ + --per_device_train_batch_size 2 \ + --max_steps 1000 \ + --learning_rate 5e-6 \ + --gradient_accumulation_steps 8 \ + --output_dir Qwen3-0.6B-TPO-LoRA \ + --no_remove_unused_columns \ + --use_peft \ + --lora_r 32 \ + --lora_alpha 16 +``` +""" + +import torch +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser + +from trl import ModelConfig, ScriptArguments, get_kbit_device_map, get_peft_config, get_quantization_config +from trl.experimental.tpo import TPOConfig, TPOTrainer + + +def build_triple_preference_from_ultrafeedback(example): + """ + Build a TPO triple-preference example from a raw UltraFeedback row. + + Following the TPO paper (Saeidi et al., 2025), completions are sorted by `overall_score` and we pick: + - the highest-scored response as the gold `reference`, + - the second-highest as `chosen`, + - the lowest as `rejected`. + + Emits the *conversational* format so that [`TPOTrainer`] applies the model's chat template automatically (see + `trl.data_utils.is_conversational`). Completions with a missing `overall_score` or `response` are filtered out; if + fewer than 3 valid completions remain, the returned example contains `None` values and should be filtered out + downstream. + """ + scored = [c for c in example["completions"] if c.get("overall_score") is not None and c.get("response")] + if len(scored) < 3: + return {"prompt": None, "reference": None, "chosen": None, "rejected": None} + scored.sort(key=lambda c: c["overall_score"], reverse=True) + return { + "prompt": [{"role": "user", "content": example["instruction"]}], + "reference": [{"role": "assistant", "content": scored[0]["response"]}], + "chosen": [{"role": "assistant", "content": scored[1]["response"]}], + "rejected": [{"role": "assistant", "content": scored[-1]["response"]}], + } + + +def to_conversational(example): + """ + Wrap a standard-format triple-preference example (plain strings) in the *conversational* format, so that + [`TPOTrainer`] applies the model's chat template automatically. This is the format expected by Instruct models; for + non-Instruct base models the standard format can be used directly. + """ + return { + "prompt": [{"role": "user", "content": example["prompt"]}], + "reference": [{"role": "assistant", "content": example["reference"]}], + "chosen": [{"role": "assistant", "content": example["chosen"]}], + "rejected": [{"role": "assistant", "content": example["rejected"]}], + } + + +if __name__ == "__main__": + parser = HfArgumentParser((ScriptArguments, TPOConfig, ModelConfig)) + script_args, training_args, model_args = parser.parse_args_into_dataclasses() + + ################ + # Model & Tokenizer + ################ + dtype = model_args.dtype if model_args.dtype in ["auto", None] else getattr(torch, model_args.dtype) + model_kwargs = dict( + revision=model_args.model_revision, + attn_implementation=model_args.attn_implementation, + dtype=dtype, + ) + quantization_config = get_quantization_config(model_args) + if quantization_config is not None: + model_kwargs["device_map"] = get_kbit_device_map() + model_kwargs["quantization_config"] = quantization_config + + model = AutoModelForCausalLM.from_pretrained(model_args.model_name_or_path, **model_kwargs) + tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + ################ + # Dataset + ################ + dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config) + + # Auto-build the triple-preference schema from raw UltraFeedback. + first_example = next(iter(dataset[script_args.dataset_train_split])) + if "completions" in first_example and "instruction" in first_example: + dataset = dataset.map( + build_triple_preference_from_ultrafeedback, + remove_columns=list(first_example.keys()), + ) + dataset = dataset.filter(lambda ex: ex["reference"] is not None) + first_example = next(iter(dataset[script_args.dataset_train_split])) + + # Auto-wrap standard-format triple-preference data (plain strings) into conversational messages so the + # model's chat template gets applied. This matches how Instruct models are trained and is what the TPO + # paper's data preparation produces. + if {"prompt", "chosen", "rejected", "reference"}.issubset(first_example) and isinstance( + first_example["prompt"], str + ): + dataset = dataset.map(to_conversational) + + ################ + # Training + ################ + trainer = TPOTrainer( + model, + args=training_args, + train_dataset=dataset[script_args.dataset_train_split], + eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None, + processing_class=tokenizer, + peft_config=get_peft_config(model_args), + ) + + # train and save the model + trainer.train() + + # Run a final evaluation pass and persist the metrics + if training_args.eval_strategy != "no": + metrics = trainer.evaluate() + trainer.log_metrics("eval", metrics) + trainer.save_metrics("eval", metrics) + + # Save and push to hub + trainer.save_model(training_args.output_dir) + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/tpo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/tpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..2e05a73b39c683326c4a3a2e6cbb44dfc0ebded7 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/tpo_config.py @@ -0,0 +1,174 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field +from typing import Any + +from ...trainer.base_config import _BaseConfig + + +@dataclass +class TPOConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`experimental.tpo.TPOTrainer`]. + + This class includes only the parameters that are specific to TPO training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + 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: + > Parameters that control the model + + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model` + argument of the [`experimental.tpo.TPOTrainer`] is provided as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and + [`~transformers.AutoProcessor.from_pretrained`]. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model. + + > Parameters that control the data preprocessing + + dataset_num_proc (`int`, *optional*): + Number of processes to use for processing the dataset. + max_length (`int` or `None`, *optional*, defaults to `1024`): + Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from the left or + right depending on the `truncation_mode`. If `None`, no truncation is applied. + truncation_mode (`str`, *optional*, defaults to `"keep_start"`): + Truncation mode to use when the sequence exceeds `max_length`. Possible values are `"keep_start"` and + `"keep_end"`. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + + > Parameters that control the training + + loss_type (`str`, *optional*, defaults to `"sigmoid"`): + Type of loss to use. Possible values are: + + - `"sigmoid"`: sigmoid loss from the original [TPO](https://huggingface.co/papers/2405.16681) paper. + - `"hinge"`: hinge loss on the normalized likelihood from the + [SLiC](https://huggingface.co/papers/2305.10425) paper. + - `"ipo"`: IPO loss from the [IPO](https://huggingface.co/papers/2310.12036) paper. + - `"tpo-l"`: length-normalized TPO variant from the + [TPO](https://huggingface.co/papers/2405.16681) paper, which adds a target reward margin + `tpo_l_gamma` to the Bradley-Terry objective. + + beta (`float`, *optional*, defaults to `0.01`): + Parameter controlling the temperature of the TPO loss. For the IPO loss (`loss_type="ipo"`), β is the + regularization parameter denoted by τ in the [paper](https://huggingface.co/papers/2310.12036). + label_smoothing (`float`, *optional*, defaults to `0.0`): + Label smoothing factor. + tpo_alpha (`float`, *optional*, defaults to `1.0`): + Weight of the supervised negative log-likelihood term computed on the gold (`reference`) response in TPO + training. Setting `tpo_alpha=0.0` disables the NLL term and skips the corresponding forward pass. + tpo_l_gamma (`float`, *optional*, defaults to `0.5`): + Target reward margin γ for the TPO-L loss, used only when `loss_type="tpo-l"`. + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `5e-7` instead of `5e-5`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=5e-7, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + # Parameters that control the model + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument of " + "the `TPOTrainer` is provided as a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the model."}, + ) + + # Parameters that control the data preprocessing + dataset_num_proc: int | None = field( + default=None, + metadata={"help": "Number of processes to use for processing the dataset."}, + ) + max_length: int | None = field( + default=1024, + metadata={ + "help": "Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from " + "the left or right depending on the `truncation_mode`. If `None`, no truncation is applied." + }, + ) + truncation_mode: str = field( + default="keep_start", + metadata={ + "help": "Truncation mode to use when the sequence exceeds `max_length`.", + "choices": ["keep_end", "keep_start"], + }, + ) + pad_to_multiple_of: int | None = field( + default=None, + metadata={"help": "If set, the sequences will be padded to a multiple of this value."}, + ) + + # Parameters that control the training + loss_type: str = field( + default="sigmoid", + metadata={ + "help": "Type of loss to use.", + "choices": ["sigmoid", "hinge", "ipo", "tpo-l"], + }, + ) + beta: float = field( + default=0.01, + metadata={ + "help": "Parameter controlling the temperature of the TPO loss. For the IPO loss (`loss_type='ipo'`), this " + "value is the regularization parameter denoted by τ in the IPO paper." + }, + ) + label_smoothing: float = field( + default=0.0, + metadata={"help": "Label smoothing factor."}, + ) + tpo_alpha: float = field( + default=1.0, + metadata={ + "help": "Weight of the supervised NLL term computed on the gold (`reference`) response in TPO training. " + "Setting `tpo_alpha=0.0` disables the NLL term and skips the corresponding forward pass." + }, + ) + tpo_l_gamma: float = field( + default=0.5, + metadata={"help": "Target reward margin γ for the TPO-L loss, used only when `loss_type='tpo-l'`."}, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/tpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/tpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..0ea3a6f86f6346376969c263790a1b12e7e8fc80 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/tpo/tpo_trainer.py @@ -0,0 +1,790 @@ +# Copyright 2020-2026 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 textwrap +from collections import defaultdict +from collections.abc import Callable +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import torch +import torch.nn.functional as F +import transformers +from accelerate import PartialState +from accelerate.logging import get_logger +from accelerate.utils import is_peft_model +from datasets import Dataset, IterableDataset +from packaging.version import Version +from transformers import ( + AutoProcessor, + DataCollator, + PreTrainedModel, + PreTrainedTokenizerBase, +) +from transformers.data.data_collator import DataCollatorMixin +from transformers.trainer_callback import TrainerCallback +from transformers.trainer_utils import EvalPrediction +from transformers.utils import is_peft_available + +from ...data_utils import extract_prompt, is_conversational +from ...trainer.base_trainer import _BaseTrainer +from ...trainer.utils import ( + create_model_from_path, + disable_dropout_in_model, + entropy_from_logits, + get_config_model_id, + pad, + selective_log_softmax, +) +from .tpo_config import TPOConfig + + +if is_peft_available(): + from peft import PeftConfig, PeftModel, get_peft_model + + +logger = get_logger(__name__) + + +def _extract_triple_prompt(example: dict) -> dict: + """Extract the shared prompt from `chosen`/`rejected` and also strip it from `reference`. + + Wraps [`~trl.data_utils.extract_prompt`] — which only rewrites `chosen` and `rejected` — and additionally strips + the extracted prompt prefix from the `reference` (gold) completion. This is specific to TPO and assumes that the + `reference` completion shares the same implicit prompt prefix as `chosen` and `rejected`. If it does not, a + `ValueError` is raised asking the caller to provide an explicit `prompt` column. + """ + extracted = extract_prompt(example) + prompt = extracted["prompt"] + reference = example["reference"] + if reference[: len(prompt)] != prompt: + raise ValueError( + "The `reference` completion does not start with the implicit prompt extracted from `chosen`/`rejected`. " + "Either provide an explicit `prompt` column, or make sure the `reference` completion shares the same " + "prompt prefix as the `chosen` and `rejected` completions." + ) + extracted["reference"] = reference[len(prompt) :] + return extracted + + +@dataclass +class DataCollatorForTriplePreference(DataCollatorMixin): + """ + Data collator used for triple-preference data. Inputs are dynamically padded to the maximum length of a batch. + + This collator expects each example in the input list to be a dictionary containing the keys `"prompt_ids"`, + `"chosen_ids"` and `"rejected_ids"`. When `include_reference=True` (the default) each example must additionally + contain `"reference_ids"`. The collator returns a dictionary containing the following keys: + - `"input_ids"`: Tensor of input IDs, padded to the maximum length of the batch. When + `include_reference=True`, the first third of the batch corresponds to the `"chosen_ids"`, the second third to + the `"rejected_ids"` and the last third to the `"reference_ids"`. When `include_reference=False`, the first + half corresponds to the `"chosen_ids"` and the second half to the `"rejected_ids"` (matching the layout of + [`~trl.trainer.dpo_trainer.DataCollatorForPreference`]). + - `"attention_mask"`: Tensor of attention mask, padded to the maximum length of the batch. + - `"completion_mask"`: Tensor indicating the positions of the completion tokens, padded to the maximum length of + the batch. + + Args: + pad_token_id (`int`): + Token ID to use for padding. + max_length (`int`, *optional*): + Maximum length of the sequences after concatenation. Sequences longer than `max_length` are truncated + before padding, which avoids allocating oversized tensors for batches containing very long sequences. + truncation_mode (`str`, *optional*, defaults to `"keep_start"`): + Truncation mode when a concatenated sequence exceeds `max_length`. Possible values are `"keep_end"` and + `"keep_start"`. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + return_tensors (`str`, *optional*, defaults to `"pt"`): + Type of Tensor to return. Only `"pt"` is currently supported. + include_reference (`bool`, *optional*, defaults to `True`): + Whether to include the `"reference_ids"` branch in the collated batch. When `False`, the collator emits + only the chosen/rejected halves and skips the gold-response sequences entirely, which matches the behavior + expected when `tpo_alpha=0.0` (no NLL term). + + Examples: + ```python + >>> from trl.experimental.tpo.tpo_trainer import DataCollatorForTriplePreference + + >>> collator = DataCollatorForTriplePreference(pad_token_id=0) + >>> examples = [ + ... {"prompt_ids": [1, 2, 3], "chosen_ids": [4, 5], "rejected_ids": [6], "reference_ids": [7, 8]}, + ... {"prompt_ids": [9, 10], "chosen_ids": [11], "rejected_ids": [12, 13], "reference_ids": [14]}, + ... ] + >>> collator(examples) + {'input_ids': tensor([[ 1, 2, 3, 4, 5], + [ 9, 10, 11, 0, 0], + [ 1, 2, 3, 6, 0], + [ 9, 10, 12, 13, 0], + [ 1, 2, 3, 7, 8], + [ 9, 10, 14, 0, 0]]), + 'attention_mask': tensor([[1, 1, 1, 1, 1], + [1, 1, 1, 0, 0], + [1, 1, 1, 1, 0], + [1, 1, 1, 1, 0], + [1, 1, 1, 1, 1], + [1, 1, 1, 0, 0]]), + 'completion_mask': tensor([[0, 0, 0, 1, 1], + [0, 0, 1, 0, 0], + [0, 0, 0, 1, 0], + [0, 0, 1, 1, 0], + [0, 0, 0, 1, 1], + [0, 0, 1, 0, 0]])} + ``` + """ + + pad_token_id: int + max_length: int | None = None + truncation_mode: str = "keep_start" + pad_to_multiple_of: int | None = None + return_tensors: str = "pt" + include_reference: bool = True + + def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]: + prompt_chosen_ids = [example["prompt_ids"] + example["chosen_ids"] for example in examples] + prompt_rejected_ids = [example["prompt_ids"] + example["rejected_ids"] for example in examples] + chosen_mask = [[0] * len(example["prompt_ids"]) + [1] * len(example["chosen_ids"]) for example in examples] + rejected_mask = [[0] * len(example["prompt_ids"]) + [1] * len(example["rejected_ids"]) for example in examples] + if self.include_reference: + prompt_reference_ids = [example["prompt_ids"] + example["reference_ids"] for example in examples] + reference_mask = [ + [0] * len(example["prompt_ids"]) + [1] * len(example["reference_ids"]) for example in examples + ] + + if self.max_length is not None: + if self.truncation_mode == "keep_start": + sl = slice(None, self.max_length) + elif self.truncation_mode == "keep_end": + sl = slice(-self.max_length, None) + else: + raise ValueError( + f"Unsupported truncation mode: {self.truncation_mode}, expected 'keep_start' or 'keep_end'" + ) + prompt_chosen_ids = [ids[sl] for ids in prompt_chosen_ids] + prompt_rejected_ids = [ids[sl] for ids in prompt_rejected_ids] + chosen_mask = [m[sl] for m in chosen_mask] + rejected_mask = [m[sl] for m in rejected_mask] + if self.include_reference: + prompt_reference_ids = [ids[sl] for ids in prompt_reference_ids] + reference_mask = [m[sl] for m in reference_mask] + + chosen_attention_mask = [[1] * len(ids) for ids in prompt_chosen_ids] + rejected_attention_mask = [[1] * len(ids) for ids in prompt_rejected_ids] + input_ids = prompt_chosen_ids + prompt_rejected_ids + attention_mask = chosen_attention_mask + rejected_attention_mask + completion_mask = chosen_mask + rejected_mask + if self.include_reference: + reference_attention_mask = [[1] * len(ids) for ids in prompt_reference_ids] + input_ids = input_ids + prompt_reference_ids + attention_mask = attention_mask + reference_attention_mask + completion_mask = completion_mask + reference_mask + + # Convert to tensor + input_ids = [torch.tensor(ids) for ids in input_ids] + attention_mask = [torch.tensor(m, dtype=torch.long) for m in attention_mask] + completion_mask = [torch.tensor(m, dtype=torch.long) for m in completion_mask] + + # Pad + output = {} + output["input_ids"] = pad( + input_ids, + padding_value=self.pad_token_id, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + output["attention_mask"] = pad( + attention_mask, + padding_value=0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + output["completion_mask"] = pad( + completion_mask, + padding_value=0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + return output + + +class TPOTrainer(_BaseTrainer): + """ + Trainer for Triple Preference Optimization (TPO) method. This algorithm was initially proposed in the paper [Triple + Preference Optimization: Achieving Better Alignment using a Single Step + Optimization](https://huggingface.co/papers/2405.16681). This class is a wrapper around the + [`~transformers.Trainer`] class and inherits all of its attributes and methods. + + Args: + model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]): + Model to be trained. Can be either: + + - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using `.from_pretrained` (where `` is derived from the model + config) with the keyword arguments in `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported. + - A [`~peft.PeftModel`] object. Only causal language models are supported. + args ([`experimental.tpo.TPOConfig`], *optional*): + Configuration for this trainer. If `None`, a default configuration is used. + data_collator ([`~transformers.DataCollator`], *optional*): + Function to use to form a batch from a list of elements of the processed `train_dataset` or `eval_dataset`. + Will default to [`~trl.experimental.tpo.tpo_trainer.DataCollatorForTriplePreference`]. Custom collators + must truncate sequences before padding; the trainer does not apply post-collation truncation. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + Dataset to use for training. TPO requires a *triple-preference* dataset: each sample must contain a + `"chosen"`, a `"rejected"` and a `"reference"` (gold) completion. The format of the samples can be either: + + - [Standard](dataset_formats#standard): Each sample contains plain text. + - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role + and content). + eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`): + Dataset to use for evaluation. It must meet the same requirements as `train_dataset`. + processing_class ([`~transformers.PreTrainedTokenizerBase`], *optional*): + Processing class used to process the data. If `None`, the processing class is loaded from the model's name + with [`~transformers.AutoProcessor.from_pretrained`]. A padding token, `tokenizer.pad_token`, must be set. + If the processing class has not set a padding token, `tokenizer.eos_token` will be used as the default. + compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*): + The function that will be used to compute metrics at evaluation. Must take a + [`~transformers.EvalPrediction`] and return a dictionary string to metric values. + callbacks (list of [`~transformers.TrainerCallback`], *optional*): + List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed + in [here](https://huggingface.co/docs/transformers/main_classes/callback). + + If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`] + method. + optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`): + A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your + model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration used to wrap the model. If `None`, the model is not wrapped. + """ + + _tag_names = ["trl", "tpo"] + _name = "TPO" + _paper = { + "title": "Triple Preference Optimization: Achieving Better Alignment using a Single Step Optimization", + "id": "2405.16681", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @misc{saeidi2025triplepreferenceoptimizationachieving, + title = {{Triple Preference Optimization: Achieving Better Alignment using a Single Step Optimization}}, + author = {Amir Saeidi and Shivanshu Verma and Aswin RRV and Kashif Rasul and Chitta Baral}, + year = 2025, + eprint = {2405.16681}, + archivePrefix= {arXiv}, + primaryClass = {cs.CL}, + url = {https://arxiv.org/abs/2405.16681}, + }"""), + } + + def __init__( + self, + model: "str | PreTrainedModel | PeftModel", + args: TPOConfig | None = None, + data_collator: DataCollator | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | None = None, + compute_metrics: Callable[[EvalPrediction], dict] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + peft_config: "PeftConfig | None" = None, + ): + # Args + if args is None: + model_name = model if isinstance(model, str) else get_config_model_id(model.config) + model_name = model_name.split("/")[-1] + args = TPOConfig(f"{model_name}-TPO") + + if train_dataset is None: + raise ValueError("`train_dataset` is required") + elif isinstance(train_dataset, IterableDataset): + # IterableDataset requires dispatch_batches=False because Accelerate's dispatch mode may try to concatenate + # batches from multiple processes, leading to mismatch errors. + if args.accelerator_config.dispatch_batches is True: + logger.warning( + "You are using an `IterableDataset` for training with `dispatch_batches=True`. `dispatch_batches` " + "is forced to `False` when using an `IterableDataset`. To remove this warning, unset " + "`dispatch_batches` in `TPOConfig` or set it to `False`." + ) + args.accelerator_config.dispatch_batches = False + + # Model + if isinstance(model, str): + model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + model = create_model_from_path(model, **model_init_kwargs) + else: + if args.model_init_kwargs is not None: + logger.warning( + "You passed `model_init_kwargs` to the `TPOConfig`, but your model is already instantiated. " + "The `model_init_kwargs` will be ignored." + ) + + # Processing class + if processing_class is None: + processing_class = AutoProcessor.from_pretrained( + get_config_model_id(model.config), trust_remote_code=args.trust_remote_code + ) + if not isinstance(processing_class, PreTrainedTokenizerBase): + raise TypeError( + "The `processing_class` must be a `PreTrainedTokenizerBase`. `TPOTrainer` does not currently " + "support vision-language models." + ) + self._tokenizer = processing_class + + if self._tokenizer.pad_token is None: + self._tokenizer.pad_token = self._tokenizer.eos_token + + # PEFT + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge " + "and unload the existing adapter, save the resulting base model, and then pass that base model along " + "with the new `peft_config` to the trainer." + ) + # Create PEFT model + model = get_peft_model(model, peft_config) + + # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally + # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489 + if is_peft_model(model) and args.gradient_checkpointing: + model.enable_input_require_grads() + + # Data collator. When `tpo_alpha=0.0`, the NLL term on the gold response is disabled, so we can drop the + # reference branch from the batch entirely — this spares the model from computing logits for a third of + # each step. + if data_collator is None: + data_collator = DataCollatorForTriplePreference( + pad_token_id=self._tokenizer.pad_token_id, + max_length=args.max_length, + truncation_mode=args.truncation_mode, + pad_to_multiple_of=args.pad_to_multiple_of, + include_reference=args.tpo_alpha != 0.0, + ) + + # Training arguments + self.beta = args.beta + self.loss_type = args.loss_type + self.label_smoothing = args.label_smoothing + self.tpo_alpha = args.tpo_alpha + self.tpo_l_gamma = args.tpo_l_gamma + if self.loss_type in ["hinge", "ipo"] and self.label_smoothing > 0: + logger.warning( + f"You are using the {self.loss_type} loss type that does not support label smoothing. The " + "`label_smoothing` parameter will be ignored. Set `label_smoothing` to `0.0` to remove this warning." + ) + + # Dataset + train_dataset = self._prepare_dataset(train_dataset, processing_class, args, "train") + if eval_dataset is not None: + if isinstance(eval_dataset, dict): + eval_dataset = { + key: self._prepare_dataset(dataset, processing_class, args, key) + for key, dataset in eval_dataset.items() + } + else: + eval_dataset = self._prepare_dataset(eval_dataset, processing_class, args, "eval") + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + ) + + # Disable dropout in the model + if args.disable_dropout: + disable_dropout_in_model(model) + + # Initialize the metrics + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + self._total_train_tokens = 0 + + # Add tags to the model + self.model.add_model_tags(self._tag_names) + + def _tokenize( + self, + processing_class: PreTrainedTokenizerBase, + input: str | list, + **kwargs, + ) -> dict[str, list]: + """Tokenize a single example for dataset preprocessing. + + Dispatches to `apply_chat_template` for conversational input (list of message dicts) and to `__call__` for + non-conversational input (str). + + Args: + processing_class ([`~transformers.PreTrainedTokenizerBase`]): + The tokenizer to use. + input (`str` or `list`): + A string for non-conversational input, or a list of message dicts for conversational input. + **kwargs: + Forwarded to `apply_chat_template` (e.g. `add_generation_prompt`). + + Returns: + `dict` with at least an `"input_ids"` key mapping to a flat `list[int]`. + """ + if isinstance(input, list): # conversational: list of message dicts + return processing_class.apply_chat_template(input, tokenize=True, return_dict=True, **kwargs) + # non-conversational: plain text string + return processing_class(text=input) + + def _prepare_dataset( + self, + dataset: Dataset | IterableDataset, + processing_class: PreTrainedTokenizerBase, + args: TPOConfig, + dataset_name: str, + ) -> Dataset | IterableDataset: + # Validate that the triple-preference columns are present + first_example = next(iter(dataset)) + if "chosen" not in first_example or "rejected" not in first_example: + raise ValueError( + "TPO requires a triple-preference dataset with `chosen`, `rejected` and `reference` columns, but the " + f"dataset is missing `chosen` or `rejected`. Got columns: {list(first_example.keys())}." + ) + if "reference" not in first_example: + raise ValueError( + "TPO requires a triple-preference dataset with `chosen`, `rejected` and `reference` columns, but the " + f"dataset is missing the `reference` (gold) column. Got columns: {list(first_example.keys())}." + ) + + # Build the kwargs for the `map` function + map_kwargs = {} + if isinstance(dataset, Dataset): # IterableDataset does not support num_proc + map_kwargs["num_proc"] = args.dataset_num_proc + + with PartialState().main_process_first(): + # Extract the prompt if needed. Unlike DPO, we must also strip the extracted prompt from the reference + # column (see `_extract_triple_prompt`), which assumes the reference shares the same implicit prompt. + first_example = next(iter(dataset)) + if "prompt" not in first_example: + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Extracting prompt from {dataset_name} dataset" + dataset = dataset.map(_extract_triple_prompt, **map_kwargs) + + # Add EOS to completions for non-conversational data + first_example = next(iter(dataset)) + if not is_conversational(first_example): + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Adding EOS to {dataset_name} dataset" + + def add_eos(example, eos_token): + if not example["chosen"].endswith(eos_token): + example["chosen"] = example["chosen"] + eos_token + if not example["rejected"].endswith(eos_token): + example["rejected"] = example["rejected"] + eos_token + if not example["reference"].endswith(eos_token): + example["reference"] = example["reference"] + eos_token + return example + + dataset = dataset.map(add_eos, fn_kwargs={"eos_token": processing_class.eos_token}, **map_kwargs) + + # Tokenize the dataset + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset" + + def tokenize_fn(example, processing_class): + tools = example.get("tools") + tools = json.loads(tools) if isinstance(tools, str) else tools + output = {} + if is_conversational(example): + prompt_ids = self._tokenize( + processing_class, + example["prompt"], + tools=tools, + add_generation_prompt=True, + **example.get("chat_template_kwargs", {}), + )["input_ids"] + prompt_chosen_ids = self._tokenize( + processing_class, + example["prompt"] + example["chosen"], + tools=tools, + **example.get("chat_template_kwargs", {}), + )["input_ids"] + prompt_rejected_ids = self._tokenize( + processing_class, + example["prompt"] + example["rejected"], + tools=tools, + **example.get("chat_template_kwargs", {}), + )["input_ids"] + prompt_reference_ids = self._tokenize( + processing_class, + example["prompt"] + example["reference"], + tools=tools, + **example.get("chat_template_kwargs", {}), + )["input_ids"] + else: + prompt_ids = self._tokenize(processing_class, example["prompt"])["input_ids"] + prompt_chosen_ids = self._tokenize(processing_class, example["prompt"] + example["chosen"])[ + "input_ids" + ] + prompt_rejected_ids = self._tokenize(processing_class, example["prompt"] + example["rejected"])[ + "input_ids" + ] + prompt_reference_ids = self._tokenize(processing_class, example["prompt"] + example["reference"])[ + "input_ids" + ] + + # Check if the tokenized prompt starts with the tokenized prompt+completion + if not prompt_chosen_ids[: len(prompt_ids)] == prompt_ids: + logger.warning( + "Mismatch between tokenized prompt and the start of tokenized prompt+chosen. " + "This may be due to unexpected tokenizer behavior, whitespace issues, or special " + "token handling. Verify that the tokenizer is processing text consistently." + ) + if not prompt_rejected_ids[: len(prompt_ids)] == prompt_ids: + logger.warning( + "Mismatch between tokenized prompt and the start of tokenized prompt+rejected. " + "This may be due to unexpected tokenizer behavior, whitespace issues, or special " + "token handling. Verify that the tokenizer is processing text consistently." + ) + if not prompt_reference_ids[: len(prompt_ids)] == prompt_ids: + logger.warning( + "Mismatch between tokenized prompt and the start of tokenized prompt+reference. " + "This may be due to unexpected tokenizer behavior, whitespace issues, or special " + "token handling. Verify that the tokenizer is processing text consistently." + ) + + output["prompt_ids"] = prompt_ids + output["chosen_ids"] = prompt_chosen_ids[len(prompt_ids) :] + output["rejected_ids"] = prompt_rejected_ids[len(prompt_ids) :] + output["reference_ids"] = prompt_reference_ids[len(prompt_ids) :] + return output + + dataset = dataset.map(tokenize_fn, fn_kwargs={"processing_class": processing_class}, **map_kwargs) + + return dataset + + def _set_signature_columns_if_needed(self): + # If `self.args.remove_unused_columns` is True, non-signature columns are removed. + # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids" + # and "attention_mask"). + if self._signature_columns is None: + self._signature_columns = ["prompt_ids", "chosen_ids", "rejected_ids", "reference_ids"] + + def _compute_loss(self, model, inputs, return_outputs): + mode = "train" if self.model.training else "eval" + + # When `tpo_alpha=0.0` the NLL term is disabled and the collator drops the reference branch, so the batch + # is laid out as `[chosen, rejected]` (n_branches=2). Otherwise it is `[chosen, rejected, reference]` + # (n_branches=3). + n_branches = 3 if self.tpo_alpha != 0.0 else 2 + + _non_model_keys = {"completion_mask"} + model_kwargs = {k: v for k, v in inputs.items() if k not in _non_model_keys} + model_kwargs["use_cache"] = False + outputs = model(**model_kwargs) + + input_ids = inputs["input_ids"] + completion_mask = inputs["completion_mask"] + shift_logits = outputs.logits[..., :-1, :] + shift_labels = input_ids[..., 1:] + shift_completion_mask = completion_mask[..., 1:] + per_token_logps = selective_log_softmax(shift_logits, shift_labels) + per_token_logps[shift_completion_mask == 0] = 0.0 # mask out non-completion tokens + + # Length-normalized for IPO and TPO-L (matches the SimPO-style implicit reward used by the TPO paper); + # summed otherwise. + if self.loss_type in ("ipo", "tpo-l"): + completion_lengths = shift_completion_mask.sum(dim=1).clamp(min=1) + logps = per_token_logps.sum(dim=1) / completion_lengths + else: + logps = per_token_logps.sum(dim=1) + logps_chunks = logps.chunk(n_branches, dim=0) + chosen_logps, rejected_logps = logps_chunks[0], logps_chunks[1] + + # Contrastive loss between chosen and rejected. Unlike DPO, TPO does not subtract reference-model log-probs: + # the "reference" in TPO is a gold response used in the NLL term below, not a separate reference policy. + delta_score = chosen_logps - rejected_logps + + if self.loss_type == "sigmoid": + per_sequence_loss = ( + -F.logsigmoid(self.beta * delta_score) * (1 - self.label_smoothing) + - F.logsigmoid(-self.beta * delta_score) * self.label_smoothing + ) + + elif self.loss_type == "hinge": + per_sequence_loss = torch.relu(1 - self.beta * delta_score) + + elif self.loss_type == "ipo": + # (Eq. 17) of the IPO paper where beta is the regularization parameter for the IPO loss, denoted by τ. + per_sequence_loss = (delta_score - 1 / (2 * self.beta)) ** 2 + + elif self.loss_type == "tpo-l": + # Length-normalized TPO-L variant: subtract a target reward margin γ/β before the sigmoid. + gamma_logratios = self.tpo_l_gamma / self.beta + shifted_delta = delta_score - gamma_logratios + per_sequence_loss = ( + -F.logsigmoid(self.beta * shifted_delta) * (1 - self.label_smoothing) + - F.logsigmoid(-self.beta * shifted_delta) * self.label_smoothing + ) + + else: + raise ValueError( + f"Unknown loss type: {self.loss_type}. Should be one of ['sigmoid', 'hinge', 'ipo', 'tpo-l']" + ) + + loss = per_sequence_loss.mean() + + # NLL loss on the gold (`reference`) response. Mirrors the `"sft"` loss branch of `DPOTrainer._compute_loss`: + # we restrict the cross-entropy to the completion tokens of the reference sequence and let `F.cross_entropy` + # average over them. The NLL contribution is folded into the main `loss` (matching DPO/SFT convention: the + # individual NLL term is not logged separately). + if n_branches == 3: + _, _, ref_logits = shift_logits.chunk(3, dim=0) + _, _, ref_labels = shift_labels.chunk(3, dim=0) + _, _, ref_mask = shift_completion_mask.chunk(3, dim=0) + ref_mask = ref_mask.bool() + nll_loss = F.cross_entropy(ref_logits[ref_mask], ref_labels[ref_mask]) + loss = loss + self.tpo_alpha * nll_loss + + # Log the metrics + # Entropy + per_token_entropy = entropy_from_logits(shift_logits.detach()) + entropy = per_token_entropy[shift_completion_mask.bool()].mean() + entropy = self.accelerator.gather_for_metrics(entropy).mean().item() + self._metrics[mode]["entropy"].append(entropy) + + # Number of tokens + if mode == "train": + num_tokens_in_batch = self.accelerator.gather_for_metrics(inputs["attention_mask"].sum()).sum().item() + self._total_train_tokens += num_tokens_in_batch + self._metrics[mode]["num_tokens"] = [self._total_train_tokens] + + # Average logits for chosen and rejected completions + logits_chunks = shift_logits.detach().chunk(n_branches, dim=0) + mask_chunks = shift_completion_mask.chunk(n_branches, dim=0) + labels_chunks = shift_labels.chunk(n_branches, dim=0) + chosen_logits, rejected_logits = logits_chunks[0], logits_chunks[1] + chosen_mask, rejected_mask = mask_chunks[0], mask_chunks[1] + chosen_labels = labels_chunks[0] + total_chosen_logits = chosen_logits[chosen_mask.bool()].mean(-1).sum() + total_chosen_tokens = chosen_mask.sum() + total_rejected_logits = rejected_logits[rejected_mask.bool()].mean(-1).sum() + total_rejected_tokens = rejected_mask.sum() + total_chosen_logits = self.accelerator.gather_for_metrics(total_chosen_logits).sum().item() + total_chosen_tokens = self.accelerator.gather_for_metrics(total_chosen_tokens).sum().item() + total_rejected_logits = self.accelerator.gather_for_metrics(total_rejected_logits).sum().item() + total_rejected_tokens = self.accelerator.gather_for_metrics(total_rejected_tokens).sum().item() + avg_chosen_logits = total_chosen_logits / total_chosen_tokens if total_chosen_tokens > 0 else 0.0 + avg_rejected_logits = total_rejected_logits / total_rejected_tokens if total_rejected_tokens > 0 else 0.0 + self._metrics[mode]["logits/chosen"].append(avg_chosen_logits) + self._metrics[mode]["logits/rejected"].append(avg_rejected_logits) + + # Token accuracy for the chosen completions + predictions = chosen_logits.argmax(dim=-1) + chosen_bool_mask = chosen_mask.bool() + correct_predictions = (predictions == chosen_labels) & chosen_bool_mask + total_tokens = chosen_bool_mask.sum() + correct_tokens = correct_predictions.sum() + correct_tokens = self.accelerator.gather_for_metrics(correct_tokens) + total_tokens = self.accelerator.gather_for_metrics(total_tokens) + total_sum = total_tokens.sum() + accuracy = (correct_tokens.sum() / total_sum).item() if total_sum > 0 else 0.0 + self._metrics[mode]["mean_token_accuracy"].append(accuracy) + + # Rewards for chosen and rejected completions (β · log π_θ as in the SimPO/TPO implicit reward) + chosen_rewards = self.beta * chosen_logps.detach() + rejected_rewards = self.beta * rejected_logps.detach() + agg_chosen_rewards = self.accelerator.gather(chosen_rewards) + agg_rejected_rewards = self.accelerator.gather(rejected_rewards) + self._metrics[mode]["rewards/chosen"].append(agg_chosen_rewards.mean().item()) + self._metrics[mode]["rewards/rejected"].append(agg_rejected_rewards.mean().item()) + + # Reward accuracy + reward_accuracies = (chosen_rewards > rejected_rewards).float() + agg_reward_accuracies = self.accelerator.gather(reward_accuracies) + self._metrics[mode]["rewards/accuracies"].append(agg_reward_accuracies.mean().item()) + + # Reward margins + margins = chosen_rewards - rejected_rewards + agg_margins = self.accelerator.gather(margins) + self._metrics[mode]["rewards/margins"].append(agg_margins.mean().item()) + + # Average log probabilities for chosen and rejected completions + self._metrics[mode]["logps/chosen"].append(self.accelerator.gather(chosen_logps).mean().item()) + self._metrics[mode]["logps/rejected"].append(self.accelerator.gather(rejected_logps).mean().item()) + + return (loss, outputs) if return_outputs else loss + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + return self._compute_loss(model, inputs, return_outputs) + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} # average the metrics + + # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs` + # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() + + # During eval, Trainer calls prediction_step. If no labels are present in the inputs, it only runs forward and + # returns logits. We override prediction_step to force compute_loss, because this trainer doesn't involve labels. + def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys: list[str] | None = None): + inputs = self._prepare_inputs(inputs) + with torch.no_grad(), self.compute_loss_context_manager(): + if prediction_loss_only: + loss = self.compute_loss(model, inputs, return_outputs=False) + logits, labels = None, None + else: + loss, outputs = self.compute_loss(model, inputs, return_outputs=True) + logits, labels = outputs.logits, inputs["input_ids"] + return loss, logits, labels + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..db784a7f4894897e2d3ea249362c1419c45d127b --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/utils.py @@ -0,0 +1,858 @@ +# Copyright 2020-2026 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. + +# This file contains utility classes and functions that are used across more than one experimental trainer or feature. + +import inspect +import logging +from copy import deepcopy +from dataclasses import dataclass +from typing import Any + +import pyarrow as pa +import pyarrow.types +import torch +from accelerate.utils import is_peft_model +from packaging.version import Version +from pyarrow import compute as pc +from torch import nn +from torch.nn.utils.rnn import pad_sequence +from transformers import PreTrainedModel, PreTrainedTokenizerBase, TrainingArguments +from transformers.integrations.deepspeed import is_deepspeed_zero3_enabled +from transformers.utils import ( + is_peft_available, + is_torch_mlu_available, + is_torch_mps_available, + is_torch_npu_available, + is_torch_xpu_available, +) + +from ..data_utils import DatasetType, _get_dataset_format +from ..trainer.utils import pad + + +if is_peft_available(): + import peft + from peft import PeftConfig, PeftModel, get_peft_model + + +@dataclass +class DPODataCollatorWithPadding: + r""" + DPO DataCollator class that pads the tokenized inputs to the maximum length of the batch. + + Args: + pad_token_id (`int` defaults to 0): + The tokenizer's pad_token_id. + is_encoder_decoder (`bool` or `None`, `optional`, defaults to `None`): + Whether you model has an encoder_decoder architecture. + """ + + pad_token_id: int = 0 + is_encoder_decoder: bool | None = False + + def __call__(self, features: list[dict[str, Any]]) -> dict[str, Any]: + # first, pad everything to the same length + padded_batch = {} + for k in features[0].keys(): + if k.endswith(("_input_ids", "_attention_mask", "_labels", "_pixel_values")): + if self.is_encoder_decoder: + to_pad = [torch.LongTensor(ex[k]) for ex in features] + + if (k.startswith("prompt")) and (k.endswith("input_ids")): + if self.pad_token_id is None: + raise ValueError( + "Padding is enabled, but the tokenizer is not configured with a padding token." + " Explicitly set `tokenizer.pad_token` (e.g. `tokenizer.pad_token = tokenizer.eos_token`)" + " before calling the trainer." + ) + padding_value = self.pad_token_id + elif k.endswith("_attention_mask"): + padding_value = 0 + elif k.startswith(("chosen", "rejected", "completion")) or ("decoder" in k): + padding_value = -100 + else: + raise ValueError(f"Unexpected key in batch '{k}'") + padded_batch[k] = pad_sequence(to_pad, batch_first=True, padding_value=padding_value) + else: + # Set padding value based on the key + if k.endswith("_input_ids"): + if self.pad_token_id is None: + raise ValueError( + "Padding is enabled, but the tokenizer is not configured with a padding token." + " Explicitly set `tokenizer.pad_token` (e.g. `tokenizer.pad_token = tokenizer.eos_token`)" + " before calling the trainer." + ) + padding_value = self.pad_token_id + elif k.endswith("_labels"): + padding_value = -100 + elif k.endswith("_attention_mask"): + padding_value = 0 + elif k.endswith("_pixel_values"): + padding_value = 0 # TODO: check if this is correct + else: + raise ValueError(f"Unexpected key in batch '{k}'") + + # Set padding side based on the key + if k in ["prompt_input_ids", "prompt_attention_mask"]: + padding_side = "left" + else: + padding_side = "right" + + # Set the dtype + if k.endswith("_pixel_values"): + dtype = torch.float32 # will be downcasted if necessary by the Trainer + else: + dtype = torch.int64 + + # Convert to tensor and pad + to_pad = [torch.tensor(ex[k], dtype=dtype) for ex in features] + padded_batch[k] = pad(to_pad, padding_value=padding_value, padding_side=padding_side) + elif k.endswith("_logps"): + # the cached reference model logprobs + padded_batch[k] = torch.tensor([ex[k] for ex in features]) + else: + padded_batch[k] = [ex[k] for ex in features] + + return padded_batch + + +def pad_byte_offsets(offsets: list[tuple[int, int]], target_length: int, padding_side: str) -> torch.Tensor: + """Build a ``[target_length, 2]`` long tensor from ``(start, end)`` byte-offset tuples, + padding with ``(0, 0)`` on the requested side.""" + offs = torch.tensor(offsets, dtype=torch.long).reshape(-1, 2) + pad_len = target_length - offs.size(0) + if pad_len <= 0: + return offs + pad_block = torch.zeros(pad_len, 2, dtype=torch.long) + return torch.cat([pad_block, offs], dim=0) if padding_side == "left" else torch.cat([offs, pad_block], dim=0) + + +def is_byte_level_tokenizer(backend) -> bool: + """Whether ``backend`` is a ByteLevel BPE tokenizer (Llama-3 family, SmolLM, Qwen, \u2026) \u2014 its pieces are in + byte\u2192unicode space, one char per source byte. Detected via the pre-tokenizer / decoder repr.""" + return "ByteLevel" in repr(backend.pre_tokenizer) or "ByteLevel" in repr(backend.decoder) + + +def piece_byte_len(piece: str) -> int: + """UTF-8 byte length of a ByteLevel BPE token piece \u2014 each char maps 1:1 to one source byte. + + Cross-tokenizer ULD targets ByteLevel BPE pairs (Llama-3, Qwen, SmolLM, Phi, Mistral v0.3+, \u2026); SentencePiece + students are out of scope here and would need the loss-level projection from X-Token to align.""" + return len(piece) + + +def _bytes_to_unicode() -> dict[int, str]: + bs = list(range(ord("!"), ord("~") + 1)) + list(range(ord("\u00a1"), ord("\u00ac") + 1)) + bs += list(range(ord("\u00ae"), ord("\u00ff") + 1)) + cs = bs[:] + n = 0 + for b in range(256): + if b not in bs: + bs.append(b) + cs.append(256 + n) + n += 1 + return dict(zip(bs, [chr(n) for n in cs], strict=True)) + + +_BYTE_LEVEL_DECODER = {ch: b for b, ch in _bytes_to_unicode().items()} + + +def _byte_level_piece_len(piece: str, text_bytes: bytes, start: int) -> int | None: + piece_bytes = [] + for ch in piece: + if ch not in _BYTE_LEVEL_DECODER: + return None + piece_bytes.append(_BYTE_LEVEL_DECODER[ch]) + if piece_bytes and piece_bytes[0] == ord(" ") and text_bytes[start : start + 1] != b" ": + piece_bytes = piece_bytes[1:] + return len(piece_bytes) + + +def _split_repeated_byte_offsets(byte_offsets: list[tuple[int, int]], tokens: list[str]) -> list[tuple[int, int]]: + """Split repeated char-derived spans for byte-fallback or byte-level tokens.""" + normalized = list(byte_offsets) + i = 0 + while i < len(byte_offsets): + j = i + 1 + while j < len(byte_offsets) and byte_offsets[j] == byte_offsets[i]: + j += 1 + + if j - i > 1: + start, end = byte_offsets[i] + piece_lengths = [piece_byte_len(token) for token in tokens[i:j]] + if sum(piece_lengths) == end - start: + cursor = start + for offset_idx, length in enumerate(piece_lengths, start=i): + normalized[offset_idx] = (cursor, cursor + length) + cursor += length + + i = j + return normalized + + +def _normalize_byte_offsets( + byte_offsets: list[tuple[int, int]], tokens: list[str], text_bytes: bytes +) -> list[tuple[int, int]]: + byte_offsets = _split_repeated_byte_offsets(byte_offsets, tokens) + normalized = [] + cursor = 0 + + for idx, (start, end) in enumerate(byte_offsets): + if start == end: + normalized.append((cursor, cursor)) + continue + + piece_len = _byte_level_piece_len(tokens[idx], text_bytes, start) + next_start = byte_offsets[idx + 1][0] if idx + 1 < len(byte_offsets) else None + has_overlap = start < cursor or (next_start is not None and next_start < end) + + if piece_len is not None and (has_overlap or piece_len == end - start): + candidate_start = max(start, cursor) + candidate_end = candidate_start + piece_len + if candidate_end <= end: + start = candidate_start + end = candidate_end + + if start < cursor or end < start: + raise ValueError( + "Tokenizer produced overlapping byte offsets that could not be normalized. " + "Cross-tokenizer ULD requires monotonic byte offsets." + ) + + normalized.append((start, end)) + cursor = end + + return normalized + + +def encode_with_byte_offsets(backend, texts: list[str], add_special_tokens: bool = False): + """Encode ``texts`` and return per-text ``(ids, byte_offsets)`` pairs. + + Byte offsets are derived from the fast tokenizer's character offsets via an O(N) char-to-byte cumulative table. + Overlapping spans from byte-level and byte-fallback tokens are split across their byte pieces.""" + if not is_byte_level_tokenizer(backend): + raise NotImplementedError( + "Cross-tokenizer ULD currently supports only ByteLevel BPE tokenizers " + "(Llama-3, Qwen, SmolLM, Phi, Mistral v0.3+, …). The given tokenizer is not ByteLevel." + ) + encs = backend.encode_batch(texts, add_special_tokens=add_special_tokens) + out = [] + for text, enc in zip(texts, encs, strict=True): + char_to_byte = [0] + for ch in text: + char_to_byte.append(char_to_byte[-1] + len(ch.encode("utf-8"))) + byte_offsets = [(char_to_byte[s], char_to_byte[e]) for s, e in enc.offsets] + byte_offsets = _normalize_byte_offsets(byte_offsets, enc.tokens, text.encode("utf-8")) + out.append((list(enc.ids), byte_offsets)) + return out + + +@dataclass +class DataCollatorForChatML: + """ + Data collator for ChatML format datasets. + """ + + tokenizer: PreTrainedTokenizerBase + ignore_index: int = -100 + max_length: int = None + prompt_key: str = "prompt" + messages_key: str = "messages" + + def __post_init__(self): + if self.tokenizer.pad_token_id is None: + raise ValueError("The tokenizer does not have a pad token. Please set `pad_token_id` in the tokenizer.") + if self.max_length is None: + # set a sensible default + self.max_length = min(self.tokenizer.model_max_length, 1024) + + def __call__(self, examples: list[dict[str, Any]]) -> dict[str, torch.Tensor]: + input_ids = [] + attention_mask = [] + prompts_input_ids = [] + prompt_attention_mask = [] + labels = [] + byte_offsets: list[list[tuple[int, int]]] = [] + + for example in examples: + formatted_prompt = example.get(self.prompt_key, example.get("original_prompt_text", None)) + if formatted_prompt is None: + prompt = example[self.messages_key][:-1] + formatted_prompt = self.tokenizer.apply_chat_template( + prompt, add_generation_prompt=True, tokenize=False + ) + + if "input_ids" not in example: + message = example[self.messages_key] + formatted_message = self.tokenizer.apply_chat_template( + message, add_generation_prompt=False, tokenize=False + ) + if is_byte_level_tokenizer(self.tokenizer.backend_tokenizer): + [(message_input_ids_full, full_offs)] = encode_with_byte_offsets( + self.tokenizer.backend_tokenizer, [formatted_message], add_special_tokens=False + ) + prompt_byte_len = len(formatted_prompt.encode("utf-8")) + completion_start_idx_full = next( + (idx for idx, (start, _) in enumerate(full_offs) if start >= prompt_byte_len), + len(message_input_ids_full), + ) + else: + # Non-ByteLevel tokenizer: byte offsets are unnecessary (cross-tokenizer ULD requires ByteLevel + # anyway). Fall back to plain tokenization so GKD / non-ULD trainers with SentencePiece or + # Unigram tokenizers still work through this collator. + message_input_ids_full = self.tokenizer( + formatted_message, add_special_tokens=False, return_tensors=None + )["input_ids"] + completion_start_idx_full = len( + self.tokenizer(formatted_prompt, add_special_tokens=False, return_tensors=None)["input_ids"] + ) + full_offs = [(0, 0)] * len(message_input_ids_full) + prompt_byte_len = 0 + + # Keep the last max_length tokens — drops oldest prompt context first, + # never drops from the END (the model's recent context). + if self.max_length is not None and len(message_input_ids_full) > self.max_length: + sample_ids = message_input_ids_full[-self.max_length :] + sample_offs = full_offs[-self.max_length :] + current_prompt_len = max( + 0, completion_start_idx_full - (len(message_input_ids_full) - self.max_length) + ) + else: + sample_ids = message_input_ids_full + sample_offs = full_offs + current_prompt_len = completion_start_idx_full + + # Make completion-relative: prompt positions zeroed, completion offsets shifted. If truncation + # ate into the completion (no prompt tokens kept and the first kept token is mid-completion), + # rebase to byte 0 of the kept completion so teacher/student share the same coordinate system. + kept_completion_offs = sample_offs[current_prompt_len:] + base = ( + kept_completion_offs[0][0] if kept_completion_offs and current_prompt_len == 0 else prompt_byte_len + ) + completion_offs = [(s - base, e - base) for s, e in kept_completion_offs] + sample_offs = [(0, 0)] * current_prompt_len + completion_offs + + input_ids.append(sample_ids) + attention_mask.append([1] * len(sample_ids)) + current_prompt_ids = sample_ids[:current_prompt_len] + byte_offsets.append(sample_offs) + else: + sample_ids = example["input_ids"] + input_ids.append(sample_ids) + attention_mask.append(example.get("attention_mask", [1] * len(sample_ids))) + completion_mask = example.get("completion_mask") + if completion_mask is not None: + # Use the tracked boundary directly: no re-tokenization, survives truncation. + prompt_len = completion_mask.index(1) if 1 in completion_mask else len(sample_ids) + current_prompt_ids = sample_ids[:prompt_len] + else: + # No tracked boundary: tokenize the prompt and cap with a slice (avoid `truncation=True`, + # which would persist on the shared backend used by `encode_with_byte_offsets`). + tokenized_prompt = self.tokenizer( + formatted_prompt, + padding=False, + return_tensors=None, + add_special_tokens=False, + ) + current_prompt_ids = tokenized_prompt["input_ids"][: len(sample_ids)] + byte_offsets.append(example.get("byte_offsets", [(0, 0)] * len(sample_ids))) + + prompts_input_ids.append(current_prompt_ids) + prompt_attention_mask.append([1] * len(current_prompt_ids)) + + label = [self.ignore_index] * len(sample_ids) + label[len(current_prompt_ids) :] = sample_ids[len(current_prompt_ids) :] + labels.append(label) + + input_ids = pad( + [torch.tensor(x, dtype=torch.long) for x in input_ids], + padding_side="left", + padding_value=self.tokenizer.pad_token_id, + ) + attention_mask = pad( + [torch.tensor(x, dtype=torch.long) for x in attention_mask], padding_side="left", padding_value=0 + ) + labels = pad( + [torch.tensor(x, dtype=torch.long) for x in labels], padding_side="left", padding_value=self.ignore_index + ) + prompts_input_ids = pad( + [torch.tensor(x, dtype=torch.long) for x in prompts_input_ids], + padding_side="left", + padding_value=self.tokenizer.pad_token_id, + ) + prompt_attention_mask = pad( + [torch.tensor(x, dtype=torch.long) for x in prompt_attention_mask], padding_side="left", padding_value=0 + ) + + target_len = input_ids.size(1) + byte_offsets_tensor = torch.stack( + [pad_byte_offsets(offs, target_len, padding_side="left") for offs in byte_offsets], dim=0 + ) + + out = { + "input_ids": input_ids, + "attention_mask": attention_mask, + "labels": labels, + "prompts": prompts_input_ids, + "prompt_attention_mask": prompt_attention_mask, + "byte_offsets": byte_offsets_tensor, + } + # Forward source text for cross-tokenizer ULD, when the dataset has it. + if "original_prompt_text" in examples[0] and "original_completion_text" in examples[0]: + out["original_prompt_text"] = [ex["original_prompt_text"] for ex in examples] + out["original_completion_text"] = [ex["original_completion_text"] for ex in examples] + return out + + +def truncate_right( + input_ids: torch.Tensor, stop_token_id: int, pad_token_id: int +) -> tuple[torch.Tensor, torch.Tensor]: + """ + Truncates the input tensor from the right side after the first occurrence of the stop token. + + Args: + input_ids (`torch.Tensor`): + The tensor containing the responses to be truncated + stop_token_id (`int`): + The token ID representing the stop token where truncation occurs + pad_token_id (`int`): + The token ID representing the pad token used to fill the truncated responses + + Returns: + tuple: + - `output_ids` (`torch.Tensor`): + The truncated responses tensor with pad tokens filled after the stop token + - `mask` (`torch.Tensor`): + The mask tensor to indicate the padding tokens + """ + trunc_idxs = first_true_indices(input_ids == stop_token_id).unsqueeze(-1) + new_size = [1] * (len(input_ids.size()) - 1) + [input_ids.shape[1]] + idxs = torch.arange(input_ids.shape[1], device=input_ids.device).view(*new_size) + output_ids = torch.masked_fill(input_ids, idxs > trunc_idxs, pad_token_id) + mask = torch.masked_fill(torch.ones_like(input_ids), idxs > trunc_idxs, 0) + return output_ids, mask + + +def add_bos_token_if_needed( + bos_token_id: int | None, + prompt_len_input_ids: int, + prompt_tokens: dict[str, list[int]], + chosen_prompt_len_input_ids: int, + chosen_tokens: dict[str, list[int]], + rejected_prompt_len_input_ids: int, + rejected_tokens: dict[str, list[int]], +): + if bos_token_id is not None: + if prompt_len_input_ids == 0 or bos_token_id != prompt_tokens["prompt_input_ids"][0]: + prompt_tokens["prompt_input_ids"] = [bos_token_id] + prompt_tokens["prompt_input_ids"] + prompt_tokens["prompt_attention_mask"] = [1] + prompt_tokens["prompt_attention_mask"] + if chosen_prompt_len_input_ids == 0 or bos_token_id != chosen_tokens["prompt_input_ids"][0]: + chosen_tokens["prompt_input_ids"] = [bos_token_id] + chosen_tokens["prompt_input_ids"] + chosen_tokens["prompt_attention_mask"] = [1] + chosen_tokens["prompt_attention_mask"] + if rejected_prompt_len_input_ids == 0 or bos_token_id != rejected_tokens["prompt_input_ids"][0]: + rejected_tokens["prompt_input_ids"] = [bos_token_id] + rejected_tokens["prompt_input_ids"] + rejected_tokens["prompt_attention_mask"] = [1] + rejected_tokens["prompt_attention_mask"] + return prompt_tokens, chosen_tokens, rejected_tokens + + +def add_eos_token_if_needed( + eos_token_id: int, chosen_tokens: dict[str, list[int]], rejected_tokens: dict[str, list[int]] +): + if len(chosen_tokens["input_ids"]) == 0 or eos_token_id != chosen_tokens["input_ids"][-1]: + chosen_tokens["input_ids"].append(eos_token_id) + chosen_tokens["attention_mask"].append(1) + if len(rejected_tokens["input_ids"]) == 0 or eos_token_id != rejected_tokens["input_ids"][-1]: + rejected_tokens["input_ids"].append(eos_token_id) + rejected_tokens["attention_mask"].append(1) + return chosen_tokens, rejected_tokens + + +def first_true_indices(bools: torch.Tensor, dtype=torch.long) -> torch.Tensor: + """ + Takes an N-dimensional bool tensor and returns an (N-1)-dimensional tensor of integers giving the position of the + first True in each "row". + + Returns the length of the rows (bools.size(-1)) if no element is True in a given row. + + Args: + bools (`torch.Tensor`): + An N-dimensional boolean tensor. + dtype (`torch.dtype`, *optional*): + The desired data type of the output tensor. Defaults to `torch.long`. + + Returns: + `torch.Tensor`: + An (N-1)-dimensional tensor of integers indicating the position of the first True in each row. If no True + value is found in a row, returns the length of the row. + """ + row_len = bools.size(-1) + zero_or_index = row_len * (~bools).type(dtype) + torch.arange(row_len, dtype=dtype, device=bools.device) + return torch.min(zero_or_index, dim=-1).values + + +def get_reward( + model: torch.nn.Module, query_responses: torch.Tensor, pad_token_id: int, context_length: int +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Computes the reward logits and the rewards for a given model and query responses. + + Args: + model (`torch.nn.Module`): + The model used to compute the reward logits. + query_responses (`torch.Tensor`): + The tensor containing the query responses. + pad_token_id (`int`): + The token ID representing the pad token. + context_length (`int`): + The length of the context in the query responses. + + Returns: + tuple: + - `reward_logits` (`torch.Tensor`): + The logits for the reward model. + - `final_rewards` (`torch.Tensor`): + The final rewards for each query response. + - `sequence_lengths` (`torch.Tensor`): + The lengths of the sequences in the query responses. + """ + attention_mask = query_responses != pad_token_id + position_ids = attention_mask.cumsum(1) - attention_mask.long() # exclusive cumsum + lm_backbone = getattr(model, model.base_model_prefix) + input_ids = torch.masked_fill(query_responses, ~attention_mask, 0) + output = lm_backbone( + input_ids=input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + return_dict=True, + output_hidden_states=True, + use_cache=False, # otherwise mistral-based RM would error out + ) + reward_logits = model.score(output.hidden_states[-1]) + sequence_lengths = first_true_indices(query_responses[:, context_length:] == pad_token_id) - 1 + context_length + # https://github.com/huggingface/transformers/blob/dc68a39c8111217683bf49a4912d0c9018bab33d/src/transformers/models/gpt2/modeling_gpt2.py#L1454 + return ( + reward_logits, + reward_logits[ + torch.arange(reward_logits.size(0), device=reward_logits.device), + sequence_lengths, + ].squeeze(-1), + sequence_lengths, + ) + + +def prepare_model_for_kbit_training(model, use_gradient_checkpointing=True, gradient_checkpointing_kwargs=None): + r""" + Prepare a k-bit quantized transformers model for training (PEFT/QLoRA). + """ + loaded_in_kbit = getattr(model, "is_loaded_in_8bit", False) or getattr(model, "is_loaded_in_4bit", False) + quant_methods = ["gptq", "aqlm", "eetq", "torchao", "hqq"] + is_quantized = getattr(model, "quantization_method", None) in quant_methods or getattr( + model, "hqq_quantized", False + ) + + if gradient_checkpointing_kwargs is None: + gradient_checkpointing_kwargs = {} + + for _, param in model.named_parameters(): + # freeze all parameters + param.requires_grad = False + + # Enable gradient checkpointing if needed + if (loaded_in_kbit or is_quantized) and use_gradient_checkpointing: + if hasattr(model, "enable_input_require_grads"): + model.enable_input_require_grads() + else: + # backward-compatible hook + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + supports_gc_kwargs = "gradient_checkpointing_kwargs" in list( + inspect.signature(model.gradient_checkpointing_enable).parameters + ) + gc_kwargs = {"gradient_checkpointing_kwargs": gradient_checkpointing_kwargs} if supports_gc_kwargs else {} + model.gradient_checkpointing_enable(**gc_kwargs) + + return model + + +def enable_gradient_checkpointing( + model: PreTrainedModel, gradient_checkpointing_kwargs: dict | None +) -> PreTrainedModel: + """Enables gradient checkpointing for the model.""" + # Enable gradient checkpointing on the base model for PEFT + if is_peft_model(model): + model.base_model.gradient_checkpointing_enable() + # Enable gradient checkpointing for non-PEFT models + else: + model.gradient_checkpointing_enable() + + gradient_checkpointing_kwargs = gradient_checkpointing_kwargs or {} + use_reentrant = ( + "use_reentrant" not in gradient_checkpointing_kwargs or gradient_checkpointing_kwargs["use_reentrant"] + ) + + if use_reentrant: + if hasattr(model, "enable_input_require_grads"): + model.enable_input_require_grads() + else: + + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) + + return model + + +def prepare_peft_model( + model: PreTrainedModel, peft_config: "PeftConfig | None", args: TrainingArguments +) -> PreTrainedModel: + """Prepares a model for PEFT training.""" + if not is_peft_available(): + raise ImportError("PEFT is required to use a peft model. Run `pip install peft`.") + + if isinstance(model, PeftModel) and peft_config is not None: + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge and " + "unload the existing adapter, save the resulting base model, and then pass that base model along with the " + "new `peft_config` to the trainer." + ) + + # Handle quantized models (QLoRA) + is_qlora = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False) + + is_sharded_qlora = False + if getattr(model, "is_loaded_in_4bit", False): + # Check if model is sharded (FSDP/DS-Zero3) + for _, param in model.named_parameters(): + if param.__class__.__name__ == "Params4bit": + is_sharded_qlora = param.data.device.type in {"cpu", "meta"} + break + + # Prepare model for kbit training if needed + if is_qlora and not is_sharded_qlora and not isinstance(model, PeftModel): + model = prepare_model_for_kbit_training( + model, + use_gradient_checkpointing=args.gradient_checkpointing, + gradient_checkpointing_kwargs=args.gradient_checkpointing_kwargs or {}, + ) + # Disable gradient checkpointing as it's handled by prepare_model_for_kbit_training + args.gradient_checkpointing = False + elif args.gradient_checkpointing: + model = enable_gradient_checkpointing(model, args.gradient_checkpointing_kwargs) + + # Create PEFT model + if peft_config is not None: + if ( + Version(peft.__version__) >= Version("0.12") # autocast_adapter_dtype introduced in 0.12 + and getattr(model, "is_loaded_in_4bit", False) + and is_sharded_qlora + ): + model = get_peft_model(model, peft_config, autocast_adapter_dtype=False) + else: + model = get_peft_model(model, peft_config) + + # Handle bf16 casting for 4-bit models + if args.bf16 and getattr(model, "is_loaded_in_4bit", False) and not is_sharded_qlora: + peft_module_casting_to_bf16(model) + + return model + + +def pad_to_length(tensor: torch.Tensor, length: int, pad_value: int | float, dim: int = -1) -> torch.Tensor: + if tensor.size(dim) >= length: + return tensor + else: + pad_size = list(tensor.shape) + pad_size[dim] = length - tensor.size(dim) + return torch.cat( + [ + tensor, + pad_value * torch.ones(*pad_size, dtype=tensor.dtype, device=tensor.device), + ], + dim=dim, + ) + + +def empty_cache() -> None: + """Empties the cache of the available torch device. + + This function checks for the availability of different torch devices (CUDA, MLU, MPS, NPU, XPU) and empties the + cache of the first available device it finds. + + If none of the specific devices are available, it defaults to emptying the CUDA cache. + """ + if is_torch_mlu_available(): + torch.mlu.empty_cache() + elif is_torch_mps_available(): + torch.mps.empty_cache() + elif is_torch_npu_available(): + torch.npu.empty_cache() + elif is_torch_xpu_available(): + torch.xpu.empty_cache() + else: + torch.cuda.empty_cache() + + +def peft_module_casting_to_bf16(model): + for name, module in model.named_modules(): + if isinstance(module, torch.nn.LayerNorm) or "norm" in name: + module = module.to(torch.float32) + elif any(x in name for x in ["lm_head", "embed_tokens", "wte", "wpe"]): + if hasattr(module, "weight"): + if module.weight.dtype == torch.float32: + module = module.to(torch.bfloat16) + + +LAYER_PATTERNS = [ + "transformer.h.{layer}", + "model.decoder.layers.{layer}", + "gpt_neox.layers.{layer}", + "model.layers.{layer}", +] + + +def create_reference_model( + model: nn.Module, num_shared_layers: int | None = None, pattern: str | None = None +) -> nn.Module: + """ + Creates a static reference copy of a model. Note that model will be in `.eval()` mode. + + Args: + model ([`nn.Module`]): The model to be copied. + num_shared_layers (`int`, *optional*): + The number of initial layers that are shared between both models and kept frozen. Shared layers reference + the same storage as the source model, so they are not duplicated in memory. + pattern (`str`, *optional*): The shared layers are selected with a string pattern + (e.g. "transformer.h.{layer}" for GPT2) and if a custom pattern is necessary it can be passed here. + + Returns: + [`nn.Module`] + """ + if is_deepspeed_zero3_enabled(): + raise ValueError( + "DeepSpeed ZeRO-3 is enabled and is not compatible with `create_reference_model()`. Please instantiate your reference model directly with `AutoModelForCausalLM.from_pretrained()`." + ) + + parameter_names = [n for n, _ in model.named_parameters()] + ref_model = deepcopy(model) + + # if no layers are shared, return copy of model + if num_shared_layers is None: + for param_name in parameter_names: + param = ref_model.get_parameter(param_name) + param.requires_grad = False + return ref_model.eval() + + # identify layer name pattern + if pattern is not None: + pattern = pattern.format(layer=num_shared_layers) + else: + for pattern_candidate in LAYER_PATTERNS: + pattern_candidate = pattern_candidate.format(layer=num_shared_layers) + if any(pattern_candidate in name for name in parameter_names): + pattern = pattern_candidate + break + + if pattern is None: + raise ValueError("Layer pattern could not be matched.") + + # divide parameters in shared and unshared parameter lists + shared_param_list = [] + unshared_param_list = [] + + shared_parameter = True + for name, _param in model.named_parameters(): + if pattern in name: + shared_parameter = False + if shared_parameter: + shared_param_list.append(name) + else: + unshared_param_list.append(name) + + # Freeze the shared layers in the source model, then point the reference parameter at the same + # storage instead of keeping the `deepcopy` duplicate. The shared (frozen) layers are thus held in + # memory only once; because they are frozen in the model, the reference stays static during training. + for param_name in shared_param_list: + param = model.get_parameter(param_name) + param.requires_grad = False + + ref_param = ref_model.get_parameter(param_name) + ref_param.data = param.data + ref_param.requires_grad = False + + # for all other parameters just make sure they don't use gradients + for param_name in unshared_param_list: + param = ref_model.get_parameter(param_name) + param.requires_grad = False + + if pattern is not None and len(unshared_param_list) == 0: + logging.warning("Pattern passed or found, but no layers matched in the model. Check for a typo.") + + return ref_model.eval() + + +def truncate_dataset( + dataset: DatasetType, + max_length: int, + map_kwargs: dict[str, Any] | None = None, +) -> DatasetType: + r""" + Truncate sequences in a dataset to a specified `max_length`. + + Args: + dataset ([`~datasets.Dataset`] or [`~datasets.DatasetDict`]): + Dataset to truncate. + max_length (`int`): + Maximum sequence length to truncate to. + map_kwargs (`dict`, *optional*): + Additional keyword arguments to pass to the dataset's map method when truncating examples. + + Returns: + [`~datasets.Dataset`] or [`~datasets.DatasetDict`]: The dataset with truncated sequences. + + Example: + ```python + >>> from datasets import Dataset + + >>> examples = { + ... "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]], + ... "attention_mask": [[0, 1, 1], [0, 0, 1, 1], [1]], + ... } + >>> dataset = Dataset.from_dict(examples) + >>> truncated_dataset = truncate_dataset(dataset, max_length=2) + >>> truncated_dataset[:] + {'input_ids': [[1, 2], [4, 5], [8]], + 'attention_mask': [[0, 1], [0, 0], [1]]} + ``` + """ + if map_kwargs is None: + map_kwargs = {} + + def truncate(examples): + truncated_columns = [] + for column in examples.columns: + if pyarrow.types.is_list(column.type) or pyarrow.types.is_large_list(column.type): + column = pc.list_slice(column, 0, max_length) + truncated_columns.append(column) + return pa.Table.from_arrays(truncated_columns, names=examples.column_names) + + format = _get_dataset_format(dataset) + dataset = dataset.with_format("arrow") + dataset = dataset.map(truncate, batched=True, **map_kwargs) + dataset = dataset.with_format(**format) + return dataset diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/xpo/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/xpo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2fc35384cd4246001ac14d1bd126430cce00b122 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/xpo/__init__.py @@ -0,0 +1,19 @@ +# Copyright 2020-2026 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. + +from .xpo_config import XPOConfig +from .xpo_trainer import XPOTrainer + + +__all__ = ["XPOConfig", "XPOTrainer"] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/xpo/xpo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/xpo/xpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..243545084617bdc8f384289cb76883d22fcfaf54 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/xpo/xpo_config.py @@ -0,0 +1,44 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field + +from ..online_dpo import OnlineDPOConfig + + +@dataclass +class XPOConfig(OnlineDPOConfig): + r""" + Configuration class for the [`experimental.xpo.XPOTrainer`]. + + Subclass of [`experimental.online_dpo.OnlineDPOConfig`] we can use all its arguments and add the following: + + Parameters: + alpha (`float` or `list[float]`, *optional*, defaults to `1e-5`): + Weight of the XPO loss term. If a list of floats is provided then the alpha is selected for each new epoch + and the last alpha is used for the rest of the epochs. + """ + + alpha: list[float] = field( + default_factory=lambda: [1e-5], + metadata={ + "help": "Weight of the XPO loss term. If a list of floats is provided then the alpha is selected for each " + "new epoch and the last alpha is used for the rest of the epochs." + }, + ) + + def __post_init__(self): + super().__post_init__() + if hasattr(self.alpha, "__len__") and len(self.alpha) == 1: + self.alpha = self.alpha[0] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/xpo/xpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/xpo/xpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..5edbbc3dc2022802816fba8ea8b52f486745d3a1 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/experimental/xpo/xpo_trainer.py @@ -0,0 +1,506 @@ +# Copyright 2020-2026 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 textwrap +from collections.abc import Callable +from typing import Any + +import torch +import torch.nn as nn +import torch.nn.functional as F +from datasets import Dataset, IterableDataset +from transformers import ( + BaseImageProcessor, + FeatureExtractionMixin, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, +) +from transformers.trainer_utils import EvalPrediction +from transformers.training_args import OptimizerNames +from transformers.utils import is_peft_available + +from ...data_utils import maybe_apply_chat_template +from ...models.utils import unwrap_model_for_generation +from ...trainer.utils import selective_log_softmax +from ..online_dpo import OnlineDPOTrainer +from ..utils import empty_cache, get_reward, truncate_right +from .xpo_config import XPOConfig + + +if is_peft_available(): + from peft import PeftConfig, PeftModel + + +class XPOTrainer(OnlineDPOTrainer): + """ + Trainer for Exploratory Preference Optimization (XPO). + + It is implemented as a subclass of [`experimental.online_dpo.OnlineDPOTrainer`]. + + Args: + model ([`~transformers.PreTrainedModel`]): + The model to train, preferably an `AutoModelForCausalLM`. + ref_model ([`~transformers.PreTrainedModel`]): + Hugging Face transformer model with a casual language modelling head. Used for implicit reward computation + and loss. If no reference model is provided, the trainer will create a reference model with the same + architecture as the model to be optimized. + reward_funcs ([`~transformers.PreTrainedModel`]): + The reward model to score completions with, preferably an + [`~transformers.AutoModelForSequenceClassification`]. + args ([`experimental.xpo.XPOConfig`]): + The XPO config arguments to use for training. + data_collator ([`~transformers.DataCollator`]): + The data collator to use for training. If None is specified, the default data collator + ([`experimental.utils.DPODataCollatorWithPadding`]) will be used which will pad the sequences to the + maximum length of the sequences in the batch, given a dataset of paired sequences. + train_dataset ([`~datasets.Dataset`]): + The dataset to use for training. + eval_dataset ([`~datasets.Dataset`]): + The dataset to use for evaluation. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.BaseImageProcessor`], [`~transformers.FeatureExtractionMixin`] or [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. If provided, will be used to automatically process the inputs + for the model, and it will be saved along the model to make it easier to rerun an interrupted training or + reuse the fine-tuned model. + reward_processing_classes ([`~transformers.PreTrainedTokenizerBase`] or `list[PreTrainedTokenizerBase]`, *optional*): + Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either: + + - A single processing class: Used when `reward_funcs` contains only one reward function. + - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`. + + If set to `None`, the tokenizer for each model-based reward function is automatically loaded using + [`~transformers.AutoTokenizer.from_pretrained`]. + peft_config ([`~peft.PeftConfig`], *optional*): + The peft config to use for training. + compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*): + The function to use to compute the metrics. Must take a `EvalPrediction` and return a dictionary string to + metric values. + callbacks (`list[transformers.TrainerCallback]`): + The callbacks to use for training. + optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`): + The optimizer and scheduler to use for training. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`): + The function to use to preprocess the logits before computing the metrics. + """ + + _tag_names = ["trl", "xpo"] + _name = "XPO" + _paper = { + "title": "Exploratory Preference Optimization: Harnessing Implicit Q*-Approximation for Sample-Efficient RLHF", + "id": "2405.21046", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @article{jung2024binary, + title = {{Exploratory Preference Optimization: Harnessing Implicit Q*-Approximation for Sample-Efficient RLHF}}, + author = {Tengyang Xie and Dylan J. Foster and Akshay Krishnamurthy and Corby Rosset and Ahmed Awadallah and Alexander Rakhlin}, + year = 2024, + eprint = {arXiv:2405.21046} + }"""), + } + + def __init__( + self, + model: PreTrainedModel | nn.Module = None, + ref_model: PreTrainedModel | nn.Module = None, + reward_funcs: nn.Module | None = None, + args: XPOConfig | None = None, + data_collator: Callable | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + processing_class: PreTrainedTokenizerBase + | BaseImageProcessor + | FeatureExtractionMixin + | ProcessorMixin + | None = None, + reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None, + peft_config: "PeftConfig | None" = None, + compute_metrics: Callable[[EvalPrediction], dict] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + ) -> None: + super().__init__( + model=model, + ref_model=ref_model, + reward_funcs=reward_funcs, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + reward_processing_classes=reward_processing_classes, + peft_config=peft_config, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + self._alpha = self.args.alpha + + # Overwrite the stats dictionary to include XPO specific statistics + self.stats = { + # Remove "non_score_reward", "rlhf_reward", "scores" + # Add "loss/dpo", "loss/xpo" + "loss/dpo": [], + "loss/xpo": [], + "objective/kl": [], + "objective/entropy": [], + "rewards/chosen": [], + "rewards/rejected": [], + "rewards/accuracies": [], + "rewards/margins": [], + "logps/chosen": [], + "logps/rejected": [], + # Replace "contain_eos_token" by "model_contain_eos_token" and "ref_contain_eos_token" + "val/model_contain_eos_token": [], + "val/ref_contain_eos_token": [], + "objective/model_scores": [], + "objective/ref_scores": [], + "objective/scores_margin": [], + "alpha": [], + "beta": [], + } + if len(self.reward_funcs) != 1: + raise ValueError("XPOTrainer only supports one reward function/model.") + self.reward_funcs = self.reward_funcs[0] + + @property + def alpha(self): + if isinstance(self._alpha, list): + epoch = self.state.epoch + return self._alpha[epoch] if epoch < len(self._alpha) else self._alpha[-1] + else: + return self._alpha + + def _generate_completions(self, prompts, model): + with ( + unwrap_model_for_generation( + model, + self.accelerator, + generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762 + ) as unwrapped_policy_model_for_gen, + ): + model_output = unwrapped_policy_model_for_gen.generate( + input_ids=prompts["input_ids"], + attention_mask=prompts["attention_mask"], + generation_config=self.generation_config, + ) + + actual_model_for_ref_generation: torch.nn.Module + if self.ref_model is None: + unwrapped_main_model_for_ref_logic = self.accelerator.unwrap_model(model) + + if is_peft_available() and isinstance(unwrapped_main_model_for_ref_logic, PeftModel): + actual_model_for_ref_generation = unwrapped_main_model_for_ref_logic.get_base_model() + else: + actual_model_for_ref_generation = unwrapped_main_model_for_ref_logic + else: + actual_model_for_ref_generation = self.accelerator.unwrap_model(self.ref_model) + + with ( + unwrap_model_for_generation( + actual_model_for_ref_generation, + self.accelerator, + generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762 + ) as final_ref_model_for_gen, + ): + ref_output = final_ref_model_for_gen.generate( + input_ids=prompts["input_ids"], + attention_mask=prompts["attention_mask"], + generation_config=self.generation_config, + ) + + return model_output, ref_output + + def _process_completions(self, model_output, ref_output, prompts): + context_length = prompts["input_ids"].shape[1] + + # Process model completions + model_completion_ids = model_output[:, context_length:] + model_completion_ids, model_completion_mask = truncate_right( + model_completion_ids, self.processing_class.eos_token_id, self.processing_class.pad_token_id + ) + model_data = { + "input_ids": torch.cat((prompts["input_ids"], model_completion_ids), dim=1), + "attention_mask": torch.cat((prompts["attention_mask"], model_completion_mask), dim=1), + "raw": prompts["raw"], + } + + # Process reference model completions + ref_completion_ids = ref_output[:, context_length:] + ref_completion_ids, ref_completion_mask = truncate_right( + ref_completion_ids, self.processing_class.eos_token_id, self.processing_class.pad_token_id + ) + ref_data = { + "input_ids": torch.cat((prompts["input_ids"], ref_completion_ids), dim=1), + "attention_mask": torch.cat((prompts["attention_mask"], ref_completion_mask), dim=1), + "raw": prompts["raw"], + } + + return model_data, ref_data + + def _compute_rewards(self, model_data, ref_data, context_length): + with torch.no_grad(): + _, model_scores, _ = get_reward( + self.reward_funcs, model_data["input_ids"], self.processing_class.pad_token_id, context_length + ) + _, ref_scores, _ = get_reward( + self.reward_funcs, ref_data["input_ids"], self.processing_class.pad_token_id, context_length + ) + + # Apply EOS penalty if needed + if self.args.missing_eos_penalty is not None: + model_contain_eos = torch.any(model_data["input_ids"] == self.processing_class.eos_token_id, dim=-1) + ref_contain_eos = torch.any(ref_data["input_ids"] == self.processing_class.eos_token_id, dim=-1) + model_scores[~model_contain_eos] -= self.args.missing_eos_penalty + ref_scores[~ref_contain_eos] -= self.args.missing_eos_penalty + + return model_scores, ref_scores + + def _compute_logprobs(self, model, model_data, ref_data, context_length): + def compute_logprobs_for_data(m, data): + output = m(data["input_ids"], attention_mask=data["attention_mask"]) + logits = output.logits[:, context_length - 1 : -1] + token_logprobs = selective_log_softmax(logits, data["input_ids"][:, context_length:]) + return token_logprobs + + # Compute logprobs for model completions + model_logprobs_model_data = compute_logprobs_for_data(model, model_data) + # Compute logprobs for model on reference completions (for XPO loss) + model_logprobs_ref_data = compute_logprobs_for_data(model, ref_data) + + # Compute logprobs for reference model completions + with torch.no_grad(): + if self.ref_model is None: + with model.disable_adapter(): + ref_logprobs_model_data = compute_logprobs_for_data(model, model_data) + ref_logprobs_ref_data = compute_logprobs_for_data(model, ref_data) + else: + ref_logprobs_model_data = compute_logprobs_for_data(self.ref_model, model_data) + ref_logprobs_ref_data = compute_logprobs_for_data(self.ref_model, ref_data) + + # Mask padding tokens + model_padding_mask = model_data["attention_mask"][:, context_length:] == 0 + ref_padding_mask = ref_data["attention_mask"][:, context_length:] == 0 + model_logprobs_model_data = model_logprobs_model_data.masked_fill(model_padding_mask, 0.0) + model_logprobs_ref_data = model_logprobs_ref_data.masked_fill(ref_padding_mask, 0.0) + ref_logprobs_ref_data = ref_logprobs_ref_data.masked_fill(ref_padding_mask, 0.0) + ref_logprobs_model_data = ref_logprobs_model_data.masked_fill(model_padding_mask, 0.0) + + return model_logprobs_model_data, model_logprobs_ref_data, ref_logprobs_ref_data, ref_logprobs_model_data + + def _compute_losses( + self, + model_logprobs_model_data, + model_logprobs_ref_data, + ref_logprobs_ref_data, + ref_logprobs_model_data, + chosen_mask, + ): + # Compute log probs + model_logprobs_model_data_sum = model_logprobs_model_data.sum(1) + model_logprobs_ref_data_sum = model_logprobs_ref_data.sum(1) + ref_logprobs_ref_data_sum = ref_logprobs_ref_data.sum(1) + ref_logprobs_model_data_sum = ref_logprobs_model_data.sum(1) + + chosen_model_logprobs = torch.where(chosen_mask, model_logprobs_model_data_sum, model_logprobs_ref_data_sum) + chosen_ref_logprobs = torch.where(chosen_mask, ref_logprobs_model_data_sum, ref_logprobs_ref_data_sum) + chosen_log_ratios = chosen_model_logprobs - chosen_ref_logprobs + + rejected_model_logprobs = torch.where(~chosen_mask, model_logprobs_model_data_sum, model_logprobs_ref_data_sum) + rejected_ref_logprobs = torch.where(~chosen_mask, ref_logprobs_model_data_sum, ref_logprobs_ref_data_sum) + rejected_log_ratios = rejected_model_logprobs - rejected_ref_logprobs + + # Compute logits as the difference between chosen and rejected log ratios + logits = chosen_log_ratios - rejected_log_ratios + + if self.args.loss_type == "sigmoid": + dpo_losses = -F.logsigmoid(self.beta * logits) + elif self.args.loss_type == "ipo": + dpo_losses = (logits - 1 / (2 * self.beta)) ** 2 + else: + raise NotImplementedError(f"invalid loss type {self.args.loss_type}") + + # Compute XPO specific loss + xpo_losses = self.alpha * model_logprobs_ref_data_sum + + # Total loss + loss = (dpo_losses + xpo_losses).mean() + + return loss, dpo_losses, xpo_losses + + def _log_statistics( + self, + model_data, + ref_data, + model_logprobs_model_data, + model_logprobs_ref_data, + ref_logprobs_ref_data, + ref_logprobs_model_data, + chosen_mask, + dpo_losses, + xpo_losses, + context_length, + model_scores, + ref_scores, + ): + # Helper function to gather and compute mean + def gather_mean(tensor): + return self.accelerator.gather_for_metrics(tensor).mean().item() + + # Log losses + self.stats["loss/dpo"].append(gather_mean(dpo_losses)) + self.stats["loss/xpo"].append(gather_mean(xpo_losses)) + + # Log scores + self.stats["objective/model_scores"].append(gather_mean(model_scores)) + self.stats["objective/ref_scores"].append(gather_mean(ref_scores)) + self.stats["objective/scores_margin"].append(gather_mean(model_scores - ref_scores)) + + # Log logprobs + model_logprobs_model_data_sum = model_logprobs_model_data.sum(1) + model_logprobs_ref_data_sum = model_logprobs_ref_data.sum(1) + ref_logprobs_ref_data_sum = ref_logprobs_ref_data.sum(1) + ref_logprobs_model_data_sum = ref_logprobs_model_data.sum(1) + + chosen_model_logprobs = torch.where(chosen_mask, model_logprobs_model_data_sum, model_logprobs_ref_data_sum) + chosen_ref_logprobs = torch.where(chosen_mask, ref_logprobs_model_data_sum, ref_logprobs_ref_data_sum) + chosen_log_ratios = chosen_model_logprobs - chosen_ref_logprobs + + rejected_model_logprobs = torch.where(~chosen_mask, model_logprobs_model_data_sum, model_logprobs_ref_data_sum) + rejected_ref_logprobs = torch.where(~chosen_mask, ref_logprobs_model_data_sum, ref_logprobs_ref_data_sum) + rejected_log_ratios = rejected_model_logprobs - rejected_ref_logprobs + + self.stats["logps/chosen"].append(gather_mean(chosen_model_logprobs.mean() + chosen_ref_logprobs.mean())) + self.stats["logps/rejected"].append(gather_mean(rejected_model_logprobs.mean() + rejected_ref_logprobs.mean())) + + # Log rewards + # Compute various statistics + chosen_rewards = chosen_log_ratios * self.beta + rejected_rewards = rejected_log_ratios * self.beta + self.stats["rewards/chosen"].append(gather_mean(chosen_rewards.mean())) + self.stats["rewards/rejected"].append(gather_mean(rejected_rewards.mean())) + + # Calculate KL divergence for model and ref data + kl_model_data = model_logprobs_model_data - ref_logprobs_model_data + kl_ref_data = model_logprobs_ref_data - ref_logprobs_ref_data + mean_kl = (kl_model_data.sum(1) + kl_ref_data.sum(1)).mean() / 2 + self.stats["objective/kl"].append(gather_mean(mean_kl)) + + # Calculate entropy for model and ref data + entropy_model_data = -model_logprobs_model_data.sum(1) + entropy_ref_data = -model_logprobs_ref_data.sum(1) + mean_entropy = (entropy_model_data.mean() + entropy_ref_data.mean()) / 2 + self.stats["objective/entropy"].append(gather_mean(mean_entropy)) + + # Calculate margins + margin = chosen_rewards - rejected_rewards + self.stats["rewards/margins"].append(gather_mean(margin.mean())) + + # Calculate accuracy + accuracy = (margin > 0).float() + self.stats["rewards/accuracies"].append(gather_mean(accuracy.mean())) + + # Log EOS token statistics + model_eos = (model_data["input_ids"][:, context_length:] == self.processing_class.eos_token_id).any(dim=1) + ref_eos = (ref_data["input_ids"][:, context_length:] == self.processing_class.eos_token_id).any(dim=1) + self.stats["val/model_contain_eos_token"].append(gather_mean(model_eos.float())) + self.stats["val/ref_contain_eos_token"].append(gather_mean(ref_eos.float())) + + # Log alpha and beta + self.stats["alpha"].append(self.alpha) + self.stats["beta"].append(self.beta) + + def training_step( + self, model: nn.Module, inputs: dict[str, torch.Tensor | Any], num_items_in_batch: int | None = None + ) -> torch.Tensor: + model.train() + + # Apply chat template and tokenize the input + batch_size = len(next(iter(inputs.values()))) + prompts = inputs["prompt"] + inputs = [{k: v[i] for k, v in inputs.items()} for i in range(batch_size)] + inputs = [maybe_apply_chat_template(x, self.processing_class) for x in inputs] + inputs = [self.tokenize_row(x, self.model.config.is_encoder_decoder, self.processing_class) for x in inputs] + inputs = self.data_collator(inputs) + + # need the prompt_ only + inputs = self._prepare_inputs(inputs) + context_length = inputs["prompt_input_ids"].shape[1] + prompts = { + "input_ids": inputs["prompt_input_ids"], + "attention_mask": inputs["prompt_attention_mask"], + "raw": prompts, + } + del inputs + + # Sample completions from both the model and the reference model + model_output, ref_output = self._generate_completions(prompts, model) + + # Process model completions + model_data, ref_data = self._process_completions(model_output, ref_output, prompts) + + # Compute rewards + model_scores, ref_scores = self._compute_rewards(model_data, ref_data, context_length) + chosen_mask = model_scores >= ref_scores + + # Compute logprobs + model_logprobs_model_data, model_logprobs_ref_data, ref_logprobs_ref_data, ref_logprobs_model_data = ( + self._compute_logprobs(model, model_data, ref_data, context_length) + ) + + # Compute loss + loss, dpo_losses, xpo_losses = self._compute_losses( + model_logprobs_model_data, + model_logprobs_ref_data, + ref_logprobs_ref_data, + ref_logprobs_model_data, + chosen_mask, + ) + + # Log everything + self._log_statistics( + model_data, + ref_data, + model_logprobs_model_data.detach(), + model_logprobs_ref_data.detach(), + ref_logprobs_ref_data, + ref_logprobs_model_data, + chosen_mask, + dpo_losses.detach(), + xpo_losses.detach(), + context_length, + model_scores, + ref_scores, + ) + + if ( + self.args.torch_empty_cache_steps is not None + and self.state.global_step % self.args.torch_empty_cache_steps == 0 + ): + empty_cache() + + kwargs = {} + # For LOMO optimizers you need to explicitly use the learning rate + if self.args.optim in [OptimizerNames.LOMO, OptimizerNames.ADALOMO]: + kwargs["learning_rate"] = self._get_learning_rate() + + if self.args.n_gpu > 1: + loss = loss.mean() # mean() to average on multi-gpu parallel training + + self.accelerator.backward(loss, **kwargs) + + return loss.detach() / self.args.gradient_accumulation_steps diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/extras/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/extras/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d2777dd0eb21a0ea67dce8775337a27ea8499da2 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/extras/__init__.py @@ -0,0 +1,13 @@ +# Copyright 2020-2026 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. diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/extras/dataset_formatting.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/extras/dataset_formatting.py new file mode 100644 index 0000000000000000000000000000000000000000..6dd89493a33263bda1506f67f661947ac69a3690 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/extras/dataset_formatting.py @@ -0,0 +1,32 @@ +# Copyright 2020-2026 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 datasets +from datasets import Value +from packaging.version import Version + + +if Version(datasets.__version__) >= Version("4.0.0"): + from datasets import List + + FORMAT_MAPPING = { + "chatml": List({"content": Value(dtype="string", id=None), "role": Value(dtype="string", id=None)}), + "instruction": {"completion": Value(dtype="string", id=None), "prompt": Value(dtype="string", id=None)}, + } +else: + FORMAT_MAPPING = { + "chatml": [{"content": Value(dtype="string", id=None), "role": Value(dtype="string", id=None)}], + "instruction": {"completion": Value(dtype="string", id=None), "prompt": Value(dtype="string", id=None)}, + } diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/extras/profiling.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/extras/profiling.py new file mode 100644 index 0000000000000000000000000000000000000000..01a7b62212cfa141ebccd145e722430ce5590c61 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/extras/profiling.py @@ -0,0 +1,224 @@ +# Copyright 2020-2026 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 functools +import time +from collections.abc import Callable + +from transformers import Trainer +from transformers.integrations import is_mlflow_available, is_trackio_available, is_wandb_available + + +if is_wandb_available(): + import wandb + +if is_mlflow_available(): + import mlflow + +if is_trackio_available(): + import trackio + + +class ProfilingContext: + """ + Context manager for profiling code blocks with configurable logging. + + This class handles timing of code execution and logging metrics to various backends (Weights & Biases, MLflow, + Trackio) without being coupled to the Trainer class. + + Args: + name (`str`): + Name of the profiling context. Used in the metric name. + report_to (`list` of `str`): + List of integrations to report metrics to (e.g., ["wandb", "mlflow", "trackio"]). + is_main_process (`bool`, *optional*, defaults to `True`): + Whether this is the main process in distributed training. Metrics are only logged from the main process. + step (`int` or `None`, *optional*): + Training step to associate with the logged metrics. + metric_prefix (`str`, *optional*, defaults to `"profiling/Time taken"`): + Prefix for the metric name in logs. + + Example: + ```python + # Direct usage + from trl.extras.profiling import ProfilingContext + + with ProfilingContext( + name="MyClass.expensive_operation", + report_to=["wandb"], + is_main_process=True, + step=100, + ): + # Code to profile + result = expensive_computation() + + # With Trainer (backwards compatible via profiling_context function) + from transformers import Trainer + from trl.extras.profiling import profiling_context + + + class MyTrainer(Trainer): + def some_method(self): + with profiling_context(self, "matrix_multiplication"): + result = matrix_multiply() + ``` + """ + + def __init__( + self, + name: str, + report_to: list[str], + is_main_process: bool = True, + step: int | None = None, + metric_prefix: str = "profiling/Time taken", + ): + self.name = name + self.report_to = report_to + self.is_main_process = is_main_process + self.step = step + self.metric_prefix = metric_prefix + self._start_time = None + + def __enter__(self): + """Start timing when entering the context.""" + self._start_time = time.perf_counter() + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + """Stop timing and log metrics when exiting the context.""" + if self._start_time is not None: + duration = time.perf_counter() - self._start_time + self._log_metrics(duration) + return False + + def _log_metrics(self, duration: float) -> None: + """ + Log profiling metrics to configured backends. + + Args: + duration (`float`): + Execution time in seconds. + """ + if not self.is_main_process: + return + + metric_name = f"{self.metric_prefix}: {self.name}" + metrics = {metric_name: duration} + + # Log to Weights & Biases if configured + if "wandb" in self.report_to and is_wandb_available() and wandb.run is not None: + wandb.log(metrics) + + # Log to MLflow if configured + if "mlflow" in self.report_to and is_mlflow_available() and mlflow.active_run() is not None: + mlflow.log_metrics(metrics, step=self.step) + + # Log to Trackio if configured + if "trackio" in self.report_to and is_trackio_available(): + trackio.log(metrics, step=self.step) + + +def profiling_context(trainer: Trainer, name: str) -> ProfilingContext: + """ + Factory function to create a ProfilingContext from a Trainer instance. + + This function maintains backwards compatibility with existing code while using the decoupled ProfilingContext class + internally. + + Args: + trainer (`~transformers.Trainer`): + Trainer object containing configuration for logging. + name (`str`): + Name of the block to be profiled. Will be prefixed with the trainer class name. + + Returns: + `ProfilingContext`: A configured profiling context manager. + + Example: + ```python + from transformers import Trainer + from trl.extras.profiling import profiling_context + + + class MyTrainer(Trainer): + def some_method(self): + A = np.random.rand(1000, 1000) + B = np.random.rand(1000, 1000) + with profiling_context(self, "matrix_multiplication"): + # Code to profile: simulate a computationally expensive operation + result = A @ B # Matrix multiplication + ``` + """ + context_name = f"{trainer.__class__.__name__}.{name}" + step = trainer.state.global_step + + return ProfilingContext( + name=context_name, + report_to=trainer.args.report_to, + is_main_process=trainer.accelerator.is_main_process, + step=step, + ) + + +def profiling_decorator(func: Callable) -> Callable: + """ + Decorator to profile a function and log execution time using [`extras.profiling.profiling_context`]. + + This decorator works with methods that have access to a trainer instance (typically as `self`). For non-Trainer + objects that have an `accelerator` attribute, it will use that for logging configuration. + + Args: + func (`Callable`): + Function to be profiled. + + Returns: + `Callable`: Wrapped function that profiles execution time. + + Example: + ```python + from transformers import Trainer + from trl.extras.profiling import profiling_decorator + + + class MyTrainer(Trainer): + @profiling_decorator + def some_method(self): + A = np.random.rand(1000, 1000) + B = np.random.rand(1000, 1000) + # Code to profile: simulate a computationally expensive operation + result = A @ B + ``` + """ + + @functools.wraps(func) + def wrapper(self, *args, **kwargs): + # Check if self is a Trainer-like object with required attributes + if hasattr(self, "state") and hasattr(self, "args"): + with profiling_context(self, func.__name__): + return func(self, *args, **kwargs) + # For non-Trainer objects (e.g., VLLMGeneration), use ProfilingContext directly + elif hasattr(self, "accelerator"): + context_name = f"{self.__class__.__name__}.{func.__name__}" + with ProfilingContext( + name=context_name, + report_to=[], # No reporting for non-Trainer objects without args + is_main_process=self.accelerator.is_main_process, + step=None, + ): + return func(self, *args, **kwargs) + else: + # No profiling available, just run the function + return func(self, *args, **kwargs) + + return wrapper diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/generation/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/generation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..22e7cf6d88463c5b6774725e2b66ee1496bddd22 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/generation/__init__.py @@ -0,0 +1,25 @@ +# Copyright 2020-2026 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. + +"""Generation backends for TRL trainers.""" + +from ..import_utils import is_vllm_available + + +__all__ = [] + +if is_vllm_available(): + from .vllm_generation import VLLMGeneration + + __all__.append("VLLMGeneration") diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/generation/vllm_client.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/generation/vllm_client.py new file mode 100644 index 0000000000000000000000000000000000000000..cb05ae5a551365f76b97f0edd54337bc976c57a3 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/generation/vllm_client.py @@ -0,0 +1,764 @@ +# Copyright 2020-2026 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 atexit +import base64 +import copy +import logging +import socket +import time +from io import BytesIO +from urllib.parse import urlparse + +import torch +import torch.distributed.distributed_c10d as c10d +from requests.adapters import HTTPAdapter +from torch import nn +from transformers import is_torch_xpu_available +from transformers.utils import get_json_schema +from urllib3.util.retry import Retry + +from ..import_utils import is_requests_available, is_vllm_ascend_available, is_vllm_available + + +if is_requests_available(): + import requests + from requests import ConnectionError + + +if is_vllm_available(): + from vllm.distributed.device_communicators.pynccl import PyNcclCommunicator + from vllm.distributed.utils import StatelessProcessGroup + + if is_vllm_ascend_available(): + from vllm_ascend.distributed.device_communicators.pyhccl import PyHcclCommunicator as PyNcclCommunicator + + +logger = logging.getLogger(__name__) + + +def pil_to_base64(image): + buffer = BytesIO() + image.save(buffer, format="PNG") + img_bytes = buffer.getvalue() + return base64.b64encode(img_bytes).decode("utf-8") + + +class VLLMClient: + """ + A client class to interact with a vLLM server. + + This class provides methods to generate completions, initialize and manage weight update groups, and update model + weights in a distributed setting. Before using it, start the vLLM server with `trl vllm-serve`. + + Args: + base_url (`str`, *optional*): + Base URL for the vLLM server (e.g., `"http://localhost:8000"`). If provided, `host` and `server_port` are + ignored. + host (`str`, *optional*, defaults to `"0.0.0.0"`): + IP address of the vLLM server. Ignored if `base_url` is provided. + server_port (`int`, *optional*, defaults to `8000`): + Port number of the vLLM server. Ignored if `base_url` is provided. + group_port (`int`, *optional*, defaults to `51216`): + Port number for the weight update group. + connection_timeout (`float`, *optional*, defaults to `0.0`): + Total timeout duration in seconds to wait for the server to be up. If the server is not up after the + timeout, a `ConnectionError` is raised. + + Examples: + Run the vLLM server with the model `Qwen/Qwen2.5-7B`: + + ``` + $ trl vllm-serve --model Qwen/Qwen2.5-7B + ... + INFO: Application startup complete. + INFO: Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit) + ``` + + Use the client to generate completions and update model weights: + + ```python + >>> from trl.generation.vllm_client import VLLMClient + + >>> client = VLLMClient() + >>> client.generate(["Hello, AI!", "Tell me a joke"]) + {'prompt_ids': [[9707, 11, 15235, 0], + [40451, 752, 264, 21646]], + 'completion_ids': [[2980, 498, 1492, 752, 448, 264, 13027, 8645, 30, 358, 2776, 4460, 311, 3270, 264, 2025], + [911, 98072, 2142, 624, 45, 51426, 2142, 374, 279, 16396, 429, 4302, 702, 36988, 7290, 476]], + 'logprobs': [[[-1.6612], [-0.0081], [-1.5189], [-0.0123], [-1.2045], [-0.6227], [-2.9791], [-2.8387], [-0.1267], [-0.0366], [-2.6528], [-0.3197], [-0.0001], [-1.8174], [-0.0251], [-1.473]], + [[-0.018], [-10.7331], [-0.1605], [-0.891], [-3.7945], [-0.0127], [-0.3073], [-1.1648], [-1.8025], [-0.409], [-0.0256], [-1.6127], [-2.2935], [-4.1785], [-0.6531], [-0.2629]]], + 'logprob_token_ids': [[[2980], [498], [1492], [752], [448], [264], [13027], [8645], [30], [358], [2776], [4460], [311], [3270], [264], [2025]], + [[911], [98072], [2142], [624], [45], [51426], [2142], [374], [279], [16396], [429], [4302], [702], [36988], [7290], [476]]]} + + >>> from transformers import AutoModelForCausalLM + + >>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-7B", device_map="cuda") + >>> client.init_communicator(device="cuda") + >>> client.update_model_params(model) + ``` + + There are several ways to initialize the client: + + ```python + VLLMClient(base_url="http://localhost:8000") + VLLMClient(base_url="http://192.168.1.100:8000") + VLLMClient(host="localhost", server_port=8000) + VLLMClient(host="192.168.1.100", server_port=8000) + ``` + """ + + def __init__( + self, + base_url: str | None = None, + host: str = "0.0.0.0", + server_port: int = 8000, + group_port: int = 51216, + connection_timeout: float = 0.0, + ): + if not is_requests_available(): + raise ImportError("requests is not installed. Please install it with `pip install requests`.") + if not is_vllm_available(): + raise ImportError("vLLM is not installed. Please install it with `pip install trl[vllm]`.") + + self.session = requests.Session() + + # Configure retries for HTTP requests made through this session. + # This is not strictly required for correctness, but it helps make training more robust to rare, transient + # failures (network hiccups, temporary 5xx errors, overloaded servers). Without this, such failures could cause + # an otherwise healthy training run to fail. + retry_strategy = Retry( + total=5, # global cap on the total number of retries across all failure types + connect=5, # retry connection-level failures (DNS issues, refused connections, etc) + read=5, # retry failures while reading the response after the connection was successfully established + status=3, # retry a limited number of times when we receive certain HTTP error responses from the server + status_forcelist=[500, 502, 503], # only retry on server-side errors that are usually temporary + backoff_factor=2, # exponential backoff between retries (2s, 4s, 8s, ...) + allowed_methods=["POST", "GET"], # allow POST as well, even though we're not sure it's safe here + ) + + adapter = HTTPAdapter(max_retries=retry_strategy) + self.session.mount("http://", adapter) + self.session.mount("https://", adapter) + + if base_url is not None: + # Parse the base_url to extract host and port + parsed_url = urlparse(base_url) + self.host = socket.gethostbyname(parsed_url.hostname) + scheme = parsed_url.scheme or "http" + self.base_url = f"{scheme}://{parsed_url.netloc}{parsed_url.path}" + else: + self.host = host + self.server_port = server_port + self.base_url = f"http://{self.host}:{self.server_port}" + self.group_port = group_port + self.check_server(connection_timeout) # check server and fail after timeout + + def check_server(self, total_timeout: float = 0.0, retry_interval: float = 2.0): + """ + Check server availability with retries on failure, within a total timeout duration. If the server is not up + after the total timeout duration, raise a `ConnectionError`. + + Args: + retry_interval (`float`, *optional*, defaults to `2.0`): + Interval in seconds between retries. + total_timeout (`float`, *optional*, defaults to `0.0`): + Total timeout duration in seconds. + """ + url = f"{self.base_url}/health/" + start_time = time.time() # Record the start time + + while True: + try: + response = requests.get(url) + except requests.exceptions.RequestException as exc: + # Check if the total timeout duration has passed + elapsed_time = time.time() - start_time + if elapsed_time >= total_timeout: + raise ConnectionError( + f"The vLLM server can't be reached at {self.base_url} after {total_timeout} seconds. Make " + "sure the server is running by running `trl vllm-serve`." + ) from exc + else: + if response.status_code == 200: + if "X-Forwarded-For" in response.headers: + self.host = response.headers["X-Forwarded-For"] + logger.info("Server is up!") + return None + + # Retry logic: wait before trying again + logger.info(f"Server is not up yet. Retrying in {retry_interval} seconds...") + time.sleep(retry_interval) + + def generate( + self, + prompts: list[str] | list[list[int]], + images: list | None = None, + n: int = 1, + repetition_penalty: float = 1.0, + temperature: float = 1.0, + top_p: float = 1.0, + top_k: int = 0, + min_p: float = 0.0, + max_tokens: int = 16, + logprobs: int | None = 0, + structured_outputs_regex: str | None = None, + generation_kwargs: dict | None = None, + ) -> dict[str, list[list[int]]]: + """ + Generates model completions for the provided prompts. + + Args: + prompts (`list[str]` or `list[list[int]]`): + List of text prompts or list of token ID lists for which the model will generate completions. + images (`list[list[PIL.Image] | None]`, *optional*): + List of image lists for VLM support. Each element is a list of PIL images for the corresponding prompt, + or `None` if no images for that prompt. + n (`int`, *optional*, defaults to `1`): + Number of completions to generate for each prompt. + repetition_penalty (`float`, *optional*, defaults to `1.0`): + Parameter for repetition penalty. 1.0 means no penalty. + temperature (`float`, *optional*, defaults to `1.0`): + Temperature parameter for sampling. Higher values increase diversity. + top_p (`float`, *optional*, defaults to `1.0`): + Top-p sampling parameter.`1.0` means no truncation. + top_k (`int`, *optional*, defaults to `0`): + Top-k sampling parameter. `0` means no truncation. + min_p (`float`, *optional*, defaults to `0.0`): + Minimum probability for sampling. + max_tokens (`int`, *optional*, defaults to `16`): + Maximum number of tokens to generate for each prompt. + logprobs (`int` or `None`, *optional*, defaults to `0`): + Number of top logprobs to return per token. When 0, only the sampled token's logprob is returned. When + N>0, returns up to N+1 logprobs sorted by descending probability, because vLLM always includes the + sampled token's logprob (which may fall outside the top-N). + structured_outputs_regex (`str`, *optional*): + Regular expression to guide the decoding process. + generation_kwargs (`dict`, *optional*): + Additional generation parameters to pass to the vLLM `SamplingParams`. This can include parameters like + `seed`, `frequency_penalty`, etc. If it contains keys that conflict with the other parameters, they + will override them. + + Returns: + `dict` with keys: + - `prompt_ids` (`list[list[int]]`): + List of lists of token IDs representing the tokenized input prompts. + - `completion_ids` (`list[list[int]]`): + List of lists of token IDs representing the model-generated completions for each prompt. + - `logprobs` (`list[list[list[float]]]`): + Per-token logprobs of shape (num_sequences, seq_len, num_logprobs), sorted by descending + probability. + - `logprob_token_ids` (`list[list[list[int]]]`): + Token IDs corresponding to each logprob, same shape as `logprobs`. + """ + url = f"{self.base_url}/generate/" + + # Convert PIL images to base64 strings. Each element is a list of images for the corresponding prompt, + # or None if no images for that prompt. + if images: + images = [ + [pil_to_base64(img) for img in img_list] if img_list is not None else None for img_list in images + ] + + response = self.session.post( + url, + json={ + "prompts": prompts, + "images": images, + "n": n, + "repetition_penalty": repetition_penalty, + "temperature": temperature, + "top_p": top_p, + "top_k": top_k, + "min_p": min_p, + "max_tokens": max_tokens, + "logprobs": logprobs, + "structured_outputs_regex": structured_outputs_regex, + "generation_kwargs": generation_kwargs or {}, + }, + ) + if response.status_code == 200: + json_response = response.json() + return { + "prompt_ids": json_response["prompt_ids"], + "completion_ids": json_response["completion_ids"], + "logprobs": json_response["logprobs"], + "logprob_token_ids": json_response["logprob_token_ids"], + } + else: + raise Exception(f"Request failed: {response.status_code}, {response.text}") + + def chat( + self, + messages: list[list[dict]], + n: int = 1, + repetition_penalty: float = 1.0, + temperature: float = 1.0, + top_p: float = 1.0, + top_k: int = 0, + min_p: float = 0.0, + max_tokens: int = 16, + logprobs: int | None = 0, + structured_outputs_regex: str | None = None, + generation_kwargs: dict | None = None, + chat_template_kwargs: dict | None = None, + tools: list | None = None, + chat_template: str | None = None, + ) -> dict[str, list[list[int]]]: + """ + Generates model completions for the provided chat messages. + + Args: + messages (`list[list[dict]]`): + List of message lists for which the model will generate completions. Each message is a dictionary with + keys like "role" and "content". + n (`int`, *optional*, defaults to `1`): + Number of completions to generate for each message list. + repetition_penalty (`float`, *optional*, defaults to `1.0`): + Parameter for repetition penalty. 1.0 means no penalty. + temperature (`float`, *optional*, defaults to `1.0`): + Temperature parameter for sampling. Higher values increase diversity. + top_p (`float`, *optional*, defaults to `1.0`): + Top-p sampling parameter.`1.0` means no truncation. + top_k (`int`, *optional*, defaults to `0`): + Top-k sampling parameter. `0` means no truncation. + min_p (`float`, *optional*, defaults to `0.0`): + Minimum probability for sampling. + max_tokens (`int`, *optional*, defaults to `16`): + Maximum number of tokens to generate for each message list. + logprobs (`int` or `None`, *optional*, defaults to `0`): + Number of top logprobs to return per token. When 0, only the sampled token's logprob is returned. When + N>0, returns up to N+1 logprobs sorted by descending probability, because vLLM always includes the + sampled token's logprob (which may fall outside the top-N). + structured_outputs_regex (`str`, *optional*): + Regular expression to guide the decoding process. + generation_kwargs (`dict`, *optional*): + Additional generation parameters to pass to the vLLM `SamplingParams`. This can include parameters like + `seed`, `frequency_penalty`, etc. If it contains keys that conflict with the other parameters, they + will override them. + chat_template_kwargs (`dict`, *optional*): + Additional keyword arguments to customize the chat template used by the model. + tools (`list[dict | Callable]`, *optional*): + List of tool functions available for tool calling during chat generation. + chat_template (`str`, *optional*): + Template to use for structuring the chat. If not provided, the model's default chat template will be + used. + + Returns: + `dict` with keys: + - `prompt_ids` (`list[list[int]]`): + List of lists of token IDs representing the tokenized input messages. + - `completion_ids` (`list[list[int]]`): + List of lists of token IDs representing the model-generated completions for each message list. + - `logprobs` (`list[list[list[float]]]`): + Per-token logprobs of shape (num_sequences, seq_len, num_logprobs), sorted by descending + probability. + - `logprob_token_ids` (`list[list[list[int]]]`): + Token IDs corresponding to each logprob, same shape as `logprobs`. + """ + if chat_template is not None: + raise NotImplementedError("Custom chat templates are not yet implemented in VLLMClient.chat().") + + url = f"{self.base_url}/chat/" + + # Convert PIL images to base64 strings + messages = copy.deepcopy(messages) # avoid modifying the original messages + for message_list in messages: + for message in message_list: + if isinstance(message["content"], list): + for part in message["content"]: + if part["type"] == "image_pil": + part["image_pil"] = pil_to_base64(part["image_pil"]) + + if isinstance(tools, list) and len(tools) > 0: + tools = [get_json_schema(tool) if callable(tool) else tool for tool in tools] + + response = self.session.post( + url, + json={ + "messages": messages, + "n": n, + "repetition_penalty": repetition_penalty, + "temperature": temperature, + "top_p": top_p, + "top_k": top_k, + "min_p": min_p, + "max_tokens": max_tokens, + "logprobs": logprobs, + "structured_outputs_regex": structured_outputs_regex, + "generation_kwargs": generation_kwargs or {}, + "chat_template_kwargs": chat_template_kwargs or {}, + "tools": tools, + }, + ) + if response.status_code == 200: + json_response = response.json() + return { + "prompt_ids": json_response["prompt_ids"], + "completion_ids": json_response["completion_ids"], + "logprobs": json_response["logprobs"], + "logprob_token_ids": json_response["logprob_token_ids"], + } + else: + raise Exception(f"Request failed: {response.status_code}, {response.text}") + + def init_communicator(self, device: torch.device | str | int = 0): + """ + Initializes the weight update group in a distributed setup for model synchronization. + + Args: + device (`torch.device`, `str`, or `int`, *optional*, defaults to `0`): + Device of trainer main process. It's the device that will be used for the weights synchronization. Can + be a `torch.device` object, a string like `'cuda:0'`, or an integer device index. + """ + # Get the world size from the server + url = f"{self.base_url}/get_world_size/" + response = requests.get(url) + if response.status_code == 200: + vllm_world_size = response.json()["world_size"] + else: + raise Exception(f"Request failed: {response.status_code}, {response.text}") + + world_size = vllm_world_size + 1 # add the client to the world + self.rank = vllm_world_size # the client's rank is the last process + + # Initialize weight update group + url = f"{self.base_url}/init_communicator/" + # Will simplify it after torch xpu 2.9 support get uuid. + if is_torch_xpu_available(): + if hasattr(torch.xpu.get_device_properties(device), "uuid"): + client_device_uuid = str(torch.xpu.get_device_properties(device).uuid) + else: + client_device_uuid = "42" + else: + client_device_uuid = str(torch.cuda.get_device_properties(device).uuid) + + # Set the weight update group's host to "0.0.0.0" so that + # clients from different IPs can send updated weights + response = self.session.post( + url, + json={ + "host": "0.0.0.0", + "port": self.group_port, + "world_size": world_size, + "client_device_uuid": client_device_uuid, + }, + ) + if response.status_code != 200: + raise Exception(f"Request failed: {response.status_code}, {response.text}") + + # Brief delay to allow server initialization. While not strictly required (client socket will retry on + # connection failure), this prevents log warnings like: + # [W416 23:24:57.460001114 socket.cpp:204] [c10d] The hostname of the client socket cannot be retrieved. err=-3 + time.sleep(0.1) + + # Set up the communication group for weight broadcasting + if is_torch_xpu_available(): + store = torch.distributed.TCPStore( + host_name=self.host, port=self.group_port, world_size=world_size, is_master=(self.rank == 0) + ) + prefixed_store = c10d.PrefixStore("client2server", store) + xccl_options = c10d.ProcessGroupXCCL.Options() + pg = c10d.ProcessGroupXCCL( + store=prefixed_store, + rank=self.rank, + size=world_size, + options=xccl_options, + ) + self.communicator = pg + else: + pg = StatelessProcessGroup.create( + host=self.host, port=self.group_port, rank=self.rank, world_size=world_size + ) + self.communicator = PyNcclCommunicator(pg, device=device) + + # When the client object is deleted, close the weight update group + atexit.register(self.close_communicator) + + def update_named_param(self, name: str, weights: torch.Tensor): + """ + Updates a specific named parameter in the model and broadcasts it to other processes. + + Args: + name (`str`): + Name of the layer whose weights are being updated. + weights (`torch.Tensor`): + Tensor containing the updated weights. + """ + dtype, shape = str(weights.dtype), tuple(weights.shape) + url = f"{self.base_url}/update_named_param/" + response = self.session.post(url, json={"name": name, "dtype": dtype, "shape": shape}) + if response.status_code != 200: + raise Exception(f"Request failed: {response.status_code}, {response.text}") + + if is_torch_xpu_available(): + # Use XCCL to broadcast the updated weights from the client (src) to all workers. + self.communicator.broadcast(weights, root=self.rank) + self.communicator.barrier() + else: + # Use NCCL to broadcast the updated weights from the client (src) to all workers. + self.communicator.broadcast(weights, src=self.rank) + self.communicator.group.barrier() + + def update_model_params(self, model: nn.Module): + """ + Updates all parameters of the given model by calling `update_named_param` for each parameter in the model. + + Args: + model (`nn.Module`): + Model whose parameters (weights/biases) are to be updated. + """ + for name, param in model.named_parameters(): + # Update each parameter individually + self.update_named_param(name, param.data) + + def get_sequence_logprobs( + self, + sequences: list[list[int]], + prompt_lengths: list[int], + top_logprobs: int = 100, + temperature: float = 1.0, + use_binary: bool = True, + chunk_size: int = 0, + max_concurrent_requests: int = 4, + ) -> dict[str, list]: + """ + Computes teacher logprobs for existing token sequences without generating new tokens. + + Sends full sequences (prompt + completion) to the vLLM server and retrieves per-token top-k logprobs for the + completion region only. This is used for knowledge distillation where the teacher model evaluates existing + sequences rather than generating new ones. + + When `chunk_size > 0`, splits the batch into chunks and dispatches them concurrently via a thread pool, keeping + the server's data-parallel workers busy. + + When `use_binary=True`, uses base64-encoded numpy arrays for fast serialization instead of nested JSON lists. + + Args: + sequences (`list[list[int]]`): + List of full token ID sequences (prompt + completion). + prompt_lengths (`list[int]`): + Number of prompt tokens in each sequence. Logprobs are returned starting from this position. + top_logprobs (`int`, *optional*, defaults to `100`): + Number of top logprobs to return per token position. + temperature (`float`, *optional*, defaults to `1.0`): + Temperature used when scoring the teacher distribution. + use_binary (`bool`, *optional*, defaults to `True`): + Use binary (base64 numpy) response format for faster serialization. + chunk_size (`int`, *optional*, defaults to `0`): + If > 0, split batch into chunks of this size and dispatch concurrently. If 0, send the entire batch in + a single request. + max_concurrent_requests (`int`, *optional*, defaults to `4`): + Maximum number of concurrent requests when using chunked dispatch. + + Returns: + `dict` with keys: + - `logprobs` (`list[list[list[float]]]`): + Per-token logprobs of shape (batch, completion_len, top_logprobs), sorted by descending + probability. + - `logprob_token_ids` (`list[list[list[int]]]`): + Token IDs corresponding to each logprob, same shape as `logprobs`. + """ + from concurrent.futures import ThreadPoolExecutor, as_completed + + if temperature <= 0: + raise ValueError(f"temperature must be positive, got {temperature}") + + url = f"{self.base_url}/get_sequence_logprobs/" + response_format = "binary" if use_binary else "json" + + if chunk_size > 0 and len(sequences) > chunk_size: + # Chunked concurrent dispatch + n = len(sequences) + chunks = [] + for i in range(0, n, chunk_size): + chunks.append((sequences[i : i + chunk_size], prompt_lengths[i : i + chunk_size])) + + responses = [None] * len(chunks) + + def _send_chunk(idx, seqs, plens): + resp = self.session.post( + url, + json={ + "sequences": seqs, + "prompt_lengths": plens, + "top_logprobs": top_logprobs, + "temperature": temperature, + "response_format": response_format, + }, + ) + if resp.status_code != 200: + raise Exception(f"Request failed: {resp.status_code}, {resp.text}") + return idx, resp.json() + + with ThreadPoolExecutor(max_workers=min(max_concurrent_requests, len(chunks))) as executor: + futures = { + executor.submit(_send_chunk, idx, seqs, plens): idx for idx, (seqs, plens) in enumerate(chunks) + } + for future in as_completed(futures): + idx, result = future.result() + responses[idx] = result + + # Merge results + if use_binary: + return self._merge_binary_responses(responses, top_logprobs) + else: + all_logprobs = [] + all_token_ids = [] + for resp in responses: + all_logprobs.extend(resp["logprobs"]) + all_token_ids.extend(resp["logprob_token_ids"]) + return {"logprobs": all_logprobs, "logprob_token_ids": all_token_ids} + else: + # Single request + response = self.session.post( + url, + json={ + "sequences": sequences, + "prompt_lengths": prompt_lengths, + "top_logprobs": top_logprobs, + "temperature": temperature, + "response_format": response_format, + }, + ) + if response.status_code != 200: + raise Exception(f"Request failed: {response.status_code}, {response.text}") + + json_response = response.json() + if use_binary: + return self._decode_binary_logprobs(json_response) + else: + return { + "logprobs": json_response["logprobs"], + "logprob_token_ids": json_response["logprob_token_ids"], + } + + @staticmethod + def _decode_binary_logprobs(response: dict) -> dict[str, list]: + """Decode base64-encoded numpy arrays back to nested lists. + + Returns a dict with: + ``logprobs`` / ``logprob_token_ids`` — teacher's sorted top-k logprobs and + token IDs (shape per sequence: ``(comp_len, top_k)``). Used for the forward KL term. + ``actual_logprobs`` / ``actual_token_ids`` — teacher logprob for the actual + token at each position (shape per sequence: ``(comp_len, 1)``). Used for the reverse KL term. + """ + import numpy as np + + shape = response["shape"] # [batch, max_comp_len, top_k] + comp_lengths = response["completion_lengths"] + + logprobs_arr = np.frombuffer(base64.b64decode(response["logprobs_b64"]), dtype=np.float32).reshape(shape) + token_ids_arr = np.frombuffer(base64.b64decode(response["token_ids_b64"]), dtype=np.int32).reshape(shape) + + # Convert back to nested lists, trimming padding + all_logprobs = [] + all_token_ids = [] + for i, comp_len in enumerate(comp_lengths): + all_logprobs.append(logprobs_arr[i, :comp_len, :].tolist()) + all_token_ids.append(token_ids_arr[i, :comp_len, :].tolist()) + + result = {"logprobs": all_logprobs, "logprob_token_ids": all_token_ids} + + # Decode actual-token logprobs (for reverse KL) + if "actual_logprobs_b64" in response: + actual_shape = [shape[0], shape[1], 1] + actual_lp = np.frombuffer(base64.b64decode(response["actual_logprobs_b64"]), dtype=np.float32).reshape( + actual_shape + ) + actual_ids = np.frombuffer(base64.b64decode(response["actual_token_ids_b64"]), dtype=np.int32).reshape( + actual_shape + ) + all_actual_lps = [] + all_actual_ids = [] + for i, comp_len in enumerate(comp_lengths): + all_actual_lps.append(actual_lp[i, :comp_len, :].tolist()) + all_actual_ids.append(actual_ids[i, :comp_len, :].tolist()) + result["actual_logprobs"] = all_actual_lps + result["actual_token_ids"] = all_actual_ids + + return result + + @staticmethod + def _merge_binary_responses(responses: list[dict], top_logprobs: int) -> dict[str, list]: + """Merge binary responses from multiple chunks into a single result.""" + + all_logprobs = [] + all_token_ids = [] + all_actual_lps = [] + all_actual_ids = [] + for resp in responses: + decoded = VLLMClient._decode_binary_logprobs(resp) + all_logprobs.extend(decoded["logprobs"]) + all_token_ids.extend(decoded["logprob_token_ids"]) + if "actual_logprobs" in decoded: + all_actual_lps.extend(decoded["actual_logprobs"]) + all_actual_ids.extend(decoded["actual_token_ids"]) + + result = {"logprobs": all_logprobs, "logprob_token_ids": all_token_ids} + if all_actual_lps: + if len(all_actual_lps) != len(all_logprobs): + raise ValueError( + f"Inconsistent chunks: {len(all_actual_lps)} actual_logprobs entries " + f"but {len(all_logprobs)} logprobs entries." + ) + result["actual_logprobs"] = all_actual_lps + result["actual_token_ids"] = all_actual_ids + return result + + def reset_prefix_cache(self): + """ + Resets the prefix cache for the model. + """ + url = f"{self.base_url}/reset_prefix_cache/" + response = self.session.post(url) + if response.status_code != 200: + raise Exception(f"Request failed: {response.status_code}, {response.text}") + + def close_communicator(self): + """ + Closes the weight update group and cleans up the communication group. + """ + url = f"{self.base_url}/close_communicator/" + + try: + response = self.session.post(url) + except ConnectionError: + # The server might be already down, so we don't need to close the communicator + pass + else: + if response.status_code != 200: + raise Exception(f"Request failed: {response.status_code}, {response.text}") + + if self.communicator is not None: + self.communicator = None + + +# Example usage +if __name__ == "__main__": + from vllm import SamplingParams + + device = "xpu" if is_torch_xpu_available() else "cuda" + client = VLLMClient() + client.init_communicator(device=device) + + # Generate completions + responses = client.generate(["Hello, AI!", "Tell me a joke"], n=4, max_tokens=32, sampling_params=SamplingParams()) + print("Responses:", responses) # noqa + + # Update model weights + from transformers import AutoModelForCausalLM + + model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-7B").to(device) + client.update_model_params(model) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/generation/vllm_generation.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/generation/vllm_generation.py new file mode 100644 index 0000000000000000000000000000000000000000..0c9cea9b586449e4a39471b3f766bc9bc2069b3f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/generation/vllm_generation.py @@ -0,0 +1,689 @@ +# Copyright 2020-2026 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. + +"""vLLM-based generation backend for TRL trainers.""" + +import logging +import math +import os +from contextlib import nullcontext +from typing import TYPE_CHECKING + +import torch +from accelerate.utils import broadcast_object_list, gather_object, is_peft_model +from torch import nn +from torch.distributed.fsdp import FullyShardedDataParallel as FSDP +from transformers import PreTrainedModel, PreTrainedTokenizerBase, ProcessorMixin, is_bitsandbytes_available +from transformers.utils import ( + is_torch_mlu_available, + is_torch_mps_available, + is_torch_npu_available, + is_torch_xpu_available, +) + +from ..distributed import DistributedBackend +from ..extras.profiling import ProfilingContext +from ..import_utils import is_vllm_available +from ..trainer.utils import ensure_master_addr_port +from .vllm_client import VLLMClient + + +if is_vllm_available(): + from vllm import LLM, RequestOutput, SamplingParams + from vllm.sampling_params import StructuredOutputsParams + + +logger = logging.getLogger(__name__) + + +def empty_cache() -> None: + """Empties the cache of the available torch device. + + This function checks for the availability of different torch devices (CUDA, MLU, MPS, NPU, XPU) and empties the + cache of the first available device it finds. + + If none of the specific devices are available, it defaults to emptying the CUDA cache. + """ + if is_torch_mlu_available(): + torch.mlu.empty_cache() + elif is_torch_mps_available(): + torch.mps.empty_cache() + elif is_torch_npu_available(): + torch.npu.empty_cache() + elif is_torch_xpu_available(): + torch.xpu.empty_cache() + else: + torch.cuda.empty_cache() + + +def extract_logprobs(all_outputs: list["RequestOutput"]): + """ + Extract logprobs and token IDs from vLLM generation outputs. + + Returns logprobs and token IDs sorted by rank (most probable first). Each returned list has shape (num_sequences, + seq_len, num_logprobs), where num_logprobs is determined by the `logprobs` parameter passed to vLLM (1 when + `logprobs=0`, up to N+1 when `logprobs=N`). NaN logprob values are replaced with `None`. + + Args: + all_outputs (list of `RequestOutput`): + List of vLLM `RequestOutput` objects from generation. + + Returns: + Tuple of (logprobs, logprob_token_ids), each of shape (num_sequences, seq_len, num_logprobs). + """ + all_logprobs = [] + all_token_ids = [] + for outputs in all_outputs: + for output in outputs.outputs: + if output.logprobs is None: + return None, None + seq_logprobs = [] + seq_token_ids = [] + for lp in output.logprobs: + sorted_items = sorted(lp.items(), key=lambda x: x[1].rank) + seq_token_ids.append([token_id for token_id, _ in sorted_items]) + seq_logprobs.append([None if math.isnan(item.logprob) else item.logprob for _, item in sorted_items]) + all_logprobs.append(seq_logprobs) + all_token_ids.append(seq_token_ids) + return all_logprobs, all_token_ids + + +if TYPE_CHECKING: + from accelerate import Accelerator + from peft import PeftModel + + +if is_bitsandbytes_available(): + import bitsandbytes as bnb + + +class VLLMGeneration: + """Handles vLLM-based generation for trainers. + + Extracts all vLLM-specific logic (initialization, generation, weight sync) from trainers into a separate, testable + class. + + Args: + model ([`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]): + Model to use for generation. + accelerator ([`~accelerate.Accelerator`]): + Accelerator for distributed training. + processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`]): + Tokenizer or processor for the model. + + > Parameters for vLLM: + + mode (`str`, *optional*, defaults to `"colocate"`): + vLLM mode. Must be one of `"colocate"` or `"server"`. + + - `"colocate"`: vLLM will run in the same process and share the training GPUs. This avoids the need for a + separate server but may cause resource contention with training. + - `"server"`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM + server is running (start with `trl vllm-serve`). + + structured_outputs_regex (`str`, *optional*): + Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled. + + > Parameters for "server" vLLM mode: + + server_base_url (`str`, *optional*): + Base URL for the vLLM server (e.g., `"http://localhost:8000"`). If provided, `server_host` and + `server_port` are ignored. + server_host (`str`, *optional*, defaults to `"0.0.0.0"`): + Host of the vLLM server to connect to. Ignored if `server_base_url` is provided. + server_port (`int`, *optional*, defaults to `8000`): + Port of the vLLM server to connect to. Ignored if `server_base_url` is provided. + server_timeout (`float`, *optional*, defaults to `240.0`): + Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the + timeout, a `ConnectionError` is raised. + group_port (`int`, *optional*, defaults to `51216`): + Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port + is occupied, there is no need to change it. + + > Parameters for "colocate" vLLM mode: + + tensor_parallel_size (`int`, *optional*, defaults to `1`): + The number of GPUs to use for distributed execution with tensor parallelism. This setting only applies when + `mode` is set to `"colocate"`. If you are using `mode="server"`, this parameter must be passed separately + when launching the vLLM server via the `--vllm_tensor_parallel_size` flag. + gpu_memory_utilization (`float`, *optional*, defaults to `0.9`): + Ratio (between 0 and 1) of GPU memory to reserve for the model weights, activations, and KV cache. Higher + values will increase the KV cache size and thus improve the model's throughput. However, if the value is + too high, it may cause out-of- memory (OOM) errors. This setting only applies when `mode` is set to + `"colocate"`. If you are using `mode="server"`, this parameter must be passed separately when launching the + vLLM server via the `--vllm_gpu_memory_utilization` flag. + max_model_length (`int`, *optional*): + Model context length (prompt and completion). Set it to at least the maximum prompt length in the dataset + plus `max_completion_length`; if omitted, it is inferred from the model config. + max_num_seqs (`int`, *optional*): + Maximum number of sequences to process in parallel, effectively capping the batch size. + enable_sleep_mode (`bool`, *optional*, defaults to `False`): + Whether to enable sleep mode for the engine to offload weights/cache during the optimizer step. Keeps GPU + memory usage low, but waking the engine adds host–device transfer latency. + model_impl (`str`, *optional*, defaults to `"auto"`): + Model implementation to use for vLLM. + - "auto" will try to use the vLLM implementation, if it exists, and fall back to the Transformers + implementation if no vLLM implementation is available. + - "vllm" will use the vLLM model implementation. + - "transformers" will use the Transformers model implementation. + - "terratorch" will use the TerraTorch model implementation. + + > Parameters for generation: + + repetition_penalty (`float`, *optional*, defaults to `1.0`): + Parameter for repetition penalty. It penalizes new tokens based on whether they appear in the prompt and + the generated text so far. Values > 1 encourage the model to use new tokens, while values < 1 encourage the + model to repeat tokens. Default `1.0` means no penalty. + temperature (`float`, *optional*, defaults to `1.0`): + Sampling temperature. It controls the randomness of the sampling. Lower values make the model more + deterministic, while higher values make the model more random and increase diversity. + top_p (`float`, *optional*, defaults to `1.0`): + Top-p sampling parameter. It controls the cumulative probability of the top tokens to consider. Defaults to + `1.0` to consider all tokens. + top_k (`int`, *optional*, defaults to `0`): + Top-k sampling parameter. It controls the number of top tokens to consider. Defaults to `0` to consider all + tokens. + min_p (`float`, *optional*, defaults to `0.0`): + Min-p sampling parameter. It represents the minimum probability for a token to be considered, relative to + the probability of the most likely token. Default `0.0` means min-p is disabled. + max_completion_length (`int`, *optional*, defaults to `16`): + Maximum number of tokens to generate for each prompt. + logprobs (`int` or `None`, *optional*, defaults to `0`): + Number of top logprobs to return per token. When 0 (default), only the sampled token's logprob is returned + (inner dimension = 1). When N>0, returns up to N+1 logprobs sorted by descending probability, because vLLM + always includes the sampled token's logprob alongside the top-N (the sampled token may or may not already + be in the top-N). + generation_kwargs (`dict`, *optional*): + Additional generation parameters to pass to the vLLM `SamplingParams`. This can include parameters like + `seed`, `frequency_penalty`, etc. If it contains keys that conflict with the other parameters, they will + override them. + + > Parameters for chat/tools: + + chat_template (`str`, *optional*): + Template to use for structuring the chat. If not provided, the model's default chat template will be used. + chat_template_kwargs (`dict`, *optional*): + Additional keyword arguments to customize the chat template used by the model. + tools (`list`, *optional*): + Tools available for tool calling during chat generation. + """ + + def __init__( + self, + model: "PreTrainedModel | PeftModel", + accelerator: "Accelerator", + processing_class: PreTrainedTokenizerBase | ProcessorMixin, + # vLLM configuration + mode: str = "colocate", + structured_outputs_regex: str | None = None, + # Server mode configuration + server_base_url: str | None = None, + server_host: str = "0.0.0.0", + server_port: int = 8000, + server_timeout: float = 240.0, + group_port: int = 51216, + # Colocate mode configuration + tensor_parallel_size: int = 1, + gpu_memory_utilization: float = 0.9, + max_model_length: int | None = None, + max_num_seqs: int | None = None, + enable_sleep_mode: bool = False, + model_impl: str = "auto", + # Generation configuration + repetition_penalty: float = 1.0, + temperature: float = 1.0, + top_p: float = 1.0, + top_k: int = 0, + min_p: float = 0.0, + max_completion_length: int = 16, + logprobs: int | None = 0, + generation_kwargs: dict | None = None, + ): + self.model = model + self.accelerator = accelerator + self._dist = DistributedBackend(accelerator) + self.processing_class = processing_class + + # vLLM configuration + self.mode = mode + self.structured_outputs_regex = structured_outputs_regex + + # Server mode configuration + self.server_base_url = server_base_url + self.server_host = server_host + self.server_port = server_port + self.group_port = group_port + self.server_timeout = server_timeout + + # Colocate mode configuration + self.tensor_parallel_size = tensor_parallel_size + self.gpu_memory_utilization = gpu_memory_utilization + self.max_model_length = max_model_length + self.max_num_seqs = max_num_seqs + self.enable_sleep_mode = enable_sleep_mode + self.model_impl = model_impl + + # Generation configuration + self.repetition_penalty = repetition_penalty + self.temperature = temperature + self.top_p = top_p + self.top_k = top_k + self.min_p = min_p + self.max_completion_length = max_completion_length + self.logprobs = logprobs + self.generation_kwargs = generation_kwargs or {} + + self._init_vllm() + + def _init_vllm(self): + """Initialize vLLM in server or colocate mode.""" + model = self.model + accelerator = self.accelerator + + if not is_vllm_available(): + raise ImportError( + "vLLM is not available and `use_vllm` is set to True. Please install vLLM with " + "`pip install trl[vllm]` to use it." + ) + + if self.mode == "server": + if accelerator.is_main_process: + if self.server_base_url is not None: + base_url = self.server_base_url + else: + base_url = f"http://{self.server_host}:{self.server_port}" + self.vllm_client = VLLMClient( + base_url=base_url, group_port=self.group_port, connection_timeout=self.server_timeout + ) + self.vllm_client.init_communicator(device=torch.cuda.current_device()) + + elif self.mode == "colocate": + # Make sure tensor_parallel_size group size evenly divides the world size - each group should have + # the same number of ranks + if not accelerator.num_processes % self.tensor_parallel_size == 0: + raise ValueError( + f"tensor_parallel_size ({self.tensor_parallel_size}) must divide world size " + f"({accelerator.num_processes}) evenly." + ) + + if self.tensor_parallel_size > 1: + # Create subgroups of ranks for TP, each group with `tensor_parallel_size` ranks. + # For example, if world_size=8 and tensor_parallel_size=2 → groups: [0,1], [2,3], [4,5], [6,7] + self.tp_group, _ = torch.distributed.new_subgroups_by_enumeration( + [ + list(range(i * self.tensor_parallel_size, (i + 1) * self.tensor_parallel_size)) + for i in range(accelerator.num_processes // self.tensor_parallel_size) + ] + ) + + # vLLM requires the environment variables to be set for distributed training. + os.environ["RANK"] = str(accelerator.process_index) + os.environ["LOCAL_RANK"] = str(accelerator.local_process_index) + os.environ["WORLD_SIZE"] = str(accelerator.num_processes) + # Ensure distributed rendezvous variables are set without colliding across concurrent runs + ensure_master_addr_port() + + quantization = None + if is_bitsandbytes_available(): + for _, module in model.named_modules(): + if isinstance(module, bnb.nn.Linear4bit): + quantization = "bitsandbytes" + break + elif isinstance(module, bnb.nn.Linear8bitLt): + raise ValueError("vLLM does not support in-flight 8-bit quantization.") + + # Build LLM initialization kwargs + self.llm = LLM( + model=model.name_or_path, + tensor_parallel_size=self.tensor_parallel_size, + gpu_memory_utilization=self.gpu_memory_utilization, + max_model_len=self.max_model_length, + max_num_seqs=self.max_num_seqs, + enable_sleep_mode=self.enable_sleep_mode, + model_impl=self.model_impl, + distributed_executor_backend="external_launcher", + # Feed identical seed for tp groups to ensure sampling results are the same across workers + seed=accelerator.process_index // self.tensor_parallel_size, + # Latest vLLM v1 memory profiler is misled by the high default value (i.e., 32768) - thinking there's not enough memory + max_num_batched_tokens=4096, + # Important so temperature scaling/logit tweaking affects the TIS log probs + logprobs_mode="processed_logprobs", + quantization=quantization, + ) + if self.enable_sleep_mode: + self.llm.sleep(level=2) + else: + raise ValueError(f"vllm_mode must be either 'server' or 'colocate', got '{self.mode}'.") + + # When using vLLM, the main process is responsible for loading the model weights. This can cause process + # desynchronization and seems to lead to DeepSpeed hanging during initialization. To prevent this, we + # synchronize all processes after vLLM has been fully initialized. + accelerator.wait_for_everyone() + + def _fix_param_name_to_vllm(self, name: str, extra_prefixes: list[str] | None = None) -> str: + """Fix parameter name for vLLM compatibility.""" + extra_prefixes = extra_prefixes or [] + prefixes = ["_checkpoint_wrapped_module."] + extra_prefixes + for prefix in prefixes: + name = name.replace(prefix, "") + return name + + def _push_param_to_vllm(self, name: str, param) -> None: + """Push a single parameter tensor to the vLLM engine (server or colocate mode).""" + if self.mode == "server" and self.accelerator.is_main_process: + self.vllm_client.update_named_param(name, param) + elif self.mode == "colocate": + self.llm.llm_engine.model_executor.driver_worker.model_runner.model.load_weights([(name, param)]) + + def _sync_fsdp1_params_to_vllm(self, module: nn.Module, prefix: str = "", visited: set[str] | None = None): + """Memory-efficient post-order traversal of FSDP modules to extract full parameters and sync with vLLM.""" + # For FSDP1, we need to recurse into children and also use summon_full_params + if visited is None: + visited = set() + for child_name, child_module in module.named_children(): + child_prefix = f"{prefix}.{child_name}" if prefix else child_name + self._sync_fsdp1_params_to_vllm( + child_module, prefix=child_prefix, visited=visited + ) # recurse into the child + + if isinstance(module, FSDP): + with FSDP.summon_full_params(module, recurse=False, writeback=False): + for param_name, param in module.named_parameters(): + full_name = f"{prefix}.{param_name}" if prefix else param_name + full_name = self._fix_param_name_to_vllm(full_name, extra_prefixes=["_fsdp_wrapped_module."]) + + if full_name in visited: + continue # skip FSDP subtrees already traversed + visited.add(full_name) + + self._push_param_to_vllm(full_name, param.data) + + def _sync_fsdp2_params_to_vllm(self, module: nn.Module): + """FSDP2-specific parameter synchronization.""" + # For FSDP2, module.state_dict() already covers all parameters, so no need for recursion + for name, param in module.state_dict().items(): + # When using PEFT, we need to recover the original parameter name + name = name.removeprefix("base_model.model.").replace(".base_layer", "") + # Skip PEFT layers: they don't exist in vLLM, and they are merged already. + if is_peft_model(module) and module.prefix in name: + continue + # When module to save, remove its prefix and discard the original module + if "original_module" in name: + continue + name = self._fix_param_name_to_vllm(name, extra_prefixes=["modules_to_save.default."]) + + if param.is_cpu: + param = param.to(torch.device("cuda")) + param = param.full_tensor() + + self._push_param_to_vllm(name, param) + + def _sync_fsdp_params_to_vllm(self, model: nn.Module): + """Dispatch FSDP weight sync to the version-appropriate method.""" + if self._dist.fsdp_version == 1: + self._sync_fsdp1_params_to_vllm(model) + elif self._dist.fsdp_version == 2: + self._sync_fsdp2_params_to_vllm(model) + + def sync_weights(self): + """Synchronize model weights to vLLM. + + Handles FSDP, DeepSpeed, PEFT weight synchronization. + """ + # Wake up vLLM weights before loading to ensure device memory is mapped. Without this, load_weights() writes to + # freed/unmapped memory when sleep mode is active, which crashes on backends with strict physical memory + # management (e.g., Ascend NPU). See https://github.com/huggingface/trl/issues/5142 + if self.mode == "colocate" and self.enable_sleep_mode: + empty_cache() # required to avoid OOM in some cases + self.llm.wake_up(tags=["weights"]) + + model = self.model + accelerator = self.accelerator + + if is_peft_model(model): + # With PEFT and FSDP/DeepSpeed ZeRO Stage 3, we must gather the full model at once before merging, as + # merging adapters in a sharded manner is not supported. + # TODO: does this work with FSDP? + with self._dist.gather_params(list(model.parameters())): + model.merge_adapter() + + # Update vLLM weights while parameters are gathered + if self._dist.is_fsdp: # note if using FSDP, gather_params is a no-op + # For PEFT with FSDP we need to use the memory efficient post-order traversal + self._sync_fsdp_params_to_vllm(model) + else: + # DeepSpeed ZeRO-3 with PEFT + for name, param in model.named_parameters(): + # When using PEFT, we need to recover the original parameter name + name = name.removeprefix("base_model.model.").replace(".base_layer", "") + # Skip PEFT layers: they don't exist in vLLM, and they are merged already. + if model.prefix in name: + continue + # When module to save, remove its prefix and discard the original module + if "original_module" in name: + continue + name = self._fix_param_name_to_vllm(name, extra_prefixes=["modules_to_save.default."]) + + self._push_param_to_vllm(name, param.data) + # Unmerge adapters while parameters are still gathered + model.unmerge_adapter() + # Parameters will automatically be repartitioned when exiting the context + else: + # For non-PEFT models, simply gather (if needed) and update each parameter individually. + if self._dist.is_fsdp: + self._sync_fsdp_params_to_vllm(model) + else: + for name, param in model.named_parameters(): + name = self._fix_param_name_to_vllm(name) + with self._dist.gather_params([param]): + self._push_param_to_vllm(name, param.data) + + # Reset cache on vLLM + if self.mode == "server" and accelerator.is_main_process: + self.vllm_client.reset_prefix_cache() + elif self.mode == "colocate": + self.llm.reset_prefix_cache() + + def generate( + self, + prompts: list[list[int]], + images: list[list | None] | None, + num_generations: int, + profiler: ProfilingContext | None = None, + ) -> tuple: + """Generate completions using vLLM. + + Args: + prompts: List of token ID lists, one per prompt (already tokenized). + images: Optional list of image lists for VLM support. Each element is a list of PIL images for the + corresponding prompt, or `None` if no images for that prompt. `None` if no images at all. + num_generations: Number of generations per prompt. + profiler: Optional profiler for performance tracking. + + Returns: + Tuple of (prompt_ids, completion_ids, logprobs, logprob_token_ids). + + - `prompt_ids`: `list[list[int]]` of shape `(batch_size, prompt_len)`. + - `completion_ids`: `list[list[int]]` of shape `(batch_size, completion_len)`. + - `logprobs`: `list[list[list[float | None]]]` of shape `(batch_size, completion_len, num_logprobs)`. + - `logprob_token_ids`: `list[list[list[int]]]` of shape `(batch_size, completion_len, num_logprobs)`. + + `num_logprobs` is 1 when `logprobs=0`, or up to N+1 when `logprobs=N` (the sampled token is always included + and may fall outside the top-N). + """ + profiler = profiler or nullcontext() + accelerator = self.accelerator + temperature = self.temperature + top_p = self.top_p + top_k = self.top_k + min_p = self.min_p + repetition_penalty = self.repetition_penalty + max_completion_length = self.max_completion_length + + # Wake up colocated vLLM weights if needed (idempotent if already awake from sync_weights) + if self.mode == "colocate" and self.enable_sleep_mode: + empty_cache() # required to avoid OOM in some cases + self.llm.wake_up(tags=["weights"]) + # Work around for https://github.com/vllm-project/vllm/issues/29341 + try: + self.llm.collective_rpc("reload_weights") + except NotImplementedError: + # Non-CUDA vLLM backends (e.g., vllm-ascend's NPUWorkerV1), don't implement reload_weights + pass + + # Generate completions using vLLM: gather all prompts and use them in a single call in the main process + if self.mode == "server": + all_prompts = gather_object(prompts) + # Always gather images (even when None) to avoid deadlock: images may be None on some ranks + # and non-None on others in mixed datasets, and gather_object is a collective operation. + all_images = gather_object(images if images is not None else [None] * len(prompts)) + if all(img is None for img in all_images): + all_images = None + + if accelerator.is_main_process: + # Since 'prompts' contains 'num_generations' duplicates, we first take unique prompts, and + # generate num_generations outputs for each one. This is faster than generating outputs for each + # duplicate prompt individually. + ordered_set_of_prompt_ids = all_prompts[::num_generations] + ordered_set_of_images = all_images[::num_generations] if all_images is not None else None + + sampling_params = { + "n": num_generations, + "repetition_penalty": repetition_penalty, + "temperature": temperature, + "top_p": top_p, + "top_k": top_k, + "min_p": 0.0 if min_p is None else min_p, + "max_tokens": max_completion_length, + "logprobs": self.logprobs, + "structured_outputs_regex": self.structured_outputs_regex, + "generation_kwargs": self.generation_kwargs, + } + with profiler: + output = self.vllm_client.generate( + prompts=ordered_set_of_prompt_ids, + images=ordered_set_of_images, + **sampling_params, + ) + payload = ( + output["prompt_ids"], + output["completion_ids"], + output["logprobs"], + output.get("logprob_token_ids"), + ) + else: + payload = None + + # Broadcast the completions from the main process to all processes, ensuring each process receives its corresponding slice. + obj_list = [payload] + broadcast_object_list(obj_list, from_process=0) + all_prompt_ids, all_completion_ids, all_logprobs, all_logprob_token_ids = obj_list[0] + + # vllm_client.generate(n=num_generations) returns num_generations completions per prompt. + # Duplicate prompt_ids to align with per-completion entries. + all_prompt_ids = [ids for ids in all_prompt_ids for _ in range(num_generations)] + + process_slice = slice( + accelerator.process_index * len(prompts), + (accelerator.process_index + 1) * len(prompts), + ) + prompt_ids = all_prompt_ids[process_slice] + completion_ids = all_completion_ids[process_slice] + logprobs = all_logprobs[process_slice] if all_logprobs is not None else None + logprob_token_ids = all_logprob_token_ids[process_slice] if all_logprob_token_ids is not None else None + + # Generate completions using colocated vLLM instances: each device holds vLLM copy and work on their own batch of prompts + elif self.mode == "colocate": + generation_kwargs = { + "n": 1, # vLLM on each GPU generates only 1 in colocate mode + "repetition_penalty": repetition_penalty, + "temperature": temperature, + "top_p": top_p, + "top_k": top_k, + "min_p": 0.0 if min_p is None else min_p, + "max_tokens": max_completion_length, + "logprobs": self.logprobs, + } + generation_kwargs.update(self.generation_kwargs) + + if self.structured_outputs_regex is not None: + if generation_kwargs.get("structured_outputs") is not None: + logger.warning( + "Both `structured_outputs_regex` and `generation_kwargs['structured_outputs']` are set; " + "`structured_outputs_regex` takes precedence." + ) + generation_kwargs["structured_outputs"] = StructuredOutputsParams(regex=self.structured_outputs_regex) + elif isinstance(structured_outputs_kwargs := generation_kwargs.get("structured_outputs"), dict): + generation_kwargs["structured_outputs"] = StructuredOutputsParams(**structured_outputs_kwargs) + sampling_params = SamplingParams(**generation_kwargs) + + if self.tensor_parallel_size > 1: + # Gather prompts from all ranks in the TP group and flatten. + # Each rank starts with its own prompts; after gathering, all ranks see the full group set. + orig_size = len(prompts) + gathered_prompts = [None for _ in range(self.tensor_parallel_size)] + torch.distributed.all_gather_object(gathered_prompts, prompts, group=self.tp_group) + all_prompts = [p for sublist in gathered_prompts for p in sublist] + # Always gather images (even when None) to avoid deadlock: images may be None on some + # ranks and non-None on others in mixed datasets, and all_gather_object is collective. + local_images = images if images is not None else [None] * len(prompts) + gathered_images = [None for _ in range(self.tensor_parallel_size)] + torch.distributed.all_gather_object(gathered_images, local_images, group=self.tp_group) + all_images = [img for sublist in gathered_images for img in sublist] + if all(img is None for img in all_images): + all_images = None + else: + all_prompts = prompts + all_images = images + + if self.enable_sleep_mode: + self.llm.wake_up(tags=["kv_cache"]) + + # Build vLLM-compatible prompt inputs with token IDs and optional multi-modal data + vllm_prompts = [] + if all_images is not None: + for ids, img_list in zip(all_prompts, all_images, strict=True): + row = {"prompt_token_ids": ids} + if img_list is not None: + row["multi_modal_data"] = {"image": img_list if len(img_list) > 1 else img_list[0]} + vllm_prompts.append(row) + else: + vllm_prompts = [{"prompt_token_ids": ids} for ids in all_prompts] + + with profiler: + all_outputs = self.llm.generate(vllm_prompts, sampling_params=sampling_params, use_tqdm=False) + + all_prompt_ids = [output.prompt_token_ids for output in all_outputs] + all_completion_ids = [output.token_ids for outputs in all_outputs for output in outputs.outputs] + all_logprobs, all_logprob_token_ids = extract_logprobs(all_outputs) + + if self.tensor_parallel_size > 1: + # Slice completions for this rank within its TP group. + # Each rank generates all outputs — we keep only our share. + local_rank_in_group = torch.distributed.get_rank(group=self.tp_group) + tp_slice = slice(local_rank_in_group * orig_size, (local_rank_in_group + 1) * orig_size) + prompt_ids = all_prompt_ids[tp_slice] + completion_ids = all_completion_ids[tp_slice] + logprobs = all_logprobs[tp_slice] if all_logprobs is not None else None + logprob_token_ids = all_logprob_token_ids[tp_slice] if all_logprob_token_ids is not None else None + else: + prompt_ids = all_prompt_ids + completion_ids = all_completion_ids + logprobs = all_logprobs + logprob_token_ids = all_logprob_token_ids + + if self.enable_sleep_mode: + self.llm.sleep(level=2) + + return prompt_ids, completion_ids, logprobs, logprob_token_ids diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/import_utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/import_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..3b7655bf60f6be9a0613b1083e55c572d6100c87 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/import_utils.py @@ -0,0 +1,149 @@ +# Copyright 2020-2026 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 importlib +import importlib.metadata +import importlib.util +import warnings +from contextlib import contextmanager + +from packaging.version import Version + + +LIGER_KERNEL_MIN_VERSION = "0.8.0" +PACKAGE_DISTRIBUTION_MAPPING = importlib.metadata.packages_distributions() + + +# From transformers: https://github.com/huggingface/transformers/blob/556312cd45a5e619c41b0f8adf680eab0d334324/src/transformers/utils/import_utils.py#L48-L77 +def _is_package_available(pkg_name: str, return_version: bool = False) -> tuple[bool, str] | bool: + """Check if `pkg_name` exist, and optionally try to get its version""" + spec = importlib.util.find_spec(pkg_name) + package_exists = spec is not None + package_version = "N/A" + if package_exists and return_version: + try: + # importlib.metadata works with the distribution package, which may be different from the import + # name (e.g. `PIL` is the import name, but `pillow` is the distribution name) + distributions = PACKAGE_DISTRIBUTION_MAPPING[pkg_name] + # Per PEP 503, underscores and hyphens are equivalent in package names. + # Prefer the distribution that matches the (normalized) package name. + normalized_pkg_name = pkg_name.replace("_", "-") + if normalized_pkg_name in distributions: + distribution_name = normalized_pkg_name + elif pkg_name in distributions: + distribution_name = pkg_name + else: + distribution_name = distributions[0] + package_version = importlib.metadata.version(distribution_name) + except (importlib.metadata.PackageNotFoundError, KeyError): + # If we cannot find the metadata (because of editable install for example), try to import directly. + # Note that this branch will almost never be run, so we do not import packages for nothing here + package = importlib.import_module(pkg_name) + package_version = getattr(package, "__version__", "N/A") + if return_version: + return package_exists, package_version + else: + return package_exists + + +def is_deepspeed_available() -> bool: + return _is_package_available("deepspeed") + + +def is_fastapi_available() -> bool: + return _is_package_available("fastapi") + + +def is_harbor_available() -> bool: + return _is_package_available("harbor") + + +def is_jmespath_available() -> bool: + return _is_package_available("jmespath") + + +def is_joblib_available() -> bool: + return _is_package_available("joblib") + + +def is_liger_kernel_available(min_version: str = LIGER_KERNEL_MIN_VERSION) -> bool: + _liger_kernel_available, _liger_kernel_version = _is_package_available("liger_kernel", return_version=True) + return _liger_kernel_available and Version(_liger_kernel_version) >= Version(min_version) + + +def is_math_verify_available() -> bool: + return _is_package_available("math_verify") + + +def is_mergekit_available() -> bool: + return _is_package_available("mergekit") + + +def is_openreward_available() -> bool: + return _is_package_available("openreward") + + +def is_pydantic_available() -> bool: + return _is_package_available("pydantic") + + +def is_requests_available() -> bool: + return _is_package_available("requests") + + +def is_unsloth_available() -> bool: + return _is_package_available("unsloth") + + +def is_uvicorn_available() -> bool: + return _is_package_available("uvicorn") + + +def is_vllm_available(min_version: str | None = None) -> bool: + _vllm_available, _vllm_version = _is_package_available("vllm", return_version=True) + if _vllm_available: + if not (Version("0.13.0") <= Version(_vllm_version) <= Version("0.19.1")): + warnings.warn( + f"TRL currently supports vLLM versions from 0.13.0 to 0.19.1. You have version {_vllm_version} " + "installed. We recommend installing a supported version to avoid compatibility issues.", + stacklevel=2, + ) + if min_version is not None and Version(_vllm_version) < Version(min_version): + return False + return _vllm_available + + +def is_vllm_ascend_available() -> bool: + return _is_package_available("vllm_ascend") + + +def is_weave_available() -> bool: + return _is_package_available("weave") + + +class TRLExperimentalWarning(UserWarning): + """Warning for using the 'trl.experimental' submodule.""" + + pass + + +@contextmanager +def suppress_warning(category): + with warnings.catch_warnings(): + warnings.simplefilter("ignore", category=category) + yield + + +def suppress_experimental_warning(): + return suppress_warning(TRLExperimentalWarning) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/models/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f84d989c2825020b0b69c4b31f0285fdcdf54b41 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/models/__init__.py @@ -0,0 +1,32 @@ +# Copyright 2020-2026 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. + +from typing import TYPE_CHECKING + +from .._lazy_module import _LazyModule + + +_import_structure = { + "activation_offloading": ["get_act_offloading_ctx_manager"], + "utils": ["create_reference_model", "prepare_deepspeed", "prepare_fsdp", "unwrap_model_for_generation"], +} + + +if TYPE_CHECKING: + from .activation_offloading import get_act_offloading_ctx_manager + from .utils import create_reference_model, prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation +else: + import sys + + sys.modules[__name__] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/models/activation_offloading.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/models/activation_offloading.py new file mode 100644 index 0000000000000000000000000000000000000000..b6cff43f7a34db1d492a8aa7600005a42433d0b8 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/models/activation_offloading.py @@ -0,0 +1,762 @@ +# Copyright 2020-2026 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. + +# Copyright (c) Meta Platforms, Inc. and affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of https://github.com/pytorch/torchtune. + + +import sys + +import psutil +import torch +from accelerate import logging +from accelerate.utils.versions import is_torch_version +from torch import nn +from torch.autograd.graph import saved_tensors_hooks +from transformers import is_torch_npu_available + + +if is_torch_npu_available(): + import torch_npu # noqa: F401 + +# Import DTensor for FSDP v2 support with version-aware import path +DTensor = None +if torch.distributed.is_available(): + try: + if is_torch_version(">=", "2.5.0"): + from torch.distributed.tensor import DTensor + else: + # from torch 2.0.0 (oldest supported accelerate torch version), DTensor is in torch.distributed._tensor + from torch.distributed._tensor import DTensor + except (ImportError, AttributeError): + DTensor = None + +logger = logging.get_logger(__name__) + + +def _get_unique_tensor_key(tensor: torch.Tensor) -> tuple: + """ + Get a unique key for a tensor based on its storage pointer and dtype. This allows deduplication of tensors that + share the same underlying storage. From: + https://github.com/volcengine/verl/blob/main/verl/utils/activation_offload.py + + Args: + tensor: The tensor to get the key for + + Returns: + A tuple of (storage_pointer, dtype) that uniquely identifies the tensor's storage + """ + # Handle special tensor types - primarily for FSDP v2 DTensor + actual_tensor = tensor + + # For DTensor (FSDP v2), extract the local tensor + if DTensor is not None and isinstance(tensor, DTensor) and hasattr(tensor, "_local_tensor"): + actual_tensor = tensor._local_tensor + + # Try to get storage pointer, but fall back to tensor id if not accessible + try: + storage_ptr = actual_tensor.untyped_storage().data_ptr() + actual_tensor.storage_offset() + except (RuntimeError, AttributeError): + # For tensors with invalid storage, use tensor id + # This won't enable deduplication for these tensors, but allows offloading to work + storage_ptr = id(actual_tensor) + + return (storage_ptr, actual_tensor.dtype) + + +class OffloadActivations(saved_tensors_hooks): + """ + Context manager under which activation tensors created in the forward pass will be offloaded. + + Enable the memory efficiency technique of activation offloading, where activations bigger than `min_offload_size` + bytes will be offloaded to CPU in the forward and brought back in the backward. This is in contrast to maintaining + the activation on GPU VRAM throughout the program. + + This manager contains the option of using one additional CUDA stream to handle the communication between CUDA and + CPU, which is intended to overlap with the default computation stream to improve runtime. We designed + synchronization with a few heuristics for optimizing the tradeoff between runtime vs memory usage. + + Args: + use_pin_memory (`bool`, *optional*, defaults to `True`): + Whether to offloaded Tensor will be placed in pinned memory on the CPU. Pinned memory allows the Tensor to + be moved back onto GPU more quickly but is a limited resource. + use_streams (`bool`, *optional*, defaults to `True`): + Whether to use streams for performance optimization where the communications get overlapped with the + computation. Requires a torch build after torch-2.5.0. + min_offload_size (`int`, *optional*, defaults to `1024`): + Minimum number of bytes a Tensor must be in order to qualify for offloading. If the tensor is too small, we + do not want to waste bandwidth and resources moving it to CPU and back. + max_fwd_stash_size (`int`, *optional*, defaults to `5`): + Maximum size of the forward stash, or the maximum number of consecutive activations to keep alive during + the forward pass. This number must be at least 1. Keeping alive more activations will potentially allow + more overlap between the communication and compute streams at the cost of increasing memory usage. Keeping + alive fewer activations will conserve memory, but may cause poor overlap between the streams, increasing + runtime. + + Raises: + ValueError: if `max_fwd_stash_size` is not at least `1`. + + Example: + ```python + >>> with OffloadActivations(): + ... outputs = model(inputs, labels=labels) + >>> loss = outputs.loss + >>> loss.backward() + ``` + """ + + def __init__( + self, + use_pin_memory: bool = True, + use_streams: bool = True, + min_offload_size: int = 1024, + max_fwd_stash_size: int = 5, + ) -> None: + self.use_streams = use_streams + + self.min_tensor_size_bytes = min_offload_size # we don't want to bother with small tensors + self.tracker = {} # tensor_id => (new_tensor, if_modified) ---> track what saved/offloaded tensors are where + self.tensor_id = 0 + self.is_first_forward_call = True + self.is_first_backward_call = True + self.is_first_forward_pass = True + + # Storage deduplication: maps storage key to tensor_id to avoid offloading same storage multiple times + self.storage_to_tensor_id = {} + + # Parameter filtering: track parameter storage pointers to skip them during offloading + self.param_storages = set() + + # Managing cpu memory + self.use_pin_memory = use_pin_memory + self.virtual_memory_safe_pct = 60 # we should not exceed this percentage of memory + + self.accelerator_type = ( + torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + ) + # NOTE: xpu doesn't have `default_stream` API, use `current_stream` instead + if self.accelerator_type == "xpu": # comp stream + self.s0 = torch.xpu.current_stream() + elif is_torch_npu_available() and self.accelerator_type == "npu": + self.s0 = torch.npu.current_stream() + else: + self.s0 = torch.cuda.default_stream() + + # For streaming + if self.use_streams: + if self.accelerator_type == "xpu": # comms stream + self.s1 = torch.xpu.Stream() + elif self.accelerator_type == "npu": + self.s1 = torch.npu.Stream() + else: + self.s1 = torch.cuda.Stream() + self.fwd_stash = {} # tensor_id => (activation, ev1) + if max_fwd_stash_size < 1: + raise ValueError(f"max_fwd_stash_size should be at least 1 but is {max_fwd_stash_size}") + self.max_fwd_stash_size = max_fwd_stash_size + self.bwd_tensor_stash = {} # tensor_id => activation + self.bwd_ev_stash = {} # tensor_id => ev0 + self.curr_graph_id = None + self.curr_autograd_node = None + + # -------- platform util functions -------- # + def verify_sufficient_virtual_memory(): + curr_pct = get_cpu_ram_pct() + if curr_pct > self.virtual_memory_safe_pct: + logger.warning(f"{curr_pct=}% > {self.virtual_memory_safe_pct=}% of virtual memory used") + + def get_cpu_ram_pct() -> float: + # get the percentage of memory used by the system + return psutil.virtual_memory().percent + + def get_tensor_id() -> int: + # create a unique id for each tensor we are managing + self.tensor_id += 1 + return self.tensor_id + + def get_num_bytes_tensor(x: torch.Tensor) -> int: + # get the number of bytes in a tensor, for memory management purposes + return x.element_size() * x.nelement() # x.element_size() * x._base_storage().nbytes() + + # -------- core pack / unpack work -------- # + def pack_tensor(activation: torch.Tensor) -> int: + # activations are passed in during forward pass - from here we take over and return a unique id + if self.is_first_forward_call: + if len(self.tracker) != 0: + raise ValueError("Backward pass should have cleared tracker of all tensors") + + # set training phase trackers + self.is_first_forward_call = False + self.is_first_backward_call = True + # Reset deduplication map for new forward pass + self.storage_to_tensor_id = {} + + # query for basic tensor info + num_bytes = get_num_bytes_tensor(activation) + tensor_id = get_tensor_id() + + # Check for tensor deduplication using storage pointer + # If this storage is already being tracked, we still create a new tensor_id + # but don't offload again (just keep the tensor in GPU) + storage_key = _get_unique_tensor_key(activation) + if storage_key in self.storage_to_tensor_id: + # Storage already offloaded - don't offload again, just track the reference + self.tracker[tensor_id] = (activation, False, None, None, None) # Keep on GPU, don't offload + return tensor_id + + # Check if tensor is on CPU (skip offloading) + if activation.device.type not in ["cuda", "xpu", "npu"]: + self.tracker[tensor_id] = (activation, False, None, None, None) + return tensor_id + + # Check if tensor is too small + if num_bytes < self.min_tensor_size_bytes: + self.tracker[tensor_id] = (activation, False, None, None, None) + return tensor_id + + # Check if tensor is a parameter or buffer + if isinstance(activation, torch.nn.Parameter) or ( + hasattr(torch.nn, "Buffer") and isinstance(activation, torch.nn.Buffer) + ): + self.tracker[tensor_id] = (activation, False, None, None, None) + return tensor_id + + # Check if tensor is an FP8 tensor (TorchAO) - skip offloading as they're already compressed + tensor_class_name = type(activation).__name__ + if tensor_class_name in ["Float8TrainingTensor", "ScaledMMConfig", "LinearMMConfig"]: + self.tracker[tensor_id] = (activation, False, None, None, None) + return tensor_id + + # Check if tensor storage is a model parameter (for FSDP compatibility) + try: + # Extract actual tensor for DTensor + check_tensor = activation + if DTensor is not None and isinstance(activation, DTensor) and hasattr(activation, "_local_tensor"): + check_tensor = activation._local_tensor + + if check_tensor.untyped_storage().data_ptr() in self.param_storages: + self.tracker[tensor_id] = (activation, False, None, None, None) + return tensor_id + except (RuntimeError, AttributeError): + # If we can't get data_ptr, skip this check + pass + + # Tensor qualifies for offloading + if self.use_streams: + # First, sync back and dereference previously offloaded tensors + # as the offloading should be done sufficiently long ago. + for id in list(self.fwd_stash.keys()): + if id <= tensor_id - self.max_fwd_stash_size: + _, ev = self.fwd_stash[id] + self.s0.wait_event(ev) + del self.fwd_stash[id] + else: + break + + # Sync in, offload, and add an event to sync back later + self.s1.wait_stream(self.s0) + + stream = self.s1 if self.use_streams else self.s0 + if self.accelerator_type == "xpu": + stream_ctx = torch.xpu.stream(stream) + elif self.accelerator_type == "npu": + stream_ctx = torch.npu.stream(stream) + else: + stream_ctx = torch.cuda.stream(stream) + with stream_ctx: + # Save original stride and shape information + original_stride = activation.stride() + original_storage_offset = activation.storage_offset() + original_shape = activation.size() + + # Check if tensor has broadcast dimensions (stride == 0) + # If so, copy the underlying storage directly instead of materializing the broadcast + has_broadcast = 0 in original_stride + + if has_broadcast: + # Copy only the actual underlying storage, not the materialized broadcast + # Create CPU tensor with same storage size as original + storage_size = activation.untyped_storage().size() + cpu_storage = torch.empty( + storage_size // activation.element_size(), + dtype=activation.dtype, + pin_memory=self.use_pin_memory, + device="cpu", + ) + # Copy the raw storage + cpu_storage_view = torch.as_strided( + activation, size=(storage_size // activation.element_size(),), stride=(1,), storage_offset=0 + ) + cpu_storage.copy_(cpu_storage_view, non_blocking=True) + cpu_tensor = cpu_storage + else: + # No broadcast - use normal contiguous copy + # .contiguous() can be a no-op for contiguous views with + # non-zero storage_offset. Force a clone for those views + # so later as_strided reconstruction stays in bounds. + if not activation.is_contiguous() or activation.storage_offset() != 0: + if activation.storage_offset() != 0: + activation = activation.clone(memory_format=torch.contiguous_format) + else: + activation = activation.contiguous() + original_stride = activation.stride() + original_storage_offset = activation.storage_offset() + cpu_tensor = torch.empty_like(activation, pin_memory=self.use_pin_memory, device="cpu") + cpu_tensor.copy_(activation, non_blocking=True) + + # Store CPU tensor along with stride information + self.tracker[tensor_id] = ( + cpu_tensor, + True, # True = (in future) modified + original_stride, # Save original GPU stride + original_storage_offset, # Save original storage offset + original_shape, # Save original shape for broadcast restoration + ) + + if self.use_streams: + event = self.s1.record_event() + + # Stash to keep activation alive til s1 is done + self.fwd_stash[tensor_id] = (activation, event) + + # Track this storage for deduplication + self.storage_to_tensor_id[storage_key] = tensor_id + + return tensor_id + + def unpack_tensor_single_stream(unpack_tensor_id: int) -> torch.Tensor: + # backward pass - we are called with the tensor_id, which + # we will use to retrieve the saved/offloaded tensor + if self.is_first_backward_call: + if self.is_first_forward_pass: + self.is_first_forward_pass = False + if self.use_pin_memory: + verify_sufficient_virtual_memory() + + self.is_first_backward_call = False + + if unpack_tensor_id not in self.tracker: + raise ValueError(f"Untracked tensor with id {unpack_tensor_id}") + + ( + maybe_accelerator_tensor, + modified, + original_stride, + original_storage_offset, + original_shape, + ) = self.tracker[unpack_tensor_id] + + if modified: + # Restore tensor to GPU + accelerator_tensor = maybe_accelerator_tensor.to(self.accelerator_type, non_blocking=True) + # Restore original stride if we saved it (handles both broadcast and non-broadcast cases) + if original_stride is not None: + accelerator_tensor = torch.as_strided( + accelerator_tensor, + size=original_shape, + stride=original_stride, + storage_offset=original_storage_offset, + ) + maybe_accelerator_tensor = accelerator_tensor + + # clear tensor from tracking + del self.tracker[unpack_tensor_id] + # Only set is_first_forward_call to True when all tensors have been unpacked + if len(self.tracker) == 0: + self.is_first_forward_call = True + return maybe_accelerator_tensor + + def unpack_tensor_with_streams(unpack_tensor_id: int) -> torch.Tensor: + # backward pass - we are called with the tensor_id, which + # we will use to retrieve the saved/offloaded tensor + if self.is_first_backward_call: + self.curr_graph_id = torch._C._current_graph_task_id() + + def wait_and_del_remaining_references() -> None: + for id in list(self.bwd_tensor_stash.keys()): + if id in self.bwd_ev_stash: + event = self.bwd_ev_stash[id] + self.s1.wait_event(event) + del self.bwd_tensor_stash[id] + + # Register a callback to the end of autograd to clean everything up + torch.autograd.variable.Variable._execution_engine.queue_callback(wait_and_del_remaining_references) + + if self.is_first_forward_pass: + self.is_first_forward_pass = False + if self.use_pin_memory: + verify_sufficient_virtual_memory() + + self.is_first_backward_call = False + + if unpack_tensor_id not in self.tracker: + raise ValueError(f"untracked tensor with id {unpack_tensor_id}") + + ( + maybe_accelerator_tensor, + modified, + original_stride, + original_storage_offset, + original_shape, + ) = self.tracker[unpack_tensor_id] + + if modified: + # Get data on the current autograd node + graph_id = torch._C._current_graph_task_id() + node = torch._C._current_autograd_node() + prev_node_ids = [] + + # If we're on a new node, mark prev node's tensors to be freed later + if graph_id == self.curr_graph_id and self.curr_autograd_node != node: + self.curr_autograd_node = node + prev_node_ids = list(self.bwd_tensor_stash.keys()) + + brought_back_from_cpu = True + if unpack_tensor_id in self.fwd_stash: + maybe_accelerator_tensor = self.fwd_stash[unpack_tensor_id][0] + brought_back_from_cpu = False + else: + # Kick off the process to bring tensors back + if self.accelerator_type == "xpu": + stream_ctx = torch.xpu.stream(self.s1) + elif self.accelerator_type == "npu": + stream_ctx = torch.npu.stream(self.s1) + else: + stream_ctx = torch.cuda.stream(self.s1) + with stream_ctx: + # Restore tensor to GPU + accelerator_tensor = maybe_accelerator_tensor.to(self.accelerator_type, non_blocking=True) + # Restore original stride if we saved it (handles both broadcast and non-broadcast cases) + if original_stride is not None: + accelerator_tensor = torch.as_strided( + accelerator_tensor, + size=original_shape, + stride=original_stride, + storage_offset=original_storage_offset, + ) + maybe_accelerator_tensor = accelerator_tensor + + # Tell comp stream to wait for the info to be loaded before executing + self.s0.wait_stream(self.s1) + + # Stash the tensor to keep memory alive until compute stream is complete + self.bwd_tensor_stash[unpack_tensor_id] = maybe_accelerator_tensor + + # Note: [Track views of the unpacked] + # Why do we get the use count of the unpacked tensor here? We want an + # initial count to compare to later, during the post-hook of the + # backward node, when we need to decide whether we're allowed to free + # the tensor yet. In what obscure cases must we delay freeing the + # tensor (and thus call record_stream)? + # 1. Any of the outputs of the backward node is a view of the unpacked + # tensor. + # 2. In the case that this unpacked tensor will be used in a + # checkpointed region, if one of the recomputed saved tensors ends + # up as a view of the unpacked tensor. + # 3. The user abuses the system somehow and manually relies on the + # unpacked tensor to exist after the backward node has executed. + if self.accelerator_type == "npu": + storage_refcount = torch_npu._C._storage_Use_Count( + maybe_accelerator_tensor.untyped_storage()._cdata + ) + else: + storage_refcount = torch._C._storage_Use_Count( + maybe_accelerator_tensor.untyped_storage()._cdata + ) + + def hook(outputs, inputs): + # create events for the current node inputs/outputs if they were streamed in + if brought_back_from_cpu: + # See Note: [Track views of the unpacked] + # IF any of the outputs is a view of the tensor, OR if a view of + # the tensor has been saved as a part of checkpoint's recompute + # process, OR the user has abusedly incurred a reference on the + # unpacked tensor, THEN the tensor might be used later and we + # cannot presume to delete it after only the current node is + # done! So we use our frenemy, record_stream, to ensure the + # Tensor stays unmessed with until it's done getting used in the + # compute stream (s0 here). Note that the con here is we introduce + # non-deterministic (thus higher) memory usage, but this case + # should not happen often. + # Check if tensor still exists (might have been cleaned up by a previous node) + if unpack_tensor_id in self.bwd_tensor_stash: + unpacked_tensor = self.bwd_tensor_stash[unpack_tensor_id] + if self.accelerator_type == "npu": + storage_count = torch_npu._C._storage_Use_Count( + unpacked_tensor.untyped_storage()._cdata + ) + else: + storage_count = torch._C._storage_Use_Count(unpacked_tensor.untyped_storage()._cdata) + if storage_count > storage_refcount: + unpacked_tensor.record_stream(self.s0) + del self.bwd_tensor_stash[unpack_tensor_id] + else: + event = self.s0.record_event() + self.bwd_ev_stash[unpack_tensor_id] = event + + # if there are still things in the fwd_stash, get rid of them as we're in bwd now + for id in list(self.fwd_stash.keys()): + _, ev = self.fwd_stash[id] + self.s0.wait_event(ev) + del self.fwd_stash[id] + + # wait on prev node's events and del those + for id in prev_node_ids: + # Only wait on events that exist (some tensors may have used record_stream instead) + if id in self.bwd_ev_stash: + event = self.bwd_ev_stash[id] + self.s1.wait_event(event) + del self.bwd_ev_stash[id] + if id in self.bwd_tensor_stash: + del self.bwd_tensor_stash[id] + + return outputs + + node.register_hook(hook) + + # clear tensor from tracking + del self.tracker[unpack_tensor_id] + # Only set is_first_forward_call to True when all tensors have been unpacked + if len(self.tracker) == 0: + self.is_first_forward_call = True + return maybe_accelerator_tensor + + unpack_tensor = unpack_tensor_with_streams if self.use_streams else unpack_tensor_single_stream + super().__init__(pack_tensor, unpack_tensor) + + def update_model_params(self, model: nn.Module): + """ + Update the set of parameter storage pointers from the model. This allows filtering out model parameters during + offloading, which is especially important for FSDP models where parameters may not be detected by isinstance + checks. + + For FSDP v2, this method handles DTensor parameters which may be sharded across ranks and not have valid local + storage on all ranks. We extract the local tensor from DTensors using _local_tensor when available. + + Args: + model: The model whose parameters should be tracked + """ + param_storages = set() + + for p in model.parameters(): + # For FSDP v2: extract local tensor from DTensor + actual_tensor = p + if DTensor is not None and isinstance(p, DTensor) and hasattr(p, "_local_tensor"): + actual_tensor = p._local_tensor + + # Try to get storage pointer + try: + storage_ptr = actual_tensor.untyped_storage().data_ptr() + if storage_ptr != 0: + param_storages.add(storage_ptr) + except RuntimeError: + # Parameter doesn't have accessible storage (e.g., FSDP v2 sharded without local shard, FP8 parameters) + # These will be caught by other checks (isinstance for Parameter, class name for FP8) + continue + + self.param_storages = param_storages + + def __enter__(self): + """Clear stale state and release BNB buffers before entering. + + By the time __enter__ is called, the previous forward/backward has already completed, so anything still in + tracker, storage_to_tensor_id, or the stashes is leaked and safe to drop. + + Two leak paths are handled: + 1. MoE + sample_packing + torch.compile: dynamic expert routing may leave saved tensors on subgraphs whose + backward nodes never execute, so the unpack-then-delete logic never fires. tracker/stashes from the previous + step survive into the next. + 2. QLoRA BNB dequantization buffers: tracker retains references to tensors sharing allocator blocks with BNB + buffers, and the allocator cache is never flushed between steps (~0.6 GiB/step, OOM after 30-40). + + Returns super().__enter__() to register pack/unpack hooks via saved_tensors_hooks (PyTorch autograd engine). + """ + self.tracker.clear() + self.storage_to_tensor_id.clear() + self.tensor_id = 0 + self.is_first_forward_call = True + self.is_first_backward_call = True + if self.use_streams: + self.bwd_tensor_stash.clear() + self.bwd_ev_stash.clear() + self.fwd_stash.clear() + if "bitsandbytes" in sys.modules: + if self.accelerator_type == "xpu": + torch.xpu.empty_cache() + elif is_torch_npu_available() and self.accelerator_type == "npu": + torch.npu.empty_cache() + else: + torch.cuda.empty_cache() + return super().__enter__() + + def __exit__(self, *args, **kwargs): + """Sync streams and clear stashes before parent cleanup. + + try/finally ensures the saved_tensors_hooks parent cleanup runs even if stream sync raises — otherwise hooks + stay permanently installed, creating a silent memory leak. + """ + try: + if self.use_streams: + self.s0.synchronize() + self.s1.synchronize() + self.bwd_tensor_stash.clear() + self.bwd_ev_stash.clear() + self.fwd_stash.clear() + finally: + result = super().__exit__(*args, **kwargs) + return result + + +class NoOpManager(saved_tensors_hooks): + """ + A `saved_tensors_hook` manager used to disable any other `saved_tensors_hook` manager applied before. This relies + on the behavior that only the most recently registered `saved_tensors_hook` will run. + + One example usage is to opt a local region of code out of activations offloading, which is usually applied globally + to best track state. + """ + + def __init__(self) -> None: + def noop(tensor): + return tensor + + super().__init__(noop, noop) + + +def get_act_offloading_ctx_manager( + model: nn.Module, + use_pin_memory: bool = True, + use_streams: bool = True, + min_offload_size: int = 1024, + max_fwd_stash_size: int = 5, + warn_if_no_head: bool = True, +) -> OffloadActivations: + """ + Returns the activation offloading context manager for the model. All but the last output Linear in every step will + be offloaded. + + If activation offloading is enabled, we return the OffloadActivations context manager. If activation offloading is + disabled, we return a NoOpManager context manager. + + Args: + model (`nn.Module`): + Model to wrap with the activation offloading context manager. + use_pin_memory (`bool`, *optional*, defaults to `True`): + Whether to offloaded Tensor will be placed in pinned memory on the CPU. Pinned memory allows the Tensor to + be moved back onto GPU more quickly but is a limited resource. + use_streams (`bool`, *optional*, defaults to `True`): + Whether to use streams for performance optimization where the communications get overlapped with the + computation. Requires a torch build after torch-2.5.0. + min_offload_size (`int`, *optional*, defaults to `1024`): + Minimum number of bytes a Tensor must be in order to qualify for offloading. If the tensor is too small, we + do not want to waste bandwidth and resources moving it to CPU and back. + max_fwd_stash_size (`int`, *optional*, defaults to `5`): + Maximum size of the forward stash, or the maximum number of consecutive activations to keep alive during + the forward pass. This number must be at least 1. Keeping alive more activations will potentially allow + more overlap between the communication and compute streams at the cost of increasing memory usage. Keeping + alive fewer activations will conserve memory, but may cause poor overlap between the streams, increasing + runtime. + warn_if_no_head (`bool`, *optional*, defaults to `True`): + Whether to warn if no output head is detected. If set to `False`, no warning will be raised if no output + head is detected. + + Returns: + `contextlib.ContextDecorator`: + Activation offloading context manager for the model. + """ + activations_handling_ctx = OffloadActivations( + use_pin_memory=use_pin_memory, + use_streams=use_streams, + min_offload_size=min_offload_size, + max_fwd_stash_size=max_fwd_stash_size, + ) + + # Update parameter storages to filter them during offloading (important for FSDP) + activations_handling_ctx.update_model_params(model) + + # Below is our hack to disable offloading the last output Linear in every + # step, as the cost for offloading the activation and then soon after bringing + # it back is expensive. + output_head_detected = False + noop_ctx = NoOpManager() + + # Try to get the actual model if it's wrapped + unwrapped_model = model + if hasattr(unwrapped_model, "module"): + unwrapped_model = unwrapped_model.module + # check for PEFT models + if hasattr(unwrapped_model, "base_model") and hasattr(unwrapped_model, "peft_config"): + unwrapped_model = unwrapped_model.base_model + + # Check for different types of output heads + if hasattr(unwrapped_model, "output"): + if isinstance(unwrapped_model.output, nn.Module): + unwrapped_model.output.register_forward_pre_hook(lambda *args: noop_ctx.__enter__()) + unwrapped_model.output.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True) + output_head_detected = True + elif hasattr(unwrapped_model.output, "linear") and isinstance(unwrapped_model.output.linear, nn.Module): + unwrapped_model.output.linear.register_forward_pre_hook(lambda *args: noop_ctx.__enter__()) + unwrapped_model.output.linear.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True) + output_head_detected = True + + # Check for HuggingFace model output heads + elif hasattr(unwrapped_model, "lm_head"): + unwrapped_model.lm_head.register_forward_pre_hook(lambda *args: noop_ctx.__enter__()) + unwrapped_model.lm_head.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True) + output_head_detected = True + + # Check for decoder-based models + elif hasattr(unwrapped_model, "decoder"): + decoder = unwrapped_model.decoder + if hasattr(decoder, "output"): + decoder.output.register_forward_pre_hook(lambda *args: noop_ctx.__enter__()) + decoder.output.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True) + output_head_detected = True + # Some models have lm_head in the decoder + elif hasattr(decoder, "lm_head"): + decoder.lm_head.register_forward_pre_hook(lambda *args: noop_ctx.__enter__()) + decoder.lm_head.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True) + output_head_detected = True + + # Check for transformer models with final layer norm + elif hasattr(unwrapped_model, "final_layer_norm") or hasattr(unwrapped_model, "ln_f"): + final_norm = getattr(unwrapped_model, "final_layer_norm", None) or unwrapped_model.ln_f + final_norm.register_forward_pre_hook(lambda *args: noop_ctx.__enter__()) + final_norm.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True) + output_head_detected = True + + # Check for models with head module + elif hasattr(unwrapped_model, "head") and isinstance(unwrapped_model.head, nn.Module): + unwrapped_model.head.register_forward_pre_hook(lambda *args: noop_ctx.__enter__()) + unwrapped_model.head.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True) + output_head_detected = True + + if not output_head_detected and warn_if_no_head: + logger.warning( + "During activation offloading, no output head was detected. If your model has an output head, it will be " + "offloaded. This usually greatly slows training, given the large vocabulary size. To change this " + "behavior, set your output head as model.output and make it an nn.Module. You can disable this warning by " + "passing `warn_if_no_head=False`." + ) + + # Disable offloading for any Liger modules + for name, module in unwrapped_model.named_modules(): + if "liger" in name.lower(): + module.register_forward_pre_hook(lambda *args: noop_ctx.__enter__()) + module.register_forward_hook(lambda *args: noop_ctx.__exit__(), always_call=True) + + return activations_handling_ctx diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/models/utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/models/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..52badde5ed6a278595bc968d081ec83b2ad52b2d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/models/utils.py @@ -0,0 +1,406 @@ +# Copyright 2020-2026 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 itertools +import warnings +from collections.abc import Callable +from contextlib import contextmanager +from copy import deepcopy +from typing import TYPE_CHECKING, Any + +import accelerate +import torch.nn as nn +import transformers +from accelerate import Accelerator +from packaging.version import Version +from torch.distributed.fsdp import FSDPModule +from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP +from transformers import GenerationConfig, PreTrainedModel + +from ..import_utils import suppress_experimental_warning + + +with suppress_experimental_warning(): + from ..experimental.utils import create_reference_model as _create_reference_model + + +if Version(accelerate.__version__) >= Version("1.11.0"): + from accelerate.utils.fsdp_utils import get_parameters_from_modules + +if TYPE_CHECKING: + from deepspeed.runtime.engine import DeepSpeedEngine + from torch.nn import Module + from torch.nn.parallel.distributed import DistributedDataParallel + + +def remove_hooks(model: "DeepSpeedEngine") -> None: + """Removes the optimizer hooks from a DeepSpeed ZeRO-3 model.""" + if not hasattr(model, "optimizer"): # before the first training step, the model has no optimizer + return + if model.optimizer is not None and hasattr(model.optimizer, "parameter_offload"): + optimizer_offload = model.optimizer.parameter_offload + elif model.optimizer is not None: + optimizer_offload = model.optimizer + else: + raise RuntimeError("The model optimizer is None, which is not yet supported.") + + for param in iter_params(optimizer_offload.module, recurse=True): + param.ds_active_sub_modules.clear() + + for hook in optimizer_offload.forward_hooks: + hook.remove() + for hook in optimizer_offload.backward_hooks: + hook.remove() + + optimizer_offload.forward_hooks = [] + optimizer_offload.backward_hooks = [] + + +def get_all_parameters(sub_module, recurse=False): + return itertools.chain(sub_module.named_parameters(recurse=recurse), sub_module.ds_external_parameters()) + + +def iter_params(module, recurse=False): + return [param for _, param in get_all_parameters(module, recurse)] + + +def add_hooks(model: "DeepSpeedEngine") -> None: + """Adds the optimizer hooks from a DeepSpeed ZeRO-3 model.""" + import deepspeed + + if not hasattr(model, "optimizer"): # before the first training step, the model has no optimizer + return + if model.optimizer is not None and hasattr(model.optimizer, "parameter_offload"): + optimizer_offload = model.optimizer.parameter_offload + elif model.optimizer is not None: + optimizer_offload = model.optimizer + else: + raise RuntimeError("The model optimizer is None, which is not yet supported.") + + # Invalidate parameter coordinator trace to prevent stale state + # after generation forward passes (fixes ZeRO-3 + GKD compatibility) + if hasattr(optimizer_offload, "param_coordinator"): # param_coordinator only exists in ZeRO stage 3 + coordinator = optimizer_offload.param_coordinator + # Only invalidate if trace is not already invalid + if not coordinator.is_invalid_trace(): + coordinator._invalidate_trace() + + if Version(deepspeed.__version__) >= Version("0.16.4"): + # Account for renaming in https://github.com/deepspeedai/DeepSpeed/pull/6847 + optimizer_offload._register_deepspeed_module(optimizer_offload.module) + else: + optimizer_offload._register_hooks_recursively(optimizer_offload.module) + + +@contextmanager +def _unwrap_model_for_generation( + model: "DistributedDataParallel | DeepSpeedEngine", + accelerator: "Accelerator", + gather_deepspeed3_params: bool = True, +): + """ + Context manager to unwrap distributed or accelerated models for generation tasks. + + Args: + model (`DistributedDataParallel | DeepSpeedEngine`): + Model to be unwrapped. + accelerator ([`~accelerate.Accelerator`]): + Accelerator instance managing the model. + gather_deepspeed3_params (`bool`, *optional*, defaults to `True`): + Whether to gather weights for DeepSpeed ZeRO Stage 3 models. If `False`, skips parameter gathering, which + can be more memory-efficient but may lead to slower generation times. + + Yields: + Unwrapped model. + + Example: + ```python + with _unwrap_model_for_generation(model, accelerator) as unwrapped_model: + generated_outputs = unwrapped_model.generate(input_ids) + ``` + """ + unwrapped_model = accelerator.unwrap_model(model) + is_gradient_checkpointing = unwrapped_model.is_gradient_checkpointing + if is_gradient_checkpointing: + unwrapped_model.gradient_checkpointing_disable() + from ..distributed import DistributedBackend + + if DistributedBackend(accelerator).is_zero3: + if not gather_deepspeed3_params: + yield accelerator.unwrap_model(model) + else: + import deepspeed + + with deepspeed.zero.GatheredParameters(model.parameters()): + remove_hooks(model) + yield accelerator.unwrap_model(model) + add_hooks(model) + else: + yield unwrapped_model + if is_gradient_checkpointing: + unwrapped_model.gradient_checkpointing_enable() + + +@contextmanager +def _override_model_generation_config(model, generation_kwargs=None): + """ + Context manager to temporarily override a model's generation_config with training config. + + This works around transformers' config merging logic that would otherwise overwrite values matching global defaults + with model-specific values (see upstream issue transformers#42762; fixed in transformers v5 by PR + `transformers#42702`). + + By temporarily setting the model's generation_config to match the passed generation_config, we avoid the conflict. + + The model's original generation_config is preserved outside this context, ensuring that saved/pushed models retain + their intended inference behavior. + + Args: + model: The model (typically unwrapped_model) whose generation_config to temporarily override. + generation_kwargs (dict): Generation kwargs to be used to override model's generation config. + """ + if ( + # Issue fixed in transformers v5 by PR transformers#42702 + Version(transformers.__version__) >= Version("5.0.0") + or generation_kwargs is None + or not hasattr(model, "generation_config") + ): + yield model + return + # If it is a PEFT model, override the underlying base model + if hasattr(model, "get_base_model"): + model = model.get_base_model() + # Keep original model generation_config + original_config = model.generation_config + # Create training-specific generation config from the model's original generation config + # Then overwrite it with the training-specific generation kwargs + generation_config = GenerationConfig.from_dict(model.generation_config.to_dict()) + generation_config.update(**generation_kwargs) + model.generation_config = generation_config + try: + yield + finally: + model.generation_config = original_config + + +@contextmanager +def unwrap_model_for_generation( + model: "DistributedDataParallel | DeepSpeedEngine", + accelerator: "Accelerator", + gather_deepspeed3_params: bool = True, + generation_kwargs: dict | None = None, +): + """ + Context manager to unwrap distributed or accelerated models for generation tasks. + + This function unwraps distributed models (FSDP, DeepSpeed) and optionally overrides the model's generation_config + temporarily during generation. This is useful for applying training-specific generation parameters without + permanently modifying the model's original generation_config. + + Args: + model (`DistributedDataParallel | DeepSpeedEngine`): + Model to be unwrapped. + accelerator ([`~accelerate.Accelerator`]): + Accelerator instance managing the model. + gather_deepspeed3_params (`bool`, *optional*, defaults to `True`): + Whether to gather weights for DeepSpeed ZeRO Stage 3 models. If `False`, skips parameter gathering, which + can be more memory-efficient but may lead to slower generation times. + generation_kwargs (dict, *optional*): + If provided, temporarily overrides the model's generation_config during generation. The original config is + automatically restored when exiting the context. This is useful for using different generation parameters + during training vs. inference. + + Yields: + Unwrapped model with optionally overridden generation_config. + """ + with ( + _unwrap_model_for_generation( + model, accelerator, gather_deepspeed3_params=gather_deepspeed3_params + ) as unwrapped_model, + _override_model_generation_config(unwrapped_model, generation_kwargs=generation_kwargs), + ): + yield unwrapped_model + + +def prepare_deepspeed(model: "Module", accelerator: "Accelerator"): + """Prepares the model for DeepSpeed inference or evaluation by initializing it with the appropriate configuration. + + Adapted from accelerate: + https://github.com/huggingface/accelerate/blob/739b135f8367becb67ffaada12fe76e3aa60fefd/src/accelerate/accelerator.py#L1473 + """ + import deepspeed # local import (instead of top-level) to avoid DS init interfering with other backends (like vllm): https://github.com/deepspeedai/DeepSpeed/issues/7252 + + deepspeed_plugin = accelerator.state.deepspeed_plugin + config_kwargs = deepcopy(deepspeed_plugin.deepspeed_config) + stage = config_kwargs["zero_optimization"]["stage"] + + if model is not None: + 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 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 stage != 3: + config_kwargs["zero_optimization"]["stage"] = 0 + model, *_ = deepspeed.initialize(model=model, config=config_kwargs) + model.eval() + return model + + +def prepare_fsdp(model, accelerator: Accelerator) -> FSDP | FSDPModule: + # Check if the model is already a FSDP model due to `Manual Wrapping` and if so, don't wrap it again + if not isinstance(model, (FSDP, FSDPModule)): + fsdp_plugin = accelerator.state.fsdp_plugin + if fsdp_plugin.fsdp_version == 1: + accelerator.state.fsdp_plugin.set_auto_wrap_policy(model) + kwargs = { + "sharding_strategy": fsdp_plugin.sharding_strategy or fsdp_plugin.reshard_after_forward, + "cpu_offload": fsdp_plugin.cpu_offload, + "auto_wrap_policy": fsdp_plugin.auto_wrap_policy, + "mixed_precision": fsdp_plugin.mixed_precision_policy, + "sync_module_states": fsdp_plugin.sync_module_states, + "backward_prefetch": fsdp_plugin.backward_prefetch, + "forward_prefetch": fsdp_plugin.forward_prefetch, + "use_orig_params": fsdp_plugin.use_orig_params, + "param_init_fn": fsdp_plugin.param_init_fn, + "ignored_modules": fsdp_plugin.ignored_modules, + "limit_all_gathers": fsdp_plugin.limit_all_gathers, + "device_id": accelerator.device, + } + model = FSDP(model, **kwargs) + elif fsdp_plugin.fsdp_version == 2: + from torch.distributed.fsdp import MixedPrecisionPolicy, fully_shard + + mesh = getattr(accelerator, "torch_device_mesh", None) + if Version(accelerate.__version__) >= Version("1.11.0"): + ignored_params = get_parameters_from_modules(fsdp_plugin.ignored_modules, model, accelerator.device) + else: + warnings.warn( + "FSDP version 2 is being used with accelerate version < 1.11.0, which may lead to incorrect " + "handling of ignored modules. Please upgrade accelerate to v1.11.0 or later for proper support." + ) + ignored_params = None + fully_shard( + model, + reshard_after_forward=fsdp_plugin.reshard_after_forward, + offload_policy=fsdp_plugin.cpu_offload, + # `fully_shard` doesn't accept `None` in case of `MixedPrecisionPolicy` + mp_policy=fsdp_plugin.mixed_precision_policy or MixedPrecisionPolicy(), + mesh=mesh[tuple(accelerator.parallelism_config.fsdp_dim_names)] if mesh is not None else None, + ignored_params=ignored_params, + ) + else: + raise ValueError(f"FSDP version {fsdp_plugin.fsdp_version} is not supported.") + model.eval() + return model + + +class _ForwardRedirection: + """Implements the `forward-redirection`. + + Taken from Pytorch-lightning: + https://github.com/Lightning-AI/pytorch-lightning/blob/02311d03fb982560246eead7c08104481fac9579/src/lightning/pytorch/strategies/strategy.py#L602 + + A method call to a wrapped module gets rerouted through the wrapper's `forward` method instead. + + """ + + def __call__( + self, wrapper_module: nn.Module, original_module: nn.Module, method: Callable, *args: Any, **kwargs: Any + ): + """Reroutes a method call through the `wrapper_module`'s `forward` method. + + Args: + wrapper_module: The module that has `original_module` wrapped. + original_module: The module that was wrapped inside `wrapper_module`. + method: The method that should be called on the `original_module` after inputs get + redirected through the `wrapper_module`'s `forward` method. + *args: The positional arguments to the `method`. They will get passed to a patched + `forward` method instead. + **kwargs: The keyword arguments to the `method`. They will get passed to a patched + `forward` method instead. + + """ + original_forward = original_module.forward + + def wrapped_forward(*_args: Any, **_kwargs: Any) -> Any: + # Unpatch ourselves immediately before calling the method `method_name` + # because itself may want to call the real `forward` + original_module.forward = original_forward # type: ignore[method-assign] + # Call the actual method e.g. `.training_step(...)` + out = method(*_args, **_kwargs) + self.on_after_inner_forward(wrapper_module, original_module) + return out + + # Patch the original_module's forward so we can redirect the arguments back to the real method + original_module.forward = wrapped_forward # type: ignore[method-assign] + + wrapper_output = wrapper_module(*args, **kwargs) + self.on_after_outer_forward(wrapper_module, original_module) + return wrapper_output + + def on_after_inner_forward(self, wrapper_module: nn.Module, original_module: nn.Module) -> None: + pass + + def on_after_outer_forward(self, wrapper_module: nn.Module, original_module: nn.Module) -> None: + pass + + +@contextmanager +def disable_gradient_checkpointing(model: PreTrainedModel, gradient_checkpointing_kwargs: dict | None = None): + """ + Temporarily disable gradient checkpointing, restoring the previous state afterward. + + Args: + model (`PreTrainedModel`): + Model for which to temporarily disable gradient checkpointing. + gradient_checkpointing_kwargs (`dict` or `None`, *optional*): + Additional kwargs for gradient checkpointing enabling. + """ + was_enabled = model.is_gradient_checkpointing + if was_enabled: + model.gradient_checkpointing_disable() + try: + yield + finally: + if was_enabled: + model.gradient_checkpointing_enable(gradient_checkpointing_kwargs) + + +def create_reference_model( + model: nn.Module, num_shared_layers: int | None = None, pattern: str | None = None +) -> nn.Module: + warnings.warn( + "The `create_reference_model` function is now located in `trl.experimental.utils`. Please update your " + "imports to `from trl.experimental.utils import create_reference_model`. This import path will be removed in " + "TRL 1.0.0.", + FutureWarning, + stacklevel=2, + ) + return _create_reference_model(model, num_shared_layers=num_shared_layers, pattern=pattern) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/py.typed b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..646c8ebdede92389d96a9b7b039e147d32ff1e1a --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/__init__.py @@ -0,0 +1,35 @@ +# Copyright 2020-2026 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 sys +from typing import TYPE_CHECKING + +from .._lazy_module import _LazyModule + + +_import_structure = { + "accuracy_rewards": ["accuracy_reward", "reasoning_accuracy_reward"], + "format_rewards": ["think_format_reward"], + "other_rewards": ["get_repetition_penalty_reward", "get_soft_overlong_punishment"], +} + + +if TYPE_CHECKING: + from .accuracy_rewards import accuracy_reward, reasoning_accuracy_reward + from .format_rewards import think_format_reward + from .other_rewards import get_repetition_penalty_reward, get_soft_overlong_punishment + + +else: + sys.modules[__name__] = _LazyModule(__name__, __file__, _import_structure, module_spec=__spec__) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/accuracy_rewards.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/accuracy_rewards.py new file mode 100644 index 0000000000000000000000000000000000000000..45b061d846b6823d234d3e6e9d360f8af00755b9 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/accuracy_rewards.py @@ -0,0 +1,244 @@ +# Copyright 2020-2026 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 logging +import threading +from collections.abc import Callable + +from ..import_utils import is_math_verify_available + + +if is_math_verify_available(): + from latex2sympy2_extended import NormalizationConfig + from math_verify import LatexExtractionConfig, parse, verify + + +def accuracy_reward( + completions: list[list[dict[str, str]]], + solution: list[str], + log_extra: Callable[[str, list], None] | None = None, + **kwargs, +) -> list[float | None]: + r""" + Reward function that checks if the completion matches the ground truth. + - If both gold and prediction are parseable → use math verification. + - If gold is not parseable → return `None` to skip the example. + + Args: + completions (`list[list[dict[str, str]]]`): + List of completions to be evaluated. Each completion must be a list of one message, i.e. a dictionary + containing the key `"content"` with the value being the text of the completion. + solution (`list[str]`): + List of the raw-text solutions to the questions/problems/prompts. + log_extra (`callable`, *optional*): + Callable to log extra columns to the completions table, provided automatically by the trainer. Defaults to + `None` to allow calling the function directly outside of a trainer (e.g., for testing). + **kwargs: + Additional keyword arguments. This function does not use them, but they are required in the function + signature to ensure compatibility with trainers like [`GRPOTrainer`]. + Example: + ```python + >>> from trl.rewards import accuracy_reward + + >>> solutions = [r"\frac{1}{3}", r"\frac{1}{3}"] + >>> completions = [ + ... [{"role": "assistant", "content": r"My answer is \boxed{\frac{1}{3}}"}], + ... [{"role": "assistant", "content": r"My answer is \boxed{\frac{1}{2}}"}], + ... ] + >>> accuracy_reward(completions, solutions) + [1.0, 0.0] + ``` + """ + if not is_math_verify_available(): + raise ImportError("Please install the `math_verify` package to use accuracy_reward") + + contents = [completion[0]["content"] for completion in completions] + rewards = [] + gold_parsed_strs = [] + answer_parsed_strs = [] + + # math_verify uses signal.alarm() for timeouts, which only works in the main thread. + # Disable timeouts when running in a non-main thread to avoid ValueError. + is_main_thread = threading.current_thread() is threading.main_thread() + parsing_timeout = None if not is_main_thread else 10 + verify_timeout = None if not is_main_thread else 5 + + # Suppress the "Timeout is disabled" warnings from math_verify when we intentionally disable timeouts + if not is_main_thread: + logging.getLogger("math_verify.parser").setLevel(logging.ERROR) + logging.getLogger("math_verify.grader").setLevel(logging.ERROR) + + for content, sol in zip(contents, solution, strict=True): + gold_parsed = parse(sol, parsing_timeout=parsing_timeout) + if len(gold_parsed) != 0: + # We require the answer to be provided in correct latex (no malformed operators) + answer_parsed = parse( + content, + extraction_config=[ + LatexExtractionConfig( + normalization_config=NormalizationConfig(units=True), + # Ensures that boxed is tried first + boxed_match_priority=0, + try_extract_without_anchor=False, + ) + ], + extraction_mode="first_match", + parsing_timeout=parsing_timeout, + ) + reward = float(verify(gold_parsed, answer_parsed, timeout_seconds=verify_timeout)) + gold_parsed_strs.append(str(gold_parsed)) + answer_parsed_strs.append(str(answer_parsed) if answer_parsed else "[unparseable]") + else: + # If the gold solution cannot be parsed, we assign `None` to skip this example + reward = None + gold_parsed_strs.append("[unparseable]") + answer_parsed_strs.append("[skipped]") + rewards.append(reward) + + if log_extra is not None: + log_extra("solution", list(solution)) + log_extra("gold_parsed", gold_parsed_strs) + log_extra("answer_parsed", answer_parsed_strs) + + return rewards + + +def reasoning_accuracy_reward( + completions: list[list[dict[str, str]]], + solution: list[str], + reasoning_delimiters: list[str] | None = None, + log_extra: Callable[[str, list], None] | None = None, + **kwargs, +) -> list[float | None]: + r""" + Reward function that removes the reasoning content and checks if the final answer matches the ground truth. + - If both gold and prediction are parseable → use math verification. + - If gold is not parseable → return `None` to skip the example. + + Args: + completions (`list[list[dict[str, str]]]`): + List of completions to be evaluated. Each completion must be a list of one message, i.e. a dictionary + containing the key `"content"` with the value being the text of the completion. + solution (`list[str]`): + List of the raw-text solutions to the questions/problems/prompts. + reasoning_delimiters (`list[str]]`, *optional*): + List of strings indicating where the reasoning content ends. The final answer is assumed to be after the + last occurrence of any of these delimiters. If `None`, defaults to `[""]`. + log_extra (`callable`, *optional*): + Callable to log extra columns to the completions table, provided automatically by the trainer. Defaults to + `None` to allow calling the function directly outside of a trainer (e.g., for testing). + **kwargs: + Additional keyword arguments. This function does not use them, but they are required in the function + signature to ensure compatibility with trainers like [`GRPOTrainer`]. + Example: + ```python + >>> from trl.rewards import reasoning_accuracy_reward + + >>> reasoning_delimiters = [""] + >>> solutions = [r"\frac{1}{3}", r"\frac{1}{3}", r"\frac{1}{3}"] + >>> completions = [ + ... [ + ... { + ... "role": "assistant", + ... "content": r" Reasoning content The final answer is \boxed{\frac{1}{3}}", + ... } + ... ], + ... [ + ... { + ... "role": "assistant", + ... "content": r" Reasoning content The final answer is \boxed{\frac{1}{2}}", + ... } + ... ], + ... [ + ... { + ... "role": "assistant", + ... "content": r" Reasoning content with partial answers \boxed{\frac{1}{3}} but no final answer", + ... } + ... ], + ... ] + >>> reasoning_accuracy_reward(completions, solutions, reasoning_delimiters=reasoning_delimiters) + [1.0, 0.0, 0.0] + ``` + """ + if not is_math_verify_available(): + raise ImportError("Please install the `math_verify` package to use reasoning_accuracy_reward") + + if reasoning_delimiters is None: + # Use sensible defaults for majority of reasoning models + reasoning_delimiters = [""] + + rewards = [] + contents = [completion[0]["content"] for completion in completions] + gold_parsed_strs = [] + answer_parsed_strs = [] + + # math_verify uses signal.alarm() for timeouts, which only works in the main thread. + # Disable timeouts when running in a non-main thread to avoid ValueError. + is_main_thread = threading.current_thread() is threading.main_thread() + parsing_timeout = None if not is_main_thread else 10 + verify_timeout = None if not is_main_thread else 5 + + # Suppress the "Timeout is disabled" warnings from math_verify when we intentionally disable timeouts + if not is_main_thread: + logging.getLogger("math_verify.parser").setLevel(logging.ERROR) + logging.getLogger("math_verify.grader").setLevel(logging.ERROR) + + for content, sol in zip(contents, solution, strict=True): + # Split final answer from reasoning content + is_reasoning_complete = False + for delim in reasoning_delimiters: + if delim in content: + content = content.split(delim)[-1] + is_reasoning_complete = True + break + if not is_reasoning_complete: + # We assign zero reward instead of `None` to penalize incomplete reasoning + rewards.append(0.0) + gold_parsed_strs.append("[incomplete reasoning]") + answer_parsed_strs.append("[incomplete reasoning]") + continue + + gold_parsed = parse(sol, parsing_timeout=parsing_timeout) + if len(gold_parsed) != 0: + # We require the answer to be provided in correct latex (no malformed operators) + answer_parsed = parse( + content, + extraction_config=[ + LatexExtractionConfig( + boxed_match_priority=0, + normalization_config=NormalizationConfig( + units=True, + ), + try_extract_without_anchor=False, + ) + ], + extraction_mode="first_match", + parsing_timeout=parsing_timeout, + ) + reward = float(verify(gold_parsed, answer_parsed, timeout_seconds=verify_timeout)) + gold_parsed_strs.append(str(gold_parsed)) + answer_parsed_strs.append(str(answer_parsed) if answer_parsed else "[unparseable]") + else: + # If the gold solution cannot be parsed, we assign `None` to skip this example + reward = None + gold_parsed_strs.append("[unparseable]") + answer_parsed_strs.append("[skipped]") + rewards.append(reward) + + if log_extra is not None: + log_extra("solution", list(solution)) + log_extra("gold_parsed", gold_parsed_strs) + log_extra("answer_parsed", answer_parsed_strs) + + return rewards diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/format_rewards.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/format_rewards.py new file mode 100644 index 0000000000000000000000000000000000000000..c737d0036b165ebf4a15e2c2558f82187e87038d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/format_rewards.py @@ -0,0 +1,50 @@ +# Copyright 2020-2026 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 re + + +def think_format_reward(completions: list[list[dict[str, str]]], **kwargs) -> list[float]: + r""" + Reward function that checks if the reasoning process is enclosed within `""` and `""` tags. The + function returns a reward of 1.0 if the format is correct, otherwise 0.0. + + Args: + completions (`list[list[dict[str, str]]]`): + List of completions to be evaluated. Each completion must be a list of one message, i.e. a dictionary + containing the key `"content"` with the value being the text of the completion. + **kwargs: + Additional keyword arguments. This function does not use them, but they are required in the function + signature to ensure compatibility with trainers like [`GRPOTrainer`]. + + Returns: + `list[float]`: + A list of rewards, where each reward is 1.0 if the completion matches the expected format, otherwise 0.0. + + Example: + ```python + >>> from trl.rewards import think_format_reward + + >>> completions = [ + ... [{"content": "\nThis is my reasoning.\n\nThis is my answer."}], + ... [{"content": "\nThis is my reasoning.\nThis is my answer."}], + ... ] + >>> think_format_reward(completions) + [1.0, 0.0] + ``` + """ + pattern = r"^(?!.*)(.*?).*$" + completion_contents = [completion[0]["content"] for completion in completions] + matches = [re.match(pattern, content, re.DOTALL | re.MULTILINE) for content in completion_contents] + return [1.0 if match else 0.0 for match in matches] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/other_rewards.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/other_rewards.py new file mode 100644 index 0000000000000000000000000000000000000000..a0a81870b813e51224979e67a5f53e074cbfe21a --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/rewards/other_rewards.py @@ -0,0 +1,138 @@ +# Copyright 2020-2026 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. + +from collections.abc import Callable + + +def get_repetition_penalty_reward(ngram_size: int = 3, max_penalty: float = -1.0) -> Callable: + # docstyle-ignore + r""" + Reward function that penalizes repeated n-grams in a completion, used to discourage degenerate, repetitive text + (a common failure mode and reward-hacking strategy when length- or format-shaping rewards are used). Reference: + Appendix C.2 of the "Demystifying Long Chain-of-Thought Reasoning" paper (https://huggingface.co/papers/2502.03373). + + The penalty is proportional to the fraction of repeated n-grams in the completion: + + $$ + R_{\text{repetition}}(y) = \left(1 - \frac{\#\,\text{unique } n\text{-grams}}{\#\,\text{total } n\text{-grams}}\right) \times p + $$ + + where $p$ is `max_penalty`. A completion with no repeated n-gram gets a reward of `0.0`, while a fully repetitive + one approaches `max_penalty`. The n-grams are computed over the completion token ids (the paper applies the penalty + to repeated tokens), so the reward is tokenizer-defined and language-agnostic. Completions with fewer than + `ngram_size` tokens get a reward of `0.0`. + + Args: + ngram_size (`int`, *optional*, defaults to `3`): + Size of the token n-grams to consider. + max_penalty (`float`, *optional*, defaults to `-1.0`): + Most negative penalty, applied to a fully repetitive completion. Must be non-positive. + + Returns: + `Callable`: + A reward function that takes a list of completion token ids and returns a list of penalties (each in + `[max_penalty, 0.0]`). + + Example: + ```python + >>> from trl.rewards import get_repetition_penalty_reward + + >>> repetition_penalty = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0) + >>> completion_ids = [[1, 2, 3, 4], [5, 5, 5, 5, 5]] + >>> repetition_penalty(completion_ids) + [0.0, -0.75] + ``` + """ + if max_penalty > 0: + raise ValueError(f"max_penalty {max_penalty} should not be positive") + return _RepetitionPenalty(ngram_size, max_penalty) + + +class _RepetitionPenalty: + # Callable class rather than a closure so the reward stays picklable: the async GRPO rollout + # worker forwards reward funcs to a spawned child process, and closures can't be pickled. + __name__ = "repetition_penalty_reward" + + def __init__(self, ngram_size: int, max_penalty: float): + self.ngram_size = ngram_size + self.max_penalty = max_penalty + + def __call__(self, completion_ids: list[list[int]], **kwargs) -> list[float]: + rewards = [] + for ids in completion_ids: + if len(ids) < self.ngram_size: + rewards.append(0.0) + continue + ngrams = list(zip(*[ids[i:] for i in range(self.ngram_size)], strict=False)) + scaling = 1 - len(set(ngrams)) / len(ngrams) + rewards.append(scaling * self.max_penalty if scaling else 0.0) + return rewards + + +def get_soft_overlong_punishment(max_completion_len: int, soft_punish_cache: int) -> Callable: + # docstyle-ignore + r""" + Reward function that penalizes overlong completions. It is used to penalize overlong completions, but not to reward + shorter completions. Reference: Eq. (13) from the DAPO paper (https://huggingface.co/papers/2503.14476) + + $$ + R_{\text{length}}(y) = \begin{cases} + 0, & |y| \le L_{\max} - L_{\text{cache}} \\ + \dfrac{(L_{\max} - L_{\text{cache}}) - |y|}{L_{\text{cache}}}, & L_{\max} - L_{\text{cache}} < |y| \le L_{\max} \\ + -1, & L_{\max} < |y| + \end{cases} + $$ + + Args: + max_completion_len (`int`): + Maximum length of the completion, \( L_{\max} \). + soft_punish_cache (`int`): + Minimum length of the completion, \( L_{\text{cache}} \). If set to `0`, no minimum length is applied. + + Example: + ```python + from trl.rewards import get_soft_overlong_punishment + + soft_overlong_punishment = get_soft_overlong_punishment(max_completion_len=100, soft_punish_cache=20) + completion_ids = [[1] * 90] # simulating a completion with 90 tokens. 90 is between 80 and 100. + rewards = soft_overlong_punishment(completion_ids) + print(rewards) # [-0.5] + ``` + """ + return _SoftOverlongPunishment(max_completion_len, soft_punish_cache) + + +class _SoftOverlongPunishment: + # Callable class rather than a closure so the reward stays picklable: the async GRPO rollout + # worker forwards reward funcs to a spawned child process, and closures can't be pickled. + # `__name__` mirrors the old inner-function name so metric logging keys are unchanged. + __name__ = "soft_overlong_punishment_reward" + + def __init__(self, max_completion_len: int, soft_punish_cache: int): + self.max_completion_len = max_completion_len + self.soft_punish_cache = soft_punish_cache + + def __call__(self, completion_ids: list[list[int]], **kwargs) -> list[float]: + rewards = [] + for ids in completion_ids: + completion_length = len(ids) + if completion_length <= self.max_completion_len - self.soft_punish_cache: + rewards.append(0.0) + elif self.max_completion_len - self.soft_punish_cache < completion_length <= self.max_completion_len: + rewards.append( + (self.max_completion_len - self.soft_punish_cache - completion_length) / self.soft_punish_cache + ) + else: + rewards.append(-1.0) + return rewards diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cb15e6cdfe5446affd20a72cd22a8c74c6f15e1e --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/__init__.py @@ -0,0 +1,29 @@ +# Copyright 2020-2026 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. + +from typing import TYPE_CHECKING + +from .._lazy_module import _LazyModule + + +_import_structure = { + "utils": ["DatasetMixtureConfig", "ScriptArguments", "TrlParser", "get_dataset", "init_zero_verbose"], +} + +if TYPE_CHECKING: + from .utils import DatasetMixtureConfig, ScriptArguments, TrlParser, get_dataset, init_zero_verbose +else: + import sys + + sys.modules[__name__] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/_hf_argparser.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/_hf_argparser.py new file mode 100644 index 0000000000000000000000000000000000000000..f6b214154404dcc5f23791a577bdef85ac263eba --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/_hf_argparser.py @@ -0,0 +1,454 @@ +# Copyright 2020-2026 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. + + +# Copied from: https://github.com/huggingface/transformers/blob/3a275d3581c0ecf962f7412aa764c2047331fd6b/src/transformers/hf_argparser.py +# This avoids an upstream latency issue: https://github.com/huggingface/transformers/issues/44273 +# - Moved yaml import inside function + + +import dataclasses +import json +import os +import sys +import types +from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser, ArgumentTypeError +from collections.abc import Callable, Iterable +from copy import copy +from enum import Enum +from inspect import isclass +from pathlib import Path +from typing import Any, Literal, NewType, Union, get_type_hints + + +DataClass = NewType("DataClass", Any) +DataClassType = NewType("DataClassType", Any) + + +# From https://stackoverflow.com/questions/15008758/parsing-boolean-values-with-argparse +def string_to_bool(v): + if isinstance(v, bool): + return v + if v.lower() in ("yes", "true", "t", "y", "1"): + return True + elif v.lower() in ("no", "false", "f", "n", "0"): + return False + else: + raise ArgumentTypeError( + f"Truthy value expected: got {v} but expected one of yes/no, true/false, t/f, y/n, 1/0 (case insensitive)." + ) + + +def _accept_none(inner: Callable[[str], Any]) -> Callable[[str], Any]: + """Wrap a type converter so `'none'` and `'null'` (case-insensitive) parse to Python `None`. + + Used for `T | None` fields so they can be set to `None` from the CLI (argparse's `type=int` rejects `'None'`). + Mirrors the case-insensitive convention of [`string_to_bool`]. + """ + + def parse(v: str) -> Any: + if v.lower() in ("none", "null"): + return None + return inner(v) + + parse.__name__ = getattr(inner, "__name__", "value") # so argparse error messages keep the inner type name + return parse + + +def make_choice_type_function(choices: list) -> Callable[[str], Any]: + """ + Creates a mapping function from each choices string representation to the actual value. Used to support multiple + value types for a single argument. + + Args: + choices (list): List of choices. + + Returns: + Callable[[str], Any]: Mapping function from string representation to actual value for each choice. + """ + str_to_choice = {str(choice): choice for choice in choices} + return lambda arg: str_to_choice.get(arg, arg) + + +def HfArg( + *, + aliases: str | list[str] | None = None, + help: str | None = None, + default: Any = dataclasses.MISSING, + default_factory: Callable[[], Any] = dataclasses.MISSING, + metadata: dict | None = None, + **kwargs, +) -> dataclasses.Field: + """Argument helper enabling a concise syntax to create dataclass fields for parsing with `HfArgumentParser`. + + Example comparing the use of `HfArg` and `dataclasses.field`: + ``` + @dataclass + class Args: + regular_arg: str = dataclasses.field(default="Huggingface", metadata={"aliases": ["--example", "-e"], "help": "This syntax could be better!"}) + hf_arg: str = HfArg(default="Huggingface", aliases=["--example", "-e"], help="What a nice syntax!") + ``` + + Args: + aliases (Union[str, list[str]], *optional*): + Single string or list of strings of aliases to pass on to argparse, e.g. `aliases=["--example", "-e"]`. + Defaults to None. + help (str, *optional*): + Help string to pass on to argparse that can be displayed with --help. Defaults to None. + default (Any, *optional*): + Default value for the argument. If not default or default_factory is specified, the argument is required. + Defaults to dataclasses.MISSING. + default_factory (Callable[[], Any], *optional*): + The default_factory is a 0-argument function called to initialize a field's value. It is useful to provide + default values for mutable types, e.g. lists: `default_factory=list`. Mutually exclusive with `default=`. + Defaults to dataclasses.MISSING. + metadata (dict, *optional*): Further metadata to pass on to `dataclasses.field`. Defaults to None. + + Returns: + Field: A `dataclasses.Field` with the desired properties. + """ + if metadata is None: + # Important, don't use as default param in function signature because dict is mutable and shared across function calls + metadata = {} + if aliases is not None: + metadata["aliases"] = aliases + if help is not None: + metadata["help"] = help + + return dataclasses.field(metadata=metadata, default=default, default_factory=default_factory, **kwargs) + + +class HfArgumentParser(ArgumentParser): + """ + This subclass of `argparse.ArgumentParser` uses type hints on dataclasses to generate arguments. + + The class is designed to play well with the native argparse. In particular, you can add more (non-dataclass backed) + arguments to the parser after initialization and you'll get the output back after parsing as an additional + namespace. Optional: To create sub argument groups use the `_argument_group_name` attribute in the dataclass. + + Args: + dataclass_types (`DataClassType` or `Iterable[DataClassType]`, *optional*): + Dataclass type, or list of dataclass types for which we will "fill" instances with the parsed args. + kwargs (`dict[str, Any]`, *optional*): + Passed to `argparse.ArgumentParser()` in the regular way. + """ + + dataclass_types: Iterable[DataClassType] + + def __init__(self, dataclass_types: DataClassType | Iterable[DataClassType] | None = None, **kwargs): + # Make sure dataclass_types is an iterable + if dataclass_types is None: + dataclass_types = [] + elif not isinstance(dataclass_types, Iterable): + dataclass_types = [dataclass_types] + + # To make the default appear when using --help + if "formatter_class" not in kwargs: + kwargs["formatter_class"] = ArgumentDefaultsHelpFormatter + super().__init__(**kwargs) + if dataclasses.is_dataclass(dataclass_types): + dataclass_types = [dataclass_types] + self.dataclass_types = list(dataclass_types) + for dtype in self.dataclass_types: + self._add_dataclass_arguments(dtype) + + @staticmethod + def _parse_dataclass_field(parser: ArgumentParser, field: dataclasses.Field): + # Long-option strings are conventionlly separated by hyphens rather + # than underscores, e.g., "--long-format" rather than "--long_format". + # Argparse converts hyphens to underscores so that the destination + # string is a valid attribute name. Hf_argparser should do the same. + long_options = [f"--{field.name}"] + if "_" in field.name: + long_options.append(f"--{field.name.replace('_', '-')}") + + kwargs = field.metadata.copy() + # field.metadata is not used at all by Data Classes, + # it is provided as a third-party extension mechanism. + if isinstance(field.type, str): + raise RuntimeError( + "Unresolved type detected, which should have been done with the help of " + "`typing.get_type_hints` method by default" + ) + + aliases = kwargs.pop("aliases", []) + if isinstance(aliases, str): + aliases = [aliases] + + origin_type = getattr(field.type, "__origin__", field.type) + accepts_none = False + if origin_type is Union or (hasattr(types, "UnionType") and isinstance(origin_type, types.UnionType)): + if str not in field.type.__args__ and ( + len(field.type.__args__) != 2 or type(None) not in field.type.__args__ + ): + raise ValueError( + "Only `Union[X, NoneType]` (i.e., `Optional[X]`) is allowed for `Union` because" + " the argument parser only supports one type per argument." + f" Problem encountered in field '{field.name}'." + ) + if type(None) not in field.type.__args__: + # filter `str` in Union + field.type = field.type.__args__[0] if field.type.__args__[1] is str else field.type.__args__[1] + origin_type = getattr(field.type, "__origin__", field.type) + elif bool not in field.type.__args__: + # filter `NoneType` in Union (except for `Union[bool, NoneType]`) + field.type = ( + field.type.__args__[0] if isinstance(None, field.type.__args__[1]) else field.type.__args__[1] + ) + origin_type = getattr(field.type, "__origin__", field.type) + # Enable the `'none'`/`'null'` sentinel only when the inner type can't possibly accept those as + # legitimate string values (i.e. anything non-str). For str-typed fields, `'none'` may be a real + # value — e.g. `report_to`, whose CLI string `'none'` means "no integrations" downstream. + accepts_none = field.type is not str + + # A variable to store kwargs for a boolean field, if needed + # so that we can init a `no_*` complement argument (see below) + bool_kwargs = {} + if origin_type is Literal or (isinstance(field.type, type) and issubclass(field.type, Enum)): + if origin_type is Literal: + kwargs["choices"] = field.type.__args__ + else: + kwargs["choices"] = [x.value for x in field.type] + + kwargs["type"] = make_choice_type_function(kwargs["choices"]) + + if field.default is not dataclasses.MISSING: + kwargs["default"] = field.default + else: + kwargs["required"] = True + elif field.type is bool or field.type == bool | None: + # Copy the correct kwargs to use to instantiate a `no_*` complement argument below. + # We do not initialize it here because the `no_*` alternative must be instantiated after the real argument + bool_kwargs = copy(kwargs) + + # Hack because type=bool in argparse does not behave as we want. + kwargs["type"] = string_to_bool + if field.type is bool or (field.default is not None and field.default is not dataclasses.MISSING): + # Default value is False if we have no default when of type bool. + default = False if field.default is dataclasses.MISSING else field.default + # This is the value that will get picked if we don't include --{field.name} in any way + kwargs["default"] = default + # This tells argparse we accept 0 or 1 value after --{field.name} + kwargs["nargs"] = "?" + # This is the value that will get picked if we do --{field.name} (without value) + kwargs["const"] = True + elif isclass(origin_type) and issubclass(origin_type, list): + kwargs["type"] = field.type.__args__[0] + kwargs["nargs"] = "+" + if field.default_factory is not dataclasses.MISSING: + kwargs["default"] = field.default_factory() + elif field.default is dataclasses.MISSING: + kwargs["required"] = True + else: + kwargs["type"] = _accept_none(field.type) if accepts_none else field.type + if field.default is not dataclasses.MISSING: + kwargs["default"] = field.default + elif field.default_factory is not dataclasses.MISSING: + kwargs["default"] = field.default_factory() + else: + kwargs["required"] = True + parser.add_argument(*long_options, *aliases, **kwargs) + + # Add a complement `no_*` argument for a boolean field AFTER the initial field has already been added. + # Order is important for arguments with the same destination! + # We use a copy of earlier kwargs because the original kwargs have changed a lot before reaching down + # here and we do not need those changes/additional keys. + if field.default is True and (field.type is bool or field.type == bool | None): + bool_kwargs["default"] = False + parser.add_argument( + f"--no_{field.name}", + f"--no-{field.name.replace('_', '-')}", + action="store_false", + dest=field.name, + **bool_kwargs, + ) + + def _add_dataclass_arguments(self, dtype: DataClassType): + if hasattr(dtype, "_argument_group_name"): + parser = self.add_argument_group(dtype._argument_group_name) + else: + parser = self + + try: + type_hints: dict[str, type] = get_type_hints(dtype) + except NameError: + raise RuntimeError( + f"Type resolution failed for {dtype}. Try declaring the class in global scope or " + "removing line of `from __future__ import annotations` which opts in Postponed " + "Evaluation of Annotations (PEP 563)" + ) from None + + for field in dataclasses.fields(dtype): + if not field.init: + continue + field.type = type_hints[field.name] + self._parse_dataclass_field(parser, field) + + def parse_args_into_dataclasses( + self, + args=None, + return_remaining_strings=False, + look_for_args_file=True, + args_filename=None, + args_file_flag=None, + ) -> tuple[DataClass, ...]: + """ + Parse command-line args into instances of the specified dataclass types. + + This relies on argparse's `ArgumentParser.parse_known_args`. See the doc at: + docs.python.org/3/library/argparse.html#argparse.ArgumentParser.parse_args + + Args: + args: + List of strings to parse. The default is taken from sys.argv. (same as argparse.ArgumentParser) + return_remaining_strings: + If true, also return a list of remaining argument strings. + look_for_args_file: + If true, will look for a ".args" file with the same base name as the entry point script for this + process, and will append its potential content to the command line args. + args_filename: + If not None, will uses this file instead of the ".args" file specified in the previous argument. + args_file_flag: + If not None, will look for a file in the command-line args specified with this flag. The flag can be + specified multiple times and precedence is determined by the order (last one wins). + + Returns: + Tuple consisting of: + + - the dataclass instances in the same order as they were passed to the initializer.abspath + - if applicable, an additional namespace for more (non-dataclass backed) arguments added to the parser + after initialization. + - The potential list of remaining argument strings. (same as argparse.ArgumentParser.parse_known_args) + """ + + if args_file_flag or args_filename or (look_for_args_file and len(sys.argv)): + args_files = [] + + if args_filename: + args_files.append(Path(args_filename)) + elif look_for_args_file and len(sys.argv): + args_files.append(Path(sys.argv[0]).with_suffix(".args")) + + # args files specified via command line flag should overwrite default args files so we add them last + if args_file_flag: + # Create special parser just to extract the args_file_flag values + args_file_parser = ArgumentParser() + args_file_parser.add_argument(args_file_flag, type=str, action="append") + + # Use only remaining args for further parsing (remove the args_file_flag) + cfg, args = args_file_parser.parse_known_args(args=args) + cmd_args_file_paths = vars(cfg).get(args_file_flag.lstrip("-"), None) + + if cmd_args_file_paths: + args_files.extend([Path(p) for p in cmd_args_file_paths]) + + file_args = [] + for args_file in args_files: + if args_file.exists(): + file_args += args_file.read_text().split() + + # in case of duplicate arguments the last one has precedence + # args specified via the command line should overwrite args from files, so we add them last + args = file_args + args if args is not None else file_args + sys.argv[1:] + namespace, remaining_args = self.parse_known_args(args=args) + outputs = [] + for dtype in self.dataclass_types: + keys = {f.name for f in dataclasses.fields(dtype) if f.init} + inputs = {k: v for k, v in vars(namespace).items() if k in keys} + for k in keys: + delattr(namespace, k) + obj = dtype(**inputs) + outputs.append(obj) + if len(namespace.__dict__) > 0: + # additional namespace. + outputs.append(namespace) + if return_remaining_strings: + return (*outputs, remaining_args) + else: + if remaining_args: + raise ValueError(f"Some specified arguments are not used by the HfArgumentParser: {remaining_args}") + + return (*outputs,) + + def parse_dict(self, args: dict[str, Any], allow_extra_keys: bool = False) -> tuple[DataClass, ...]: + """ + Alternative helper method that does not use `argparse` at all, instead uses a dict and populating the dataclass + types. + + Args: + args (`dict`): + dict containing config values + allow_extra_keys (`bool`, *optional*, defaults to `False`): + Defaults to False. If False, will raise an exception if the dict contains keys that are not parsed. + + Returns: + Tuple consisting of: + + - the dataclass instances in the same order as they were passed to the initializer. + """ + unused_keys = set(args.keys()) + outputs = [] + for dtype in self.dataclass_types: + keys = {f.name for f in dataclasses.fields(dtype) if f.init} + inputs = {k: v for k, v in args.items() if k in keys} + unused_keys.difference_update(inputs.keys()) + obj = dtype(**inputs) + outputs.append(obj) + if not allow_extra_keys and unused_keys: + raise ValueError(f"Some keys are not used by the HfArgumentParser: {sorted(unused_keys)}") + return tuple(outputs) + + def parse_json_file(self, json_file: str | os.PathLike, allow_extra_keys: bool = False) -> tuple[DataClass, ...]: + """ + Alternative helper method that does not use `argparse` at all, instead loading a json file and populating the + dataclass types. + + Args: + json_file (`str` or `os.PathLike`): + File name of the json file to parse + allow_extra_keys (`bool`, *optional*, defaults to `False`): + Defaults to False. If False, will raise an exception if the json file contains keys that are not + parsed. + + Returns: + Tuple consisting of: + + - the dataclass instances in the same order as they were passed to the initializer. + """ + with open(Path(json_file), encoding="utf-8") as open_json_file: + data = json.loads(open_json_file.read()) + outputs = self.parse_dict(data, allow_extra_keys=allow_extra_keys) + return tuple(outputs) + + def parse_yaml_file(self, yaml_file: str | os.PathLike, allow_extra_keys: bool = False) -> tuple[DataClass, ...]: + """ + Alternative helper method that does not use `argparse` at all, instead loading a yaml file and populating the + dataclass types. + + Args: + yaml_file (`str` or `os.PathLike`): + File name of the yaml file to parse + allow_extra_keys (`bool`, *optional*, defaults to `False`): + Defaults to False. If False, will raise an exception if the json file contains keys that are not + parsed. + + Returns: + Tuple consisting of: + + - the dataclass instances in the same order as they were passed to the initializer. + """ + import yaml + + outputs = self.parse_dict(yaml.safe_load(Path(yaml_file).read_text()), allow_extra_keys=allow_extra_keys) + return tuple(outputs) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/dpo.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/dpo.py new file mode 100644 index 0000000000000000000000000000000000000000..ff71252768c531aac020016cd9549d7068432c78 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/dpo.py @@ -0,0 +1,146 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# "peft", +# "trackio", +# "kernels", +# ] +# /// + +""" +# Full training +```bash +python trl/scripts/dpo.py \ + --dataset_name trl-lib/ultrafeedback_binarized \ + --model_name_or_path Qwen/Qwen2-0.5B-Instruct \ + --learning_rate 5.0e-7 \ + --num_train_epochs 1 \ + --per_device_train_batch_size 2 \ + --max_steps 1000 \ + --gradient_accumulation_steps 8 \ + --eval_strategy steps \ + --eval_steps 50 \ + --output_dir Qwen2-0.5B-DPO \ + --no_remove_unused_columns +``` + +# LoRA: +```bash +python trl/scripts/dpo.py \ + --dataset_name trl-lib/ultrafeedback_binarized \ + --model_name_or_path Qwen/Qwen2-0.5B-Instruct \ + --learning_rate 5.0e-6 \ + --num_train_epochs 1 \ + --per_device_train_batch_size 2 \ + --max_steps 1000 \ + --gradient_accumulation_steps 8 \ + --eval_strategy steps \ + --eval_steps 50 \ + --output_dir Qwen2-0.5B-DPO \ + --no_remove_unused_columns \ + --use_peft \ + --lora_r 32 \ + --lora_alpha 16 +``` +""" + +import argparse + + +def main(script_args, training_args, model_args, dataset_args): + from accelerate import logging + from datasets import load_dataset + + from trl import DPOTrainer, get_dataset, get_kbit_device_map, get_peft_config, get_quantization_config + + logger = logging.get_logger(__name__) + + training_args.model_init_kwargs = dict( + revision=model_args.model_revision, + trust_remote_code=training_args.trust_remote_code, + attn_implementation=model_args.attn_implementation, + dtype=model_args.dtype, + ) + quantization_config = get_quantization_config(model_args) + if quantization_config is not None: + # Passing None would not be treated the same as omitting the argument, so we include it only when valid. + training_args.model_init_kwargs["device_map"] = get_kbit_device_map() + training_args.model_init_kwargs["quantization_config"] = quantization_config + + # Load the dataset + if dataset_args.datasets and script_args.dataset_name: + logger.warning( + "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the " + "dataset and `dataset_name` will be ignored." + ) + dataset = get_dataset(dataset_args) + elif dataset_args.datasets and not script_args.dataset_name: + dataset = get_dataset(dataset_args) + elif not dataset_args.datasets and script_args.dataset_name: + dataset = load_dataset( + script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming + ) + else: + raise ValueError("Either `datasets` or `dataset_name` must be provided.") + + # Initialize the DPO trainer + trainer = DPOTrainer( + model=model_args.model_name_or_path, + args=training_args, + train_dataset=dataset[script_args.dataset_train_split], + eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None, + peft_config=get_peft_config(model_args), + ) + + if script_args.ignore_bias_buffers: + import torch + + # torch distributed hack + trainer.model._ddp_params_and_buffers_to_ignore = [ + name for name, buffer in trainer.model.named_buffers() if buffer.dtype == torch.bool + ] + + # Train the model + trainer.train() + + # Log training complete + trainer.accelerator.print("✅ Training completed.") + + # Save and push to Hub + trainer.save_model(training_args.output_dir) + trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.") + + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name) + trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.") + + +def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None): + from trl import DatasetMixtureConfig, DPOConfig, ModelConfig, ScriptArguments, TrlParser + + dataclass_types = (ScriptArguments, DPOConfig, ModelConfig, DatasetMixtureConfig) + if subparsers is not None: + parser = subparsers.add_parser("dpo", help="Run the DPO training script", dataclass_types=dataclass_types) + else: + parser = TrlParser(dataclass_types, prog=prog) + return parser + + +if __name__ == "__main__": + parser = make_parser() + script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False) + main(script_args, training_args, model_args, dataset_args) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/env.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/env.py new file mode 100644 index 0000000000000000000000000000000000000000..830bbee0a9ab39e1426f011bcdf06df3a9b85f9e --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/env.py @@ -0,0 +1,81 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# ] +# /// + +import os +import platform +from importlib.metadata import version + + +def print_env(): + import torch + from accelerate.commands.config import default_config_file, load_config_from_file + from transformers import is_bitsandbytes_available + from transformers.utils import is_peft_available + + from trl import __version__ + from trl.import_utils import is_deepspeed_available, is_liger_kernel_available, is_vllm_available + from trl.scripts.utils import get_git_commit_hash + + devices = None + if torch.cuda.is_available(): + devices = [torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())] + elif torch.backends.mps.is_available(): + devices = ["MPS"] + elif torch.xpu.is_available(): + devices = [torch.xpu.get_device_name(i) for i in range(torch.xpu.device_count())] + + accelerate_config = accelerate_config_str = "not found" + + # Get the default from the config file. + if os.path.isfile(default_config_file): + accelerate_config = load_config_from_file(default_config_file).to_dict() + + accelerate_config_str = ( + "\n" + "\n".join([f" - {prop}: {val}" for prop, val in accelerate_config.items()]) + if isinstance(accelerate_config, dict) + else accelerate_config + ) + + commit_hash = get_git_commit_hash("trl") + + info = { + "Platform": platform.platform(), + "Python version": platform.python_version(), + "TRL version": f"{__version__}+{commit_hash[:7]}" if commit_hash else __version__, + "PyTorch version": version("torch"), + "accelerator(s)": ", ".join(devices) if devices is not None else "cpu", + "Transformers version": version("transformers"), + "Accelerate version": version("accelerate"), + "Accelerate config": accelerate_config_str, + "Datasets version": version("datasets"), + "HF Hub version": version("huggingface_hub"), + "bitsandbytes version": version("bitsandbytes") if is_bitsandbytes_available() else "not installed", + "DeepSpeed version": version("deepspeed") if is_deepspeed_available() else "not installed", + "Liger-Kernel version": version("liger_kernel") if is_liger_kernel_available() else "not installed", + "PEFT version": version("peft") if is_peft_available() else "not installed", + "vLLM version": version("vllm") if is_vllm_available() else "not installed", + } + + info_str = "\n".join([f"- {prop}: {val}" for prop, val in info.items()]) + print(f"\nCopy-paste the following information when reporting an issue:\n\n{info_str}\n") # noqa + + +if __name__ == "__main__": + print_env() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/grpo.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/grpo.py new file mode 100644 index 0000000000000000000000000000000000000000..401eaf1ccb9409ea45e4931735d832ffdfdc738f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/grpo.py @@ -0,0 +1,177 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# "peft", +# "trackio", +# "kernels", +# ] +# /// + +import argparse +import importlib +import os +import sys +from dataclasses import dataclass, field + +from trl import ScriptArguments + + +@dataclass +class GRPOScriptArguments(ScriptArguments): + """ + Script arguments for the GRPO training script. + + Args: + reward_model_name_or_path (`str`, *optional*): + Reward model id of a pretrained model hosted inside a model repo on huggingface.co or local path to a + directory containing model weights saved using [`~transformers.PreTrainedModel.save_pretrained`]. + reward_funcs (`list[str]`, *optional*): + Reward functions to use. Supported values are: + - `"accuracy_reward"` + - `"reasoning_accuracy_reward"` + - `"think_format_reward"` + - `"get_soft_overlong_punishment"` (used value are `max_completion_len=1280`, `soft_punish_cache=256`) + - any dotted import path " (e.g., `'my_lib.rewards.custom_reward'`). + """ + + reward_model_name_or_path: str | None = field( + default=None, + metadata={ + "help": "Reward model id of a pretrained model hosted inside a model repo on huggingface.co or " + "local path to a directory containing model weights saved using `PreTrainedModel.save_pretrained`." + }, + ) + reward_funcs: list[str] | None = field( + default=None, + metadata={ + "help": "Reward functions to use. Supported values are: `accuracy_reward`, `reasoning_accuracy_reward`, `think_format_reward`, " + "`get_soft_overlong_punishment` (used values are `max_completion_len=1280`, `soft_punish_cache=256`), or " + "any dotted import path (e.g., `'my_lib.rewards.custom_reward'`)." + }, + ) + + +def main(script_args, training_args, model_args, dataset_args): + from accelerate import logging + from datasets import load_dataset + + from trl import GRPOTrainer, get_dataset, get_kbit_device_map, get_peft_config, get_quantization_config + from trl.rewards import ( + accuracy_reward, + get_soft_overlong_punishment, + reasoning_accuracy_reward, + think_format_reward, + ) + + logger = logging.get_logger(__name__) + + reward_funcs_registry = { + "accuracy_reward": accuracy_reward, + "reasoning_accuracy_reward": reasoning_accuracy_reward, + "think_format_reward": think_format_reward, + "get_soft_overlong_punishment": get_soft_overlong_punishment(max_completion_len=1280, soft_punish_cache=256), + } + + # Get the reward models and functions + reward_funcs = [] + if script_args.reward_model_name_or_path: + reward_funcs.append(script_args.reward_model_name_or_path) + + if script_args.reward_funcs: + for func_name in script_args.reward_funcs: + if func_name in reward_funcs_registry: + reward_funcs.append(reward_funcs_registry[func_name]) + elif "." in func_name: + module_path, func_name = func_name.rsplit(".", 1) + sys.path.insert(0, os.getcwd()) + module = importlib.import_module(module_path) + reward_func = getattr(module, func_name) + reward_funcs.append(reward_func) + else: + raise ValueError( + f"Could not load reward function '{func_name}'. Expected one of " + f"{list(reward_funcs_registry.keys())} or a valid import path." + ) + + training_args.model_init_kwargs = dict( + revision=model_args.model_revision, + trust_remote_code=training_args.trust_remote_code, + attn_implementation=model_args.attn_implementation, + dtype=model_args.dtype, + ) + quantization_config = get_quantization_config(model_args) + if quantization_config is not None: + # Passing None would not be treated the same as omitting the argument, so we include it only when valid. + training_args.model_init_kwargs["device_map"] = get_kbit_device_map() + training_args.model_init_kwargs["quantization_config"] = quantization_config + + # Load the dataset + if dataset_args.datasets and script_args.dataset_name: + logger.warning( + "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the " + "dataset and `dataset_name` will be ignored." + ) + dataset = get_dataset(dataset_args) + elif dataset_args.datasets and not script_args.dataset_name: + dataset = get_dataset(dataset_args) + elif not dataset_args.datasets and script_args.dataset_name: + dataset = load_dataset( + script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming + ) + else: + raise ValueError("Either `datasets` or `dataset_name` must be provided.") + + # Initialize the GRPO trainer + trainer = GRPOTrainer( + model=model_args.model_name_or_path, + reward_funcs=reward_funcs, + args=training_args, + train_dataset=dataset[script_args.dataset_train_split], + eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None, + peft_config=get_peft_config(model_args), + ) + + # Train the model + trainer.train() + + # Log training complete + trainer.accelerator.print("✅ Training completed.") + + # Save and push to Hub + trainer.save_model(training_args.output_dir) + trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.") + + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name) + trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.") + + +def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None): + from trl import DatasetMixtureConfig, GRPOConfig, ModelConfig, TrlParser + + dataclass_types = (GRPOScriptArguments, GRPOConfig, ModelConfig, DatasetMixtureConfig) + if subparsers is not None: + parser = subparsers.add_parser("grpo", help="Run the GRPO training script", dataclass_types=dataclass_types) + else: + parser = TrlParser(dataclass_types, prog=prog) + return parser + + +if __name__ == "__main__": + parser = make_parser() + script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False) + main(script_args, training_args, model_args, dataset_args) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/kto.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/kto.py new file mode 100644 index 0000000000000000000000000000000000000000..a75885482fedc405f4d78da7dbb0b5a61f2b919a --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/kto.py @@ -0,0 +1,151 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# "peft", +# "trackio", +# "kernels", +# ] +# /// + +""" +Run the KTO training script with the commands below. In general, the optimal configuration for KTO will be similar to +that of DPO. + +# Full training: +```bash +python trl/scripts/kto.py \ + --dataset_name trl-lib/kto-mix-14k \ + --model_name_or_path=trl-lib/qwen1.5-1.8b-sft \ + --per_device_train_batch_size 16 \ + --num_train_epochs 1 \ + --learning_rate 5e-7 \ + --lr_scheduler_type=cosine \ + --gradient_accumulation_steps 1 \ + --eval_steps 500 \ + --output_dir=kto-aligned-model \ + --warmup_steps 0.1 \ + --logging_first_step +``` + +# QLoRA: +```bash +# QLoRA: +python trl/scripts/kto.py \ + --dataset_name trl-lib/kto-mix-14k \ + --model_name_or_path=trl-lib/qwen1.5-1.8b-sft \ + --per_device_train_batch_size 8 \ + --num_train_epochs 1 \ + --learning_rate 5e-7 \ + --lr_scheduler_type=cosine \ + --gradient_accumulation_steps 1 \ + --eval_steps 500 \ + --output_dir=kto-aligned-model-lora \ + --warmup_steps 0.1 \ + --logging_first_step \ + --use_peft \ + --load_in_4bit \ + --lora_target_modules=all-linear \ + --lora_r=16 \ + --lora_alpha=16 +``` +""" + +import argparse + + +def main(script_args, training_args, model_args, dataset_args): + from accelerate import logging + from datasets import load_dataset + from transformers import AutoModelForCausalLM, AutoTokenizer + + from trl import get_dataset, get_peft_config + from trl.experimental.kto import KTOTrainer + + logger = logging.get_logger(__name__) + + # Load a pretrained model + model = AutoModelForCausalLM.from_pretrained( + model_args.model_name_or_path, trust_remote_code=training_args.trust_remote_code + ) + ref_model = AutoModelForCausalLM.from_pretrained( + model_args.model_name_or_path, trust_remote_code=training_args.trust_remote_code + ) + + tokenizer = AutoTokenizer.from_pretrained( + model_args.model_name_or_path, trust_remote_code=training_args.trust_remote_code + ) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + # Load the dataset + if dataset_args.datasets and script_args.dataset_name: + logger.warning( + "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the " + "dataset and `dataset_name` will be ignored." + ) + dataset = get_dataset(dataset_args) + elif dataset_args.datasets and not script_args.dataset_name: + dataset = get_dataset(dataset_args) + elif not dataset_args.datasets and script_args.dataset_name: + dataset = load_dataset( + script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming + ) + else: + raise ValueError("Either `datasets` or `dataset_name` must be provided.") + + # Initialize the KTO trainer + trainer = KTOTrainer( + model, + ref_model, + args=training_args, + train_dataset=dataset[script_args.dataset_train_split], + eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None, + processing_class=tokenizer, + peft_config=get_peft_config(model_args), + ) + + # Train the model + trainer.train() + + # Log training complete + trainer.accelerator.print("✅ Training completed.") + + # Save and push to Hub + trainer.save_model(training_args.output_dir) + trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.") + + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name) + trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.") + + +def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None): + from trl import DatasetMixtureConfig, ModelConfig, ScriptArguments, TrlParser + from trl.experimental.kto import KTOConfig + + dataclass_types = (ScriptArguments, KTOConfig, ModelConfig, DatasetMixtureConfig) + if subparsers is not None: + parser = subparsers.add_parser("kto", help="Run the KTO training script", dataclass_types=dataclass_types) + else: + parser = TrlParser(dataclass_types, prog=prog) + return parser + + +if __name__ == "__main__": + parser = make_parser() + script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False) + main(script_args, training_args, model_args, dataset_args) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/reward.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/reward.py new file mode 100644 index 0000000000000000000000000000000000000000..ec676ac73fefed95c789c84fb4fa3ce7fea5be03 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/reward.py @@ -0,0 +1,103 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# "peft", +# "trackio", +# "kernels", +# ] +# /// + +import argparse + + +def main(script_args, training_args, model_args, dataset_args): + from accelerate import logging + from datasets import load_dataset + + from trl import RewardTrainer, get_dataset, get_kbit_device_map, get_peft_config, get_quantization_config + + logger = logging.get_logger(__name__) + + training_args.model_init_kwargs = dict( + revision=model_args.model_revision, + trust_remote_code=training_args.trust_remote_code, + attn_implementation=model_args.attn_implementation, + dtype=model_args.dtype, + ) + quantization_config = get_quantization_config(model_args) + if quantization_config is not None: + # Passing None would not be treated the same as omitting the argument, so we include it only when valid. + training_args.model_init_kwargs["device_map"] = get_kbit_device_map() + training_args.model_init_kwargs["quantization_config"] = quantization_config + + # Load the dataset + if dataset_args.datasets and script_args.dataset_name: + logger.warning( + "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the " + "dataset and `dataset_name` will be ignored." + ) + dataset = get_dataset(dataset_args) + elif dataset_args.datasets and not script_args.dataset_name: + dataset = get_dataset(dataset_args) + elif not dataset_args.datasets and script_args.dataset_name: + dataset = load_dataset( + script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming + ) + else: + raise ValueError("Either `datasets` or `dataset_name` must be provided.") + + # Initialize the reward trainer + trainer = RewardTrainer( + model=model_args.model_name_or_path, + args=training_args, + train_dataset=dataset[script_args.dataset_train_split], + eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None, + peft_config=get_peft_config(model_args), + ) + + # Train the model + trainer.train() + + # Log training complete + trainer.accelerator.print("✅ Training completed.") + + # Save and push to Hub + trainer.save_model(training_args.output_dir) + trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.") + + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name) + trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.") + + +def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None): + from trl import DatasetMixtureConfig, ModelConfig, RewardConfig, ScriptArguments, TrlParser + + dataclass_types = (ScriptArguments, RewardConfig, ModelConfig, DatasetMixtureConfig) + if subparsers is not None: + parser = subparsers.add_parser( + "reward", help="Run the reward training script", dataclass_types=dataclass_types + ) + else: + parser = TrlParser(dataclass_types, prog=prog) + return parser + + +if __name__ == "__main__": + parser = make_parser() + script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False) + main(script_args, training_args, model_args, dataset_args) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/rloo.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/rloo.py new file mode 100644 index 0000000000000000000000000000000000000000..55fea144d731598cea4807c04f809ad5f578e61d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/rloo.py @@ -0,0 +1,177 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# "peft", +# "trackio", +# "kernels", +# ] +# /// + +import argparse +import importlib +import os +import sys +from dataclasses import dataclass, field + +from trl import ScriptArguments + + +@dataclass +class RLOOScriptArguments(ScriptArguments): + """ + Script arguments for the RLOO training script. + + Args: + reward_model_name_or_path (`str`, *optional*): + Reward model id of a pretrained model hosted inside a model repo on huggingface.co or local path to a + directory containing model weights saved using [`~transformers.PreTrainedModel.save_pretrained`]. + reward_funcs (`list[str]`, *optional*): + Reward functions to use. Supported values are: + - `"accuracy_reward"` + - `"reasoning_accuracy_reward"` + - `"think_format_reward"` + - `"get_soft_overlong_punishment"` (used value are `max_completion_len=1280`, `soft_punish_cache=256`) + - any dotted import path " (e.g., `'my_lib.rewards.custom_reward'`). + """ + + reward_model_name_or_path: str | None = field( + default=None, + metadata={ + "help": "Reward model id of a pretrained model hosted inside a model repo on huggingface.co or " + "local path to a directory containing model weights saved using `PreTrainedModel.save_pretrained`." + }, + ) + reward_funcs: list[str] | None = field( + default=None, + metadata={ + "help": "Reward functions to use. Supported values are: `accuracy_reward`, `reasoning_accuracy_reward`, `think_format_reward`, " + "`get_soft_overlong_punishment` (used values are `max_completion_len=1280`, `soft_punish_cache=256`), or " + "any dotted import path (e.g., `'my_lib.rewards.custom_reward'`)." + }, + ) + + +def main(script_args, training_args, model_args, dataset_args): + from accelerate import logging + from datasets import load_dataset + + from trl import RLOOTrainer, get_dataset, get_kbit_device_map, get_peft_config, get_quantization_config + from trl.rewards import ( + accuracy_reward, + get_soft_overlong_punishment, + reasoning_accuracy_reward, + think_format_reward, + ) + + logger = logging.get_logger(__name__) + + reward_funcs_registry = { + "accuracy_reward": accuracy_reward, + "reasoning_accuracy_reward": reasoning_accuracy_reward, + "think_format_reward": think_format_reward, + "get_soft_overlong_punishment": get_soft_overlong_punishment(max_completion_len=1280, soft_punish_cache=256), + } + + # Get the reward models and functions + reward_funcs = [] + if script_args.reward_model_name_or_path: + reward_funcs.append(script_args.reward_model_name_or_path) + + if script_args.reward_funcs: + for func_name in script_args.reward_funcs: + if func_name in reward_funcs_registry: + reward_funcs.append(reward_funcs_registry[func_name]) + elif "." in func_name: + module_path, func_name = func_name.rsplit(".", 1) + sys.path.insert(0, os.getcwd()) + module = importlib.import_module(module_path) + reward_func = getattr(module, func_name) + reward_funcs.append(reward_func) + else: + raise ValueError( + f"Could not load reward function '{func_name}'. Expected one of " + f"{list(reward_funcs_registry.keys())} or a valid import path." + ) + + training_args.model_init_kwargs = dict( + revision=model_args.model_revision, + trust_remote_code=training_args.trust_remote_code, + attn_implementation=model_args.attn_implementation, + dtype=model_args.dtype, + ) + quantization_config = get_quantization_config(model_args) + if quantization_config is not None: + # Passing None would not be treated the same as omitting the argument, so we include it only when valid. + training_args.model_init_kwargs["device_map"] = get_kbit_device_map() + training_args.model_init_kwargs["quantization_config"] = quantization_config + + # Load the dataset + if dataset_args.datasets and script_args.dataset_name: + logger.warning( + "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the " + "dataset and `dataset_name` will be ignored." + ) + dataset = get_dataset(dataset_args) + elif dataset_args.datasets and not script_args.dataset_name: + dataset = get_dataset(dataset_args) + elif not dataset_args.datasets and script_args.dataset_name: + dataset = load_dataset( + script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming + ) + else: + raise ValueError("Either `datasets` or `dataset_name` must be provided.") + + # Initialize the RLOO trainer + trainer = RLOOTrainer( + model=model_args.model_name_or_path, + reward_funcs=reward_funcs, + args=training_args, + train_dataset=dataset[script_args.dataset_train_split], + eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None, + peft_config=get_peft_config(model_args), + ) + + # Train the model + trainer.train() + + # Log training complete + trainer.accelerator.print("✅ Training completed.") + + # Save and push to Hub + trainer.save_model(training_args.output_dir) + trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.") + + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name) + trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.") + + +def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None): + from trl import DatasetMixtureConfig, ModelConfig, RLOOConfig, TrlParser + + dataclass_types = (RLOOScriptArguments, RLOOConfig, ModelConfig, DatasetMixtureConfig) + if subparsers is not None: + parser = subparsers.add_parser("rloo", help="Run the RLOO training script", dataclass_types=dataclass_types) + else: + parser = TrlParser(dataclass_types, prog=prog) + return parser + + +if __name__ == "__main__": + parser = make_parser() + script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False) + main(script_args, training_args, model_args, dataset_args) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/sft.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/sft.py new file mode 100644 index 0000000000000000000000000000000000000000..fa6f6306330dfdb030e47fdf69482b853d7b6764 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/sft.py @@ -0,0 +1,140 @@ +# Copyright 2020-2026 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. + +# /// script +# dependencies = [ +# "trl", +# "peft", +# "trackio", +# "kernels", +# ] +# /// + +""" +# Full training +``` +python trl/scripts/sft.py \ + --model_name_or_path Qwen/Qwen2-0.5B \ + --dataset_name trl-lib/Capybara \ + --learning_rate 2.0e-5 \ + --num_train_epochs 1 \ + --packing \ + --per_device_train_batch_size 2 \ + --gradient_accumulation_steps 8 \ + --eos_token '<|im_end|>' \ + --eval_strategy steps \ + --eval_steps 100 \ + --output_dir Qwen2-0.5B-SFT \ + --push_to_hub +``` + +# LoRA +``` +python trl/scripts/sft.py \ + --model_name_or_path Qwen/Qwen2-0.5B \ + --dataset_name trl-lib/Capybara \ + --learning_rate 2.0e-4 \ + --num_train_epochs 1 \ + --packing \ + --per_device_train_batch_size 2 \ + --gradient_accumulation_steps 8 \ + --eos_token '<|im_end|>' \ + --eval_strategy steps \ + --eval_steps 100 \ + --use_peft \ + --lora_r 32 \ + --lora_alpha 16 \ + --output_dir Qwen2-0.5B-SFT \ + --push_to_hub +``` +""" + +import argparse + + +def main(script_args, training_args, model_args, dataset_args): + from accelerate import logging + from datasets import load_dataset + + from trl import SFTTrainer, get_dataset, get_kbit_device_map, get_peft_config, get_quantization_config + + logger = logging.get_logger(__name__) + + training_args.model_init_kwargs = dict( + revision=model_args.model_revision, + trust_remote_code=training_args.trust_remote_code, + attn_implementation=model_args.attn_implementation, + dtype=model_args.dtype, + ) + quantization_config = get_quantization_config(model_args) + if quantization_config is not None: + # Passing None would not be treated the same as omitting the argument, so we include it only when valid. + training_args.model_init_kwargs["device_map"] = get_kbit_device_map() + training_args.model_init_kwargs["quantization_config"] = quantization_config + + # Load the dataset + if dataset_args.datasets and script_args.dataset_name: + logger.warning( + "Both `datasets` and `dataset_name` are provided. The `datasets` argument will be used to load the " + "dataset and `dataset_name` will be ignored." + ) + dataset = get_dataset(dataset_args) + elif dataset_args.datasets and not script_args.dataset_name: + dataset = get_dataset(dataset_args) + elif not dataset_args.datasets and script_args.dataset_name: + dataset = load_dataset( + script_args.dataset_name, name=script_args.dataset_config, streaming=script_args.dataset_streaming + ) + else: + raise ValueError("Either `datasets` or `dataset_name` must be provided.") + + # Initialize the SFT trainer + trainer = SFTTrainer( + model=model_args.model_name_or_path, + args=training_args, + train_dataset=dataset[script_args.dataset_train_split], + eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None, + peft_config=get_peft_config(model_args), + ) + + # Train the model + trainer.train() + + # Log training complete + trainer.accelerator.print("✅ Training completed.") + + # Save and push to Hub + trainer.save_model(training_args.output_dir) + trainer.accelerator.print(f"💾 Model saved to {training_args.output_dir}.") + + if training_args.push_to_hub: + trainer.push_to_hub(dataset_name=script_args.dataset_name) + trainer.accelerator.print(f"🤗 Model pushed to the Hub in https://huggingface.co/{trainer.hub_model_id}.") + + +def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None): + from trl import DatasetMixtureConfig, ModelConfig, ScriptArguments, SFTConfig, TrlParser + + dataclass_types = (ScriptArguments, SFTConfig, ModelConfig, DatasetMixtureConfig) + if subparsers is not None: + parser = subparsers.add_parser("sft", help="Run the SFT training script", dataclass_types=dataclass_types) + else: + parser = TrlParser(dataclass_types, prog=prog) + return parser + + +if __name__ == "__main__": + parser = make_parser() + script_args, training_args, model_args, dataset_args = parser.parse_args_and_config(fail_with_unknown_args=False) + main(script_args, training_args, model_args, dataset_args) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..165fec49fc32ed3c00cb3001f64f35ab5d690a6f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/utils.py @@ -0,0 +1,466 @@ +# Copyright 2020-2026 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 argparse +import importlib +import inspect +import logging +import os +import subprocess +import sys +from collections.abc import Iterable +from dataclasses import dataclass, field +from typing import TYPE_CHECKING + +# Temporarily import from the local module instead of transformers to avoid an upstream latency issue +# See: https://github.com/huggingface/transformers/issues/44273 +# This workaround can be reverted once the fix is included in the minimum required transformers version +from trl.scripts._hf_argparser import DataClass, DataClassType, HfArgumentParser + + +if TYPE_CHECKING: + from datasets import DatasetDict + + +logger = logging.getLogger(__name__) + + +@dataclass +class DatasetConfig: + """ + Configuration for a dataset. + + This class matches the signature of [`~datasets.load_dataset`] and the arguments are used directly in the + [`~datasets.load_dataset`] function. You can refer to the [`~datasets.load_dataset`] documentation for more + details. + + Parameters: + path (`str`): + Path or name of the dataset. + name (`str`, *optional*): + Defining the name of the dataset configuration. + data_dir (`str`, *optional*): + Defining the `data_dir` of the dataset configuration. If specified for the generic builders(csv, text etc.) + or the Hub datasets and `data_files` is `None`, the behavior is equal to passing `os.path.join(data_dir, + **)` as `data_files` to reference all the files in a directory. + data_files (`str` or `Sequence` or `Mapping`, *optional*): + Path(s) to source data file(s). + split (`str`, *optional*, defaults to `"train"`): + Which split of the data to load. + columns (`list[str]`, *optional*): + List of column names to select from the dataset. If `None`, all columns are selected. + """ + + path: str + name: str | None = None + data_dir: str | None = None + data_files: str | list[str] | dict[str, str] | None = None + split: str = "train" + columns: list[str] | None = None + + +@dataclass +class DatasetMixtureConfig: + """ + Configuration class for a mixture of datasets. + + 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: + datasets (`list[DatasetConfig]`): + List of dataset configurations to include in the mixture. + streaming (`bool`, *optional*, defaults to `False`): + Whether to stream the datasets. If `True`, the datasets will be loaded in streaming mode. + test_split_size (`float`, *optional*): + Size of the test split. Refer to the `test_size` parameter in the [`~datasets.train_test_split`] function + for more details. If `None`, the dataset will not be split into train and test sets. + + Usage: + When using the CLI, you can add the following section to your YAML config file: + + ```yaml + datasets: + - path: ... + name: ... + data_dir: ... + data_files: ... + split: ... + columns: ... + - path: ... + name: ... + data_dir: ... + data_files: ... + split: ... + columns: ... + streaming: ... + test_split_size: ... + ``` + """ + + datasets: list[DatasetConfig] = field( + default_factory=list, + metadata={"help": "List of dataset configurations to include in the mixture."}, + ) + streaming: bool = field( + default=False, + metadata={"help": "Whether to stream the datasets. If True, the datasets will be loaded in streaming mode."}, + ) + test_split_size: float | None = field( + default=None, + metadata={ + "help": "Size of the test split. Refer to the `test_size` parameter in the `datasets.train_test_split` " + "function for more details. If None, the dataset will not be split into train and test sets." + }, + ) + + def __post_init__(self): + # Convert any dataset dicts (from CLI/config parsing) into DatasetConfig objects + for idx, dataset in enumerate(self.datasets): + if isinstance(dataset, dict): + # If it's a dict, convert it to DatasetConfig + self.datasets[idx] = DatasetConfig(**dataset) + + +@dataclass +class ScriptArguments: + """ + Arguments common to all scripts. + + Args: + dataset_name (`str`,, *optional*): + Path or name of the dataset to load. If `datasets` is provided, this will be ignored. + dataset_config (`str`, *optional*): + Dataset configuration name. Corresponds to the `name` argument of the [`~datasets.load_dataset`] function. + If `datasets` is provided, this will be ignored. + dataset_train_split (`str`, *optional*, defaults to `"train"`): + Dataset split to use for training. If `datasets` is provided, this will be ignored. + dataset_test_split (`str`, *optional*, defaults to `"test"`): + Dataset split to use for evaluation. If `datasets` is provided, this will be ignored. + dataset_streaming (`bool`, *optional*, defaults to `False`): + Whether to stream the dataset. If True, the dataset will be loaded in streaming mode. If `datasets` is + provided, this will be ignored. + ignore_bias_buffers (`bool`, *optional*, defaults to `False`): + Debug argument for distributed training. Fix for DDP issues with LM bias/mask buffers - invalid scalar + type, inplace operation. See + https://github.com/huggingface/transformers/issues/22482#issuecomment-1595790992. + """ + + dataset_name: str | None = field( + default=None, + metadata={"help": "Path or name of the dataset to load. If `datasets` is provided, this will be ignored."}, + ) + dataset_config: str | None = field( + default=None, + metadata={ + "help": "Dataset configuration name. Corresponds to the `name` argument of the `datasets.load_dataset` " + "function. If `datasets` is provided, this will be ignored." + }, + ) + dataset_train_split: str = field( + default="train", + metadata={"help": "Dataset split to use for training. If `datasets` is provided, this will be ignored."}, + ) + dataset_test_split: str = field( + default="test", + metadata={"help": "Dataset split to use for evaluation. If `datasets` is provided, this will be ignored."}, + ) + dataset_streaming: bool = field( + default=False, + metadata={ + "help": "Whether to stream the dataset. If True, the dataset will be loaded in streaming mode. If " + "`datasets` is provided, this will be ignored." + }, + ) + ignore_bias_buffers: bool = field( + default=False, + metadata={ + "help": "Debug argument for distributed training. Fix for DDP issues with LM bias/mask buffers - invalid " + "scalar type, inplace operation. See " + "https://github.com/huggingface/transformers/issues/22482#issuecomment-1595790992." + }, + ) + + +def init_zero_verbose(): + """ + Perform zero verbose init - use this method on top of the CLI modules to make logging and warning output cleaner. + Uses Rich if available, falls back otherwise. + """ + import logging + import warnings + + from transformers.utils import is_rich_available + + FORMAT = "%(message)s" + + if is_rich_available(): + from rich.logging import RichHandler + + handler = RichHandler() + else: + handler = logging.StreamHandler() + + logging.basicConfig(format=FORMAT, datefmt="[%X]", handlers=[handler], level=logging.ERROR) + + # Custom warning handler to redirect warnings to the logging system + def warning_handler(message, category, filename, lineno, file=None, line=None): + logging.warning(f"{filename}:{lineno}: {category.__name__}: {message}") + + # Add the custom warning handler - we need to do that before importing anything to make sure the loggers work well + warnings.showwarning = warning_handler + + +class TrlParser(HfArgumentParser): + """ + A subclass of [`transformers.HfArgumentParser`] designed for parsing command-line arguments with dataclass-backed + configurations, while also supporting configuration file loading and environment variable management. + + Args: + dataclass_types (`DataClassType | Iterable[DataClassType]`, *optional*): + Dataclass types to use for argument parsing. + **kwargs: + Additional keyword arguments passed to the [`transformers.HfArgumentParser`] constructor. + + Examples: + + ```yaml + # config.yaml + env: + VAR1: value1 + arg1: 23 + ``` + + ```python + # main.py + import os + from dataclasses import dataclass + from trl import TrlParser + + + @dataclass + class MyArguments: + arg1: int + arg2: str = "alpha" + + + parser = TrlParser(dataclass_types=[MyArguments]) + training_args = parser.parse_args_and_config() + + print(training_args, os.environ.get("VAR1")) + ``` + + ```bash + $ python main.py --config config.yaml + (MyArguments(arg1=23, arg2='alpha'),) value1 + + $ python main.py --arg1 5 --arg2 beta + (MyArguments(arg1=5, arg2='beta'),) None + ``` + """ + + def __init__( + self, + dataclass_types: DataClassType | Iterable[DataClassType] | None = None, + **kwargs, + ): + # Make sure dataclass_types is an iterable + if dataclass_types is None: + dataclass_types = [] + elif not isinstance(dataclass_types, Iterable): + dataclass_types = [dataclass_types] + + # Check that none of the dataclasses have the "config" field + for dataclass_type in dataclass_types: + if "config" in dataclass_type.__dataclass_fields__: + raise ValueError( + f"Dataclass {dataclass_type.__name__} has a field named 'config'. This field is reserved for the " + f"config file path and should not be used in the dataclass." + ) + + super().__init__(dataclass_types=dataclass_types, **kwargs) + + def parse_args_and_config( + self, + args: Iterable[str] | None = None, + return_remaining_strings: bool = False, + fail_with_unknown_args: bool = True, + separate_remaining_strings: bool = False, + ) -> tuple[DataClass, ...]: + """ + Parse command-line args and config file into instances of the specified dataclass types. + + This method wraps [`transformers.HfArgumentParser.parse_args_into_dataclasses`] and also parses the config file + specified with the `--config` flag. The config file (in YAML format) provides argument values that replace the + default values in the dataclasses. Command line arguments can override values set by the config file. The + method also sets any environment variables specified in the `env` field of the config file. + """ + import yaml + + args = list(args) if args is not None else sys.argv[1:] + if "--config" in args: + # Get the config file path from + config_index = args.index("--config") + args.pop(config_index) # remove the --config flag + config_path = args.pop(config_index) # get the path to the config file + with open(config_path) as yaml_file: + config = yaml.safe_load(yaml_file) + + # Set the environment variables specified in the config file + if "env" in config: + env_vars = config.pop("env", {}) + if not isinstance(env_vars, dict): + raise ValueError("`env` field should be a dict in the YAML file.") + for key, value in env_vars.items(): + os.environ[key] = str(value) + + # Set the defaults from the config values + config_remaining_strings = self.set_defaults_with_config(**config) + else: + config_remaining_strings = [] + + # Parse the arguments from the command line + output = self.parse_args_into_dataclasses(args=args, return_remaining_strings=return_remaining_strings) + + # Merge remaining strings from the config file with the remaining strings from the command line + if return_remaining_strings: + args_remaining_strings = output[-1] + if separate_remaining_strings: + return output[:-1] + (config_remaining_strings, args_remaining_strings) + return output[:-1] + (config_remaining_strings + args_remaining_strings,) + elif fail_with_unknown_args and config_remaining_strings: + raise ValueError( + f"Unknown arguments from config file: {config_remaining_strings}. Please remove them, add them to the " + "dataclass, or set `fail_with_unknown_args=False`." + ) + else: + return output + + def set_defaults_with_config(self, **kwargs) -> list[str]: + """ + Overrides the parser's default values with those provided via keyword arguments, including for subparsers. + + Any argument with an updated default will also be marked as not required if it was previously required. + + Returns a list of strings that were not consumed by the parser. + """ + + def apply_defaults(parser, kw): + used_keys = set() + for action in parser._actions: + # Handle subparsers recursively + if isinstance(action, argparse._SubParsersAction): + for subparser in action.choices.values(): + used_keys.update(apply_defaults(subparser, kw)) + elif action.dest in kw: + action.default = kw[action.dest] + action.required = False + used_keys.add(action.dest) + return used_keys + + used_keys = apply_defaults(self, kwargs) + # Remaining args not consumed by the parser + remaining = [ + item for key, value in kwargs.items() if key not in used_keys for item in (f"--{key}", str(value)) + ] + return remaining + + +def get_git_commit_hash(package_name): + try: + # Import the package to locate its path + package = importlib.import_module(package_name) + # Get the path to the package using inspect + package_path = os.path.dirname(inspect.getfile(package)) + + # Navigate up to the Git repository root if the package is inside a subdirectory + git_repo_path = os.path.abspath(os.path.join(package_path, "..")) + git_dir = os.path.join(git_repo_path, ".git") + + if os.path.isdir(git_dir): + # Run the git command to get the current commit hash + commit_hash = ( + subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=git_repo_path).strip().decode("utf-8") + ) + return commit_hash + else: + return None + except Exception as e: + return f"Error: {str(e)}" + + +def get_dataset(mixture_config: DatasetMixtureConfig) -> "DatasetDict": + """ + Load a mixture of datasets based on the configuration. + + Args: + mixture_config ([`DatasetMixtureConfig`]): + Script arguments containing dataset configuration. + + Returns: + [`~datasets.DatasetDict`]: + Combined dataset(s) from the mixture configuration, with optional train/test split if `test_split_size` is + set. + + Example: + ```python + from trl import DatasetMixtureConfig, get_dataset + from trl.scripts.utils import DatasetConfig + + mixture_config = DatasetMixtureConfig(datasets=[DatasetConfig(path="trl-lib/tldr")]) + dataset = get_dataset(mixture_config) + print(dataset) + ``` + + ``` + DatasetDict({ + train: Dataset({ + features: ['prompt', 'completion'], + num_rows: 116722 + }) + }) + ``` + """ + import datasets + + logger.info(f"Creating dataset mixture with {len(mixture_config.datasets)} datasets") + datasets_list = [] + for dataset_config in mixture_config.datasets: + logger.info(f"Loading dataset for mixture: {dataset_config.path} (config name: {dataset_config.name})") + dataset = datasets.load_dataset( + path=dataset_config.path, + name=dataset_config.name, + data_dir=dataset_config.data_dir, + data_files=dataset_config.data_files, + split=dataset_config.split, + streaming=mixture_config.streaming, + ) + if dataset_config.columns is not None: + dataset = dataset.select_columns(dataset_config.columns) + datasets_list.append(dataset) + + if datasets_list: + combined_dataset = datasets.concatenate_datasets(datasets_list) + if isinstance(combined_dataset, datasets.Dataset): # IterableDataset does not have a length + logger.info(f"Created dataset mixture with {len(combined_dataset)} examples") + + if mixture_config.test_split_size is not None: + logger.info(f"Splitting dataset into train and test sets with test size: {mixture_config.test_split_size}") + combined_dataset = combined_dataset.train_test_split(test_size=mixture_config.test_split_size) + return combined_dataset + else: + return datasets.DatasetDict({"train": combined_dataset}) + else: + raise ValueError("No datasets were loaded from the mixture configuration") diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/vllm_serve.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/vllm_serve.py new file mode 100644 index 0000000000000000000000000000000000000000..ccf182eeaacfbc498b3fbcd5c455a3e93be16536 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/scripts/vllm_serve.py @@ -0,0 +1,1220 @@ +# Copyright 2020-2026 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 argparse +import base64 +import json +import logging +import math +import os +from collections.abc import Sequence +from contextlib import asynccontextmanager +from dataclasses import dataclass, field +from io import BytesIO +from itertools import chain +from multiprocessing import Pipe, Process +from multiprocessing.connection import Connection + + +# We use CUDA with multiprocessing, so we must use the 'spawn' start method. Otherwise, we will get the following +# error: RuntimeError: Cannot re-initialize CUDA in forked subprocess. To use CUDA with multiprocessing, you must use +# the 'spawn' start method +os.environ["VLLM_WORKER_MULTIPROC_METHOD"] = "spawn" + + +class WeightSyncWorkerExtension: + """ + A vLLM worker extension that enables weight synchronization between a client and multiple server workers. + + This worker uses a `StatelessProcessGroup` to establish communication and a `PyNcclCommunicator` or + `ProcessGroupXCCL` to handle efficient GPU-based communication using NCCL. The primary purpose of this class is to + receive updated model weights from a client process and distribute them to all worker processes participating in + model inference. + """ + + # The following attributes are initialized when `init_communicator` method is called. + communicator = None # Communicator for weight updates + client_rank = None # Source rank for broadcasting updated weights + + def init_communicator(self, host: str, port: int, world_size: int, client_device_uuid: str) -> None: + """ + Initializes the weight update communicator using a stateless process group. + + This method creates a `StatelessProcessGroup` that allows external training processes to communicate with vLLM + workers without interfering with the global torch distributed group. + + Args: + host (`str`): + Hostname or IP address of the master node. + port (`int`): + Port number to be used for communication. + world_size (`int`): + Total number of participating processes in the update group. + client_device_uuid (`str`): + UUID of the device of client main process. Used to assert that devices are different from vllm workers + devices. + """ + import torch + import torch.distributed.distributed_c10d as c10d + from transformers import is_torch_xpu_available + from vllm.distributed.device_communicators.pynccl import PyNcclCommunicator + from vllm.distributed.parallel_state import get_world_group + from vllm.distributed.utils import StatelessProcessGroup + + from trl.import_utils import is_vllm_ascend_available + + if is_vllm_ascend_available(): + from vllm_ascend.distributed.device_communicators.pyhccl import PyHcclCommunicator as PyNcclCommunicator + + if self.communicator is not None: + raise RuntimeError("Weight update group already initialized. Call close_communicator first.") + + # TODO: will remove after torch xpu 2.9 support uuid in get_device_properties + if torch.cuda.is_available() or ( + is_torch_xpu_available() and hasattr(torch.xpu.get_device_properties(self.device), "uuid") + ): + accelerator_module = torch.xpu if is_torch_xpu_available() else torch.cuda + if client_device_uuid == str(accelerator_module.get_device_properties(self.device).uuid): + raise RuntimeError( + f"Attempting to use the same CUDA device (UUID: {client_device_uuid}) for multiple distinct " + "roles/ranks within the same communicator. This setup is unsupported and will likely lead to program " + "hangs or incorrect behavior. Ensure that trainer is using different devices than vLLM server." + ) + # Get the rank of the current worker in the global world group. + rank = get_world_group().rank + + if is_torch_xpu_available(): + store = torch.distributed.TCPStore(host_name=host, port=port, world_size=world_size, is_master=(rank == 0)) + prefixed_store = c10d.PrefixStore("client2server", store) + xccl_options = c10d.ProcessGroupXCCL.Options() + pg = c10d.ProcessGroupXCCL( + store=prefixed_store, + rank=rank, + size=world_size, + options=xccl_options, + ) + self.communicator = pg + else: + # Create a stateless process group to manage communication between training processes and vLLM workers. + # Initialize the NCCL-based communicator for weight synchronization. + pg = StatelessProcessGroup.create(host=host, port=port, rank=rank, world_size=world_size) + self.communicator = PyNcclCommunicator(pg, device=self.device) + + # The client process that sends updated weights has the highest rank (world_size - 1). + self.client_rank = world_size - 1 + + def update_named_param(self, name: str, dtype: str, shape: Sequence[int]) -> None: + """ + Receives updated weights from the client process and updates the named parameter in the model. + + Args: + name (`str`): + Name of the weight tensor being updated. + dtype (`str`): + Data type of the weight tensor as a string (e.g., `"torch.float32"`). + shape (`Sequence[int]`): + Shape of the weight tensor. + """ + import torch + from transformers import is_torch_xpu_available + + if self.communicator is None: + raise RuntimeError("Communicator not initialized. Call `init_communicator` first.") + + dtype = getattr(torch, dtype.split(".")[-1]) + # Allocate memory for the incoming weight tensor on the correct device. + weight = torch.empty(shape, dtype=dtype, device=self.device) + + if is_torch_xpu_available(): + # Use XCCL to broadcast the updated weights from the client (src) to all workers. + self.communicator.broadcast(weight, root=self.client_rank) + self.communicator.barrier() + else: + # Use NCCL to broadcast the updated weights from the client (src) to all workers. + self.communicator.broadcast(weight, src=self.client_rank) + self.communicator.group.barrier() + + # Load the received weights into the model. + self.model_runner.model.load_weights(weights=[(name, weight)]) + + def close_communicator(self) -> None: + """ + Closes the communicator when weight synchronization is no longer needed. + + This method deletes the NCCL communicator to release associated resources. + """ + + if self.communicator is not None: + del self.communicator + self.communicator = None # Ensure attribute is reset to None + self.client_rank = None # Ensure attribute is reset to None + + +@dataclass +class ScriptArguments: + r""" + Arguments for the script. + + Args: + model (`str`): + Model name or path to load the model from. + revision (`str`, *optional*): + Revision to use for the model. If not specified, the default branch will be used. + tensor_parallel_size (`int`, *optional*, defaults to `1`): + Number of tensor parallel workers to use. + data_parallel_size (`int`, *optional*, defaults to `1`): + Number of data parallel workers to use. For dense models, keep this at 1. Starting from vLLM `0.14.0`, + setting this above `1` for dense models is no longer supported/useful and will error out (see vLLM PR + #30739). + host (`str`, *optional*, defaults to `"0.0.0.0"`): + Host address to run the server on. + port (`int`, *optional*, defaults to `8000`): + Port to run the server on. + gpu_memory_utilization (`float`, *optional*, defaults to `0.9`): + Ratio (between 0 and 1) of GPU memory to reserve for the model weights, activations, and KV cache on the + device dedicated to generation powered by vLLM. Higher values will increase the KV cache size and thus + improve the model's throughput. However, if the value is too high, it may cause out-of-memory (OOM) errors + during initialization. + dtype (`str`, *optional*, defaults to `"auto"`): + Data type to use for vLLM generation. If set to `"auto"`, the data type will be automatically determined + based on the model configuration. Find the supported values in the vLLM documentation. + max_model_len (`int`, *optional*): + If set, the `max_model_len` to use for vLLM. This can be useful when running with reduced + `vllm_gpu_memory_utilization`, leading to a reduced KV cache size. If not set, vLLM will use the model + context size, which might be much larger than the KV cache, leading to inefficiencies. + enable_prefix_caching (`bool`, *optional*): + Whether to enable prefix caching in vLLM. If set to `True`, ensure that the model and the hardware support + this feature. + enforce_eager (`bool`, *optional*, defaults to `False`): + Whether to enforce eager execution. If set to `True`, we will disable CUDA graph and always execute the + model in eager mode. If `False` (default behavior), we will use CUDA graph and eager execution in hybrid. + vllm_model_impl (`str`, *optional*, defaults to `"vllm"`): + Model implementation to use for vLLM. Must be one of `"transformers"` or `"vllm"`. `"transformers"`: Use + the `transformers` backend for model implementation. `"vllm"`: Use the `vllm` library for model + implementation. + kv_cache_dtype (`str`, *optional*, defaults to `"auto"`): + Data type to use for KV cache. If set to `"auto"`, the dtype will default to the model data type. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to trust remote code when loading models. Set to `True` to allow executing code from model + repositories. This is required for some custom models but introduces security risks. + log_level (`str`, *optional*, defaults to `"info"`): + Log level for uvicorn. Possible choices: `"critical"`, `"error"`, `"warning"`, `"info"`, `"debug"`, + `"trace"`. + distributed_executor_backend (`str` or `None`, *optional*): + Distributed executor backend for vLLM. Set to `"ray"` to distribute tensor parallel workers across multiple + nodes via a Ray cluster. Required when `tensor_parallel_size` exceeds the number of local GPUs. If not set, + vLLM defaults to the multiproc backend (single-node only). + speculative_config (`str`, *optional*): + JSON string for vLLM speculative decoding config, forwarded to `LLM(speculative_config=...)`. When unset, + speculative decoding is disabled. Example: `'{"method": "qwen3_next_mtp", "num_speculative_tokens": 5}'`. + """ + + model: str = field( + metadata={"help": "Model name or path to load the model from."}, + ) + revision: str | None = field( + default=None, + metadata={"help": "Revision to use for the model. If not specified, the default branch will be used."}, + ) + tensor_parallel_size: int = field( + default=1, + metadata={"help": "Number of tensor parallel workers to use."}, + ) + data_parallel_size: int = field( + default=1, + metadata={ + "help": "Number of data parallel workers to use. For dense models, keep this at 1. Starting from vLLM " + "`0.14.0`, setting this above `1` for dense models is no longer supported/useful and will error out (see " + "vLLM PR #30739)." + }, + ) + host: str = field( + default="0.0.0.0", + metadata={"help": "Host address to run the server on."}, + ) + port: int = field( + default=8000, + metadata={"help": "Port to run the server on."}, + ) + gpu_memory_utilization: float = field( + default=0.9, + metadata={ + "help": "Ratio (between 0 and 1) of GPU memory to reserve for the model weights, activations, and KV " + "cache on the device dedicated to generation powered by vLLM. Higher values will increase the KV cache " + "size and thus improve the model's throughput. However, if the value is too high, it may cause " + "out-of-memory (OOM) errors during initialization." + }, + ) + dtype: str = field( + default="auto", + metadata={ + "help": "Data type to use for vLLM generation. If set to 'auto', the data type will be automatically " + "determined based on the model configuration. Find the supported values in the vLLM documentation." + }, + ) + max_model_len: int | None = field( + default=None, + metadata={ + "help": "If set, the `max_model_len` to use for vLLM. This can be useful when running with reduced " + "`vllm_gpu_memory_utilization`, leading to a reduced KV cache size. If not set, vLLM will use the model " + "context size, which might be much larger than the KV cache, leading to inefficiencies." + }, + ) + enable_prefix_caching: bool | None = field( + default=None, + metadata={ + "help": "Whether to enable prefix caching in vLLM. If set to `True`, ensure that the model and the " + "hardware support this feature." + }, + ) + enforce_eager: bool | None = field( + default=False, + metadata={ + "help": "Whether to enforce eager execution. If set to `True`, we will disable CUDA graph and always " + "execute the model in eager mode. If `False` (default behavior), we will use CUDA graph and eager " + "execution in hybrid." + }, + ) + kv_cache_dtype: str = field( + default="auto", + metadata={ + "help": "Data type to use for KV cache. If set to 'auto', the dtype will default to the model data type." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to trust remote code when loading models. Set to True to allow executing code from model " + "repositories. This is required for some custom models but introduces security risks." + }, + ) + log_level: str = field( + default="info", + metadata={ + "help": "Log level for uvicorn. Possible choices: 'critical', 'error', 'warning', 'info', 'debug', " + "'trace'." + }, + ) + vllm_model_impl: str = field( + default="vllm", + metadata={ + "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: " + "Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for " + "model implementation." + }, + ) + distributed_executor_backend: str | None = field( + default=None, + metadata={ + "help": "Distributed executor backend for vLLM. When set to 'ray', vLLM uses Ray to distribute tensor " + "parallel workers across multiple nodes. Required when tensor_parallel_size exceeds the number of local " + "GPUs. If not set, vLLM defaults to the multiproc backend (single-node only)." + }, + ) + speculative_config: str | None = field( + default=None, + metadata={ + "help": "JSON string for vLLM speculative decoding config. " + 'Example: \'{"method": "qwen3_next_mtp", "num_speculative_tokens": 5}\'' + }, + ) + + +def llm_worker( + script_args: ScriptArguments, data_parallel_rank: int, master_port: int, connection: Connection +) -> None: + from vllm import LLM + + # Set required environment variables for DP to work with vLLM + os.environ["VLLM_DP_RANK"] = str(data_parallel_rank) + os.environ["VLLM_DP_RANK_LOCAL"] = str(data_parallel_rank) + os.environ["VLLM_DP_SIZE"] = str(script_args.data_parallel_size) + os.environ["VLLM_DP_MASTER_PORT"] = str(master_port) + + llm = LLM( + model=script_args.model, + revision=script_args.revision, + tensor_parallel_size=script_args.tensor_parallel_size, + gpu_memory_utilization=script_args.gpu_memory_utilization, + enforce_eager=script_args.enforce_eager, + dtype=script_args.dtype, + # Automatic Prefix Caching caches the KV cache of existing queries, so that a new query can + # directly reuse the KV cache if it shares the same prefix with one of the existing queries. + # This is particularly useful here because we generate completions from the same prompts. + enable_prefix_caching=script_args.enable_prefix_caching, + kv_cache_dtype=script_args.kv_cache_dtype, + max_model_len=script_args.max_model_len, + worker_extension_cls="trl.scripts.vllm_serve.WeightSyncWorkerExtension", + trust_remote_code=script_args.trust_remote_code, + model_impl=script_args.vllm_model_impl, + distributed_executor_backend=script_args.distributed_executor_backend, + # Important so temperature scaling/logit tweaking affects the TIS log probs + logprobs_mode="processed_logprobs", + speculative_config=json.loads(script_args.speculative_config) if script_args.speculative_config else None, + ) + + # Send ready signal to parent process + connection.send({"status": "ready"}) + + while True: + # Wait for commands from the parent process + try: + command = connection.recv() + except KeyboardInterrupt: + llm.collective_rpc(method="close_communicator") + break + + # Handle commands + if command["type"] in ["call", "fire_and_forget"]: + method_name = command["method"] + args, kwargs = command.get("args", ()), command.get("kwargs", {}) + method = getattr(llm, method_name) + result = method(*args, **kwargs) + if command["type"] == "call": + connection.send(result) + elif command["type"] == "shutdown": + break + + +def chunk_list(lst: list, n: int) -> list[list]: + """ + Split list `lst` into `n` evenly distributed sublists. + + Example: + ```python + >>> chunk_list([1, 2, 3, 4, 5, 6], 2) + [[1, 2, 3], [4, 5, 6]] + + >>> chunk_list([1, 2, 3, 4, 5, 6], 4) + [[1, 2], [3, 4], [5], [6]] + + >>> chunk_list([1, 2, 3, 4, 5, 6], 8) + [[1], [2], [3], [4], [5], [6], [], []] + ``` + """ + k, r = divmod(len(lst), n) + return [lst[i * k + min(i, r) : (i + 1) * k + min(i + 1, r)] for i in range(n)] + + +def main(script_args: ScriptArguments): + import asyncio + + from transformers import is_vision_available + + from trl.generation.vllm_generation import extract_logprobs + from trl.import_utils import ( + is_fastapi_available, + is_pydantic_available, + is_uvicorn_available, + is_vllm_available, + ) + + if not is_fastapi_available(): + raise ImportError( + "FastAPI is required to run the vLLM serve script. Please install it using `pip install fastapi`." + ) + + if not is_pydantic_available(): + raise ImportError( + "Pydantic is required to run the vLLM serve script. Please install it using `pip install pydantic`." + ) + + if not is_uvicorn_available(): + raise ImportError( + "Uvicorn is required to run the vLLM serve script. Please install it using `pip install uvicorn`." + ) + + if not is_vllm_available(): + raise ImportError("vLLM is required to run the vLLM serve script. Please install it using `pip install vllm`.") + + import uvicorn + from fastapi import FastAPI + from pydantic import BaseModel + from vllm import SamplingParams + from vllm.sampling_params import StructuredOutputsParams + from vllm.utils.network_utils import get_open_port + + if is_vision_available(): + from PIL import Image + + logger = logging.getLogger(__name__) + + # Spawn dp workers, and setup pipes for communication + master_port = get_open_port() + connections = [] + processes = [] + for data_parallel_rank in range(script_args.data_parallel_size): + parent_connection, child_connection = Pipe() + process = Process(target=llm_worker, args=(script_args, data_parallel_rank, master_port, child_connection)) + process.start() + connections.append(parent_connection) + processes.append(process) + + @asynccontextmanager + async def lifespan(app: FastAPI): + # Wait for all workers to send "ready" + ready_connections = set() + while len(ready_connections) < script_args.data_parallel_size: + for connection in connections: + msg = connection.recv() + if isinstance(msg, dict) and msg.get("status") == "ready": + ready_connections.add(connection) + + # Start the logprob request batcher background task + batcher_task = asyncio.create_task(_logprob_batcher()) + + yield + + batcher_task.cancel() + + # Wait for processes to terminate + for process in processes: + process.join(timeout=10) # Wait for 10 seconds for the process to terminate + if process.is_alive(): + logger.warning(f"Process {process} is still alive after 10 seconds, attempting to terminate...") + process.terminate() + process.join() # ensure process termination after calling terminate() + + app = FastAPI(lifespan=lifespan) + + # Define the endpoints for the model server + @app.get("/health/") + async def health(): + """ + Health check endpoint to verify that the server is running. + """ + return {"status": "ok"} + + @app.get("/get_world_size/") + async def get_world_size(): + """ + Retrieves the world size of the LLM engine, which is `tensor_parallel_size * data_parallel_size`. + + Returns: + `dict`: + A dictionary containing the world size. + + Example response: + ```json + {"world_size": 8} + ``` + """ + return {"world_size": script_args.tensor_parallel_size * script_args.data_parallel_size} + + class GenerateRequest(BaseModel): + prompts: list[str] | list[list[int]] + images: list[list[str] | None] | None = None + n: int = 1 + repetition_penalty: float = 1.0 + temperature: float = 1.0 + top_p: float = 1.0 + top_k: int = -1 + min_p: float = 0.0 + max_tokens: int = 16 + logprobs: int | None = 0 + structured_outputs_regex: str | None = None + generation_kwargs: dict = field(default_factory=dict) + + class GenerateResponse(BaseModel): + prompt_ids: list[list[int]] + completion_ids: list[list[int]] + logprobs: list[list[list[float | None]]] | None + logprob_token_ids: list[list[list[int]]] | None + + @app.post("/generate/", response_model=GenerateResponse) + async def generate(request: GenerateRequest): + """ + Generates completions for the provided prompts. + + Args: + request (`GenerateRequest`): + - `prompts` (list of `str` or list of list of `int`): A list of prompts. It accepts either text strings + or pre-tokenized token ID lists. When text strings are provided, `images` can optionally be included. + - `images` (list of list of `str` or `None`, *optional*): A list of image lists. Each element is a list + of base64-encoded images for the corresponding prompt, or `None` if no images for that prompt. + - `n` (`int`, *optional*, defaults to `1`): Number of completions to generate for each prompt. + - `repetition_penalty` (`float`, *optional*, defaults to `1.0`): Repetition penalty to apply during + generation. + - `temperature` (`float`, *optional*, defaults to `1.0`): Temperature for sampling. Higher values lead + to more random outputs. + - `top_p` (`float`, *optional*, defaults to `1.0`): Top-p (nucleus) sampling parameter. It controls the + diversity of the generated text. + - `top_k` (`int`, *optional*, defaults to `-1`): Top-k sampling parameter. If set to `-1`, it disables + top-k sampling. + - `min_p` (`float`, *optional*, defaults to `0.0`): Minimum probability threshold for sampling. + - `max_tokens` (`int`, *optional*, defaults to `16`): Maximum number of tokens to generate for each + completion. + - `logprobs` (`int`, *optional*, defaults to `0`): Number of top logprobs to return per token. When 0, + only the sampled token's logprob is returned. When N>0, returns up to N+1 logprobs sorted by + descending probability, because vLLM always includes the sampled token's logprob (which may fall + outside the top-N). + - `structured_outputs_regex` (`str`, *optional*): A regex pattern for structured outputs. If provided, + the model will only generate tokens that match this regex pattern. + - `generation_kwargs` (`dict`, *optional*): Additional generation parameters to pass to the vLLM + `SamplingParams`. This can include parameters like `seed`, `frequency_penalty`, etc. If it contains + keys that conflict with the other parameters, they will override them. + + Returns: + `GenerateResponse`: + - `prompt_ids` (list of list of `int`): A list of lists of token IDs for each input prompt. + - `completion_ids` (list of list of `int`): A list of lists of token IDs for each generated completion. + - `logprobs` (list of list of list of `float`): Per-token logprobs of shape (num_sequences, seq_len, + num_logprobs), sorted by descending probability. + - `logprob_token_ids` (list of list of list of `int`): Token IDs corresponding to each logprob, same + shape as `logprobs`. + + Example request (text prompts): + ```json + {"prompts": ["Hello world", "What is AI?"]} + ``` + + Example request (token IDs): + ```json + {"prompts": [[101, 102], [201, 202]]} + ``` + + Example response: + ```json + { + "prompt_ids": [[101, 102], [201, 202]], + "completion_ids": [[103, 104, 105], [203, 204, 205]], + "logprobs": [[[-0.1], [-0.2], [-0.3]], [[-0.4], [-0.5], [-0.6]]], + "logprob_token_ids": [[[103], [104], [105]], [[203], [204], [205]]] + } + ``` + """ + # Build vLLM-compatible prompt inputs + is_token_ids = request.prompts and isinstance(request.prompts[0], list) + request.images = request.images or [None] * len(request.prompts) + + prompts = [] + for prompt, image_list in zip(request.prompts, request.images, strict=True): + row = {"prompt_token_ids": prompt} if is_token_ids else {"prompt": prompt} + if image_list is not None: + row["multi_modal_data"] = {"image": [Image.open(BytesIO(base64.b64decode(img))) for img in image_list]} + prompts.append(row) + + generation_kwargs = { + "n": request.n, + "repetition_penalty": request.repetition_penalty, + "temperature": request.temperature, + "top_p": request.top_p, + "top_k": request.top_k, + "min_p": request.min_p, + "max_tokens": request.max_tokens, + "logprobs": request.logprobs, + } + generation_kwargs.update(request.generation_kwargs) + + # Structured outputs, if enabled + if request.structured_outputs_regex is not None: + if generation_kwargs.get("structured_outputs") is not None: + logger.warning( + "Both `structured_outputs_regex` and `generation_kwargs['structured_outputs']` are set; " + "`structured_outputs_regex` takes precedence." + ) + generation_kwargs["structured_outputs"] = StructuredOutputsParams(regex=request.structured_outputs_regex) + elif isinstance(structured_outputs_kwargs := generation_kwargs.get("structured_outputs"), dict): + generation_kwargs["structured_outputs"] = StructuredOutputsParams(**structured_outputs_kwargs) + sampling_params = SamplingParams(**generation_kwargs) + + # Evenly distribute prompts across DP ranks + chunked_prompts = chunk_list(prompts, script_args.data_parallel_size) + + # Send the prompts to each worker + for connection, prompts in zip(connections, chunked_prompts, strict=True): + # When the number of prompts is less than data_parallel_size, some workers will receive empty prompts. + # However, vLLM requires that we always send at least one prompt. So we send a placeholder prompt to comply + # with vLLM's requirement, and we later ignore the result. + if not prompts: + prompts = [""] + kwargs = {"prompts": prompts, "sampling_params": sampling_params} + connection.send({"type": "call", "method": "generate", "kwargs": kwargs}) + + # Receive results + all_outputs = [connection.recv() for connection in connections] + + # Handle empty prompts (see above) + all_outputs = [output for output, prompts in zip(all_outputs, chunked_prompts, strict=True) if prompts] + + # Flatten and combine all results + all_outputs = list(chain.from_iterable(all_outputs)) # from list of list to single list + prompt_ids = [output.prompt_token_ids for output in all_outputs] + completion_ids = [list(output.token_ids) for outputs in all_outputs for output in outputs.outputs] + logprobs, logprob_token_ids = extract_logprobs(all_outputs) + + return { + "prompt_ids": prompt_ids, + "completion_ids": completion_ids, + "logprobs": logprobs, + "logprob_token_ids": logprob_token_ids, + } + + class SequenceLogprobsRequest(BaseModel): + sequences: list[list[int]] + prompt_lengths: list[int] + top_logprobs: int = 100 + temperature: float = 1.0 + response_format: str = "json" # "json" (legacy) or "binary" (base64 numpy arrays) + + class SequenceLogprobsResponse(BaseModel): + logprobs: list[list[list[float | None]]] | None = None + logprob_token_ids: list[list[list[int]]] | None = None + # Binary format fields (base64-encoded numpy arrays) + logprobs_b64: str | None = None + token_ids_b64: str | None = None + actual_logprobs_b64: str | None = None + actual_token_ids_b64: str | None = None + shape: list[int] | None = None # [batch_size, max_completion_len, top_logprobs] + completion_lengths: list[int] | None = None # actual completion length per sample + + def _run_prompt_logprobs(prompts, sampling_params): + """Send prompts to DP workers and collect outputs.""" + chunked_prompts = chunk_list(prompts, script_args.data_parallel_size) + for connection, chunk in zip(connections, chunked_prompts, strict=True): + if not chunk: + chunk = [{"prompt_token_ids": [0]}] + kwargs = {"prompts": chunk, "sampling_params": sampling_params} + connection.send({"type": "call", "method": "generate", "kwargs": kwargs}) + all_outputs = [connection.recv() for connection in connections] + all_outputs = [output for output, chunk in zip(all_outputs, chunked_prompts, strict=True) if chunk] + return list(chain.from_iterable(all_outputs)) + + # ── Request batching for get_sequence_logprobs ── + # Collects concurrent requests into batches and dispatches them together so that + # all DP workers stay busy. Without this, async endpoint handlers block the event + # loop during pipe I/O, serializing requests and leaving DP workers idle. + _logprob_queue: asyncio.Queue = asyncio.Queue() + + # Maximum time (seconds) to wait for more requests before dispatching a batch. + _BATCH_WAIT_S = 0.005 # 5ms - short enough to not add much latency when lightly loaded + # Maximum number of HTTP requests to collect per batcher cycle + _MAX_BATCH_REQUESTS = max(script_args.data_parallel_size * 4, 16) + # Maximum total tokens per batch. prompt_logprobs materializes full-vocab logits + # during the forward pass, so each worker can safely handle ~1 max-length sequence. + # Budget = max_model_len * dp_size gives ~1 sequence per worker at max length. + _max_model_len = script_args.max_model_len or 8192 + _MAX_BATCH_TOKENS = _max_model_len * script_args.data_parallel_size + + async def _logprob_batcher(): + """Background task that continuously drains the queue, batches requests, and dispatches.""" + loop = asyncio.get_running_loop() + + while True: + batch = [] + try: + # Wait for the first request + batch_tokens = 0 + item = await _logprob_queue.get() + batch.append(item) + # Count tokens in this item's sequences + for prompt in item[0]: + batch_tokens += len(prompt.get("prompt_token_ids", [])) + + # Collect more requests up to batch limit, timeout, or token budget + deadline = loop.time() + _BATCH_WAIT_S + while len(batch) < _MAX_BATCH_REQUESTS and batch_tokens < _MAX_BATCH_TOKENS: + remaining = deadline - loop.time() + if remaining <= 0: + break + try: + item = await asyncio.wait_for(_logprob_queue.get(), timeout=remaining) + # Check if adding this item would exceed the token budget + item_tokens = sum(len(p.get("prompt_token_ids", [])) for p in item[0]) + if batch_tokens + item_tokens > _MAX_BATCH_TOKENS and len(batch) > 0: + # Put it back and dispatch current batch + await _logprob_queue.put(item) + break + batch.append(item) + batch_tokens += item_tokens + except asyncio.TimeoutError: + break + + # batch is a list of (prompts, prompt_lengths, top_logprobs, temperature, response_format, future) + # All items in a batch must share the same (top_logprobs, temperature) pair. + # Group by those execution parameters to handle mixed requests. + groups = {} + for prompts, prompt_lengths, top_logprobs, temperature, response_format, future in batch: + key = (top_logprobs, temperature) + if key not in groups: + groups[key] = [] + groups[key].append((prompts, prompt_lengths, response_format, future)) + + for (top_logprobs, temperature), items in groups.items(): + # Merge all sequences into a single batch + all_prompts = [] + all_prompt_lengths = [] + offsets = [] # (start_idx, count) per original request + for prompts, prompt_lengths, _response_format, _future in items: + start = len(all_prompts) + all_prompts.extend(prompts) + all_prompt_lengths.extend(prompt_lengths) + offsets.append((start, len(prompts))) + + sampling_params = SamplingParams( + max_tokens=1, + temperature=temperature, + prompt_logprobs=top_logprobs, + ) + + # Dispatch to workers in a thread to avoid blocking the event loop + try: + all_outputs = await loop.run_in_executor( + None, _run_prompt_logprobs, all_prompts, sampling_params + ) + + # Split results back to individual requests + for (start, count), (_, prompt_lengths, response_format, future) in zip( + offsets, items, strict=True + ): + outputs_slice = all_outputs[start : start + count] + if not future.done(): + future.set_result((outputs_slice, prompt_lengths, top_logprobs, response_format)) + except Exception as e: + # Signal error to all waiting requests in this execution-parameter group + for *_, future in items: + if not future.done(): + future.set_exception(e) + except Exception as e: + # Prevent killing the batcher task — signal error to all unfulfilled futures + for *_, future in batch: + if not future.done(): + future.set_exception(e) + + def _format_logprob_response(all_outputs, prompt_lengths, top_k, response_format): + """Format vLLM outputs into the response dict (runs in any thread).""" + import numpy as np + + batch_size = len(all_outputs) + use_binary = response_format == "binary" + + if use_binary: + from starlette.responses import Response + + comp_lengths = [] + for output, prompt_length in zip(all_outputs, prompt_lengths, strict=True): + prompt_lps = output.prompt_logprobs + if prompt_lps is None: + raise ValueError("prompt_logprobs is None.") + comp_lengths.append(len(prompt_lps) - prompt_length) + + max_comp_len = max(comp_lengths) if comp_lengths else 0 + + # logprobs_arr / token_ids_arr: teacher's sorted top-k logprobs + token ids (for forward KL). + # actual_logprobs_arr / actual_token_ids_arr: actual token's teacher logprob (for reverse KL). + logprobs_arr = np.full((batch_size, max_comp_len, top_k), float("-inf"), dtype=np.float32) + token_ids_arr = np.zeros((batch_size, max_comp_len, top_k), dtype=np.int32) + actual_logprobs_arr = np.full((batch_size, max_comp_len, 1), float("-inf"), dtype=np.float32) + actual_token_ids_arr = np.zeros((batch_size, max_comp_len, 1), dtype=np.int32) + + for i, (output, prompt_length) in enumerate(zip(all_outputs, prompt_lengths, strict=True)): + prompt_lps = output.prompt_logprobs + seq_tokens = output.prompt_token_ids + if comp_lengths[i] == 0: + continue + + for pos in range(prompt_length, len(prompt_lps)): + lp = prompt_lps[pos] + if lp is None: + continue + t = pos - prompt_length + actual_token = seq_tokens[pos] + + # Actual token's logprob (for reverse KL) + if actual_token in lp: + val = lp[actual_token].logprob + if not math.isnan(val): + actual_logprobs_arr[i, t, 0] = val + actual_token_ids_arr[i, t, 0] = actual_token + + # Teacher's top-k logprobs (for forward KL) + if top_k == 1: + # Fast path: find rank-1 directly instead of sorting + for token_id, logprob_obj in lp.items(): + if logprob_obj.rank == 1: + val = logprob_obj.logprob + if not math.isnan(val): + logprobs_arr[i, t, 0] = val + token_ids_arr[i, t, 0] = token_id + break + else: + sorted_items = sorted(lp.items(), key=lambda x: x[1].rank) + for k_idx, (token_id, logprob_obj) in enumerate(sorted_items[:top_k]): + val = logprob_obj.logprob + if not math.isnan(val): + logprobs_arr[i, t, k_idx] = val + token_ids_arr[i, t, k_idx] = token_id + + payload = { + "logprobs_b64": base64.b64encode(logprobs_arr.tobytes()).decode("ascii"), + "token_ids_b64": base64.b64encode(token_ids_arr.tobytes()).decode("ascii"), + "actual_logprobs_b64": base64.b64encode(actual_logprobs_arr.tobytes()).decode("ascii"), + "actual_token_ids_b64": base64.b64encode(actual_token_ids_arr.tobytes()).decode("ascii"), + "shape": [batch_size, max_comp_len, top_k], + "completion_lengths": comp_lengths, + } + + try: + import orjson + + return Response(content=orjson.dumps(payload), media_type="application/json") + except ImportError: + return payload + else: + all_logprobs = [] + all_token_ids = [] + for output, prompt_length in zip(all_outputs, prompt_lengths, strict=True): + prompt_lps = output.prompt_logprobs + if prompt_lps is None: + raise ValueError("prompt_logprobs is None.") + seq_logprobs = [] + seq_token_ids = [] + for pos in range(prompt_length, len(prompt_lps)): + lp = prompt_lps[pos] + if lp is None: + seq_logprobs.append([]) + seq_token_ids.append([]) + continue + sorted_items = sorted(lp.items(), key=lambda x: x[1].rank) + seq_token_ids.append([token_id for token_id, _ in sorted_items]) + seq_logprobs.append( + [None if math.isnan(item.logprob) else item.logprob for _, item in sorted_items] + ) + all_logprobs.append(seq_logprobs) + all_token_ids.append(seq_token_ids) + return {"logprobs": all_logprobs, "logprob_token_ids": all_token_ids} + + @app.post("/get_sequence_logprobs/", response_model=SequenceLogprobsResponse) + async def get_sequence_logprobs(request: SequenceLogprobsRequest): + """ + Computes teacher logprobs for existing token sequences without generating new tokens. + + Concurrent requests are automatically batched and dispatched together to maximize GPU utilization across DP + workers. This avoids the event-loop-blocking problem where synchronous pipe I/O serializes requests despite + having multiple DP workers. + + Args: + request (`SequenceLogprobsRequest`): + - `sequences` (list of list of `int`): Full token sequences (prompt + completion) per sample. + - `prompt_lengths` (list of `int`): Number of prompt tokens per sequence; completion logprobs start + after each prompt. + - `top_logprobs` (`int`, *optional*, defaults to `100`): Number of top teacher logprobs to return per + completion position (sorted by vLLM rank). + - `temperature` (`float`, *optional*, defaults to `1.0`): Sampling temperature passed to vLLM for + logprob computation. + - `response_format` (`str`, *optional*, defaults to `"json"`): Either `"json"` (nested lists, + backward-compatible) or `"binary"` (base64-encoded numpy arrays for fast serialization). + + Returns: + `SequenceLogprobsResponse` or Starlette `Response`: + When `response_format` is `"json"`, a JSON object with: + - `logprobs` (list of list of list of `float` or `None`): Top-k teacher logprobs per completion token. + - `logprob_token_ids` (list of list of list of `int`): Token IDs aligned with `logprobs`. + When `response_format` is `"binary"`, a JSON response (Starlette `Response` if `orjson` is installed) + whose body is a JSON object with base64-encoded float32/int32 arrays: `logprobs_b64`, `token_ids_b64`, + `actual_logprobs_b64`, `actual_token_ids_b64`, plus `shape` (`list[int]`, `[batch_size, + max_completion_len, top_k]`) and `completion_lengths` (`list[int]`). + """ + if len(request.sequences) != len(request.prompt_lengths): + raise ValueError("sequences and prompt_lengths must have the same length.") + + for i, (seq, pl) in enumerate(zip(request.sequences, request.prompt_lengths, strict=True)): + if pl < 0 or pl > len(seq): + raise ValueError( + f"Sequence {i} has prompt_length={pl} which is out of range [0, {len(seq)}]. " + f"prompt_length must be between 0 and the sequence length inclusive." + ) + + # Validate sequence lengths against max_model_len to prevent worker OOM crashes + if _max_model_len: + for i, seq in enumerate(request.sequences): + if len(seq) > _max_model_len: + raise ValueError( + f"Sequence {i} has length {len(seq)} which exceeds max_model_len={_max_model_len}. " + f"Truncate sequences or increase --max-model-len." + ) + + prompts = [{"prompt_token_ids": seq} for seq in request.sequences] + + # Submit to the batching queue and await result + loop = asyncio.get_running_loop() + future = loop.create_future() + await _logprob_queue.put( + ( + prompts, + list(request.prompt_lengths), + request.top_logprobs, + request.temperature, + request.response_format, + future, + ) + ) + + # Wait for the batcher to process our request + all_outputs, prompt_lengths, top_k, response_format = await future + + return await loop.run_in_executor( + None, _format_logprob_response, all_outputs, prompt_lengths, top_k, response_format + ) + + class ChatRequest(BaseModel): + messages: list[list[dict]] + n: int = 1 + repetition_penalty: float = 1.0 + temperature: float = 1.0 + top_p: float = 1.0 + top_k: int = -1 + min_p: float = 0.0 + max_tokens: int = 16 + logprobs: int | None = 0 + structured_outputs_regex: str | None = None + generation_kwargs: dict = field(default_factory=dict) + chat_template_kwargs: dict = field(default_factory=dict) + tools: list | None = None + + class ChatResponse(BaseModel): + prompt_ids: list[list[int]] + completion_ids: list[list[int]] + logprobs: list[list[list[float | None]]] | None + logprob_token_ids: list[list[list[int]]] | None + + @app.post("/chat/", response_model=ChatResponse) + async def chat(request: ChatRequest): + """ + Generates completions for the provided chat messages. + + Args: + request (`ChatRequest`): + - `messages` (list of `dict`): A list of messages (dicts with "role" and "content" keys) for the model + to generate completions. + - `n` (`int`, *optional*, defaults to `1`): Number of completions to generate for each prompt. + - `repetition_penalty` (`float`, *optional*, defaults to `1.0`): Repetition penalty to apply during + generation. + - `temperature` (`float`, *optional*, defaults to `1.0`): Temperature for sampling. Higher values lead + to more random outputs. + - `top_p` (`float`, *optional*, defaults to `1.0`): Top-p (nucleus) sampling parameter. It controls the + diversity of the generated text. + - `top_k` (`int`, *optional*, defaults to `-1`): Top-k sampling parameter. If set to `-1`, it disables + top-k sampling. + - `min_p` (`float`, *optional*, defaults to `0.0`): Minimum probability threshold for sampling. + - `max_tokens` (`int`, *optional*, defaults to `16`): Maximum number of tokens to generate for each + completion. + - `logprobs` (`int`, *optional*, defaults to `0`): Number of top logprobs to return per token. When 0, + only the sampled token's logprob is returned. When N>0, returns up to N+1 logprobs sorted by + descending probability, because vLLM always includes the sampled token's logprob (which may fall + outside the top-N). + - `structured_outputs_regex` (`str`, *optional*): A regex pattern for structured outputs. If provided, + the model will only generate tokens that match this regex pattern. + - `generation_kwargs` (`dict`, *optional*): Additional generation parameters to pass to the vLLM + `SamplingParams`. This can include parameters like `seed`, `frequency_penalty`, etc. If it contains + keys that conflict with the other parameters, they will override them. + - `chat_template_kwargs` (`dict`, *optional*): Additional keyword arguments to pass to the chat + template. + + Returns: + `ChatResponse`: + - `prompt_ids` (list of list of `int`): A list of lists of token IDs for each input prompt. + - `completion_ids` (list of list of `int`): A list of lists of token IDs for each generated completion. + - `logprobs` (list of list of list of `float`): Per-token logprobs of shape (num_sequences, seq_len, + num_logprobs), sorted by descending probability. + - `logprob_token_ids` (list of list of list of `int`): Token IDs corresponding to each logprob, same + shape as `logprobs`. + + Example request: + ```bash + curl -X POST 'http://0.0.0.0:8000/chat/' \ + -H 'Content-Type: application/json' \ + -d '{"messages": [[{ "role": "user", "content": "Hello!" }]]}' + ``` + + Example response: + ```json + { + "prompt_ids": [[151644, 872, 198, 9707, 0, 151645, 198, 151644, 77091, 198]], + "completion_ids": [[151667, 198, 32313, 11, 279]], + "logprobs": [[[-0.0003], [-3.58e-07], [-0.0902], [-6.39e-05], [-0.0387]]], + "logprob_token_ids": [[[151667], [198], [32313], [11], [279]]] + } + ``` + """ + # Convert PIL images to base64 strings + for message_list in request.messages: + for message in message_list: + if isinstance(message["content"], list): + for part in message["content"]: + if part["type"] == "image_pil": + part["image_pil"] = Image.open(BytesIO(base64.b64decode(part["image_pil"]))) + + generation_kwargs = { + "n": request.n, + "repetition_penalty": request.repetition_penalty, + "temperature": request.temperature, + "top_p": request.top_p, + "top_k": request.top_k, + "min_p": request.min_p, + "max_tokens": request.max_tokens, + "logprobs": request.logprobs, + } + generation_kwargs.update(request.generation_kwargs) + + # Structured outputs, if enabled + if request.structured_outputs_regex is not None: + if generation_kwargs.get("structured_outputs") is not None: + logger.warning( + "Both `structured_outputs_regex` and `generation_kwargs['structured_outputs']` are set; " + "`structured_outputs_regex` takes precedence." + ) + generation_kwargs["structured_outputs"] = StructuredOutputsParams(regex=request.structured_outputs_regex) + elif isinstance(structured_outputs_kwargs := generation_kwargs.get("structured_outputs"), dict): + generation_kwargs["structured_outputs"] = StructuredOutputsParams(**structured_outputs_kwargs) + sampling_params = SamplingParams(**generation_kwargs) + + # Evenly distribute prompts across DP ranks + chunked_messages = chunk_list(request.messages, script_args.data_parallel_size) + + # Send the messages to each worker + for connection, messages in zip(connections, chunked_messages, strict=True): + # When the number of messages is less than data_parallel_size, some workers will receive empty messages. + # However, vLLM requires that we always send at least one prompt. So we send a placeholder prompt to comply + # with vLLM's requirement, and we later ignore the result. + if not messages: + messages = [[{"role": "user", "content": ""}]] + kwargs = { + "messages": messages, + "sampling_params": sampling_params, + "chat_template_kwargs": request.chat_template_kwargs, + "tools": request.tools, + } + connection.send({"type": "call", "method": "chat", "kwargs": kwargs}) + + # Receive results + all_outputs = [connection.recv() for connection in connections] + + # Handle empty prompts (see above) + all_outputs = [output for output, prompts in zip(all_outputs, chunked_messages, strict=True) if prompts] + + # Flatten and combine all results + all_outputs = list(chain.from_iterable(all_outputs)) # from list of list to single list + prompt_ids = [output.prompt_token_ids for output in all_outputs] + completion_ids = [list(output.token_ids) for outputs in all_outputs for output in outputs.outputs] + logprobs, logprob_token_ids = extract_logprobs(all_outputs) + + return { + "prompt_ids": prompt_ids, + "completion_ids": completion_ids, + "logprobs": logprobs, + "logprob_token_ids": logprob_token_ids, + } + + class InitCommunicatorRequest(BaseModel): + host: str + port: int + world_size: int + client_device_uuid: str + + @app.post("/init_communicator/") + async def init_communicator(request: InitCommunicatorRequest): + """ + Initializes the communicator for synchronizing model weights between a client and multiple server workers. + + Args: + request (`InitCommunicatorRequest`): + - `host` (`str`): Hostname or IP address of the master node. + - `port` (`int`): Port number to be used for communication. + - `world_size` (`int`): Total number of participating processes in the group. + - `client_device_uuid` (`str`): UUID of the device of client main process. Used to assert that devices + are different from vLLM workers devices. + """ + world_size = script_args.tensor_parallel_size * script_args.data_parallel_size + 1 + + # The function init_communicator is called this way: init_communicator(host, port, world_size) + # So with collective_rpc we need to call it this way: + # llm.collective_rpc(method="init_communicator", args=(host, port, world_size)) + kwargs = { + "method": "init_communicator", + "args": (request.host, request.port, world_size, request.client_device_uuid), + } + for connection in connections: + connection.send({"type": "fire_and_forget", "method": "collective_rpc", "kwargs": kwargs}) + + return {"message": "Request received, initializing communicator"} + + class UpdateWeightsRequest(BaseModel): + name: str + dtype: str + shape: list[int] + + @app.post("/update_named_param/") + async def update_named_param(request: UpdateWeightsRequest): + """ + Updates the model weights with the provided tensor. + + Once this endpoint is called, the client process should broadcast the updated weights to all server workers. + + Args: + request (`UpdateWeightsRequest`): + - `name` (`str`): Name of the weight tensor being updated. + - `dtype` (`str`): Data type of the weight tensor (e.g., `"torch.float32"`). + - `shape` (list of `int`): Shape of the weight + + """ + # The function update_named_param is called this way: update_named_param("name", "torch.float32", (10, 10)) + # So with collective_rpc we need to call it this way: + # llm.collective_rpc("update_named_param", args=("name", "torch.float32", (10, 10))) + kwargs = {"method": "update_named_param", "args": (request.name, request.dtype, tuple(request.shape))} + for connection in connections: + connection.send({"type": "fire_and_forget", "method": "collective_rpc", "kwargs": kwargs}) + + return {"message": "Request received, updating named parameter"} + + @app.post("/reset_prefix_cache/") + async def reset_prefix_cache(): + """ + Resets the prefix cache for the model. + """ + for connection in connections: + connection.send({"type": "call", "method": "reset_prefix_cache"}) + # Wait for and collect all results + all_outputs = [connection.recv() for connection in connections] + success = all(output for output in all_outputs) + return {"message": "Request received, resetting prefix cache status: " + str(success)} + + @app.post("/close_communicator/") + async def close_communicator(): + """ + Closes the weight update group and cleans up associated resources. + """ + kwargs = {"method": "close_communicator"} + for connection in connections: + connection.send({"type": "fire_and_forget", "method": "collective_rpc", "kwargs": kwargs}) + return {"message": "Request received, closing communicator"} + + # Start the server + uvicorn.run(app, host=script_args.host, port=script_args.port, log_level=script_args.log_level) + + +def make_parser(subparsers: argparse._SubParsersAction | None = None, prog: str | None = None): + from trl import TrlParser + + if subparsers is not None: + parser = subparsers.add_parser("vllm-serve", help="Run the vLLM serve script", dataclass_types=ScriptArguments) + else: + parser = TrlParser(ScriptArguments, prog=prog) + return parser + + +if __name__ == "__main__": + parser = make_parser() + (script_args,) = parser.parse_args_and_config() + main(script_args) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29603ebfd06c6042f7892ccff7426cf38a2936b7 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/__init__.py @@ -0,0 +1,21 @@ +# Copyright 2020-2026 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. + +from .skills import ( + install_skill, + list_agent_names, + list_skills, + resolve_target_path, + uninstall_skill, +) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/cli.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..712f50d1b0b61d751a547dc99224d71b934785fc --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/cli.py @@ -0,0 +1,199 @@ +# Copyright 2020-2026 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. + +""" +CLI commands for TRL skills installation and management. + +This module provides command-line interface for installing TRL skills to various AI agent directories. +""" + +import argparse + +from .skills import install_skill, list_agent_names, list_skills, resolve_target_path, uninstall_skill + + +def add_skills_subcommands(subparsers: argparse._SubParsersAction) -> None: + """ + Add skills subcommands to the parser. + + This creates nested subcommands under 'trl skills' for managing skill installations. + + Args: + subparsers: Subparsers from 'trl skills' command + """ + # Parent parser for common target options + target_parser = argparse.ArgumentParser(add_help=False) + target_parser.add_argument( + "--target", + default="agents", + help=f"Installation target: agent name ({', '.join(list_agent_names())}) or directory path", + ) + target_parser.add_argument( + "--scope", + choices=["project", "global"], + default="project", + help="Scope when using --target with agent name: project (./agents/skills/) or global (user-level like ~/.agents/skills/)", + ) + + # trl skills list (no target required - lists TRL's built-in skills by default) + list_parser = subparsers.add_parser( + "list", + help="List available TRL skills or installed skills in a target", + description="Show TRL skills available for installation, or if --target is specified, show installed skills", + ) + list_parser.add_argument( + "--target", + help="Optional: show installed skills in target (agent name or directory path)", + ) + list_parser.add_argument( + "--scope", + choices=["project", "global"], + default="project", + help="Scope when using --target with agent name: project (./agents/skills/) or global (user-level like ~/.agents/skills/)", + ) + list_parser.set_defaults(func=cmd_list) + + # trl skills install + install_parser = subparsers.add_parser( + "install", + parents=[target_parser], + help="Install skill", + description="Install TRL skill to target", + ) + install_parser.add_argument("skill", nargs="?", help="Skill name to install (omit to use --all)") + install_parser.add_argument("--all", action="store_true", help="Install all available TRL skills") + install_parser.add_argument("--force", action="store_true", help="Overwrite if skill already exists") + install_parser.set_defaults(func=cmd_install) + + # trl skills uninstall + uninstall_parser = subparsers.add_parser( + "uninstall", + parents=[target_parser], + help="Uninstall skill from target", + description="Remove a TRL skill from an AI agent's skills directory", + ) + uninstall_parser.add_argument("skill", help="Skill name to uninstall") + uninstall_parser.set_defaults(func=cmd_uninstall) + + +def cmd_install(args): + """Handle 'trl skills install' command.""" + # Validate arguments + if not args.skill and not args.all: + print("Error: Either provide a skill name or use --all to install all skills") + print("Usage: trl skills install --target ") + print(" or: trl skills install --all --target ") + return 1 + + if args.skill and args.all: + print("Error: Cannot specify both a skill name and --all") + return 1 + + # Determine skills to install + if args.all: + skills_to_install = list_skills() + if not skills_to_install: + print("No skills available to install") + return 1 + print(f"Installing {len(skills_to_install)} skills to {args.target}") + else: + skills_to_install = [args.skill] + + # Install each skill + success_count = 0 + for skill_name in skills_to_install: + try: + print(f"Installing '{skill_name}'...", end=" ") + install_skill( + skill_name=skill_name, + target=args.target, + scope=args.scope, + force=args.force, + ) + print("✓") + success_count += 1 + + except FileExistsError as e: + print("✗") + print(f" Error: {e}") + if not args.force: + print(" Use --force to overwrite") + except (FileNotFoundError, ValueError) as e: + print("✗") + print(f" Error: {e}") + + # Summary + print(f"\n{success_count}/{len(skills_to_install)} skills installed successfully") + + if success_count > 0: + target_path = resolve_target_path(args.target, args.scope) + print(f"\nSkills are now available at: {target_path}") + print("You may need to restart your AI agent to use the new skills.") + + return 0 if success_count == len(skills_to_install) else 1 + + +def cmd_uninstall(args): + """Handle 'trl skills uninstall' command.""" + try: + print(f"Uninstalling '{args.skill}' from {args.target}...", end=" ") + uninstall_skill(args.skill, target=args.target, scope=args.scope) + print("✓") + print(f"\nSkill '{args.skill}' has been removed") + return 0 + + except (FileNotFoundError, PermissionError, ValueError) as e: + print("✗") + print(f"Error: {e}") + return 1 + + +def cmd_list(args): + """Handle 'trl skills list' command.""" + try: + # List skills - if no target specified, list TRL's built-in skills + if args.target: + skills = list_skills(target=args.target, scope=args.scope) + location = args.target + else: + skills = list_skills() + location = "TRL (available for installation)" + + if not skills: + if args.target: + print(f"No skills installed in {args.target}") + else: + print("No TRL skills available") + return 0 + + print(f"\nSkills in {location}:\n") + + for skill in skills: + print(f" {skill}") + + print(f"\nTotal: {len(skills)} skill(s)") + + if not args.target: + print("\nUse 'trl skills install --target ' to install a skill") + + return 0 + + except ValueError as e: + print(f"Error: {e}") + return 1 + + +__all__ = [ + "add_skills_subcommands", +] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/skills.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/skills.py new file mode 100644 index 0000000000000000000000000000000000000000..6a9b15f4e13f38e930c48dfa6b7e47e687e1ab5d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/skills.py @@ -0,0 +1,353 @@ +# Copyright 2020-2026 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. + +""" +Agent Skills. + +This module: +- provides utilities for discovering and accessing TRL skills that can be used by AI agents to learn how to use the TRL + CLI +- handles installation, uninstallation, and management of TRL skills +- defines where different AI agents and coding tools look for skills, enabling easy installation of TRL skills to the + appropriate directories + +Agent Skills are folders of instructions, scripts, and resources that agents can discover and use to perform tasks more +accurately and efficiently. Learn more at https://agentskills.io +""" + +import importlib.resources as resources +import shutil +from pathlib import Path + + +AGENT_PATHS = { + "agents": { + "global": Path("~/.agents/skills"), + "project": Path("./.agents/skills"), + }, + "claude": { + "global": Path("~/.claude/skills"), + "project": Path("./.claude/skills"), + }, +} + + +def list_agent_names() -> list[str]: + """ + List available predefined agent names. + + Returns: + `list[str]`: Sorted list of agent names (e.g., ['agents', 'claude']). + """ + return sorted(AGENT_PATHS.keys()) + + +def _get_trl_skills_dir() -> Path: + """ + Get the path to the TRL skills directory. + + This is the directory inside the TRL package containing skills that can be installed to AI agent directories. + + Returns: + `Path`: TRL skills directory. + """ + return Path(str(resources.files("trl.skills"))) + + +def resolve_target_path(target: str | Path, scope: str = "project") -> Path: + """ + Resolve target to a concrete directory path. + + Converts semantic agent names (e.g., 'claude') with scope to actual filesystem paths, or normalizes provided paths. + + Args: + target (`str | Path`): Agent name (e.g., 'agents', 'claude') or directory path. + scope (`str`, defaults to `"project"`): + Scope for agent names: 'global' (user-level like ~/.agents/skills/) or 'project' (./agents/skills/). + + Returns: + `Path`: Resolved absolute path. + + Raises: + `ValueError`: If `scope` is invalid for a predefined agent target. + + Example: + ```python + from trl.skills import resolve_target_path + + # Resolve agent name with scope + path = resolve_target_path("claude", "global") + print(path) # /home/user/.claude/skills + + # Resolve custom path + path = resolve_target_path("/custom/skills") + print(path) # /custom/skills + ``` + """ + if isinstance(target, Path): + return target.expanduser().resolve() + + # Check if it's a predefined agent + if target in AGENT_PATHS: + if scope not in AGENT_PATHS[target]: + valid_scopes = ", ".join(sorted(AGENT_PATHS[target])) + raise ValueError(f"Invalid scope '{scope}' for agent '{target}'. Expected one of: {valid_scopes}") + agent_path = AGENT_PATHS[target][scope] + return agent_path.expanduser().resolve() + + # Treat as custom path string + return Path(target).expanduser().resolve() + + +def _list_skills_in_dir(skills_dir: Path) -> list[str]: + """ + List skills in directory. + + A skill is a directory containing a SKILL.md file. + + Args: + skills_dir (`Path`): Skills directory to scan. + + Returns: + `list[str]`: Skill names (directory names containing SKILL.md). + """ + if not skills_dir.exists(): + return [] + skills = [] + for item in skills_dir.iterdir(): + if item.is_dir() and (item / "SKILL.md").exists(): + skills.append(item.name) + return sorted(skills) + + +def list_skills(target: str | Path | None = None, scope: str = "project") -> list[str]: + """ + List skills. + + A skill is a directory containing a SKILL.md file. + + Args: + target (`str | Path`, *optional*): + Agent name (e.g., 'claude'), directory path, or `None` for TRL's built-in skills. + scope (`str`, defaults to `"project"`): + For agent names: 'global' (user-level) or 'project' (current directory). + + Returns: + `list[str]`: Skill names (directory names containing SKILL.md). + + Example: + ```python + from trl.skills import list_skills + + # List TRL's built-in skills + skills = list_skills() + print(skills) # ['trl-training'] + + # List skills installed for Claude globally + installed = list_skills(target="claude", scope="global") + print(installed) # ['trl-training', 'custom-skill'] + + # List skills in custom directory + custom = list_skills(target="/path/to/skills") + print(custom) # [...] + ``` + """ + if target is None: + # List TRL's built-in skills + return _list_skills_in_dir(_get_trl_skills_dir()) + + target_dir = resolve_target_path(target, scope) + return _list_skills_in_dir(target_dir) + + +def _install_skill_to_dir( + skill_name: str, + target_dir: Path, + source_dir: Path, + force: bool = False, +) -> bool: + """ + Install a skill to target directory. + + Args: + skill_name (`str`): Name of skill to install. + target_dir (`Path`): Target installation directory. + source_dir (`Path`): Source directory containing skills. + force (`bool`, defaults to `False`): Whether to overwrite if exists. + + Returns: + `bool`: True if installed successfully. + + Raises: + - `FileNotFoundError`: If skill doesn't exist in source_dir. + - `FileExistsError`: If skill already installed and not force. + - `PermissionError`: If no permission to write to target_dir. + - `ValueError`: If source_dir entry exists but is not a directory. + - `OSError`: If copying the skill fails. + """ + source_skill = source_dir / skill_name + + # Check if source skill exists + if not source_skill.exists(): + available = ", ".join(list_skills(target=source_dir)) + source_msg = f"source directory {source_dir}" + if available: + raise FileNotFoundError(f"Skill '{skill_name}' not found in {source_msg}. Available skills: {available}") + raise FileNotFoundError(f"Skill '{skill_name}' not found in {source_msg}") + + if not source_skill.is_dir(): + raise ValueError(f"Skill '{skill_name}' is not a directory") + + target_skill = target_dir / skill_name + + # Check if already exists + if target_skill.exists() and not force: + raise FileExistsError(f"Skill '{skill_name}' already installed at {target_skill}. Use --force to overwrite.") + + # Create target directory + try: + target_dir.mkdir(parents=True, exist_ok=True) + except PermissionError as e: + raise PermissionError(f"Cannot create directory {target_dir}: {e}") from e + + # Remove existing if force + if target_skill.exists() and force: + if target_skill.is_symlink(): + target_skill.unlink() + else: + shutil.rmtree(target_skill) + + # Install + try: + shutil.copytree(source_skill, target_skill) + except OSError as e: + raise OSError(f"Failed to install skill: {e}") from e + + return True + + +def install_skill( + skill_name: str, + target: str | Path, + scope: str = "project", + source: str | Path | None = None, + force: bool = False, +) -> bool: + """ + Install a skill. + + Args: + skill_name (`str`): Name of skill to install. + target (`str | Path`): Agent name (e.g., 'agents', 'claude') or directory path. + scope (`str`, defaults to `"project"`): + Scope for agent names: 'global' (user-level) or 'project' (current directory). + source (`str | Path`, *optional*): + Source directory containing skills. If `None`, defaults to TRL skills directory. + force (`bool`, defaults to `False`): Whether to overwrite if skill already exists. + + Returns: + `bool`: True if installed successfully. + + Raises: + - `FileNotFoundError`: If skill doesn't exist in source. + - `FileExistsError`: If skill already installed and not force. + - `PermissionError`: If no permission to write to target. + - `ValueError`: + - If `scope` is invalid for a predefined agent target. + - If `source` entry exists but is not a directory. + - `OSError`: If copying the skill fails. + + Example: + ```python + from trl.skills import install_skill + + # Install to Claude's global skills directory + install_skill("trl-training", target="claude", scope="global") + + # Install to custom directory + install_skill("trl-training", target="/path/to/skills") + + # Overwrite existing installation + install_skill("trl-training", target="claude", force=True) + ``` + """ + target_dir = resolve_target_path(target, scope) + source_dir = Path(source).expanduser().resolve() if source else _get_trl_skills_dir() + return _install_skill_to_dir(skill_name, target_dir, source_dir, force) + + +def _uninstall_skill_from_dir(skill_name: str, target_dir: Path) -> bool: + """ + Uninstall a skill from target directory. + + Args: + skill_name (`str`): Name of skill to uninstall. + target_dir (`Path`): Directory skill is installed in. + + Returns: + `bool`: True if uninstalled successfully. + + Raises: + - `FileNotFoundError`: If skill not installed. + - `PermissionError`: If no permission to remove. + - `OSError`: If removing the skill fails for another filesystem reason. + """ + target_skill = target_dir / skill_name + + if not target_skill.exists(): + raise FileNotFoundError(f"Skill '{skill_name}' not installed at {target_dir}") + + # Remove symlink or directory + try: + shutil.rmtree(target_skill) + except PermissionError as e: + raise PermissionError(f"Cannot remove skill: {e}") from e + except OSError as e: + raise OSError(f"Failed to remove skill: {e}") from e + + return True + + +def uninstall_skill(skill_name: str, target: str | Path, scope: str = "project") -> bool: + """ + Uninstall a skill. + + Args: + skill_name (`str`): Name of skill to uninstall. + target (`str | Path`): Agent name (e.g., 'agents', 'claude') or directory path. + scope (`str`, defaults to `"project"`): + Scope for agent names: 'global' (user-level) or 'project' (current directory). + + Returns: + `bool`: True if uninstalled successfully. + + Raises: + - `FileNotFoundError`: If skill not installed. + - `PermissionError`: If no permission to remove. + - `OSError`: If removing the skill fails for another filesystem reason. + - `ValueError`: If `scope` is invalid for a predefined agent target. + + Example: + ```python + from trl.skills import uninstall_skill + + # Uninstall from Claude's global directory + uninstall_skill("trl-training", target="claude", scope="global") + + # Uninstall from custom directory + uninstall_skill("trl-training", target="/path/to/skills") + ``` + """ + target_dir = resolve_target_path(target, scope) + return _uninstall_skill_from_dir(skill_name, target_dir) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/trl-training/SKILL.md b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/trl-training/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..1941385812d82abbbe1f466aa1204e0f8d775ea9 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/skills/trl-training/SKILL.md @@ -0,0 +1,333 @@ +--- +name: trl-training +description: Train and fine-tune transformer language models using TRL (Transformers Reinforcement Learning). Supports SFT, DPO, GRPO, KTO, RLOO and Reward Model training via CLI commands. +license: Apache-2.0 +metadata: + version: "1.0.0" + author: huggingface + commands: + - trl sft + - trl dpo + - trl grpo + - trl kto + - trl rloo + - trl reward + categories: + - machine-learning + - llm-training + - reinforcement-learning + tags: + - rlhf + - supervised-fine-tuning + - dpo + - grpo + - huggingface + - transformers + documentation: https://huggingface.co/docs/trl/en/clis +--- + +# TRL Training Skill + +You are an expert at using the TRL (Transformers Reinforcement Learning) library to train and fine-tune large language models. + +## Overview + +TRL provides CLI commands for post-training foundation models using state-of-the-art techniques: + +- **SFT** (Supervised Fine-Tuning): Fine-tune models on instruction-following or conversational datasets +- **DPO** (Direct Preference Optimization): Align models using preference data +- **GRPO** (Group Relative Policy Optimization): Train models by ranking multiple sampled outputs relative to each other and optimizing based on their comparative rewards. +- **RLOO** (Reinforce Leave One Out): Online RL training with generation-based rewards +- **Reward Model Training**: Train reward models for RLHF + +TRL is built on top of Hugging Face Transformers and Accelerate, providing seamless integration with the Hugging Face ecosystem. + +## Core Commands + +### trl sft - Supervised Fine-Tuning + +Fine-tune language models on instruction-following or conversational datasets. + +**Full training:** + +```bash +trl sft \ + --model_name_or_path Qwen/Qwen2-0.5B \ + --dataset_name trl-lib/Capybara \ + --learning_rate 2.0e-5 \ + --num_train_epochs 1 \ + --packing \ + --per_device_train_batch_size 2 \ + --gradient_accumulation_steps 8 \ + --eos_token '<|im_end|>' \ + --eval_strategy steps \ + --eval_steps 100 \ + --output_dir Qwen2-0.5B-SFT \ + --push_to_hub +``` + +**Train with LoRA adapters:** + +```bash +trl sft \ + --model_name_or_path Qwen/Qwen2-0.5B \ + --dataset_name trl-lib/Capybara \ + --learning_rate 2.0e-4 \ + --num_train_epochs 1 \ + --packing \ + --per_device_train_batch_size 2 \ + --gradient_accumulation_steps 8 \ + --eos_token '<|im_end|>' \ + --eval_strategy steps \ + --eval_steps 100 \ + --use_peft \ + --lora_r 32 \ + --lora_alpha 16 \ + --output_dir Qwen2-0.5B-SFT \ + --push_to_hub +``` + +### trl dpo - Direct Preference Optimization + +Align models using preference data (chosen/rejected pairs). + +**Full training:** + +```bash +trl dpo \ + --dataset_name trl-lib/ultrafeedback_binarized \ + --model_name_or_path Qwen/Qwen2-0.5B-Instruct \ + --learning_rate 5.0e-7 \ + --num_train_epochs 1 \ + --per_device_train_batch_size 2 \ + --max_steps 1000 \ + --gradient_accumulation_steps 8 \ + --eval_strategy steps \ + --eval_steps 50 \ + --output_dir Qwen2-0.5B-DPO \ + --no_remove_unused_columns +``` + +**Train with LoRA adapters:** + +```bash +trl dpo \ + --dataset_name trl-lib/ultrafeedback_binarized \ + --model_name_or_path Qwen/Qwen2-0.5B-Instruct \ + --learning_rate 5.0e-6 \ + --num_train_epochs 1 \ + --per_device_train_batch_size 2 \ + --max_steps 1000 \ + --gradient_accumulation_steps 8 \ + --eval_strategy steps \ + --eval_steps 50 \ + --output_dir Qwen2-0.5B-DPO \ + --no_remove_unused_columns \ + --use_peft \ + --lora_r 32 \ + --lora_alpha 16 +``` + +### trl grpo - Group Relative Policy Optimization + +Train models using reward functions or LLM-as-a-judge for evaluating generations and providing rewards. + +**Basic usage:** + +```bash +trl grpo \ + --model_name_or_path Qwen/Qwen2.5-0.5B \ + --dataset_name trl-lib/gsm8k \ + --reward_funcs accuracy_reward \ + --output_dir Qwen2-0.5B-GRPO \ + --push_to_hub +``` + +### trl rloo - Reinforce Leave One Out + +Online RL training where the model generates text and receives rewards based on custom criteria. + +**Basic usage:** + +```bash +trl rloo \ + --model_name_or_path Qwen/Qwen2.5-0.5B \ + --dataset_name trl-lib/tldr \ + --reward_model_name_or_path sentiment-analysis:nlptown/bert-base-multilingual-uncased-sentiment \ + --output_dir Qwen2-0.5B-RLOO \ + --push_to_hub +``` + +### trl reward - Reward Model Training + +Train a reward model to score text quality for RLHF. + +**Full training:** + +```bash +trl reward \ + --model_name_or_path Qwen/Qwen2-0.5B-Instruct \ + --dataset_name trl-lib/ultrafeedback_binarized \ + --output_dir Qwen2-0.5B-Reward \ + --per_device_train_batch_size 8 \ + --num_train_epochs 1 \ + --learning_rate 1.0e-5 \ + --eval_strategy steps \ + --eval_steps 50 \ + --max_length 2048 +``` + +**Train with LoRA adapters:** + +```bash +trl reward \ + --model_name_or_path Qwen/Qwen2-0.5B-Instruct \ + --dataset_name trl-lib/ultrafeedback_binarized \ + --output_dir Qwen2-0.5B-Reward-LoRA \ + --per_device_train_batch_size 8 \ + --num_train_epochs 1 \ + --learning_rate 1.0e-4 \ + --eval_strategy steps \ + --eval_steps 50 \ + --max_length 2048 \ + --use_peft \ + --lora_task_type SEQ_CLS \ + --lora_r 32 \ + --lora_alpha 16 +``` + +## Configuration Files + +TRL supports YAML configuration files for reproducible training. All CLI arguments can be specified in a config file. + +**Example config (sft_config.yaml):** + +```yaml +model_name_or_path: Qwen/Qwen2.5-0.5B +dataset_name: trl-lib/Capybara +learning_rate: 2.0e-5 +num_train_epochs: 1 +per_device_train_batch_size: 8 +gradient_accumulation_steps: 2 +output_dir: ./sft_output +use_peft: true +lora_r: 16 +lora_alpha: 16 +report_to: trackio +``` + +**Launch with config:** + +```bash +trl sft --config sft_config.yaml +``` + +**Override config values:** + +```bash +trl sft --config sft_config.yaml --learning_rate 1.0e-5 +``` + +## Distributed Training + +TRL integrates with Accelerate for multi-GPU and multi-node training. + +**Multi-GPU training:** + +```bash +trl sft \ + --config sft_config.yaml \ + --num_processes 4 +``` + +**Use predefined Accelerate configs:** + +TRL provides predefined configs: `single_gpu`, `multi_gpu`, `fsdp1`, `fsdp2`, `zero1`, `zero2`, `zero3` + +```bash +trl sft \ + --config sft_config.yaml \ + --accelerate_config zero2 +``` + +**Custom Accelerate config:** + +```bash +# Generate custom config +accelerate config + +# Use custom config +trl sft --config sft_config.yaml --config_file ~/.cache/huggingface/accelerate/default_config.yaml +``` + +**Fully Sharded Data Parallel (FSDP):** + +```bash +trl sft --config sft_config.yaml --accelerate_config fsdp2 +``` + +**DeepSpeed ZeRO:** + +```bash +trl sft --config sft_config.yaml --accelerate_config zero3 +``` + +## Troubleshooting + +### CUDA Out of Memory + +- Reduce `--per_device_train_batch_size` and increase `--gradient_accumulation_steps` +- Enable `--use_peft` for LoRA training +- Use `--gradient_checkpointing` to save memory +- Try smaller model or longer sequence truncation + +### Dataset Loading Issues + +- Verify dataset exists: check Hugging Face Hub or local path +- Check dataset format matches expected columns +- Use `--dataset_config` for multi-config datasets +- Inspect dataset: `from datasets import load_dataset; ds = load_dataset(name)` + +### Model Loading Issues + +- Verify model exists on Hugging Face Hub +- Check if gated model requires authentication: `hf auth login` +- For local models, provide absolute path +- Ensure sufficient disk space and memory + +### Slow Training + +- Enable dataset `--packing` for short sequences +- Use larger `--per_device_train_batch_size` if memory allows +- Enable `--tf32` for faster computation on Ampere GPUs +- Use `--bf16` on supported hardware +- Consider multi-GPU training with `--num_processes` + +### Generation Issues (GRPO/RLOO) + +- Check prompt format in dataset +- Adjust `--temperature` and `--top_p` for generation +- Verify the reward function (for GRPO/RLOO) + +## Additional Resources + +- **Documentation**: https://huggingface.co/docs/trl +- **GitHub**: https://github.com/huggingface/trl +- **Examples**: https://github.com/huggingface/trl/tree/main/examples + +## Best Practices + +1. **Start with SFT**: Always fine-tune base models with SFT before preference alignment +2. **Use LoRA for efficiency**: Enable `--use_peft` for faster training and lower memory +3. **Monitor training**: Use `--report_to trackio` (or `--report_to wandb` or `--report_to tensorboard`) for tracking +4. **Save checkpoints**: TRL automatically saves checkpoints in `--output_dir` +5. **Test on small datasets first**: Verify pipeline works before full training +6. **Use configuration files**: Create YAML configs for reproducibility +7. **Leverage Accelerate**: Use multi-GPU training for faster iteration + +When helping users with TRL: +- Always check which training method is appropriate for their use case +- Verify dataset format matches the expected schema +- Recommend starting with smaller models for testing +- Suggest LoRA for resource-constrained environments +- Point to specific documentation sections for advanced features diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/templates/completions_dataset_card.md b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/templates/completions_dataset_card.md new file mode 100644 index 0000000000000000000000000000000000000000..6246844db5738c7cc6807c9b221544f6939692c6 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/templates/completions_dataset_card.md @@ -0,0 +1,40 @@ +--- +{{ card_data }} +--- + +# TRL Completion logs + +This dataset contains the completions generated during training using `trl`. + +{% if hub_model_id %} +Find the trained model at https://huggingface.co/{{ hub_model_id }}. + +{% endif %} +The completions are stored in parquet files, and each file contains the completions for a single step of training (depending on the `logging_steps` argument). + +Each file contains the following columns: + +- `step`: the step of training +- `prompt`: the prompt used to generate the completion +- `completion`: the completion generated by the model +- ``: the reward(s) assigned to the completion by the reward function(s) used during training +- `advantage`: the computed advantage for the completion + +Having this data stored as a simple parquet file makes it easy to load and analyze using the Datasets Viewer, Polars, Pandas, etc. + +You can load the dataset using the `datasets` library: + +```python +import datasets + +dataset = datasets.load_dataset("{{ repo_id }}") +``` + +You can also load the dataset using Polars: + +```python +import polars as pl + +# Login using e.g. `hf auth login` to access this dataset if it's private +df = pl.read_parquet(f"hf://datasets/{{ repo_id }}/*.parquet") +``` diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/templates/lm_model_card.md b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/templates/lm_model_card.md new file mode 100644 index 0000000000000000000000000000000000000000..ae7e33bfb5d5e5864257fd0abf04bd78d1629c5f --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/templates/lm_model_card.md @@ -0,0 +1,55 @@ +--- +{{ card_data }} +--- + +# Model Card for {{ model_name }} + +This model is a fine-tuned version of [{{ base_model }}](https://huggingface.co/{{ base_model }}){% if dataset_name %} on the [{{ dataset_name }}](https://huggingface.co/datasets/{{ dataset_name }}) dataset{% endif %}. +It has been trained using [TRL](https://github.com/huggingface/trl). + +## Quick start + +```python +from transformers import pipeline + +question = "If you had a time machine, but could only go to the past or the future once and never return, which would you choose and why?" +generator = pipeline("text-generation", model="{{ hub_model_id }}", device="cuda") +output = generator([{"role": "user", "content": question}], max_new_tokens=128, return_full_text=False)[0] +print(output["generated_text"]) +``` + +## Training procedure + +{% if wandb_url %}[Visualize in Weights & Biases]({{ wandb_url }}){% endif %} +{% if trackio_url %}[Visualize in Trackio]({{ trackio_url }}){% endif %} +{% if comet_url %}[Visualize in Comet]({{ comet_url }}){% endif %} + +This model was trained with {{ trainer_name }}{% if paper_id %}, a method introduced in [{{ paper_title }}](https://huggingface.co/papers/{{ paper_id }}){% endif %}. + +### Framework versions + +- TRL: {{ trl_version }} +- Transformers: {{ transformers_version }} +- Pytorch: {{ pytorch_version }} +- Datasets: {{ datasets_version }} +- Tokenizers: {{ tokenizers_version }} + +## Citations + +{% if trainer_citation %}Cite {{ trainer_name }} as: + +```bibtex +{{ trainer_citation }} +```{% endif %} + +Cite TRL as: + +```bibtex +{% raw %}@software{vonwerra2020trl, + title = {{TRL: Transformers Reinforcement Learning}}, + author = {von Werra, Leandro and Belkada, Younes and Tunstall, Lewis and Beeching, Edward and Thrush, Tristan and Lambert, Nathan and Huang, Shengyi and Rasul, Kashif and Gallouédec, Quentin}, + license = {Apache-2.0}, + url = {https://github.com/huggingface/trl}, + year = {2020} +}{% endraw %} +``` diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/templates/rm_model_card.md b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/templates/rm_model_card.md new file mode 100644 index 0000000000000000000000000000000000000000..0e47e9724a6c38f262b63782507d5871bb4272c2 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/templates/rm_model_card.md @@ -0,0 +1,55 @@ +--- +{{ card_data }} +--- + +# Model Card for {{ model_name }} + +This model is a fine-tuned version of [{{ base_model }}](https://huggingface.co/{{ base_model }}){% if dataset_name %} on the [{{ dataset_name }}](https://huggingface.co/datasets/{{ dataset_name }}) dataset{% endif %}. +It has been trained using [TRL](https://github.com/huggingface/trl). + +## Quick start + +```python +from transformers import pipeline + +text = "The capital of France is Paris." +rewarder = pipeline(model="{{ hub_model_id }}", device="cuda") +output = rewarder(text)[0] +print(output["score"]) +``` + +## Training procedure + +{% if wandb_url %}[Visualize in Weights & Biases]({{ wandb_url }}){% endif %} +{% if trackio_url %}[Visualize in Trackio]({{ trackio_url }}){% endif %} +{% if comet_url %}[Visualize in Comet]({{ comet_url }}){% endif %} + +This model was trained with {{ trainer_name }}{% if paper_id %}, a method introduced in [{{ paper_title }}](https://huggingface.co/papers/{{ paper_id }}){% endif %}. + +### Framework versions + +- TRL: {{ trl_version }} +- Transformers: {{ transformers_version }} +- Pytorch: {{ pytorch_version }} +- Datasets: {{ datasets_version }} +- Tokenizers: {{ tokenizers_version }} + +## Citations + +{% if trainer_citation %}Cite {{ trainer_name }} as: + +```bibtex +{{ trainer_citation }} +```{% endif %} + +Cite TRL as: + +```bibtex +{% raw %}@software{vonwerra2020trl, + title = {{TRL: Transformers Reinforcement Learning}}, + author = {von Werra, Leandro and Belkada, Younes and Tunstall, Lewis and Beeching, Edward and Thrush, Tristan and Lambert, Nathan and Huang, Shengyi and Rasul, Kashif and Gallouédec, Quentin}, + license = {Apache-2.0}, + url = {https://github.com/huggingface/trl}, + year = {2020} +}{% endraw %} +``` diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/__init__.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d79d365056136a5940af7d23fb964fb8db0e62c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/__init__.py @@ -0,0 +1,83 @@ +# Copyright 2020-2026 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. + +from typing import TYPE_CHECKING + +from .._lazy_module import _LazyModule + + +_import_structure = { + "callbacks": [ + "BEMACallback", + "LogCompletionsCallback", + "RichProgressCallback", + "SyncRefModelCallback", + "WeaveCallback", + ], + "dpo_config": ["DPOConfig"], + "dpo_trainer": ["DPOTrainer"], + "grpo_config": ["GRPOConfig"], + "grpo_trainer": ["GRPOTrainer"], + "kto_config": ["KTOConfig"], + "kto_trainer": ["KTOTrainer"], + "model_config": ["ModelConfig"], + "reward_config": ["RewardConfig"], + "reward_trainer": ["RewardTrainer"], + "rloo_config": ["RLOOConfig"], + "rloo_trainer": ["RLOOTrainer"], + "sft_config": ["SFTConfig"], + "sft_trainer": ["SFTTrainer"], + "utils": [ + "disable_dropout_in_model", + "ensure_master_addr_port", + "get_kbit_device_map", + "get_peft_config", + "get_quantization_config", + "patch_chunked_lm_head", + ], +} + +if TYPE_CHECKING: + from .callbacks import ( + BEMACallback, + LogCompletionsCallback, + RichProgressCallback, + SyncRefModelCallback, + WeaveCallback, + ) + from .dpo_config import DPOConfig + from .dpo_trainer import DPOTrainer + from .grpo_config import GRPOConfig + from .grpo_trainer import GRPOTrainer + from .kto_config import KTOConfig + from .kto_trainer import KTOTrainer + from .model_config import ModelConfig + from .reward_config import RewardConfig + from .reward_trainer import RewardTrainer + from .rloo_config import RLOOConfig + from .rloo_trainer import RLOOTrainer + from .sft_config import SFTConfig + from .sft_trainer import SFTTrainer + from .utils import ( + disable_dropout_in_model, + ensure_master_addr_port, + get_kbit_device_map, + get_peft_config, + get_quantization_config, + patch_chunked_lm_head, + ) +else: + import sys + + sys.modules[__name__] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/base_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/base_config.py new file mode 100644 index 0000000000000000000000000000000000000000..fd20188c74b342974ace79b863b0566c23673ec3 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/base_config.py @@ -0,0 +1,107 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field + +from transformers import TrainingArguments + + +@dataclass +class _BaseConfig(TrainingArguments): + """ + Base configuration class for all TRL trainer configurations. + + Subclasses [`~transformers.TrainingArguments`] and overrides fields that are common across TRL trainers or that + contain unescaped "%" characters which would cause argparse to raise a `TypeError` when rendering `--help` output. + + Parameters: + logging_steps (`int` or `float`, *optional*, defaults to `10`): + Number of update steps between two logs if `logging_strategy="steps"`. Should be an integer or a float in + range `[0,1)`. If smaller than 1, will be interpreted as ratio of total training steps. + gradient_checkpointing (`bool`, *optional*, defaults to `True`): + Whether to enable gradient checkpointing to trade compute for memory. Reduces memory usage by clearing + activations during forward pass and recomputing them during backward pass. Enables training larger models + or batch sizes at the cost of ~20% slower training. + bf16 (`bool`, *optional*): + Whether to use bfloat16 (BF16) mixed precision instead of 32-bit. Generally preferred over FP16 due to + better numerical stability and no loss scaling required. Requires Ampere or higher NVIDIA architecture or + Intel XPU or using CPU (use_cpu) or Ascend NPU. If not set, it defaults to `True` if `fp16` is not set. + lr_scheduler_kwargs (`dict` or `str`, *optional*): + Additional parameters for the lr_scheduler, such as `{'num_cycles': 1}` for cosine with hard restarts. See + the documentation of each scheduler for possible values. + use_liger_kernel (`bool`, *optional*, defaults to `False`): + Enable [Liger Kernel](https://github.com/linkedin/Liger-Kernel) optimizations. Increases multi-GPU + throughput by ~20% and reduces memory usage by ~60%. Works with Flash Attention, FSDP, and DeepSpeed. + Currently, supports Llama, Mistral, Mixtral, and Gemma models. + torch_empty_cache_steps (`int`, *optional*): + Number of steps to wait before calling `torch..empty_cache()`. If left unset or set to None, cache + will not be emptied. This can help avoid CUDA out-of-memory errors by lowering peak VRAM usage at a cost of + about [10% slower performance](https://github.com/huggingface/transformers/issues/31372). + """ + + # Override fields from TrainingArguments to set defaults preferred by all TRL trainers. + logging_steps: float = field( + default=10, + metadata={ + "help": "Log every X updates steps. Should be an integer or a float in range `[0,1)`. If smaller than 1, " + "will be interpreted as ratio of total training steps." + }, + ) + gradient_checkpointing: bool = field( + default=True, + metadata={ + "help": "Enable gradient checkpointing to trade compute for memory. Reduces memory at the cost of ~20%% slower training." + }, + ) + bf16: bool | None = field( + default=None, + metadata={ + "help": "Whether to use bf16 (mixed) precision instead of 32-bit. Requires Ampere or higher NVIDIA " + "architecture or Intel XPU or using CPU (use_cpu) or Ascend NPU. If not set, it defaults to `True` if " + "`fp16` is not set." + }, + ) + # Transformers 4.57.0 introduced a bug that caused the dtype of `lr_scheduler_kwargs` to be unparsable. This issue + # was fixed in https://github.com/huggingface/transformers/pull/41322 and released in 4.57.5. We add a temporary + # workaround here, which can be removed once we drop support for versions older than 4.57.5. + lr_scheduler_kwargs: dict | str | None = field( + default=None, + metadata={ + "help": "Additional parameters for the lr_scheduler, such as {'num_cycles': 1} for cosine with hard " + "restarts. See the documentation of each scheduler for possible values." + }, + ) + + # Override fields from TrainingArguments whose help strings contain unescaped "%" characters. + # argparse interprets "%" as a format specifier, raising TypeError when rendering --help output. + # Fixed upstream in transformers v5.3.0, but overridden here to support older versions. + # - Introduced in v5.2.0; fixed in v5.3.0 + use_liger_kernel: bool = field( + default=False, + metadata={ + "help": "Enable Liger Kernel optimizations. Increases throughput by ~20%% and reduces memory by ~60%%." + }, + ) + # - Introduced in v4.54.1; fixed in v5.3.0 + torch_empty_cache_steps: int | None = field( + default=None, + metadata={ + "help": "Number of steps to wait before calling `torch..empty_cache()`. Helps avoid CUDA OOM at a cost of ~10%% slower performance. If None, cache will not be emptied." + }, + ) + + def __post_init__(self): + self.bf16 = not (self.fp16) if self.bf16 is None else self.bf16 + + super().__post_init__() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/base_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/base_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..705cdf11f236ad3bf50842c08eda4afdee69c5b4 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/base_trainer.py @@ -0,0 +1,191 @@ +# Copyright 2020-2026 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os + +import torch +from accelerate.utils import is_peft_model +from huggingface_hub.utils import send_telemetry +from transformers import CONFIG_MAPPING, Trainer, is_wandb_available + +from .. import __version__ +from .utils import generate_model_card, get_comet_experiment_url, get_config_model_id, get_trackio_space_url + + +if is_wandb_available(): + import wandb + + +# Trainer class names that may appear in telemetry topics. Any class outside this set — internal helpers, +# in-flight subclasses not yet shipped, user-defined subclasses — is reported as "other" so unreleased or +# private names never leak. Adding a new trainer requires an explicit entry here. +_TELEMETRY_TRAINERS = { + # Stable + "DPOTrainer", + "GRPOTrainer", + "KTOTrainer", + "RewardTrainer", + "RLOOTrainer", + "SFTTrainer", + # Experimental + "A2POTrainer", + "AsyncGRPOTrainer", + "BCOTrainer", + "CPOTrainer", + "DistillationTrainer", + "DPPOTrainer", + "GFPOTrainer", + "GKDTrainer", + "GOLDTrainer", + "GRPOWithReplayBufferTrainer", + "MiniLLMTrainer", + "NashMDTrainer", + "OnlineDPOTrainer", + "ORPOTrainer", + "PAPOTrainer", + "PPOTrainer", + "PRMTrainer", + "SDFTTrainer", + "SDPOTrainer", + "SSDTrainer", + "TPOTrainer", + "XPOTrainer", +} + + +class _BaseTrainer(Trainer): + _tag_names = [] + _name = "Base" + _paper = {} + _template_file = None + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._send_telemetry() + + def _send_telemetry(self): + # Only send from rank 0 to avoid multiplying pings by world size, and skip CI runs so automated tests don't + # bias the data. Honors `HF_HUB_DISABLE_TELEMETRY=1` and `HF_HUB_OFFLINE=1` (handled by `send_telemetry`). + if not self.accelerator.is_main_process or os.environ.get("CI"): + return + if self.is_deepspeed_enabled: + distributed = "deepspeed" + elif self.is_fsdp_enabled: + distributed = "fsdp" + elif self.accelerator.num_processes > 1: + distributed = "ddp" + else: + distributed = "none" + device = self.accelerator.device.type + if device == "cuda": + gpu = torch.cuda.get_device_name(0) + elif device == "xpu": + gpu = torch.xpu.get_device_name(0) + elif device == "npu": + gpu = torch.npu.get_device_name(0) + elif device == "mlu": + gpu = torch.mlu.get_device_name(0) + else: + gpu = "other" + # Bucketed to avoid fingerprinting individual deployments by their exact cluster size. + n = self.accelerator.num_processes + world_size = "1" if n == 1 else "2-8" if n <= 8 else "9-64" if n <= 64 else "65+" + # Trainer class and model arch are reported only if they come from a known upstream allowlist (TRL trainers, + # transformers `CONFIG_MAPPING`); anything else is reported as "other" so we never leak the names of internal, + # custom trainer subclasses or private model architectures. + cls = type(self) + trainer = ( + cls.__name__ if cls.__name__ in _TELEMETRY_TRAINERS and cls.__module__.startswith("trl.") else "other" + ) + model_type = self.model.config.model_type + model_arch = model_type if model_type in CONFIG_MAPPING else "other" + send_telemetry( + topic=f"trl/{trainer}", + library_name="trl", + library_version=__version__, + user_agent={ + "model_arch": model_arch, + "peft": str(is_peft_model(self.model)).lower(), + "distributed": distributed, + "world_size": world_size, + "device": device, + "gpu": gpu, + }, + ) + + def create_model_card( + self, + model_name: str | None = None, + dataset_name: str | None = None, + tags: str | list[str] | None = None, + ): + """ + Creates a draft of a model card using the information available to the `Trainer`. + + Args: + model_name (`str`, *optional*): + Name of the model. + dataset_name (`str`, *optional*): + Name of the dataset used for training. + tags (`str`, `list[str]`, *optional*): + Tags to be associated with the model card. + """ + if not self.is_world_process_zero(): + return + + model_name_or_path = get_config_model_id(self.model.config) + if model_name_or_path and not os.path.isdir(model_name_or_path): + base_model = model_name_or_path + else: + base_model = None + + # Normalize tags + if tags is None: + tags = set() + elif isinstance(tags, str): + tags = {tags} + else: + tags = set(tags) + if hasattr(self.model.config, "unsloth_version"): + tags.add("unsloth") + if "JOB_ID" in os.environ: + tags.add("hf_jobs") + tags.update(self._tag_names) + + trackio_url = get_trackio_space_url() + # Pop existing Trackio tag and re-add the one with the proper url parameters + if trackio_url is not None: + for tag in list(tags): + if tag.startswith("trackio:"): + tags.remove(tag) + tags.add(f"trackio:{trackio_url}") + + tags = list(tags) + + model_card = generate_model_card( + base_model=base_model, + model_name=model_name, + hub_model_id=self.hub_model_id, + dataset_name=dataset_name, + tags=tags, + wandb_url=wandb.run.url if is_wandb_available() and wandb.run is not None else None, + trackio_url=trackio_url, + comet_url=get_comet_experiment_url(), + trainer_name=self._name, + trainer_citation=self._paper.get("citation"), + template_file=self._template_file, + paper_title=self._paper.get("title"), + paper_id=self._paper.get("id"), + ) + model_card.save(os.path.join(self.args.output_dir, "README.md")) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/callbacks.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/callbacks.py new file mode 100644 index 0000000000000000000000000000000000000000..12e36190fd82fb287d004c30c2c26dca7e965e0a --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/callbacks.py @@ -0,0 +1,758 @@ +# Copyright 2020-2026 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 logging + +import pandas as pd +import torch +from accelerate import Accelerator +from accelerate.state import AcceleratorState +from accelerate.utils import gather_object, is_wandb_available +from transformers import ( + GenerationConfig, + PreTrainedModel, + PreTrainedTokenizerBase, + Trainer, + TrainerCallback, + TrainerControl, + TrainerState, + TrainingArguments, +) +from transformers.trainer_utils import has_length +from transformers.utils import is_rich_available + +from ..data_utils import maybe_apply_chat_template +from ..import_utils import is_weave_available +from ..models.utils import unwrap_model_for_generation +from .utils import log_table_to_comet_experiment + + +if is_rich_available(): + from rich.columns import Columns + from rich.console import Console, Group + from rich.live import Live + from rich.panel import Panel + from rich.progress import Progress + from rich.table import Table + +if is_wandb_available(): + import wandb + +if is_weave_available(): + import weave + from weave import EvaluationLogger + from weave.trace.context import weave_client_context + + +# Logger for module-level logging +logger = logging.getLogger(__name__) + + +def _generate_completions( + prompts: list[str], + model: PreTrainedModel, + tokenizer: PreTrainedTokenizerBase, + accelerator: Accelerator, + generation_config: GenerationConfig | None, + batch_size: int = 1, +) -> list[str]: + """ + Generates completions for a list of pre-formatted prompts from the given model. + + Args: + prompts (list[str]): A list of input prompts for which completions are to be generated. + model (PreTrainedModel): The pre-trained model to be used for generation. + tokenizer (PreTrainedTokenizerBase): The tokenizer to be used for encoding and decoding. + accelerator (Accelerator): The accelerator to be used for model execution. + generation_config (GenerationConfig): Configuration for text generation. + batch_size (int, *optional*): The number of prompts to process in each batch. Default is 1. + + Returns: + list[str]: A list of generated text completions corresponding to the input prompts. + """ + completions = [] + # TODO: Override model.generation_config with generation_kwargs + with unwrap_model_for_generation(model, accelerator) as unwrapped_model: + for idx in range(0, len(prompts), batch_size): + batch = prompts[idx : idx + batch_size] + tokenized_batch = tokenizer(batch, return_tensors="pt", padding=True, truncation=True).to(model.device) + generations = unwrapped_model.generate( + **tokenized_batch, + generation_config=generation_config, + ) + for prompt, generation in zip(tokenized_batch.input_ids, generations, strict=True): + # Remove prompt from generation + generation = generation[len(prompt) :] + completion = tokenizer.decode(generation, skip_special_tokens=True) + completions.append(completion) + return completions + + +class SyncRefModelCallback(TrainerCallback): + """ + Callback to synchronize the model with a reference model. + """ + + def __init__( + self, + ref_model: PreTrainedModel | torch.nn.Module, + accelerator: Accelerator | None, + ): + self.accelerator = accelerator + self.ref_model = ref_model + + @staticmethod + def _sync_target_model(model, target_model, alpha): + for target_param, copy_param in zip(target_model.parameters(), model.parameters(), strict=True): + target_param.data.mul_(1.0 - alpha).add_(copy_param.data, alpha=alpha) + + @staticmethod + def sync_target_model(model, target_model, alpha): + deepspeed_plugin = AcceleratorState().deepspeed_plugin + if deepspeed_plugin is not None and deepspeed_plugin.zero_stage == 3: + import deepspeed + + with deepspeed.zero.GatheredParameters( + list(model.parameters()) + list(target_model.parameters()), modifier_rank=0 + ): + if deepspeed.comm.get_rank() == 0: + SyncRefModelCallback._sync_target_model(model, target_model, alpha) + else: + SyncRefModelCallback._sync_target_model(model, target_model, alpha) + + def on_step_end(self, args, state, control, **kwargs): + model: PreTrainedModel = kwargs["model"] + + if self.ref_model is not None and state.global_step % args.ref_model_sync_steps == 0: + if self.accelerator: + model = self.accelerator.unwrap_model(model) + self.sync_target_model(model, self.ref_model, args.ref_model_mixup_alpha) + + +class RichProgressCallback(TrainerCallback): + """ + A [`TrainerCallback`] that displays the progress of training or evaluation using Rich. + """ + + def __init__(self): + if not is_rich_available(): + raise ImportError("RichProgressCallback requires the `rich` extra. To install, run `pip install rich`.") + + self.training_bar = None + self.evaluation_bar = None + self.training_task = None + self.evaluation_task = None + self.rich_group = None + self.rich_console = None + self.training_status = None + self.current_step = None + + def on_train_begin(self, args, state, control, **kwargs): + if not state.is_world_process_zero: + return + + self.training_bar = Progress() + self.evaluation_bar = Progress() + self.rich_console = Console() + self.training_status = self.rich_console.status("Nothing to log yet ...") + self.rich_group = Live(Panel(Group(self.training_bar, self.evaluation_bar, self.training_status))) + self.rich_group.start() + self.training_task = self.training_bar.add_task("[blue]Training ", total=state.max_steps) + self.current_step = 0 + + def on_step_end(self, args, state, control, **kwargs): + if not state.is_world_process_zero: + return + + self.training_bar.update(self.training_task, advance=state.global_step - self.current_step, update=True) + self.current_step = state.global_step + + def on_prediction_step(self, args, state, control, eval_dataloader=None, **kwargs): + if not state.is_world_process_zero: + return + + if has_length(eval_dataloader): + if self.evaluation_task is None: + self.evaluation_task = self.evaluation_bar.add_task("[blue]Evaluation", total=len(eval_dataloader)) + self.evaluation_bar.update(self.evaluation_task, advance=1, update=True) + + def on_evaluate(self, args, state, control, **kwargs): + if not state.is_world_process_zero: + return + + if self.evaluation_task is not None: + self.evaluation_bar.remove_task(self.evaluation_task) + self.evaluation_task = None + + def on_predict(self, args, state, control, **kwargs): + if not state.is_world_process_zero: + return + + if self.evaluation_task is not None: + self.evaluation_bar.remove_task(self.evaluation_task) + self.evaluation_task = None + + def on_log(self, args, state, control, logs=None, **kwargs): + if not (state.is_world_process_zero and self.training_bar): + return + + # Group keys by top-level prefix + grouped_logs = {} + for key, value in logs.items(): + parts = key.split("/") + group = parts[0] if len(parts) > 1 else None + subkey = "/".join(parts[1:]) if len(parts) > 1 else key + grouped_logs.setdefault(group, {})[subkey] = value + + # Create a table per group + tables = [] + for group_name, metrics in grouped_logs.items(): + table = Table( + title=f"[bold blue]{group_name}[/]" if group_name else None, header_style="bold magenta", box=None + ) + table.add_column("Metric", justify="left", no_wrap=True) + table.add_column("Value", justify="right") + + for metric, val in metrics.items(): + formatted = f"{val:.3f}" if isinstance(val, (float, int)) else str(val) + table.add_row(metric, formatted) + + tables.append(Panel(table, border_style="cyan", padding=(0, 1))) + + # Arrange tables in columns using Columns + column_layout = Columns(tables, equal=False, expand=True) + self.training_status.update( + Panel(column_layout, title=f"[bold green]Step {state.global_step}[/bold green]", border_style="green") + ) + + def on_train_end(self, args, state, control, **kwargs): + if not state.is_world_process_zero: + return + + self.rich_group.stop() + self.training_bar = None + self.evaluation_bar = None + self.training_task = None + self.evaluation_task = None + self.rich_group = None + self.rich_console = None + self.training_status = None + self.current_step = None + + +class LogCompletionsCallback(TrainerCallback): + r""" + A [`~transformers.TrainerCallback`] that logs completions to Weights & Biases and/or Comet. + + Usage: + ```python + trainer = DPOTrainer(...) + completions_callback = LogCompletionsCallback(trainer=trainer) + trainer.add_callback(completions_callback) + ``` + + Args: + trainer (`Trainer`): + Trainer to which the callback will be attached. The trainer's evaluation dataset must include a `"prompt"` + column containing the prompts for generating completions. + generation_config ([`~transformers.GenerationConfig`], *optional*): + The generation config to use for generating completions. + num_prompts (`int`, *optional*): + The number of prompts to generate completions for. If not provided, defaults to the number of examples in + the evaluation dataset. + freq (`int`, *optional*): + The frequency at which to log completions. If not provided, defaults to the trainer's `eval_steps`. + """ + + def __init__( + self, + trainer: Trainer, + generation_config: GenerationConfig | None = None, + num_prompts: int | None = None, + freq: int | None = None, + ): + self.trainer = trainer + self.generation_config = generation_config + self.freq = freq + self.table = [] + self._last_logged_step = -1 + + if self.trainer.eval_dataset is None: + raise ValueError("Trainer must have an evaluation dataset to use the LogCompletionsCallback.") + else: + self.eval_dataset = self.trainer.eval_dataset + + if num_prompts is not None: + self.eval_dataset = self.eval_dataset.select(range(num_prompts)) + + def on_step_end(self, args, state, control, **kwargs): + # Only log once per step (this method may be called multiple times) + if state.global_step == self._last_logged_step: + return + + # Only log every `freq` steps (if no `freq` is provided, log every `eval_steps` steps) + freq = self.freq or state.eval_steps + if state.global_step % freq != 0: + return + + tokenizer = kwargs["processing_class"] + tokenizer.padding_side = "left" + accelerator = self.trainer.accelerator + model = self.trainer.model_wrapped + with accelerator.split_between_processes(self.eval_dataset["prompt"]) as prompts: + prompts = [maybe_apply_chat_template({"prompt": prompt}, tokenizer)["prompt"] for prompt in prompts] + completions = _generate_completions( + prompts, + model=model, + tokenizer=tokenizer, + accelerator=accelerator, + generation_config=self.generation_config, + batch_size=args.per_device_eval_batch_size, + ) + completions = gather_object(completions) + prompts = gather_object(prompts) + + # Build the data to log + if self.trainer.accelerator.is_main_process: + global_step = [str(state.global_step)] * len(prompts) + data = list(zip(global_step, prompts, completions, strict=True)) + self.table.extend(data) + table = pd.DataFrame(columns=["step", "prompt", "completion"], data=self.table) + + if "wandb" in args.report_to: + wandb.log({"completions": table}) + + if "comet_ml" in args.report_to: + log_table_to_comet_experiment( + name="completions.csv", + table=table, + ) + + # Save the last logged step, so we don't log the same completions multiple times + self._last_logged_step = state.global_step + + +class WeaveCallback(TrainerCallback): + r""" + A [`~transformers.TrainerCallback`] that logs traces and evaluations to W&B Weave. The callback uses + https://weave-docs.wandb.ai/guides/evaluation/evaluation_logger/ to log traces and evaluations at each evaluation + step. + + Supports two modes based on the `scorers` parameter: + - **Tracing Mode** (when scorers=None): Logs predictions for data exploration and analysis + - **Evaluation Mode** (when scorers provided): Logs predictions with scoring and summary metrics + + Both modes use Weave's EvaluationLogger for structured, consistent data logging. + + The callback logs data during evaluation phases (`on_evaluate`) rather than training steps, making it more + efficient and semantically correct. It gracefully handles missing weave installation by logging warnings and + skipping weave-specific functionality. It also checks for existing weave clients before initializing new ones. + + Usage: + ```python + # Tracing mode (just log predictions) + trainer = DPOTrainer(...) + weave_callback = WeaveTraceCallback(trainer=trainer) # project_name optional + trainer.add_callback(weave_callback) + + # Or specify a project name + weave_callback = WeaveTraceCallback(trainer=trainer, project_name="my-llm-training") + trainer.add_callback(weave_callback) + + + # Evaluation mode (log predictions + scores + summary) + def accuracy_scorer(prompt: str, completion: str) -> float: + # Your scoring logic here (metadata available via eval_attributes) + return score + + + weave_callback = WeaveTraceCallback( + trainer=trainer, + project_name="my-llm-training", # optional and needed only if weave client is not initialized + scorers={"accuracy": accuracy_scorer}, + ) + trainer.add_callback(weave_callback) + ``` + + Args: + trainer (`Trainer`): + Trainer to which the callback will be attached. The trainer's evaluation dataset must include a `"prompt"` + column containing the prompts for generating completions. + project_name (`str`, *optional*): + Name of the Weave project where data will be logged. If not provided, will try to use existing weave client + or fall back to the active wandb run's project name. Raises an error if none of these are available. + scorers (`dict[str, Callable]`, *optional*): + Dictionary mapping scorer names to scorer functions. If `None`, operates in tracing mode (predictions + only). If provided, operates in evaluation mode (predictions + scores + summary). Scorer functions should + have signature: `scorer(prompt: str, completion: str) -> float | int` + generation_config ([`~transformers.GenerationConfig`], *optional*): + Generation config to use for generating completions. + num_prompts (`int` or `None`, *optional*): + Number of prompts to generate completions for. If not provided, defaults to the number of examples in the + evaluation dataset. + dataset_name (`str`, *optional*, defaults to `"eval_dataset"`): + Name for the dataset metadata in Weave. + model_name (`str`, *optional*): + Name for the model metadata in Weave. If not provided, attempts to extract from model config. + """ + + def __init__( + self, + trainer: Trainer, + project_name: str | None = None, + scorers: dict[str, callable] | None = None, + generation_config: GenerationConfig | None = None, + num_prompts: int | None = None, + dataset_name: str = "eval_dataset", + model_name: str | None = None, + ): + self.trainer = trainer + self.project_name = project_name + self.scorers = scorers or {} + self.generation_config = generation_config + self.dataset_name = dataset_name + self.model_name = model_name + self._last_logged_step = -1 + self._weave_initialized = False + self._eval_logger = None + + if self.trainer.eval_dataset is None: + raise ValueError("Trainer must have an evaluation dataset to use the WeaveCallback.") + else: + self.eval_dataset = self.trainer.eval_dataset + + if num_prompts is not None: + self.eval_dataset = self.eval_dataset.select(range(num_prompts)) + + def _initialize_weave(self): + """Initialize Weave and EvaluationLogger if not already initialized.""" + if not self._weave_initialized: + if not is_weave_available(): + logger.warning("Weave is not available. Please install weave to enable logging: `pip install weave`") + return + + if wc := weave_client_context.get_weave_client(): + self._weave_client = wc + else: + if self.project_name is None: + if is_wandb_available(): + if wandb.run is not None: + self.project_name = wandb.run.entity + "/" + wandb.run.project + logger.info(f"Using project name from active wandb run: {self.project_name}") + + if self.project_name is None: + raise ValueError( + "No existing Weave client found and no project_name provided. " + "Please either initialize weave with `weave.init('project-name')`, " + "provide a project_name to the `WeaveTraceCallback`, " + "or ensure an active wandb run exists." + ) + + self._weave_client = weave.init(self.project_name) + logger.info(f"Initialized Weave with project: {self.project_name}") + + if self.model_name is None: + self.model_name = getattr(self.trainer.model_wrapped.config, "_name_or_path", "unknown_model") + + self._EvaluationLogger = EvaluationLogger + + self._weave_initialized = True + + @property + def is_evaluation_mode(self) -> bool: + """True if scorers are provided (evaluation mode), False for tracing mode.""" + return bool(self.scorers) + + def on_train_begin(self, args, state, control, **kwargs): + """Initialize Weave when training begins.""" + self._initialize_weave() + + def on_evaluate(self, args, state, control, **kwargs): + if state.global_step == self._last_logged_step: + return + + self._initialize_weave() + + if not self._weave_initialized: + logger.debug("Weave not initialized, skipping logging") + return + + tokenizer = kwargs["processing_class"] + tokenizer.padding_side = "left" + accelerator = self.trainer.accelerator + model = self.trainer.model_wrapped + + with accelerator.split_between_processes(self.eval_dataset["prompt"]) as prompts: + prompts = [maybe_apply_chat_template({"prompt": prompt}, tokenizer)["prompt"] for prompt in prompts] + + completions = _generate_completions( + prompts=prompts, + model=model, + tokenizer=tokenizer, + accelerator=accelerator, + generation_config=self.generation_config, + batch_size=args.per_device_eval_batch_size, + ) + + all_prompts = gather_object(prompts) + all_completions = gather_object(completions) + + if self.trainer.accelerator.is_main_process: + eval_attributes = { + "training_step": state.global_step, + "model_name": self.model_name, + "generation_config": (self.generation_config.to_dict() if self.generation_config else None), + } + + eval_logger = self._EvaluationLogger( + model=self.model_name, + dataset=self.dataset_name, + eval_attributes=eval_attributes, + ) + + successful_predictions = 0 + total_score_values = {} # For summary statistics + + for prompt, completion in zip(all_prompts, all_completions, strict=True): + try: + pred_logger = eval_logger.log_prediction(inputs={"prompt": prompt}, output=completion) + + if self.is_evaluation_mode: + for scorer_name, scorer_func in self.scorers.items(): + try: + score = scorer_func(prompt, completion) + pred_logger.log_score(scorer=scorer_name, score=score) + + if scorer_name not in total_score_values: + total_score_values[scorer_name] = [] + total_score_values[scorer_name].append(score) + + except Exception as scorer_e: + logger.warning(f"Failed to apply scorer '{scorer_name}': {scorer_e}") + + pred_logger.finish() + successful_predictions += 1 + + except Exception as pred_e: + logger.warning(f"Failed to log prediction for prompt: {pred_e}") + # Continue with other predictions even if one fails + + if self.is_evaluation_mode and total_score_values: + try: + summary_stats = { + "total_predictions": len(all_prompts), + "successful_predictions": successful_predictions, + } + + for scorer_name, scores in total_score_values.items(): + if scores: # Only if we have valid scores + summary_stats[f"avg_{scorer_name}"] = sum(scores) / len(scores) + + eval_logger.log_summary(summary_stats) + + except Exception as summary_e: + logger.warning(f"Failed to log summary: {summary_e}") + else: + try: + eval_logger.finish() + except Exception as finish_e: + logger.warning(f"Failed to finish evaluation logger: {finish_e}") + + self._last_logged_step = state.global_step + + +class BEMACallback(TrainerCallback): + # docstyle-ignore + r""" + A [`~transformers.TrainerCallback`] that implements [BEMA](https://huggingface.co/papers/2508.00180) + (Bias-Corrected Exponential Moving Average) by [Adam Block](https://huggingface.co/abblock) and [Cyril + Zhang](https://huggingface.co/cyrilzhang). Code from https://github.com/abblock/bema under MIT license. + + BEMA computes model weights that scale like: + + $$ + \theta_t' = \alpha_t \cdot (\theta_t - \theta_0) + \text{EMA}_t + $$ + + where \\( \theta_t \\) is the current model weights, \\( \theta_0 \\) is a snapshot of the model weights at the + first `update_after` step, \\( \text{EMA}_t \\) is the exponential moving average of the model weights, and + \\( \alpha_t \\) is a scaling factor that decays with the number of steps \\( t \\) as + + $$ + \alpha_t = (\rho + \gamma \cdot t)^{-\eta}. + $$ + + The EMA is computed as: + + $$ + \text{EMA}_t = (1 - \beta_t) \cdot \text{EMA}_{t-1} + \beta_t \cdot \theta_t + $$ + + where \\( \beta_t \\) is a decay factor that decays with the number of steps \\( t \\) as + + $$ + \beta_t = (\rho + \gamma \cdot t)^{-\kappa}. + $$ + + Args: + update_freq (`int`, *optional*, defaults to `400`): + Update the BEMA weights every X steps. Denoted this as \\( \phi \\) in the paper. + ema_power (`float`, *optional*, defaults to `0.5`): + Power for the EMA decay factor. Denoted \\( \kappa \\) in the paper. To disable EMA, set this to `0.0`. + bias_power (`float`, *optional*, defaults to `0.2`): + Power for the BEMA scaling factor. Denoted \\( \eta \\) in the paper. To disable BEMA, set this to `0.0`. + lag (`int`, *optional*, defaults to `10`): + Initial offset in the weight decay schedule that controls early-stage smoothness by acting as a virtual + starting age for the updates. Denoted as \\( \rho \\) in the paper. + update_after (`int`, *optional*, defaults to `0`): + Burn-in time before starting to update the BEMA weights. Denoted \\( \tau \\) in the paper. + multiplier (`float`, *optional*, defaults to `1.0`): + Initial value for the EMA decay factor. Denoted as \\( \gamma \\) in the paper. + min_ema_multiplier (`float`, *optional*, defaults to `0.0`): + Minimum value for the EMA decay factor. + device (`str`, *optional*, defaults to `"cpu"`): + Device to use for the BEMA buffers, e.g. `"cpu"` or `"cuda"`. Note that in most cases, this device SHOULD + BE DIFFERENT from the device used for training in order to avoid OOM. + + Example: + + ```python + from trl import BEMACallback + + trainer = Trainer(..., callbacks=[BEMACallback()]) + ``` + """ + + def __init__( + self, + update_freq: int = 400, + ema_power: float = 0.5, + bias_power: float = 0.2, + lag: int = 10, + update_after: int = 0, + multiplier: float = 1.0, + min_ema_multiplier: float = 0.0, + device: str = "cpu", + ): + # User-provided hyperparams + self.update_freq = update_freq + self.ema_power = ema_power + self.bias_power = bias_power + self.lag = lag + self.update_after = update_after + self.multiplier = multiplier + self.min_ema_multiplier = min_ema_multiplier + self.device = device + + # Internal state + self.param_names = [] # references to training model param names + self.thetat_params = [] # references to training model params + self.theta0_params = [] # θ₀ buffers (on self.device) + self.ema_params = [] # EMA buffers (on self.device) + self.running_model = None # a copy of the model to run BEMA on + + @staticmethod + def _unwrap_model(model): + """ + Helper function to unwrap model from various wrappers including DataParallel, DistributedDataParallel, + DeepSpeed, and FSDP. + """ + # Handle DeepSpeed + if hasattr(model, "module") and hasattr(model, "engine"): + # DeepSpeed engine + return model.module + + # Handle FSDP + if hasattr(model, "_fsdp_wrapped_module"): + # FSDP wrapped model + return model._fsdp_wrapped_module + + # Handle DataParallel/DistributedDataParallel + if hasattr(model, "module"): + return model.module + + return model + + @torch.no_grad() + def on_train_begin( + self, args: TrainingArguments, state: TrainerState, control: TrainerControl, model: PreTrainedModel, **kwargs + ): + model = self._unwrap_model(model) + + # Create a new instance and load state_dict + self.running_model = type(model)(model.config).to(self.device) + self.running_model.load_state_dict(model.state_dict()) + + # Cache trainable parameters once in a fixed order + for name, param in model.named_parameters(): + if not param.requires_grad: + continue + self.param_names.append(name) + self.thetat_params.append(param) + + # Clone θ₀ and EMA on the same device as model + theta0 = param.detach().clone().to(self.device) + self.theta0_params.append(theta0) + self.ema_params.append(theta0.clone()) # initialize EMA with θ₀ + + def _ema_beta(self, step: int) -> float: + """Compute the EMA decay factor βₜ = (ρ + γ·t)⁻ᵏᵃᵖᵖᵃ.""" + beta = (self.lag + self.multiplier * step) ** (-self.ema_power) + return max(beta, self.min_ema_multiplier) + + def _bema_alpha(self, step: int) -> float: + """Compute the BEMA scaling factor αₜ = (ρ + γ·t)⁻ᵉᵗᵃ.""" + return (self.lag + self.multiplier * step) ** (-self.bias_power) + + def _update_bema_weights(self, step: int): + beta = self._ema_beta(step) + alpha = self._bema_alpha(step) + + # Compute EMA + BEMA in-place and write directly to running_model + for thetat, theta0, ema, run_param in zip( + self.thetat_params, self.theta0_params, self.ema_params, self.running_model.parameters(), strict=True + ): + thetat = thetat.detach().to(self.device) + ema.mul_(1 - beta).add_(thetat, alpha=beta) # EMA update: ema = (1 - beta) * ema + beta * θₜ + run_param.copy_(ema + alpha * (thetat - theta0)) # BEMA update: run_param = ema + alpha * (θₜ - θ₀) + + @torch.no_grad() + def on_step_end( + self, args: TrainingArguments, state: TrainerState, control: TrainerControl, model: PreTrainedModel, **kwargs + ): + step = state.global_step + + # If we haven't reached the update_after step, skip the BEMA update + if step < self.update_after: + return + + # Snapshot θ₀ and EMA at first update + if step == self.update_after: + for thetat_param, theta0_param, ema_param in zip( + self.thetat_params, self.theta0_params, self.ema_params, strict=True + ): + theta0_param.copy_(thetat_param) + ema_param.copy_(thetat_param) + + # Update BEMA weights every `update_freq` steps + elif (step - self.update_after) % self.update_freq == 0: + self._update_bema_weights(step) + logger.info(f"Updated BEMA weights at step {step}") + + @torch.no_grad() + def on_train_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs): + if state.is_world_process_zero: + save_directory = f"{args.output_dir}/bema" + self.running_model.save_pretrained(save_directory) + logger.info(f"Saved BEMA model to {save_directory}") diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/dpo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/dpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..1d22eba6b48dcb8df0b77c78f9f853e3f121cb07 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/dpo_config.py @@ -0,0 +1,354 @@ +# Copyright 2020-2026 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 warnings +from dataclasses import dataclass, field +from typing import Any + +from .base_config import _BaseConfig + + +@dataclass +class DPOConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`DPOTrainer`]. + + This class includes only the parameters that are specific to DPO training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + 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: + > Parameters that control the model + + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model` + argument of the [`DPOTrainer`] is provided as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and + [`~transformers.AutoProcessor.from_pretrained`]. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model and reference model. + + > Parameters that control the data preprocessing + + dataset_num_proc (`int`, *optional*): + Number of processes to use for processing the dataset. + max_length (`int` or `None`, *optional*, defaults to `1024`): + Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from the left or + right depending on the `truncation_mode`. If `None`, no truncation is applied. + truncation_mode (`str`, *optional*, defaults to `"keep_start"`): + Truncation mode to use when the sequence exceeds `max_length`. The only supported value is + `"keep_start"`. The `"keep_end"` value is deprecated and will be removed in v2.0.0. + padding_free (`bool`, *optional*, defaults to `False`): + Whether to perform forward passes without padding by flattening all sequences in the batch into a single + continuous sequence. This reduces memory usage by eliminating padding overhead. Currently, this is only + supported with the FlashAttention 2 or 3, which can efficiently handle the flattened batch structure. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + precompute_ref_log_probs (`bool`, *optional*, defaults to `False`): + Whether to precompute the reference model log probabilities for the entire training dataset before + training. This allows to save memory during training, as the reference model does not need to be kept in + memory. + precompute_ref_batch_size (`int`, *optional*): + Batch size to use when precomputing reference model log probabilities. This can be set higher than the + training batch size to speed up preprocessing. If `None`, defaults to `per_device_train_batch_size` for + training and `per_device_eval_batch_size` for evaluation. + + > Parameters that control the training + + loss_type (`list[str]`, *optional*, defaults to `["sigmoid"]`): + Type of loss to use. Possible values are: `'sigmoid'`, `'hinge'`, `'ipo'`, `'exo_pair'`, `'nca_pair'`, + `'robust'`, `'bco_pair'`, `'sppo_hard'`, `'aot'`, `'aot_unpaired'`, `'apo_zero'`, `'apo_down'`, + `'discopop'`, `'sft'`, `'sigmoid_norm'`. If multiple loss types are provided, they will be combined using + the weights specified in `loss_weights`. + loss_weights (`list[float]`, *optional*): + List of loss weights for multi-loss combinations. Used when combining multiple loss types. Example: `[0.8, + 0.2, 1.0]` for MPO. If not provided, defaults to equal weights (`1.0`) for all loss types. + ld_alpha (`float`, *optional*): + α parameter from the LD-DPO paper, which controls the weighting of the verbose token log-probabilities in + responses. If `None`, no weighting is applied to the verbose part, and the loss is equivalent to the + standard DPO loss. Must be in [0.0, 1.0]: `ld_alpha=1.0` applies no weighting, and `ld_alpha=0.0` masks + tokens beyond shared lengths. + f_divergence_type (`str`, *optional*, defaults to `"reverse_kl"`): + f-divergence regularizer between policy and reference (f-DPO paper). Possible values are: `reverse_kl` + (default), `forward_kl`, `js_divergence`, `alpha_divergence`. + f_alpha_divergence_coef (`float`, *optional*, defaults to `0.5`): + α coefficient for the α-divergence u^-α regularizer, used only when `f_divergence_type='alpha_divergence'`. + label_smoothing (`float`, *optional*, defaults to `0.0`): + Label smoothing parameter used in Robust DPO and EXO. In Robust DPO, it is interpreted as the probability + that a preference label is flipped and must lie in [0.0, 0.5); a typical value recommended by the Robust + DPO paper is 0.1. In EXO, it corresponds to the ε label smoothing parameter, for which the paper recommends + a typical value of 1e-3. + beta (`float`, *optional*, defaults to `0.1`): + Parameter controlling the deviation from the reference model. Higher β means less deviation from the + reference model. For the IPO loss (`loss_type='ipo'`), this value is the regularization parameter denoted + by τ in the [paper](https://huggingface.co/papers/2310.12036). + use_weighting (`bool`, *optional*, defaults to `False`): + Whether to apply WPO-style weighting (https://huggingface.co/papers/2406.11827) to preference pairs using + the policy's length-normalized sequence probabilities. + discopop_tau (`float`, *optional*, defaults to `0.05`): + τ/temperature parameter from the DiscoPOP paper, which controls the shape of the log-ratio modulated loss + when using `loss_type='discopop'`. The paper recommends the default value `discopop_tau=0.05`. + activation_offloading (`bool`, *optional*, defaults to `False`): + Whether to offload the activations to the CPU. + sync_ref_model (`bool`, *optional*, defaults to `False`): + Whether to synchronize the reference model with the active model every `ref_model_sync_steps` steps, using + the `ref_model_mixup_alpha` parameter. This synchronization originates from the + [TR-DPO](https://huggingface.co/papers/2404.09656) paper. `sync_ref_model=True` is not yet compatible with + PEFT or `precompute_ref_log_probs=True`. + ref_model_mixup_alpha (`float`, *optional*, defaults to `0.6`): + α parameter from the TR-DPO paper, which controls the mix between the current policy and the previous + reference policy during updates. The reference policy is updated according to the equation: `π_ref = α * + π_θ + (1 - α) * π_ref_prev`. To use this parameter, you must set `sync_ref_model=True`. + ref_model_sync_steps (`int`, *optional*, defaults to `512`): + τ parameter from the TR-DPO paper, which determines how frequently the current policy is synchronized with + the reference policy. To use this parameter, you must set `sync_ref_model=True`. + + > Deprecated parameters + + pad_token: + + + + Parameter `pad_token` is deprecated and will be removed in version v2.0.0. Set `tokenizer.pad_token` + directly and pass it as `processing_class` to the trainer instead. + + + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `1e-6` instead of `5e-5`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=1e-6, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + # Parameters that control the model + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument of " + "the `DPOTrainer` is provided as a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the model and reference model."}, + ) + + # Parameters that control the data preprocessing + dataset_num_proc: int | None = field( + default=None, + metadata={"help": "Number of processes to use for processing the dataset."}, + ) + max_length: int | None = field( + default=1024, + metadata={ + "help": "Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from " + "the left or right depending on the `truncation_mode`. If `None`, no truncation is applied." + }, + ) + truncation_mode: str = field( + default="keep_start", + metadata={ + "help": "Truncation mode to use when the sequence exceeds `max_length`. The only supported value is " + "`'keep_start'`. The `'keep_end'` value is deprecated and will be removed in v2.0.0.", + "choices": ["keep_end", "keep_start"], + }, + ) + padding_free: bool = field( + default=False, + metadata={ + "help": "Whether to perform forward passes without padding by flattening all sequences in the batch into " + "a single continuous sequence. This reduces memory usage by eliminating padding overhead. Currently, this " + "is only supported with the FlashAttention 2 or 3, which can efficiently handle the flattened batch " + "structure." + }, + ) + pad_to_multiple_of: int | None = field( + default=None, + metadata={"help": "If set, the sequences will be padded to a multiple of this value."}, + ) + precompute_ref_log_probs: bool = field( + default=False, + metadata={ + "help": "Whether to precompute the reference model log probabilities for the entire training dataset " + "before training. This allows to save memory during training, as the reference model does not need to be " + "kept in memory." + }, + ) + precompute_ref_batch_size: int | None = field( + default=None, + metadata={ + "help": "Batch size to use when precomputing reference model log probabilities. This can be set higher " + "than the training batch size to speed up preprocessing. If `None`, defaults to " + "`per_device_train_batch_size` for training and `per_device_eval_batch_size` for evaluation." + }, + ) + + # Parameters that control the training + loss_type: list[str] = field( + default_factory=lambda: ["sigmoid"], + metadata={ + "help": "Type of loss to use. Possible values are: `'sigmoid'`, `'hinge'`, `'ipo'`, `'exo_pair'`, " + "`'nca_pair'`, `'robust'`, `'bco_pair'`, `'sppo_hard'`, `'aot'`, `'aot_unpaired'`, `'apo_zero'`, " + "`'apo_down'`, `'discopop'`, `'sft'`, `'sigmoid_norm'`. If multiple loss types are provided, they will be " + "combined using the weights specified in `loss_weights`.", + }, + ) + loss_weights: list[float] | None = field( + default=None, + metadata={ + "help": "List of loss weights for multi-loss combinations. Used when combining multiple loss types. " + "Example: `[0.8, 0.2, 1.0]` for MPO. If not provided, defaults to equal weights (`1.0`) for all loss " + "types." + }, + ) + ld_alpha: float | None = field( + default=None, + metadata={ + "help": "α parameter from the LD-DPO paper, which controls the weighting of the verbose token " + "log-probabilities in responses. If `None`, no weighting is applied to the verbose part, and the loss is " + "equivalent to the standard DPO loss. Must be in [0.0, 1.0]: `ld_alpha=1.0` applies no weighting, and " + "`ld_alpha=0.0` masks tokens beyond shared lengths.", + }, + ) + f_divergence_type: str = field( + default="reverse_kl", + metadata={ + "help": "f-divergence regularizer between policy and reference (f-DPO paper). Possible values are: " + "`reverse_kl` (default), `forward_kl`, `js_divergence`, `alpha_divergence`.", + }, + ) + f_alpha_divergence_coef: float = field( + default=0.5, + metadata={ + "help": "α coefficient for the α-divergence u^-α regularizer, used only when " + "`f_divergence_type='alpha_divergence'`." + }, + ) + label_smoothing: float = field( + default=0.0, + metadata={ + "help": "Label smoothing parameter used in Robust DPO and EXO. In Robust DPO, it is interpreted as the " + "probability that a preference label is flipped and must lie in [0.0, 0.5); a typical value recommended " + "by the Robust DPO paper is 0.1. In EXO, it corresponds to the ε label smoothing parameter, for which the " + "paper recommends a typical value of 1e-3." + }, + ) + beta: float = field( + default=0.1, + metadata={ + "help": "Parameter controlling the deviation from the reference model. Higher β means less deviation from " + "the reference model. For the IPO loss (`loss_type='ipo'`), this value is the regularization parameter " + "denoted by τ in the [paper](https://huggingface.co/papers/2310.12036)." + }, + ) + use_weighting: bool = field( + default=False, + metadata={ + "help": "Whether to apply WPO-style weighting (https://huggingface.co/papers/2406.11827) to preference " + "pairs using the policy's length-normalized sequence probabilities." + }, + ) + discopop_tau: float = field( + default=0.05, + metadata={ + "help": "τ/temperature parameter from the DiscoPOP paper, which controls the shape of the log-ratio " + "modulated loss when using `loss_type='discopop'`. The paper recommends the default value " + "`discopop_tau=0.05`." + }, + ) + activation_offloading: bool = field( + default=False, + metadata={"help": "Whether to offload the activations to the CPU."}, + ) + sync_ref_model: bool = field( + default=False, + metadata={ + "help": "Whether to synchronize the reference model with the active model every `ref_model_sync_steps` " + "steps, using the `ref_model_mixup_alpha` parameter. This synchronization originates from the " + "[TR-DPO](https://huggingface.co/papers/2404.09656) paper. `sync_ref_model=True` is not yet compatible " + "with PEFT or `precompute_ref_log_probs=True`." + }, + ) + ref_model_mixup_alpha: float = field( + default=0.6, + metadata={ + "help": "α parameter from the TR-DPO paper, which controls the mix between the current policy and the " + "previous reference policy during updates. The reference policy is updated according to the equation: " + "`π_ref = α * π_θ + (1 - α) * π_ref_prev`. To use this parameter, you must set `sync_ref_model=True`." + }, + ) + ref_model_sync_steps: int = field( + default=512, + metadata={ + "help": "τ parameter from the TR-DPO paper, which determines how frequently the current policy is " + "synchronized with the reference policy. To use this parameter, you must set `sync_ref_model=True`." + }, + ) + + # Deprecated parameters + pad_token: str | None = field( + default=None, + metadata={ + "help": "Deprecated. Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead." + }, + ) + + def __post_init__(self): + if isinstance(self.loss_type, str): + self.loss_type = [self.loss_type] + if self.loss_weights is not None and len(self.loss_weights) != len(self.loss_type): + raise ValueError( + "`loss_weights` must have the same length as `loss_type` when combining multiple losses. " + f"Got {len(self.loss_weights)} weights for {len(self.loss_type)} loss types." + ) + if self.pad_token is not None: + warnings.warn( + "`pad_token` is deprecated and will be removed in v2.0.0. " + "Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead.", + FutureWarning, + stacklevel=3, + ) + if self.truncation_mode == "keep_end": + warnings.warn( + "The `'keep_end'` truncation mode is deprecated and will be removed in v2.0.0. " + "Use `truncation_mode='keep_start'` (the default) instead.", + FutureWarning, + stacklevel=3, + ) + + super().__post_init__() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/dpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/dpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..2d58d09cc1793b2aebc979a9edfc6e8a3dc0c822 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/dpo_trainer.py @@ -0,0 +1,1621 @@ +# Copyright 2020-2026 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 contextlib +import json +import os +import textwrap +from collections import defaultdict +from collections.abc import Callable +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import torch +import torch.nn.functional as F +import transformers +from accelerate import PartialState +from accelerate.logging import get_logger +from accelerate.utils import is_peft_model, tqdm +from datasets import Dataset, IterableDataset, IterableDatasetDict, concatenate_datasets +from datasets.fingerprint import Hasher +from packaging.version import Version +from torch.utils.data import DataLoader +from transformers import ( + AutoProcessor, + DataCollator, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, +) +from transformers.data.data_collator import DataCollatorMixin +from transformers.trainer_callback import TrainerCallback +from transformers.trainer_utils import EvalPrediction +from transformers.utils import is_liger_kernel_available, is_peft_available + +from ..data_utils import apply_chat_template, extract_prompt, is_conversational, prepare_multimodal_messages +from ..models import get_act_offloading_ctx_manager, prepare_deepspeed, prepare_fsdp +from ..models.utils import disable_gradient_checkpointing +from .base_trainer import _BaseTrainer +from .callbacks import SyncRefModelCallback +from .dpo_config import DPOConfig +from .utils import ( + create_model_from_path, + disable_dropout_in_model, + entropy_from_logits, + flush_left, + get_config_model_id, + hash_module, + pad, + selective_log_softmax, + use_adapter, +) + + +if is_peft_available(): + import peft + from peft import LoraConfig, PeftConfig, PeftModel, get_peft_model + + +if is_liger_kernel_available(): + from liger_kernel.chunked_loss import LigerFusedLinearDPOLoss + + +logger = get_logger(__name__) + + +FLASH_ATTENTION_VARIANTS = { + "flash_attention_2", + "flash_attention_3", + "kernels-community/flash-attn2", + "kernels-community/flash-attn3", + "kernels-community/vllm-flash-attn3", +} + + +def get_dataset_column_names(dataset: Dataset | IterableDataset) -> list[str]: + return list(next(iter(dataset)).keys()) if dataset.column_names is None else dataset.column_names + + +@dataclass +class DataCollatorForPreference(DataCollatorMixin): + """ + Data collator used for preference data. Inputs are dynamically padded to the maximum length of a batch. + + This collator expects each example in the input list to be a dictionary containing the keys `"prompt_ids"`, + `"chosen_ids"` and `"rejected_ids"`. The collator returns a dictionary containing the following keys: + - `"input_ids"`: Tensor of input IDs, padded to the maximum length of the batch. The first half of the batch + corresponds to the `"chosen_ids"` and the second half to the `"rejected_ids"`. + - `"attention_mask"`: Tensor of attention mask, padded to the maximum length of the batch. + - `"completion_mask"`: Tensor indicating the positions of the completion tokens, padded to the maximum length of + the batch. + + Optionally, the examples can contain a `"ref_chosen_logps"` and `"ref_rejected_logps"` keys, in which case the + returned dictionary will also contain these keys with the corresponding tensors. + + Args: + pad_token_id (`int`): + Token ID to use for padding. + max_length (`int`, *optional*): + Maximum length of the sequences after concatenation. Sequences longer than `max_length` are truncated + before padding, which avoids allocating oversized tensors for batches containing very long sequences. + truncation_mode (`str`, *optional*, defaults to `"keep_start"`): + Truncation mode when a concatenated sequence exceeds `max_length`. Possible values are `"keep_end"` and + `"keep_start"`. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + return_tensors (`str`, *optional*, defaults to `"pt"`): + Type of Tensor to return. Only `"pt"` is currently supported. + + Examples: + ```python + >>> from trl.trainer.dpo_trainer import DataCollatorForPreference + + >>> collator = DataCollatorForPreference(pad_token_id=0) + >>> examples = [ + ... {"prompt_ids": [1, 2, 3], "chosen_ids": [4, 5], "rejected_ids": [6]}, + ... {"prompt_ids": [7, 8], "chosen_ids": [9], "rejected_ids": [10, 11]}, + ... ] + >>> collator(examples) + {'input_ids': tensor([[ 1, 2, 3, 4, 5], + [ 7, 8, 9, 0, 0], + [ 1, 2, 3, 6, 0], + [ 7, 8, 10, 11, 0]]), + 'attention_mask': tensor([[1, 1, 1, 1, 1], + [1, 1, 1, 0, 0], + [1, 1, 1, 1, 0], + [1, 1, 1, 1, 0]]), + 'completion_mask': tensor([[0, 0, 0, 1, 1], + [0, 0, 1, 0, 0], + [0, 0, 0, 1, 0], + [0, 0, 1, 1, 0]])} + ``` + """ + + pad_token_id: int + max_length: int | None = None + truncation_mode: str = "keep_start" + pad_to_multiple_of: int | None = None + return_tensors: str = "pt" + + def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]: + prompt_chosen_ids = [example["prompt_ids"] + example["chosen_ids"] for example in examples] + prompt_rejected_ids = [example["prompt_ids"] + example["rejected_ids"] for example in examples] + chosen_mask = [[0] * len(example["prompt_ids"]) + [1] * len(example["chosen_ids"]) for example in examples] + rejected_mask = [[0] * len(example["prompt_ids"]) + [1] * len(example["rejected_ids"]) for example in examples] + + if self.max_length is not None: + if self.truncation_mode == "keep_start": + sl = slice(None, self.max_length) + elif self.truncation_mode == "keep_end": + sl = slice(-self.max_length, None) + else: + raise ValueError( + f"Unsupported truncation mode: {self.truncation_mode}, expected 'keep_start' or 'keep_end'" + ) + prompt_chosen_ids = [ids[sl] for ids in prompt_chosen_ids] + prompt_rejected_ids = [ids[sl] for ids in prompt_rejected_ids] + chosen_mask = [m[sl] for m in chosen_mask] + rejected_mask = [m[sl] for m in rejected_mask] + + chosen_attention_mask = [[1] * len(ids) for ids in prompt_chosen_ids] + rejected_attention_mask = [[1] * len(ids) for ids in prompt_rejected_ids] + input_ids = prompt_chosen_ids + prompt_rejected_ids + attention_mask = chosen_attention_mask + rejected_attention_mask + completion_mask = chosen_mask + rejected_mask + + # Convert to tensor + input_ids = [torch.tensor(ids) for ids in input_ids] + attention_mask = [torch.tensor(m, dtype=torch.long) for m in attention_mask] + completion_mask = [torch.tensor(m, dtype=torch.long) for m in completion_mask] + if "ref_chosen_logps" in examples[0]: + ref_chosen_logps = torch.tensor([example["ref_chosen_logps"] for example in examples]) + if "ref_rejected_logps" in examples[0]: + ref_rejected_logps = torch.tensor([example["ref_rejected_logps"] for example in examples]) + + # Pad + output = {} + output["input_ids"] = pad( + input_ids, + padding_value=self.pad_token_id, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + output["attention_mask"] = pad( + attention_mask, + padding_value=0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + output["completion_mask"] = pad( + completion_mask, + padding_value=0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + if "ref_chosen_logps" in examples[0]: + output["ref_chosen_logps"] = ref_chosen_logps + if "ref_rejected_logps" in examples[0]: + output["ref_rejected_logps"] = ref_rejected_logps + return output + + +@dataclass +class DataCollatorForVisionPreference(DataCollatorMixin): + """ + Data collator for vision-preference tasks. + + Unlike text-only datasets, where the collator typically receives pre-tokenized inputs ready for batching, + vision-language data processing involves converting images into pixel values. This conversion is disk-intensive, + making upfront preprocessing of the entire dataset impractical. Therefore, this collator performs tokenization and + image processing on-the-fly to efficiently prepare batches. + + Each input example should be a dictionary containing at least: + - An `"images"` key holding a list of images, or an `"image"` key holding a single image. + - Keys `"prompt"` `"chosen"` and `"rejected"` for the prompt and preference responses. + + The collator outputs a dictionary including: + - `"input_ids"`: Tensor of token IDs. + - `"attention_mask"`: Tensor indicating attention mask. + - `"completion_mask"`: Tensor indicating which tokens correspond to completions. + - `"pixel_values"`: Tensor representing image pixel values. + + Additional keys may be present depending on the processor, such as `"image_grid_thw"` or `"image_position_ids"`. + + Args: + processor ([`~transformers.ProcessorMixin`]): + The processor used to tokenize text and process images. It must be a subclass of + [`~transformers.ProcessorMixin`] and include a `tokenizer` with a defined `pad_token_id`. + max_length (`int`, *optional*): + Maximum sequence length. Sequences longer than `max_length` are truncated before padding, which avoids + allocating oversized tensors for batches containing very long sequences. Only `"keep_start"` truncation + applies to vision datasets; `"keep_end"` is rejected upstream. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + return_tensors (`str`, *optional*, defaults to `"pt"`): + The tensor type to return. Currently, only `"pt"` (PyTorch tensors) is supported. + + Example: + ```python + >>> from trl.trainer.dpo_trainer import DataCollatorForVisionPreference + >>> from transformers import AutoProcessor + + >>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct") + >>> collator = DataCollatorForVisionPreference(processor) + >>> examples = [ + ... { + ... "images": [Image.open("image_0.png")], + ... "prompt": [{"role": "user", "content": "What is this?"}], + ... "chosen": [{"role": "assistant", "content": "This is a cat."}], + ... "rejected": [{"role": "assistant", "content": "This is a dog."}], + ... }, + ... { + ... "images": [Image.open("image_1.png")], + ... "prompt": [{"role": "user", "content": "Describe this image."}], + ... "chosen": [{"role": "assistant", "content": "A beautiful landscape."}], + ... "rejected": [{"role": "assistant", "content": "An urban cityscape."}], + ... }, + ... ] + >>> collator(examples) + {'input_ids': tensor([[151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 3838, 374, 419, 30, 151645, 198, 151644, 77091, 198, 1986, 374, 264, 8251, 13, 151645, 198], + [151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 74785, 419, 2168, 13, 151645, 198, 151644, 77091, 198, 32, 6233, 18414, 13, 151645, 198, 151643], + [151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 3838, 374, 419, 30, 151645, 198, 151644, 77091, 198, 1986, 374, 264, 5562, 13, 151645, 198], + [151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 74785, 419, 2168, 13, 151645, 198, 151644, 77091, 198, 2082, 15662, 3283, 57518, 13, 151645, 198]]), + 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], + [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], + [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], + [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]), + 'pixel_values': tensor([[-1.3251, 0.1347, -0.4784, ..., 0.4537, -0.0156, 1.2358], + [ 0.5727, 0.4997, -0.9164, ..., -0.5701, 0.7950, -0.7123], + [-0.0550, -0.8288, 1.0690, ..., -0.1293, -0.1151, 1.6055], + ..., + [ 0.2953, 0.5581, 0.1785, ..., -0.7123, -0.7977, 0.1693], + [-0.7558, 1.0398, 1.3464, ..., -0.5417, -0.5417, 0.4395], + [ 0.8063, 0.6895, 0.4267, ..., -0.4422, 1.3354, 0.1266]]), + 'image_grid_thw': tensor([[1, 4, 4], + [1, 4, 4], + [1, 4, 4], + [1, 4, 4]]), + 'completion_mask': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]])} + ``` + """ + + processor: ProcessorMixin + max_length: int | None = None + pad_to_multiple_of: int | None = None + return_tensors: str = "pt" + + def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]: + if self.pad_to_multiple_of is not None: + raise NotImplementedError( + "Padding to a multiple of a value is not yet implemented for vision-language modeling and " + "prompt-completion data." + ) + if "image" in examples[0]: + for example in examples: + example["images"] = [example.pop("image")] + images = [example["images"] for example in examples] * 2 # repeat for chosen and rejected + # Transformers requires at least one image in the batch, otherwise it throws an error + if all(img_list == [] for img_list in images): + images = None + if is_conversational(examples[0]): # conversational case + for example in examples: + example["prompt"] = prepare_multimodal_messages(example["prompt"], images=example["images"]) + example["chosen"] = prepare_multimodal_messages(example["chosen"]) + example["rejected"] = prepare_multimodal_messages(example["rejected"]) + examples = [apply_chat_template(example, self.processor) for example in examples] + + prompts = [example["prompt"] for example in examples] * 2 # repeat for chosen and rejected + chosens = [example["chosen"] for example in examples] + rejecteds = [example["rejected"] for example in examples] + + processed_prompts = self.processor( + images=images, + text=prompts, + padding=True, + padding_side="left", + return_tensors=self.return_tensors, + add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens + ) + processed_chosens = self.processor( + text=chosens, + padding=True, + padding_side="right", + return_tensors=self.return_tensors, + add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens + ) + processed_rejecteds = self.processor( + text=rejecteds, + padding=True, + padding_side="right", + return_tensors=self.return_tensors, + add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens + ) + + # Concatenate prompts and completions + prompt_ids, prompt_mask = processed_prompts["input_ids"], processed_prompts["attention_mask"] + chosen_ids, chosen_mask = processed_chosens["input_ids"], processed_chosens["attention_mask"] + rejected_ids, rejected_mask = processed_rejecteds["input_ids"], processed_rejecteds["attention_mask"] + pad_token_id = self.processor.tokenizer.pad_token_id or self.processor.tokenizer.eos_token_id + completion_ids = torch.cat(tuple(pad([chosen_ids, rejected_ids], padding_value=pad_token_id))) + completion_mask = torch.cat(tuple(pad([chosen_mask, rejected_mask], padding_value=0))) + input_ids = torch.cat((prompt_ids, completion_ids), dim=1) + attention_mask = torch.cat((prompt_mask, completion_mask), dim=1) + completion_mask = torch.cat((torch.zeros_like(prompt_mask), completion_mask), dim=1) + if "token_type_ids" in processed_prompts: # special case for Gemma + prompt_token_type_ids = processed_prompts["token_type_ids"] + chosen_type_ids = processed_chosens["token_type_ids"] + rejected_type_ids = processed_rejecteds["token_type_ids"] + completion_token_type_ids = torch.cat(tuple(pad([chosen_type_ids, rejected_type_ids], padding_value=0))) + token_type_ids = torch.cat((prompt_token_type_ids, completion_token_type_ids), dim=1) + if "mm_token_type_ids" in processed_prompts: # special case for Qwen2.5-VL + prompt_mm_token_type_ids = processed_prompts["mm_token_type_ids"] + mm_token_type_ids = torch.cat((prompt_mm_token_type_ids, torch.zeros_like(completion_ids)), dim=1) + + # Flush left to reduce padding + if "token_type_ids" in processed_prompts and "mm_token_type_ids" in processed_prompts: + attention_mask, input_ids, completion_mask, token_type_ids, mm_token_type_ids = flush_left( + attention_mask, input_ids, completion_mask, token_type_ids, mm_token_type_ids + ) + elif "token_type_ids" in processed_prompts: + attention_mask, input_ids, completion_mask, token_type_ids = flush_left( + attention_mask, input_ids, completion_mask, token_type_ids + ) + elif "mm_token_type_ids" in processed_prompts: + attention_mask, input_ids, completion_mask, mm_token_type_ids = flush_left( + attention_mask, input_ids, completion_mask, mm_token_type_ids + ) + else: + attention_mask, input_ids, completion_mask = flush_left(attention_mask, input_ids, completion_mask) + + if self.max_length is not None: + input_ids = input_ids[:, : self.max_length] + attention_mask = attention_mask[:, : self.max_length] + completion_mask = completion_mask[:, : self.max_length] + if "token_type_ids" in processed_prompts: + token_type_ids = token_type_ids[:, : self.max_length] + if "mm_token_type_ids" in processed_prompts: + mm_token_type_ids = mm_token_type_ids[:, : self.max_length] + + # Build the output dictionary + output = processed_prompts # we take processed_prompts because it contains the images + output["input_ids"] = input_ids + output["attention_mask"] = attention_mask + output["completion_mask"] = completion_mask + if "token_type_ids" in processed_prompts: + output["token_type_ids"] = token_type_ids + if "mm_token_type_ids" in processed_prompts: + output["mm_token_type_ids"] = mm_token_type_ids + return output + + +class DPOTrainer(_BaseTrainer): + """ + Trainer for Direct Preference Optimization (DPO) method. This algorithm was initially proposed in the paper [Direct + Preference Optimization: Your Language Model is Secretly a Reward Model](https://huggingface.co/papers/2305.18290). + This class is a wrapper around the [`~transformers.Trainer`] class and inherits all of its attributes and methods. + + Example: + + ```python + from trl import DPOTrainer + from datasets import load_dataset + + dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train") + + trainer = DPOTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", + train_dataset=dataset, + ) + trainer.train() + ``` + + Args: + model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]): + Model to be trained. Can be either: + + - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using `.from_pretrained` (where `` is derived from the model + config) with the keyword arguments in `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported. + - A [`~peft.PeftModel`] object. Only causal language models are supported. + ref_model ([`~transformers.PreTrainedModel`], *optional*): + Reference model used to compute the reference log probabilities. + + - If provided, this model is used directly as the reference policy. + - If `None`, the trainer will automatically use the initial policy corresponding to `model`, i.e. the model + state before DPO training starts. + args ([`DPOConfig`], *optional*): + Configuration for this trainer. If `None`, a default configuration is used. + data_collator ([`~transformers.DataCollator`], *optional*): + Function to use to form a batch from a list of elements of the processed `train_dataset` or `eval_dataset`. + Will default to [`~trainer.dpo_trainer.DataCollatorForPreference`] if the model is a language model and + [`~trainer.dpo_trainer.DataCollatorForVisionPreference`] if the model is a vision-language model. Custom + collators must truncate sequences before padding; the trainer does not apply post-collation truncation. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + Dataset to use for training. This trainer supports both [language modeling](#language-modeling) type and + [prompt-completion](#prompt-completion) type. The format of the samples can be either: + + - [Standard](dataset_formats#standard): Each sample contains plain text. + - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role + and content). + eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`): + Dataset to use for evaluation. It must meet the same requirements as `train_dataset`. + processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. The padding side must be set to "left". If `None`, the + processing class is loaded from the model's name with [`~transformers.AutoProcessor.from_pretrained`]. A + padding token, `tokenizer.pad_token`, must be set. If the processing class has not set a padding token, + `tokenizer.eos_token` will be used as the default. + compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*): + The function that will be used to compute metrics at evaluation. Must take a + [`~transformers.EvalPrediction`] and return a dictionary string to metric values. When passing + [`SFTConfig`] with `batch_eval_metrics` set to `True`, your `compute_metrics` function must take a boolean + `compute_result` argument. This will be triggered after the last eval batch to signal that the function + needs to calculate and return the global summary statistics rather than accumulating the batch-level + statistics. + callbacks (list of [`~transformers.TrainerCallback`], *optional*): + List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed + in [here](https://huggingface.co/docs/transformers/main_classes/callback). + + If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`] + method. + optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`): + A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your + model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration used to wrap the model. If `None`, the model is not wrapped. + """ + + _tag_names = ["trl", "dpo"] + _name = "DPO" + _paper = { + "title": "Direct Preference Optimization: Your Language Model is Secretly a Reward Model", + "id": "2305.18290", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @inproceedings{rafailov2023direct, + title = {{Direct Preference Optimization: Your Language Model is Secretly a Reward Model}}, + author = {Rafael Rafailov and Archit Sharma and Eric Mitchell and Christopher D. Manning and Stefano Ermon and Chelsea Finn}, + year = 2023, + booktitle = {Advances in Neural Information Processing Systems 36: Annual Conference on Neural Information Processing Systems 2023, NeurIPS 2023, New Orleans, LA, USA, December 10 - 16, 2023}, + url = {http://papers.nips.cc/paper_files/paper/2023/hash/a85b405ed65c6477a4fe8302b5e06ce7-Abstract-Conference.html}, + editor = {Alice Oh and Tristan Naumann and Amir Globerson and Kate Saenko and Moritz Hardt and Sergey Levine}, + }"""), + } + + def __init__( + self, + model: "str | PreTrainedModel | PeftModel", + ref_model: PreTrainedModel | None = None, + args: DPOConfig | None = None, + data_collator: DataCollator | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + compute_metrics: Callable[[EvalPrediction], dict] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + peft_config: "PeftConfig | None" = None, + ): + # Args + if args is None: + model_name = model if isinstance(model, str) else get_config_model_id(model.config) + model_name = model_name.split("/")[-1] + args = DPOConfig(f"{model_name}-DPO") + + if train_dataset is None: + raise ValueError("`train_dataset` is required") + elif isinstance(train_dataset, IterableDataset): + # IterableDataset requires dispatch_batches=False because Accelerate's dispatch mode may try to concatenate + # batches from multiple processes, leading to mismatch errors. + if args.accelerator_config.dispatch_batches is True: + logger.warning( + "You are using an `IterableDataset` for training with `dispatch_batches=True`. `dispatch_batches` " + "is forced to `False` when using an `IterableDataset`. To remove this warning, unset " + "`dispatch_batches` in `DPOConfig` or set it to `False`." + ) + args.accelerator_config.dispatch_batches = False + + # Model + if isinstance(model, str): + model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + model = create_model_from_path(model, **model_init_kwargs) + else: + if args.model_init_kwargs is not None: + logger.warning( + "You passed `model_init_kwargs` to the `DPOConfig`, but your model is already instantiated. " + "The `model_init_kwargs` will be ignored." + ) + # Non-quantized models do not have the `is_loaded_in_{8,4}bit` attributes, whereas quantized models do + _is_quantized_model = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False) + if ref_model is model: + raise ValueError( + "`model` and `ref_model` cannot be the same object. In most cases you should omit `ref_model` and " + "we'll initialize it to a copy of `model` for you." + ) + + # Processing class + if processing_class is None: + processing_class = AutoProcessor.from_pretrained( + get_config_model_id(model.config), trust_remote_code=args.trust_remote_code + ) + + # Handle pad token for processors or tokenizers + if isinstance(processing_class, ProcessorMixin): + self._tokenizer = processing_class.tokenizer + self._is_vlm = True + elif isinstance(processing_class, PreTrainedTokenizerBase): + self._tokenizer = processing_class + self._is_vlm = False + else: + raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`") + + if self._tokenizer.pad_token is None: + self._tokenizer.pad_token = self._tokenizer.eos_token + + # PEFT + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge " + "and unload the existing adapter, save the resulting base model, and then pass that base model along " + "with the new `peft_config` to the trainer." + ) + # Create PEFT model + # ZeRO-3 + PEFT for non-quantized models: + # - PEFT's default autocast_adapter_dtype=True upcasts LoRA adapter params to fp32 even when the base model is bf16. + # - ZeRO-3's _allgather_params_coalesced allocates output buffers using the dtype of the first persistent parameter, + # so mixed-dtype persistent_parameters (bf16 base + fp32 LoRA) cause a TypeError on the first optimizer step. + # - Passing autocast_adapter_dtype=False keeps adapter params in the base model dtype (bf16), fixing the mismatch. + # - This is safe: the fp32 upcast is a QLoRA-specific concern (low-bit quantized base models), not needed for + # non-quantized bf16 training. + # - See: + # - TRL issue: https://github.com/huggingface/trl/issues/6089 + # - Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/8072 + # - autocast_adapter_dtype was introduced in PEFT 0.12.0; before, no upcast existed: no need to pass the kwarg + get_peft_model_kwargs = {} + if ( + args.deepspeed_plugin is not None + and args.deepspeed_plugin.zero_stage == 3 + and not _is_quantized_model + and Version(peft.__version__) >= Version("0.12.0") + ): + get_peft_model_kwargs["autocast_adapter_dtype"] = False + model = get_peft_model(model, peft_config, **get_peft_model_kwargs) + + elif is_peft_model(model) and ref_model is None: + # If the model is a PEFT model with a pretrained adapter, we need to create a "ref" adapter that is a copy + # of the "default" adapter, so that we can use it as the reference model during DPO training. PEFT only + # supports one adapter per model when the LoRA config uses `target_parameters` (see peft#3340), so in that + # case we skip the "ref" adapter and compute the reference log probs with adapters disabled, i.e. with the + # base model. + default_config = model.peft_config["default"] + if isinstance(default_config, LoraConfig) and default_config.target_parameters: + logger.warning( + "PEFT can't add a frozen reference adapter alongside one that uses `target_parameters` " + "(peft#3340), so the reference log probs are computed from the base model (adapters disabled). " + "If you wrapped the model only to apply LoRA, pass a `peft_config` to the trainer instead; if you " + "wrapped it deliberately (pretrained adapter or custom init), note that the base model matches " + "your adapter only when it's freshly zero-initialized. If it is, this warning is safe to ignore." + ) + else: + model.add_adapter("ref", default_config) + for name, param in model.named_parameters(): + if ".default." in name: + ref_name = name.replace(".default.", ".ref.") + ref_param = model.get_parameter(ref_name) + ref_param.data.copy_(param.data) + + # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally + # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489 + if is_peft_model(model) and args.gradient_checkpointing: + model.enable_input_require_grads() + + # When using QLoRA, the PEFT adapter weights are converted to bf16 to follow the recommendations from the + # original paper (see https://huggingface.co/papers/2305.14314, paragraph 3). Normally, this can be done by + # passing `autocast_adapter_dtype=False` to `get_peft_model`, but this option is not yet supported for + # quantized models. See: https://github.com/huggingface/peft/issues/2889 + if _is_quantized_model: + for param in model.parameters(): + if param.requires_grad: + param.data = param.data.to(torch.bfloat16) + + # Data collator + self.padding_free = args.padding_free + if self.padding_free: + logger.warning( + "`padding_free=True` is temporarily unavailable after a refactor and is currently disabled. Falling " + "back to standard padding (`padding_free=False`). This feature is planned to return in a future " + "update; for now, please set `padding_free=False` explicitly." + ) + self.padding_free = False + dataset_sample = next(iter(train_dataset)) + self._is_vision_dataset = "image" in dataset_sample or "images" in dataset_sample + if self._is_vision_dataset and not self._is_vlm: + raise ValueError( + "The dataset appears to be vision-related (contains 'image' or 'images' keys), but the provided " + "model does not seem to be a vision-language model. Please check your model and dataset." + ) + if self._is_vision_dataset and args.max_length is not None and args.truncation_mode == "keep_end": + raise ValueError( + "truncation_mode='keep_end' is not supported for vision-language models. Image tokens reside " + "inside the prompt portion of the sequence; depending on the example, keep_end may silently " + "drop them, causing pixel_values to be forwarded to the model with no corresponding visual " + "tokens in input_ids. Use truncation_mode='keep_start' (the default) or set max_length=None." + ) + if self._is_vision_dataset and args.precompute_ref_log_probs: + raise ValueError( + "`precompute_ref_log_probs=True` is not supported for vision datasets. For vision-language " + "models, all data processing is performed on the fly rather than upfront, and running a full " + "forward pass of the reference model over the entire dataset is not supported for large " + "multimodal models. Set `precompute_ref_log_probs=False`." + ) + if data_collator is None and not self._is_vision_dataset: + # Get the pad token: if not provided, use the one from the processing class or the eos token + # if the processing class does not have a pad token. + pad_token = args.pad_token or self._tokenizer.pad_token or self._tokenizer.eos_token + if pad_token not in self._tokenizer.get_vocab(): + raise ValueError( + f"The specified `pad_token` ('{pad_token}') is not found in the vocabulary of the given " + f"`processing_class` ({processing_class.__class__.__name__}). Ensure that the `pad_token` exists " + "in the vocabulary before using it as a padding token." + ) + self._tokenizer.pad_token = pad_token + data_collator = DataCollatorForPreference( + pad_token_id=self._tokenizer.pad_token_id, + max_length=args.max_length, + truncation_mode=args.truncation_mode, + pad_to_multiple_of=args.pad_to_multiple_of, + ) + elif data_collator is None and self._is_vision_dataset: + data_collator = DataCollatorForVisionPreference( + processor=processing_class, + max_length=args.max_length, + pad_to_multiple_of=args.pad_to_multiple_of, + ) + + # Training arguments + self.beta = args.beta + self.precompute_ref_logps = args.precompute_ref_log_probs + self.loss_types = args.loss_type # args.loss_type is already a list + self.loss_weights = args.loss_weights or [1.0] * len(self.loss_types) + self.ld_alpha = args.ld_alpha + self.f_divergence_type = args.f_divergence_type + self.f_alpha_divergence_coef = args.f_alpha_divergence_coef + self.label_smoothing = args.label_smoothing + self.use_weighting = args.use_weighting + if self.use_weighting and any(loss_type in {"aot", "aot_unpaired"} for loss_type in self.loss_types): + raise NotImplementedError( + "WPO-style weighting is not implemented for 'aot' or 'aot_unpaired' because those losses sort " + "samples, which would misalign per-pair weights." + ) + if "robust" in self.loss_types and not (0.0 <= self.label_smoothing < 0.5): + logger.warning( + "The `label_smoothing` parameter should lie in [0.0, 0.5) for the 'robust' loss. You provided " + f"{self.label_smoothing}." + ) + if "exo_pair" in self.loss_types and self.label_smoothing == 0.0: + raise ValueError( + "Label smoothing must be greater than 0.0 when using 'exo_pair' loss. The EXO paper recommends a " + "value of 1e-3." + ) + self.use_liger_kernel = args.use_liger_kernel + if args.use_liger_kernel: + if not is_liger_kernel_available(): + raise ImportError( + "You set `use_liger_kernel=True` but the liger kernel is not available. " + "Please install liger-kernel first: `pip install liger-kernel`" + ) + if len(self.loss_types) != 1: + raise NotImplementedError( + "Multiple loss types are not yet supported when using Liger kernel. If you need this feature, " + "please open a feature request at https://github.com/huggingface/trl/issues." + ) + self.liger_loss_fn = LigerFusedLinearDPOLoss(beta=args.beta, loss_type=self.loss_types[0]) + if compute_metrics is not None: + raise ValueError( + "compute_metrics is not supported with the Liger kernel. compute_metrics requires to be able to " + "recover the logits from the forward pass, but Liger kernel does not materialize logits." + ) + if self.precompute_ref_logps: + raise ValueError( + "Liger DPO loss does not support precomputing reference log probabilities. Either disable " + "`precompute_ref_log_probs` or set `use_liger_kernel` to False." + ) + if is_peft_model(model): + raise NotImplementedError("Liger DPO loss is not implemented for PEFT models.") + + # Dataset + # Skip dataset preparation if it's a VLM, where preprocessing (e.g., image-to-pixel conversion) is too costly + # and done on the fly instead. + skip_prepare_dataset = self._is_vision_dataset + if not skip_prepare_dataset: + train_dataset = self._prepare_dataset(train_dataset, processing_class, args, "train") + if eval_dataset is not None: + if isinstance(eval_dataset, dict): + eval_dataset = { + key: self._prepare_dataset(dataset, processing_class, args, key) + for key, dataset in eval_dataset.items() + } + else: + eval_dataset = self._prepare_dataset(eval_dataset, processing_class, args, "eval") + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + ) + + # Initialize activation offloading context + if self.args.activation_offloading: + self.maybe_activation_offload_context = get_act_offloading_ctx_manager(model=self.model) + else: + self.maybe_activation_offload_context = contextlib.nullcontext() + + # Reference model + if ref_model is None: + if is_peft_model(self.model) or args.precompute_ref_log_probs: + # If PEFT is used, the reference model is not needed since the adapter can be disabled to revert to the + # initial model. If precompute_ref_log_probs is True, the reference model does not need to be kept in + # memory during training. + self.ref_model = None + else: + ref_model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if self.args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + ref_model_init_kwargs["device_map"] = None + ref_model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + ref_model_path = get_config_model_id(self.model.config) + self.ref_model = create_model_from_path(ref_model_path, **ref_model_init_kwargs) + else: + self.ref_model = ref_model + + # Disable dropout in the models + if args.disable_dropout: + disable_dropout_in_model(model) + if self.ref_model is not None: + disable_dropout_in_model(self.ref_model) + + # Initialize the metrics + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + self._total_train_tokens = 0 + + # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the + # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set + # self.model_accepts_loss_kwargs to False to enable scaling. + self.model_accepts_loss_kwargs = False + + # Add tags to the model + self.model.add_model_tags(self._tag_names) + + if self.ref_model is not None: + if self.is_deepspeed_enabled: + self.ref_model = prepare_deepspeed(self.ref_model, self.accelerator) + elif self.is_fsdp_enabled: + self.ref_model = prepare_fsdp(self.ref_model, self.accelerator) + else: + self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True) + + if args.sync_ref_model: + if is_peft_model(self.model): + raise NotImplementedError( + "You passed `sync_ref_model=True` while using a PEFT model, which is currently not supported. " + "With PEFT, DPOTrainer does not keep a separate reference model in memory; instead, it recovers " + "reference behavior by temporarily disabling the adapter. As a result, there is no standalone " + "`ref_model` instance to synchronize. Use `sync_ref_model=False`, or opt for full fine-tuning if " + "you need a synced reference model. If you need `sync_ref_model` to work with PEFT, please open a " + "feature request at https://github.com/huggingface/trl/issues." + ) + if args.precompute_ref_log_probs: + raise ValueError( + "You cannot use `sync_ref_model=True` together with `precompute_ref_log_probs=True`. " + "`precompute_ref_log_probs=True` assumes a fixed reference model, but with `sync_ref_model=True` " + "the reference model is periodically updated during training, making any precomputed reference " + "log-probs stale. Set `precompute_ref_log_probs=False` or disable `sync_ref_model`." + ) + self.add_callback(SyncRefModelCallback(ref_model=self.ref_model, accelerator=self.accelerator)) + + if args.precompute_ref_log_probs: + if isinstance(self.train_dataset, IterableDataset) or isinstance( + self.eval_dataset, (IterableDataset, IterableDatasetDict) + ): + raise ValueError( + "`precompute_ref_log_probs=True` is not supported with IterableDataset. Please use a map-style " + "Dataset or set `precompute_ref_log_probs=False`." + ) + + self.train_dataset = self._precompute_ref_logps( + self.train_dataset, + "train", + self.args.precompute_ref_batch_size or self.args.per_device_train_batch_size, + ) + if self.eval_dataset is not None: + if isinstance(self.eval_dataset, dict): + self.eval_dataset = { + name: self._precompute_ref_logps( + dataset, name, self.args.precompute_ref_batch_size or self.args.per_device_eval_batch_size + ) + for name, dataset in self.eval_dataset.items() + } + else: + self.eval_dataset = self._precompute_ref_logps( + self.eval_dataset, + "eval", + self.args.precompute_ref_batch_size or self.args.per_device_eval_batch_size, + ) + + def _tokenize( + self, + processing_class: PreTrainedTokenizerBase | ProcessorMixin, + input: str | list, + **kwargs, + ) -> dict[str, list]: + """Tokenize a single example for dataset preprocessing. + + Dispatches to `apply_chat_template` for conversational input (list of message dicts) and to `__call__` for + non-conversational input (str). For VLMs, normalizes the batch dimension that processors emit even for single + examples. + + Args: + processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`]): + The tokenizer or processor to use. + input (`str` or `list`): + A string for non-conversational input, or a list of message dicts for conversational input. + **kwargs: + Forwarded to `apply_chat_template` (e.g. `add_generation_prompt`, `return_assistant_tokens_mask`). + + Returns: + `dict` with at least an `"input_ids"` key mapping to a flat `list[int]`. + """ + if isinstance(input, list): # conversational: list of message dicts + if self._is_vlm: + input = prepare_multimodal_messages(input) + result = processing_class.apply_chat_template(input, tokenize=True, return_dict=True, **kwargs) + else: # non-conversational: plain text string + result = processing_class(text=input) + # VLMs emit a batch dimension even for single examples; unwrap it + if self._is_vlm: + return {k: v[0] for k, v in result.items()} + return result + + def _prepare_dataset( + self, + dataset: Dataset | IterableDataset, + processing_class: PreTrainedTokenizerBase | ProcessorMixin, + args: DPOConfig, + dataset_name: str, + ) -> Dataset | IterableDataset: + # Build the kwargs for the `map` function + map_kwargs = {} + if isinstance(dataset, Dataset): # IterableDataset does not support num_proc + map_kwargs["num_proc"] = args.dataset_num_proc + + with PartialState().main_process_first(): + # Extract the prompt if needed + first_example = next(iter(dataset)) + if "prompt" not in first_example: + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Extracting prompt from {dataset_name} dataset" + dataset = dataset.map(extract_prompt, **map_kwargs) + + # Add EOS token if needed: non-conversational only + first_example = next(iter(dataset)) + if not is_conversational(first_example): + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Adding EOS to {dataset_name} dataset" + + def add_eos(example, eos_token): + if not example["chosen"].endswith(eos_token): + example["chosen"] = example["chosen"] + eos_token + if not example["rejected"].endswith(eos_token): + example["rejected"] = example["rejected"] + eos_token + return example + + dataset = dataset.map(add_eos, fn_kwargs={"eos_token": self._tokenizer.eos_token}, **map_kwargs) + + # Tokenize the dataset + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset" + + def tokenize_fn(example, processing_class): + tools = example.get("tools") + tools = json.loads(tools) if isinstance(tools, str) else tools + output = {} + if is_conversational(example): + prompt_ids = self._tokenize( + processing_class, + example["prompt"], + tools=tools, + add_generation_prompt=True, + **example.get("chat_template_kwargs", {}), + )["input_ids"] + prompt_chosen_ids = self._tokenize( + processing_class, + example["prompt"] + example["chosen"], + tools=tools, + **example.get("chat_template_kwargs", {}), + )["input_ids"] + prompt_rejected_ids = self._tokenize( + processing_class, + example["prompt"] + example["rejected"], + tools=tools, + **example.get("chat_template_kwargs", {}), + )["input_ids"] + else: + prompt_ids = self._tokenize(processing_class, example["prompt"])["input_ids"] + prompt_chosen_ids = self._tokenize(processing_class, example["prompt"] + example["chosen"])[ + "input_ids" + ] + prompt_rejected_ids = self._tokenize(processing_class, example["prompt"] + example["rejected"])[ + "input_ids" + ] + + # Check if the tokenized prompt starts with the tokenized prompt+completion + if not prompt_chosen_ids[: len(prompt_ids)] == prompt_ids: + logger.warning( + "Mismatch between tokenized prompt and the start of tokenized prompt+chosen. " + "This may be due to unexpected tokenizer behavior, whitespace issues, or special " + "token handling. Verify that the tokenizer is processing text consistently." + ) + if not prompt_rejected_ids[: len(prompt_ids)] == prompt_ids: + logger.warning( + "Mismatch between tokenized prompt and the start of tokenized prompt+rejected. " + "This may be due to unexpected tokenizer behavior, whitespace issues, or special " + "token handling. Verify that the tokenizer is processing text consistently." + ) + + output["prompt_ids"] = prompt_ids + output["chosen_ids"] = prompt_chosen_ids[len(prompt_ids) :] + output["rejected_ids"] = prompt_rejected_ids[len(prompt_ids) :] + return output + + dataset = dataset.map(tokenize_fn, fn_kwargs={"processing_class": processing_class}, **map_kwargs) + + return dataset + + def _set_signature_columns_if_needed(self): + # If `self.args.remove_unused_columns` is True, non-signature columns are removed. + # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids" + # and "attention_mask"). + if self._signature_columns is None: + if self._is_vision_dataset: + self._signature_columns = [ + "prompt", + "chosen", + "rejected", + "image", + "images", + "tools", + "chat_template_kwargs", + ] + else: + self._signature_columns = [ + "prompt_ids", + "chosen_ids", + "rejected_ids", + "ref_chosen_logps", + "ref_rejected_logps", + ] + + def _precompute_ref_logps(self, dataset: Dataset, name: str, batch_size: int) -> Dataset: + model_hash = hash_module(self.ref_model or self.model) + fingerprint = Hasher.hash((dataset._fingerprint, model_hash)) + cache_file = dataset._get_cache_file_path(fingerprint) + + if os.path.exists(cache_file): + return concatenate_datasets([dataset, Dataset.from_file(cache_file)], axis=1) + + dataloader = DataLoader( + dataset, + batch_size=batch_size, + collate_fn=self.data_collator, + num_workers=self.args.dataloader_num_workers, + pin_memory=self.args.dataloader_pin_memory, + shuffle=False, + ) + data_loader = self.accelerator.prepare(dataloader) + ref_chosen_logps = [] + ref_rejected_logps = [] + for padded_batch in tqdm(iterable=data_loader, desc=f"Computing reference log probs for {name} dataset"): + ref_chosen_logp, ref_rejected_logp = self.compute_ref_log_probs(padded_batch) + ref_chosen_logp, ref_rejected_logp = self.accelerator.gather_for_metrics( + (ref_chosen_logp, ref_rejected_logp) + ) + ref_chosen_logps.append(ref_chosen_logp.cpu()) + ref_rejected_logps.append(ref_rejected_logp.cpu()) + + ref_chosen_logps = torch.cat(ref_chosen_logps) + ref_rejected_logps = torch.cat(ref_rejected_logps) + + if self.accelerator.is_main_process: + + def add_ref_logps(batch, indices): + return { + "ref_chosen_logps": ref_chosen_logps[indices], + "ref_rejected_logps": ref_rejected_logps[indices], + } + + dataset.map( + add_ref_logps, + with_indices=True, + batched=True, + remove_columns=dataset.column_names, + new_fingerprint=fingerprint, + desc=f"Caching reference log probs for {name} dataset", + ) + self.accelerator.wait_for_everyone() + + return concatenate_datasets([dataset, Dataset.from_file(cache_file)], axis=1) + + def compute_ref_log_probs(self, inputs): + """Computes reference log probabilities for a single padded batch.""" + device = self.accelerator.device + + _non_model_keys = {"completion_mask", "ref_chosen_logps", "ref_rejected_logps"} + model_kwargs = {k: v for k, v in inputs.items() if k not in _non_model_keys} + model_kwargs["use_cache"] = False + + with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs): + if self.ref_model is None: + if is_peft_model(self.model): + model = self.accelerator.unwrap_model(self.model) + with use_adapter(model, adapter_name="ref" if "ref" in model.peft_config else None): + ref_outputs = self.model(**model_kwargs) + else: + ref_outputs = self.model(**model_kwargs) + else: + ref_outputs = self.ref_model(**model_kwargs) + + input_ids = inputs["input_ids"] + completion_mask = inputs["completion_mask"] + shift_labels = input_ids[..., 1:] + shift_completion_mask = completion_mask[..., 1:] + ref_shift_logits = ref_outputs.logits[..., :-1, :] + ref_per_token_logps = selective_log_softmax(ref_shift_logits, shift_labels) + ref_per_token_logps[shift_completion_mask == 0] = 0.0 + + if self.ld_alpha is None: + ref_logps = ref_per_token_logps.sum(dim=1) + else: + comp_pos = shift_completion_mask.cumsum(dim=1) + comp_lens = shift_completion_mask.sum(dim=1).long() + chosen_lens, rejected_lens = comp_lens.chunk(2, dim=0) + shared_lens = torch.minimum(chosen_lens, rejected_lens) + shared_lens = torch.cat([shared_lens, shared_lens], dim=0).to(device) + shared_mask = (comp_pos > 0) & (comp_pos <= shared_lens.unsqueeze(1)) + tail_mask = comp_pos > shared_lens.unsqueeze(1) + shared_logps = (ref_per_token_logps * shared_mask).sum(dim=1) + tail_logps = (ref_per_token_logps * tail_mask).sum(dim=1) + ref_logps = shared_logps + self.ld_alpha * tail_logps + + ref_chosen_logps, ref_rejected_logps = ref_logps.chunk(2, dim=0) + return ref_chosen_logps, ref_rejected_logps + + def _compute_loss_liger(self, model, inputs, return_outputs): + if return_outputs: + raise RuntimeError( + "return_outputs=True is not supported with the Liger DPO loss. The Liger loss computes the loss " + "without materializing logits, so outputs cannot be returned." + ) + + mode = "train" if self.model.training else "eval" + + _non_model_keys = {"completion_mask", "ref_chosen_logps", "ref_rejected_logps"} + model_kwargs = {k: v for k, v in inputs.items() if k not in _non_model_keys} + model_kwargs["use_cache"] = False + + # `base_model` gives the backbone model (skipping `lm_head`) — text decoder for LMs, multimodal wrapper for + # VLMs (so vision-token injection runs before the text decoder). `get_decoder()` won't do: on VLMs it + # returns just the text stack and feeds image-placeholder IDs through it. + # Pre-5.0 transformers VLMs set `base_model_prefix = ""` so `base_model is self` (re-runs `lm_head`). + # Fall back to `.model` there. + if self._is_vlm and Version(transformers.__version__) < Version("5.0.0"): + backbone, ref_backbone = model.model, self.ref_model.model + else: + backbone, ref_backbone = model.base_model, self.ref_model.base_model + + outputs = backbone(**model_kwargs) + hidden_states = outputs.last_hidden_state[:, :-1].contiguous() + lm_head = model.get_output_embeddings() + weight = lm_head.weight + bias = lm_head.bias + + with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs): + ref_outputs = ref_backbone(**model_kwargs) + ref_lm_head = self.ref_model.get_output_embeddings() + ref_hidden_states = ref_outputs.last_hidden_state[:, :-1].contiguous() + ref_weight = ref_lm_head.weight + ref_bias = ref_lm_head.bias + + input_ids = model_kwargs["input_ids"] + completion_mask = inputs["completion_mask"] + shift_completion_mask = completion_mask[:, 1:] + labels = input_ids[:, 1:].clone() + labels[shift_completion_mask == 0] = -100 + + loss, metrics = self.liger_loss_fn( + weight, hidden_states, labels, bias, ref_hidden_states, ref_weight, ref_bias + ) + + ( + chosen_logps, + rejected_logps, + chosen_logits_mean, + rejected_logits_mean, + nll_loss, + chosen_rewards, + rejected_rewards, + ) = metrics + + if mode == "train": + num_tokens_in_batch = self.accelerator.gather_for_metrics(inputs["attention_mask"].sum()).sum().item() + self._total_train_tokens += num_tokens_in_batch + self._metrics[mode]["num_tokens"] = [self._total_train_tokens] + + avg_chosen_logits = self.accelerator.gather_for_metrics(chosen_logits_mean).mean().item() + avg_rejected_logits = self.accelerator.gather_for_metrics(rejected_logits_mean).mean().item() + self._metrics[mode]["logits/chosen"].append(avg_chosen_logits) + self._metrics[mode]["logits/rejected"].append(avg_rejected_logits) + + agg_chosen_rewards = self.accelerator.gather(chosen_rewards) + agg_rejected_rewards = self.accelerator.gather(rejected_rewards) + self._metrics[mode]["rewards/chosen"].append(agg_chosen_rewards.mean().item()) + self._metrics[mode]["rewards/rejected"].append(agg_rejected_rewards.mean().item()) + + reward_accuracies = (chosen_rewards > rejected_rewards).float() + agg_reward_accuracies = self.accelerator.gather(reward_accuracies) + self._metrics[mode]["rewards/accuracies"].append(agg_reward_accuracies.mean().item()) + + margins = chosen_rewards - rejected_rewards + agg_margins = self.accelerator.gather(margins) + self._metrics[mode]["rewards/margins"].append(agg_margins.mean().item()) + + self._metrics[mode]["logps/chosen"].append(self.accelerator.gather(chosen_logps).mean().item()) + self._metrics[mode]["logps/rejected"].append(self.accelerator.gather(rejected_logps).mean().item()) + + return loss + + def _compute_loss(self, model, inputs, return_outputs): + mode = "train" if self.model.training else "eval" + device = self.accelerator.device + + _non_model_keys = {"completion_mask", "ref_chosen_logps", "ref_rejected_logps"} + model_kwargs = {k: v for k, v in inputs.items() if k not in _non_model_keys} + model_kwargs["use_cache"] = False + outputs = model(**model_kwargs) + + input_ids = inputs["input_ids"] + completion_mask = inputs["completion_mask"] + shift_logits = outputs.logits[..., :-1, :] + shift_labels = input_ids[..., 1:] + shift_completion_mask = completion_mask[..., 1:] + per_token_logps = selective_log_softmax(shift_logits, shift_labels) + per_token_logps[shift_completion_mask == 0] = 0.0 # mask out non-completion tokens + if self.ld_alpha is None: + logps = per_token_logps.sum(dim=1) # sum over sequence length + else: + comp_pos = shift_completion_mask.cumsum(dim=1) + comp_lens = shift_completion_mask.sum(dim=1).long() + chosen_lens, rejected_lens = comp_lens.chunk(2, dim=0) + shared_lens = torch.minimum(chosen_lens, rejected_lens) + shared_lens = torch.cat([shared_lens, shared_lens], dim=0).to(device) + shared_mask = (comp_pos > 0) & (comp_pos <= shared_lens.unsqueeze(1)) # shared: 1 <= pos <= shared_len + tail_mask = comp_pos > shared_lens.unsqueeze(1) # tail: pos > shared_len + shared_logps = (per_token_logps * shared_mask).sum(dim=1) + tail_logps = (per_token_logps * tail_mask).sum(dim=1) + logps = shared_logps + self.ld_alpha * tail_logps + chosen_logps, rejected_logps = logps.chunk(2, dim=0) # batch is [chosen, rejected] + + if self.precompute_ref_logps: + ref_chosen_logps, ref_rejected_logps = inputs["ref_chosen_logps"], inputs["ref_rejected_logps"] + else: + # When gradient checkpointing is enabled with use_reentrant=True (default), calling the model inside a + # torch.no_grad() block triggers a harmless PyTorch warning ("None of the inputs have requires_grad=True"). + # Temporarily disable checkpointing to avoid this warning during inference. + with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs): + if is_peft_model(model) and self.ref_model is None: + # When training a PEFT adapter, how we obtain the reference depends on the setup: + # - New adapter: disabling adapters yields the base model. + # - Re-training an existing adapter: an initial copy is loaded under the name "ref". + model = self.accelerator.unwrap_model(model) + with use_adapter(model, adapter_name="ref" if "ref" in model.peft_config else None): + ref_outputs = self.model(**model_kwargs) + else: + ref_outputs = self.ref_model(**model_kwargs) + + ref_shift_logits = ref_outputs.logits[..., :-1, :] + ref_per_token_logps = selective_log_softmax(ref_shift_logits, shift_labels) + ref_per_token_logps[shift_completion_mask == 0] = 0.0 # mask out non-completion tokens + if self.ld_alpha is None: + ref_logps = ref_per_token_logps.sum(dim=1) # sum over sequence length + else: + # reuse comp_pos/shared_mask/tail_mask computed above (they depend only on completion_mask) + ref_shared_logps = (ref_per_token_logps * shared_mask).sum(dim=1) + ref_tail_logps = (ref_per_token_logps * tail_mask).sum(dim=1) + ref_logps = ref_shared_logps + self.ld_alpha * ref_tail_logps + ref_chosen_logps, ref_rejected_logps = ref_logps.chunk(2, dim=0) # batch is [chosen, rejected] + + # Get the log ratios for the chosen and rejected responses + chosen_logratios = chosen_logps - ref_chosen_logps + rejected_logratios = rejected_logps - ref_rejected_logps + + if self.f_divergence_type == "reverse_kl": # standard DPO + chosen_scores = chosen_logratios + rejected_scores = rejected_logratios + elif self.f_divergence_type == "forward_kl": + # f'(t) = 1 - 1/t -> drop constant -> -exp(-logratio) + chosen_scores = -torch.exp(-chosen_logratios) + rejected_scores = -torch.exp(-rejected_logratios) + elif self.f_divergence_type == "js_divergence": + # f'(t) = log(2t/(t+1)) -> drop log 2 + chosen_scores = F.logsigmoid(chosen_logratios) + rejected_scores = F.logsigmoid(rejected_logratios) + elif self.f_divergence_type == "alpha_divergence": + # alpha-divergence: f'(t) = (t^(α-1) - 1)/(α-1) + if abs(self.f_alpha_divergence_coef - 1.0) < 1e-6: # limit case f'(t) -> log(t), fall back to reverse_kl + chosen_scores = chosen_logratios + rejected_scores = rejected_logratios + else: + coef = 1.0 / (self.f_alpha_divergence_coef - 1.0) + t_chosen = (self.f_alpha_divergence_coef - 1.0) * chosen_logratios + t_rejected = (self.f_alpha_divergence_coef - 1.0) * rejected_logratios + dtype = t_chosen.dtype + # Clamp max so exp(.) stays representable after casting back + clamp_max = {torch.float16: 11.0, torch.bfloat16: 80.0, torch.float32: 80.0}[dtype] + t_chosen_float = torch.clamp(t_chosen.float(), max=clamp_max) + t_rejected_float = torch.clamp(t_rejected.float(), max=clamp_max) + chosen_scores = torch.exp(t_chosen_float).to(dtype) * coef + rejected_scores = torch.exp(t_rejected_float).to(dtype) * coef + else: + raise ValueError(f"Unknown f_divergence_type: {self.f_divergence_type}") + + delta_score = chosen_scores - rejected_scores + + loss = 0.0 + for loss_type, loss_weight in zip(self.loss_types, self.loss_weights, strict=True): + if loss_type == "sigmoid": + per_sequence_loss = -F.logsigmoid(self.beta * delta_score) + + elif loss_type == "hinge": + per_sequence_loss = torch.relu(1 - self.beta * delta_score) + + elif loss_type == "ipo": + # IPO uses sequence-level log-prob differences; in code these are token-summed over the completion, + # which makes the squared loss scale with completion length. We therefore normalize by the number of + # completion tokens (average per token) to make β/loss comparable across variable lengths. This length + # normalization is not explicitly discussed in the IPO paper; we confirmed this choice with the IPO + # authors, and the results reported in the paper correspond to this normalized form. + chosen_mask, rejected_mask = completion_mask.chunk(2, dim=0) + chosen_avg_score = chosen_scores / chosen_mask.sum(dim=1).clamp(min=1.0) + rejected_avg_score = rejected_scores / rejected_mask.sum(dim=1).clamp(min=1.0) + ipo_delta = chosen_avg_score - rejected_avg_score + # (Eq. 17) of the paper where beta is the regularization parameter for the IPO loss, denoted by τ. + per_sequence_loss = (ipo_delta - 1 / (2 * self.beta)) ** 2 + + elif loss_type == "exo_pair": + # Implements EXO-pref from the paper https://huggingface.co/papers/2402.00856, (Eq. 16) + # Minimize KL(p_fθ || p_rh) for K=2; p_fθ = softmax(βπ * (log πθ − log π_ref)) over {chosen, rejected} + # p_rh = [(1−ε), ε]; expanded KL gives the weighted logsigmoid form below + epsilon = torch.tensor(self.label_smoothing, device=device) + qw = torch.sigmoid(self.beta * delta_score) + log_qw = F.logsigmoid(self.beta * delta_score) + log_pw = torch.log1p(-epsilon) + ql = torch.sigmoid(-self.beta * delta_score) + log_ql = F.logsigmoid(-self.beta * delta_score) + log_pl = torch.log(epsilon) + per_sequence_loss = qw * (log_qw - log_pw) + ql * (log_ql - log_pl) + + elif loss_type == "nca_pair": + chosen_rewards = self.beta * chosen_scores + rejected_rewards = self.beta * rejected_scores + per_sequence_loss = ( + -F.logsigmoid(chosen_rewards) + - 0.5 * F.logsigmoid(-chosen_rewards) + - 0.5 * F.logsigmoid(-rejected_rewards) + ) + + elif loss_type == "robust": + clean_loss_term = -(1 - self.label_smoothing) * F.logsigmoid(self.beta * delta_score) + flipped_loss_term = -self.label_smoothing * F.logsigmoid(-self.beta * delta_score) + per_sequence_loss = (clean_loss_term - flipped_loss_term) / (1 - 2 * self.label_smoothing) + + elif loss_type == "bco_pair": + chosen_rewards = self.beta * chosen_scores + rejected_rewards = self.beta * rejected_scores + per_sequence_loss = -F.logsigmoid(chosen_rewards) - F.logsigmoid(-rejected_rewards) + + elif loss_type == "sppo_hard": + # In the paper (https://huggingface.co/papers/2405.00675), SPPO employs a soft probability approach, + # estimated using the PairRM score. The probability calculation is conducted outside of the trainer + # class. The version described here is the hard probability version, where P in Equation (4.7) of + # Algorithm 1 is set to 1 for the winner and 0 for the loser. + winner_margin_error = (chosen_scores - 0.5 / self.beta) ** 2 + loser_margin_error = (rejected_scores + 0.5 / self.beta) ** 2 + per_sequence_loss = winner_margin_error + loser_margin_error + + elif loss_type == "aot": + logratios = chosen_logps - rejected_logps + ref_logratios = ref_chosen_logps - ref_rejected_logps + logratios_sorted, _ = torch.sort(logratios, dim=0) + ref_logratios_sorted, _ = torch.sort(ref_logratios, dim=0) + delta = logratios_sorted - ref_logratios_sorted + per_sequence_loss = ( + -F.logsigmoid(self.beta * delta) * (1 - self.label_smoothing) + - F.logsigmoid(-self.beta * delta) * self.label_smoothing + ) + + elif loss_type == "aot_unpaired": + chosen_logratios_sorted, _ = torch.sort(chosen_logratios, dim=0) + rejected_logratios_sorted, _ = torch.sort(rejected_logratios, dim=0) + delta = chosen_logratios_sorted - rejected_logratios_sorted + per_sequence_loss = ( + -F.logsigmoid(self.beta * delta) * (1 - self.label_smoothing) + - F.logsigmoid(-self.beta * delta) * self.label_smoothing + ) + + elif loss_type == "apo_zero": + # Eqn (7) of the APO paper (https://huggingface.co/papers/2408.06266) + # Use this loss when you believe the chosen outputs are better than your model's default output + # Increase chosen likelihood and decrease rejected likelihood + losses_chosen = 1 - torch.sigmoid(self.beta * chosen_logratios) + losses_rejected = torch.sigmoid(self.beta * rejected_logratios) + per_sequence_loss = losses_chosen + losses_rejected + + elif loss_type == "apo_down": + # Eqn (8) of the APO paper (https://huggingface.co/papers/2408.06266) + # Use this loss when you believe the chosen outputs are worse than your model's default output. + # Decrease chosen likelihood and decrease rejected likelihood more + losses_chosen = torch.sigmoid(self.beta * chosen_logratios) + losses_rejected = 1 - torch.sigmoid(self.beta * delta_score) + per_sequence_loss = losses_chosen + losses_rejected + + elif loss_type == "discopop": + # Eqn (5) of the DiscoPOP paper (https://huggingface.co/papers/2406.08414) + logits = delta_score * self.beta + # Modulate the mixing coefficient based on the log ratio magnitudes + log_ratio_modulation = torch.sigmoid(logits / self.args.discopop_tau) + logistic_component = -F.logsigmoid(logits) + exp_component = torch.exp(-logits) + # Blend between logistic and exponential component based on log ratio modulation + per_sequence_loss = ( + logistic_component * (1 - log_ratio_modulation) + exp_component * log_ratio_modulation + ) + + elif loss_type == "sft": + chosen_logits, _ = shift_logits.chunk(2, dim=0) + chosen_labels, _ = shift_labels.chunk(2, dim=0) + chosen_mask, _ = shift_completion_mask.chunk(2, dim=0) + batch_loss = F.cross_entropy(chosen_logits[chosen_mask.bool()], chosen_labels[chosen_mask.bool()]) + # Implementation convenience: expand the scalar SFT loss to a per-sequence tensor so it matches the + # shape of other losses; only the mean is used, so this is a no-op numerically. + per_sequence_loss = batch_loss.expand(chosen_logits.size(0)) + + elif loss_type == "sigmoid_norm": + chosen_mask, rejected_mask = completion_mask.chunk(2, dim=0) + chosen_avg_score = chosen_scores / chosen_mask.sum(dim=1).clamp(min=1.0) + rejected_avg_score = rejected_scores / rejected_mask.sum(dim=1).clamp(min=1.0) + delta = chosen_avg_score - rejected_avg_score + per_sequence_loss = -F.logsigmoid(self.beta * delta) + + else: + raise ValueError( + f"Unknown loss type: {loss_type}. Should be one of ['sigmoid', 'hinge', 'ipo', 'exo_pair', " + "'nca_pair', 'robust', 'bco_pair', 'sppo_hard', 'aot', 'aot_unpaired', 'apo_zero', 'apo_down', " + "'discopop', 'sft', 'sigmoid_norm']" + ) + + if self.use_weighting: + # Eq (2) of the WPO paper: https://huggingface.co/papers/2406.11827 + completion_lengths = shift_completion_mask.sum(dim=1).clamp_min(1) + with torch.no_grad(): + lse1 = torch.logsumexp(shift_logits, dim=-1) + lse2 = torch.logsumexp(2.0 * shift_logits, dim=-1) + log_denom = lse2 - 2.0 * lse1 + aligned_logps = (per_token_logps - log_denom) * shift_completion_mask + mean_logps = aligned_logps.sum(dim=1) / completion_lengths + weights = torch.exp(mean_logps) + chosen_weights, rejected_weights = weights.chunk(2, dim=0) + per_sequence_loss *= chosen_weights * rejected_weights + + loss += per_sequence_loss.mean() * loss_weight + + # Log the metrics + # Entropy + per_token_entropy = entropy_from_logits(shift_logits.detach()) + mask = shift_completion_mask + entropy_sum = (per_token_entropy * mask).sum() + total_tokens = mask.sum() + + # Gather counts across ranks and weight-average + entropy_sum = self.accelerator.gather_for_metrics(entropy_sum).sum() + total_tokens = self.accelerator.gather_for_metrics(total_tokens).sum() + entropy = (entropy_sum / total_tokens).item() if total_tokens > 0 else 0.0 + self._metrics[mode]["entropy"].append(entropy) + + # Number of tokens + if mode == "train": + num_tokens_in_batch = self.accelerator.gather_for_metrics(inputs["attention_mask"].sum()).sum().item() + self._total_train_tokens += num_tokens_in_batch + self._metrics[mode]["num_tokens"] = [self._total_train_tokens] + + # Average logits for chosen and rejected completions + chosen_logits, rejected_logits = shift_logits.detach().chunk(2, dim=0) + chosen_mask, rejected_mask = shift_completion_mask.chunk(2, dim=0) + total_chosen_logits = chosen_logits[chosen_mask.bool()].mean(-1).sum() + total_chosen_tokens = chosen_mask.sum() + total_rejected_logits = rejected_logits[rejected_mask.bool()].mean(-1).sum() + total_rejected_tokens = rejected_mask.sum() + total_chosen_logits = self.accelerator.gather_for_metrics(total_chosen_logits).sum().item() + total_chosen_tokens = self.accelerator.gather_for_metrics(total_chosen_tokens).sum().item() + total_rejected_logits = self.accelerator.gather_for_metrics(total_rejected_logits).sum().item() + total_rejected_tokens = self.accelerator.gather_for_metrics(total_rejected_tokens).sum().item() + avg_chosen_logits = total_chosen_logits / total_chosen_tokens if total_chosen_tokens > 0 else 0.0 + avg_rejected_logits = total_rejected_logits / total_rejected_tokens if total_rejected_tokens > 0 else 0.0 + self._metrics[mode]["logits/chosen"].append(avg_chosen_logits) + self._metrics[mode]["logits/rejected"].append(avg_rejected_logits) + + # Token accuracy for the chosen completions + predictions = chosen_logits.argmax(dim=-1) + chosen_mask = shift_completion_mask[: len(shift_completion_mask) // 2].bool() + chosen_labels = shift_labels[: len(shift_labels) // 2] + correct_predictions = (predictions == chosen_labels) & chosen_mask + total_tokens = chosen_mask.sum() + correct_tokens = correct_predictions.sum() + correct_tokens = self.accelerator.gather_for_metrics(correct_tokens) + total_tokens = self.accelerator.gather_for_metrics(total_tokens) + total_sum = total_tokens.sum() + accuracy = (correct_tokens.sum() / total_sum).item() if total_sum > 0 else 0.0 + self._metrics[mode]["mean_token_accuracy"].append(accuracy) + + # Rewards for chosen and rejected completions + chosen_rewards = self.beta * chosen_logratios.detach() + rejected_rewards = self.beta * rejected_logratios.detach() + agg_chosen_rewards = self.accelerator.gather(chosen_rewards) + agg_rejected_rewards = self.accelerator.gather(rejected_rewards) + self._metrics[mode]["rewards/chosen"].append(agg_chosen_rewards.mean().item()) + self._metrics[mode]["rewards/rejected"].append(agg_rejected_rewards.mean().item()) + + # Reward accuracy + reward_accuracies = (chosen_rewards > rejected_rewards).float() + agg_reward_accuracies = self.accelerator.gather(reward_accuracies) + self._metrics[mode]["rewards/accuracies"].append(agg_reward_accuracies.mean().item()) + + # Reward margins + margins = chosen_rewards - rejected_rewards + agg_margins = self.accelerator.gather(margins) + self._metrics[mode]["rewards/margins"].append(agg_margins.mean().item()) + + # Average log probabilities for chosen and rejected completions + self._metrics[mode]["logps/chosen"].append(self.accelerator.gather(chosen_logps).mean().item()) + self._metrics[mode]["logps/rejected"].append(self.accelerator.gather(rejected_logps).mean().item()) + + return (loss, outputs) if return_outputs else loss + + def evaluate( + self, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + ignore_keys: list[str] | None = None, + metric_key_prefix: str = "eval", + ) -> dict[str, float]: + # When a dataset is passed directly to `evaluate` (e.g. a held-out test set), preprocess it the same way + # `__init__` does, so that `evaluate` accepts the same dataset types as the trainer. `_prepare_dataset` is + # idempotent: it skips datasets that are already tokenized. A `str` selects a dataset that was already prepared + # at init time, so it's left untouched. + if not self._is_vision_dataset and eval_dataset is not None and not isinstance(eval_dataset, str): + if isinstance(eval_dataset, dict): + eval_dataset = { + key: self._prepare_dataset(dataset, self.processing_class, self.args, key) + for key, dataset in eval_dataset.items() + } + else: + eval_dataset = self._prepare_dataset(eval_dataset, self.processing_class, self.args, "eval") + # With `precompute_ref_log_probs`, `_compute_loss` reads the reference log-probs from the batch, so they + # must be precomputed here as well, mirroring `__init__`. + if self.precompute_ref_logps: + batch_size = self.args.precompute_ref_batch_size or self.args.per_device_eval_batch_size + if isinstance(eval_dataset, dict): + eval_dataset = { + name: self._precompute_ref_logps(dataset, name, batch_size) + for name, dataset in eval_dataset.items() + } + else: + eval_dataset = self._precompute_ref_logps(eval_dataset, "eval", batch_size) + return super().evaluate( + eval_dataset=eval_dataset, ignore_keys=ignore_keys, metric_key_prefix=metric_key_prefix + ) + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + try: + if self.use_liger_kernel: + return self._compute_loss_liger(model, inputs, return_outputs) + return self._compute_loss(model, inputs, return_outputs) + except ValueError as e: + if "Image features and image tokens do not match" in str(e) and self.args.max_length is not None: + raise ValueError( + f"The current `max_length` ({self.args.max_length}) is too short and causes image placeholder " + f"tokens in `input_ids` to be truncated, while the corresponding image features remain intact. " + f"Please increase `max_length` or set it to `None` to disable truncation." + ) from e + raise + + # Override training step to add activation offloading context. + def training_step(self, *args, **kwargs): + with self.maybe_activation_offload_context: + return super().training_step(*args, **kwargs) + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} # average the metrics + # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs` + # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() + + # During eval, Trainer calls prediction_step. If no labels are present in the inputs, it only runs forward and + # returns logits. We override prediction_step to force compute_loss, because this trainer doesn't involve labels. + def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys: list[str] | None = None): + inputs = self._prepare_inputs(inputs) + with torch.no_grad(), self.compute_loss_context_manager(): + if prediction_loss_only: + loss = self.compute_loss(model, inputs, return_outputs=False) # logits aren't materialized with liger + logits, labels = None, None + else: + loss, outputs = self.compute_loss(model, inputs, return_outputs=True) + logits, labels = outputs.logits, inputs["input_ids"] + return loss, logits, labels + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/grpo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/grpo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..5736b6c0ddcd1816a26de16f09dd91f70cb57c00 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/grpo_config.py @@ -0,0 +1,1061 @@ +# Copyright 2020-2026 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 warnings +from dataclasses import dataclass, field +from typing import Any + +from .base_config import _BaseConfig + + +@dataclass +class GRPOConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`GRPOTrainer`]. + + This class includes only the parameters that are specific to GRPO training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + 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: + > Parameters that control the model and reference model + + model_init_kwargs (`str`, `dict[str, Any]`, *optional*): + Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model` + argument of the [`GRPOTrainer`] is provided as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and + [`~transformers.AutoProcessor.from_pretrained`]. Also applied to reward-model and reward-tokenizer loads. + router_aux_loss_coef (`float`, *optional*, defaults to `0.001`): + Coefficient of the load-balancing auxiliary loss. Only has an effect when training a Mixture-of-Experts + (MoE) model; for other models it does nothing. The auxiliary loss is added to the training loss with this + weight. Set to `0.0` to disable it. + disable_dropout (`bool`, *optional*, defaults to `False`): + Whether to disable dropout in the model. This is useful for training with a reference model, as it prevents + the model from generating different logprobs for the same input. + cast_lm_head_to_fp32 (`bool`, *optional*, defaults to `False`): + Whether to cast the language modeling head of the policy and reference models to float32. As recommended by + the [ScaleRL](https://huggingface.co/papers/2510.13786) recipe. This flag is only supported when the model + has untied word embedding and language modeling head layers i.e. `tie_word_embeddings` in the model config + is False. + + > Parameters that control the data preprocessing + + remove_unused_columns (`bool`, *optional*, defaults to `False`): + Whether to only keep the column `"prompt"` in the dataset. If you use a custom reward function that + requires any column other than `"prompts"` and `"completions"`, you should keep this to `False`. + num_generations (`int`, *optional*, defaults to `8`): + Number of generations per prompt to sample. The effective batch size (num_processes * per_device_batch_size + * gradient_accumulation_steps) must be evenly divisible by this value. + num_generations_eval (`int` or `None`, *optional*): + Number of generations to sample during evaluation. This allows using fewer generations during evaluation to + save computation. If `None`, uses the value of `num_generations`. + max_completion_length (`int` or `None`, *optional*, defaults to `256`): + Maximum length of the generated completion. + ds3_gather_for_generation (`bool`, *optional*, defaults to `True`): + This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation, + improving generation speed. However, disabling this option allows training models that exceed the VRAM + capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible + with vLLM generation. + shuffle_dataset (`bool`, *optional*, defaults to `True`): + Whether to shuffle the training dataset. + pad_to_multiple_of (`int`, *optional*): + If set, the prompts ids and completions ids will be padded to a multiple of this value. + + > Parameters that control generation + + generation_batch_size (`int`, *optional*): + Batch size to use for generation. If `None`, it defaults to the effective training batch size: + `per_device_train_batch_size * num_processes * steps_per_generation`. In other words, there is one + generation batch processed per optimization step. Mutually exclusive with `steps_per_generation`. + steps_per_generation (`int`, *optional*): + Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`. Mutually exclusive + with `generation_batch_size`. + temperature (`float`, defaults to `1.0`): + Temperature for sampling. The higher the temperature, the more random the completions. + top_p (`float`, *optional*, defaults to `1.0`): + Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to + `1.0` to consider all tokens. + top_k (`int`, *optional*, defaults to `0`): + Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is + disabled and all tokens are considered. + min_p (`float`, *optional*): + Minimum token probability, which will be scaled by the probability of the most likely token. It must be a + value between `0.0` and `1.0`. Typical values are in the `0.01-0.2` range. + generation_kwargs (`dict[str, Any]`, *optional*): + Additional keyword arguments to pass to [`~transformers.GenerationConfig`] (if using transformers) or + `SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the + generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict + with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them. + chat_template_kwargs (`dict[str, Any]`, *optional*): + Additional keyword arguments to pass to the `apply_chat_template` function when generating completions. + repetition_penalty (`float`, *optional*, defaults to `1.0`): + Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far. + Values > `1.0` encourage the model to use new tokens, while values < `1.0` encourage the model to repeat + tokens. + cache_implementation (`str`, *optional*): + Implementation of the cache method for faster generation when `use_vllm` is set to `False`. + + > Parameters that control generation acceleration powered by vLLM + + use_vllm (`bool`, *optional*, defaults to `False`): + Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation + instead of the default model.generate(). Requires `vllm` to be installed. + vllm_mode (`str`, *optional*, defaults to `"colocate"`): + Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `"server"` or + `"colocate"`. + + - `"server"`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM + server is running (start with `trl vllm-serve`). + - `"colocate"`: vLLM will run in the same process and share the training GPUs. This avoids the need for a + separate server but may cause resource contention with training. + vllm_model_impl (`str`, *optional*, defaults to `"vllm"`): + Model implementation to use for vLLM. Must be one of `"transformers"` or `"vllm"`. `"transformers"`: Use + the `transformers` backend for model implementation. `"vllm"`: Use the `vllm` library for model + implementation. + vllm_structured_outputs_regex (`str`, *optional*): + Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled. + + > Parameters that control the vLLM server (only used when `vllm_mode` is `"server"`) + + vllm_server_base_url (`str`, *optional*): + Base URL for the vLLM server (e.g., `"http://localhost:8000"`). If provided, `vllm_server_host` and + `vllm_server_port` are ignored. + vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`): + Host of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided. + vllm_server_port (`int`, *optional*, defaults to `8000`): + Port of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided. + vllm_server_timeout (`float`, *optional*, defaults to `240.0`): + Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the + timeout, a `ConnectionError` is raised. + vllm_group_port (`int`, *optional*, defaults to `51216`): + Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port + is occupied, there is no need to change it. + + > Parameters that control colocated vLLM execution (only used when `vllm_mode` is `"colocate"`) + + vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.3`): + Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to + `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when + launching the vLLM server via the `--vllm_gpu_memory_utilization` flag. + vllm_max_model_length (`int`, *optional*): + Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus + `max_completion_length`; if omitted, it is inferred from the model config. + vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`): + Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to + `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when + launching the vLLM server via the `--vllm_tensor_parallel_size` flag. + vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`): + Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but + waking the engine adds host–device transfer latency. + + > Parameters that control generation acceleration powered by transformers continuous batching + + use_transformers_continuous_batching (`bool`, *optional*, defaults to `False`): + Whether to use transformers' continuous batching engine for generating completions. Requires + `transformers>=5.8.0`. + transformers_continuous_batching_config (`dict`, *optional*): + Keyword arguments for [`~transformers.generation.ContinuousBatchingConfig`]. + + > Parameters that control the training + + beta (`float`, *optional*, defaults to `0.0`): + KL coefficient. If `0.0` (default), the reference model is not loaded, reducing memory usage and improving + training speed. [DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement + learning](https://huggingface.co/papers/2501.12948) use a value of `0.001`. + num_iterations (`int`, *optional*, defaults to `1`): + Number of iterations per batch (denoted as μ in the algorithm). + epsilon (`float`, *optional*, defaults to `0.2`): + Epsilon value for clipping. + delta (`float`, *optional*): + Enables the upper clipping bound in two-sided GRPO loss when set to a float. If `None` (default), standard + GRPO clipping is used. Recommended to be greater than `1 + ε` when enabled. This method is introduced in + the [INTELLECT-2 tech report](https://huggingface.co/papers/2505.07291). + epsilon_high (`float`, *optional*): + Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the lower-bound + specified in argument `epsilon`. Paper [DAPO](https://huggingface.co/papers/2503.14476) recommends `0.28`. + When used with `loss_type='cispo'`, this corresponds to the ε_max param specified in the [ScaleRL + paper](https://huggingface.co/papers/2510.13786) and the recommended value is `5.0`. + sapo_temperature_neg (`float`, *optional*, defaults to `1.05`): + Temperature for tokens with non-positive advantage scores used in the `sapo` loss function. This parameter + is introduced in the [Soft Adaptive Policy Optimization paper](https://huggingface.co/papers/2511.20347). + sapo_temperature_pos (`float`, *optional*, defaults to `1.0`): + Temperature for tokens with positive advantage scores used in the `sapo` loss function. This parameter is + introduced in the [Soft Adaptive Policy Optimization paper](https://huggingface.co/papers/2511.20347). + vespo_k_pos (`float`, *optional*, defaults to `2.0`): + k parameter for positive advantages, it is the power exponent in the VESPO loss. Controls how aggressively + we down-weight samples with low importance weights (when the importance sampling ratio < 1). + vespo_lambda_pos (`float`, *optional*, defaults to `3.0`): + lambda parameter for positive advantages, it is the decay factor in the VESPO loss. Controls how + aggressively we down-weight samples with high importance weights (when the importance sampling ratio > 1). + vespo_k_neg (`float`, *optional*, defaults to `3.0`): + k parameter for negative advantages, it is the power exponent in the VESPO loss. Controls how aggressively + we down-weight samples with low importance weights (when the importance sampling ratio < 1). + vespo_lambda_neg (`float`, *optional*, defaults to `2.0`): + lambda parameter for negative advantages, it is the exponential decay factor in the VESPO loss. Controls + how aggressively we down-weight samples with high importance weights (when the importance sampling ratio > + 1). + importance_sampling_level (`str`, *optional*, defaults to `"token"`): + Controls whether importance sampling ratios are computed at the `"token"` or `"sequence"` level. `"token"` + keeps the raw per-token log-probability ratios (one weight per token). `"sequence"` averages the + log-probability ratios across valid tokens to produce a single ratio per sequence. The [GSPO + paper](https://huggingface.co/papers/2507.18071) shows that sequence-level sampling often yields more + stable training and better alignment with sequence-level rewards. + reward_weights (`list[float]`, *optional*): + Weights for each reward function. Must match the number of reward functions. If `None`, all rewards are + weighted equally with weight `1.0`. + multi_objective_aggregation (`str`, *optional*, defaults to `"sum_then_normalize"`): + Method to aggregate multiple reward functions. Supported values are: + + - `"sum_then_normalize"` (default): First sums the weighted rewards from each reward function, then applies + reward scaling/normalization as specified by `scale_rewards` (see `scale_rewards` for details). + - `"normalize_then_sum"`: First normalizes/scales each reward function across generations (within each + group), then sums the normalized rewards using the specified weights. The aggregated reward is then + normalized at the batch level when forming advantages. This is the suggested approach from the paper + [GDPO: Group reward-Decoupled Normalization Policy Optimization for Multi-reward RL + Optimization](https://huggingface.co/papers/2601.05242). + scale_rewards (`str` or `bool`, *optional*, defaults to `"group"`): + Specifies the scaling strategy for rewards. Supported values are: + + - `True` or `"group"` (default): rewards are scaled by the standard deviation within each group, ensuring + unit variance within a group. + - `"batch"`: rewards are scaled by the standard deviation across the entire batch, as recommended in the + [PPO Lite paper](https://huggingface.co/papers/2508.08221). + - `False` or `"none"`: no scaling is applied. The [Dr. GRPO + paper](https://huggingface.co/papers/2503.20783) recommends not scaling rewards, as scaling by the + standard deviation introduces a question-level difficulty bias. + loss_type (`str`, *optional*, defaults to `"dapo"`): + Specifies the loss formulation to use. Supported values are: + + - `"grpo"`: Aggregates token-level losses by normalizing over sequence length. Not recommended due to + length bias—this approach tends to prefer shorter completions with positive advantages and longer ones + with negative advantages. + - `"dr_grpo"`: Aggregates token-level losses by normalizing with a global constant. This method was + introduced in the [Dr. GRPO paper](https://huggingface.co/papers/2503.20783) to eliminate length bias. + The value of the constant corresponds to `max_completion_length`. + - `"dapo"` (default): Aggregates token-level losses by normalizing with the number of active token in the + global accumulated batch. This method was introduced in the [DAPO + paper](https://huggingface.co/papers/2503.14476) to eliminate length bias. + - `"bnpo"`: Aggregates token-level losses by normalizing with the number of active token in the local + batch. Note that normalization is performed over the local batch only, so results may slightly vary + depending on the local batch size, despite a constant effective batch size. When using + `per_device_train_batch_size==1`, the loss is equivalent to the GRPO loss. + - `"cispo"`: Clips the importance sampling weights instead of the advantage scaled importance weights. The + clipped weights are then multiplied with the advantages and policy model's log probs. Individual token + losses are aggregated by normalizing with the number of active tokens in the global accumulated batch. + This method was introduced in the [MiniMax-M1 paper](https://huggingface.co/papers/2506.13585). + - `"sapo"`: Soft Adaptive Policy Optimization loss, as introduced in the [Soft Adaptive Policy Optimization + paper](https://huggingface.co/papers/2511.20347). Replaces hard clipping with a smooth, + temperature-controlled gate that adaptively attenuates off-policy updates while preserving useful + learning signals. + - `"luspo"`: Length-Unbiased Sequence Policy Optimization loss. A sequence-level loss that scales each + sequence's loss by its length. This is a modification of GSPO and requires + `importance_sampling_level="sequence"`. Introduced in the [LUSPO + paper](https://huggingface.co/papers/2602.05261). + - `"vespo"`: Variational Sequence-Level Soft Policy Optimization. Replaces hard clipping with a smooth, + asymmetric Gamma weighting function applied directly to sequence-level importance weights. Introduced in + the [VESPO paper](https://huggingface.co/papers/2602.10693). + mask_truncated_completions (`bool`, *optional*, defaults to `False`): + When enabled, truncated completions are excluded from the loss calculation, preventing them from being + incorrectly penalized and introducing noise during training. According to the + [DAPO](https://huggingface.co/papers/2503.14476) paper, this is a good practice for training stability. + sync_ref_model (`bool`, *optional*, defaults to `False`): + Whether to synchronize the reference model with the active model every `ref_model_sync_steps` steps, using + the `ref_model_mixup_alpha` parameter. This synchronization originates from the + [TR-DPO](https://huggingface.co/papers/2404.09656) paper. + ref_model_mixup_alpha (`float`, *optional*, defaults to `0.6`): + α parameter from the [TR-DPO](https://huggingface.co/papers/2404.09656) paper, which controls the mix + between the current policy and the previous reference policy during updates. The reference policy is + updated according to the equation: `π_ref = α * π_θ + (1 - α) * π_ref_prev`. To use this parameter, you + must set `sync_ref_model=True`. + ref_model_sync_steps (`int`, *optional*, defaults to `512`): + τ parameter from the [TR-DPO](https://huggingface.co/papers/2404.09656) paper, which determines how + frequently the current policy is synchronized with the reference policy. To use this parameter, you must + set `sync_ref_model=True`. + top_entropy_quantile (`float`, *optional*, defaults to `1.0`): + ρ parameter from [Beyond the 80/20 Rule](https://huggingface.co/papers/2506.01939). Keeps in the policy + loss term only the top-ρ quantile of tokens by entropy of the probability distribution at each sequence + position, improving results. Range: `[0.0-1.0]`. A value of `0.0` masks all but the highest entropy token; + `1.0` keeps all tokens. The paper recommends a value of `0.2`. If used with + `mask_truncated_completions=True`, only tokens from non-truncated completions are considered. + max_tool_calling_iterations (`int`, *optional*): + Maximum number of tool-calling turns when training an agent. If `None`, there is no limit and generation + stops when the model generates a response turn with no tool calls or when the total response length reaches + `max_model_length`. + vllm_importance_sampling_correction (`bool`, *optional*, defaults to `True`): + Whether to apply Importance Sampling (IS) to correct for the mismatch between vLLM completion logprobs and + recomputed training logprobs. If set to `False`, no IS is applied regardless of + `vllm_importance_sampling_mode`. When `True`, the selected mode determines how the IS ratios are computed + and constrained. + vllm_importance_sampling_mode (`str`, *optional*, defaults to `"sequence_mask"`): + Specifies how Importance Sampling is performed when `vllm_importance_sampling_correction=True`. Possible + values are: + + - `"token_truncate"`: Token-level truncated IS (default). Per-token ratios are clipped to + [C_min, C_max]. + - `"token_mask"`: Token-level masked IS. Per-token ratios outside [C_min, C_max] are set to zero. + - `"sequence_truncate"`: Sequence-level truncated IS. A single sequence ratio is clipped to + [C_min, C_max] and applied to all tokens in the sequence. + - `"sequence_mask"`: Sequence-level masked IS. Sequences with ratios outside [C_min, C_max] are masked + out. + vllm_importance_sampling_clip_max (`float`, *optional*, defaults to `3.0`): + Importance sampling upper bound C_max used by `vllm_importance_sampling_mode`. For `*_truncate` modes, + importance ratios are clipped from above at C_max. For `*_mask` modes, ratios larger than C_max are set to + zero. + vllm_importance_sampling_clip_min (`float`, *optional*): + Importance sampling lower bound C_min used by `vllm_importance_sampling_mode`. For `*_truncate` modes, + ratios are clipped from below at C_min. For `*_mask` modes, ratios below C_min are set to zero. To strictly + mask ratios below C_min without upper bound, set `vllm_importance_sampling_clip_max=None`. + off_policy_mask_threshold (`float`, *optional*): + Threshold for off-policy sequence masking. If `None`, off-policy sequence masking is disabled. When set, + sequences with negative advantages and high KL divergence are masked out to stabilize training. This + parameter corresponds to the `delta` threshold in Equation 9 of the [DeepSeek-V3.2 + paper](https://huggingface.co/papers/2512.02556). It expects a positive value (e.g., 0.5). + use_bias_correction_kl (`bool`, *optional*, defaults to `False`): + Whether to use the unbiased KL divergence estimator with importance sampling correction. This corrects the + KL divergence estimate by multiplying it with the importance sampling ratio. This is described in the + [DeepSeek-V3.2 paper](https://huggingface.co/papers/2512.02556). + + > Parameters that control the logging + + log_completions (`bool`, *optional*, defaults to `False`): + Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. If `rich` is installed, + it prints the sample. If `wandb` and/or `trackio` logging is enabled, it logs it to `wandb` and/or + `trackio`. + num_completions_to_print (`int`, *optional*): + Number of completions to print with `rich`. If `None`, all completions are logged. + log_unique_prompts (`bool`, *optional*, defaults to `False`): + Whether to log unique prompts. If `True`, only unique prompts are logged. If `False`, all prompts are + logged. + log_completions_hub_repo (`str`, *optional*): + Hugging Face Hub repository to save the completions. Should be a complete repository name like + `'username/reponame'` or `'orgname/reponame'`, or just `'reponame'` in which case the repository will be + created in the currently-logged-in Hugging Face user's namespace. Note that this repository will be public + unless you set `hub_private_repo=True` or your organization's default is to create private repositories." + + > Deprecated parameters + + use_transformers_paged: + + + + Parameter `use_transformers_paged` is deprecated and will be removed in version v2.0.0. Use + `use_transformers_continuous_batching` instead. + + + + vllm_importance_sampling_cap: + + + + Parameter `vllm_importance_sampling_cap` is deprecated and will be removed in v2.0.0. Use + `vllm_importance_sampling_clip_max` instead. + + + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `1e-6` instead of `5e-5`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + [ + "model_init_kwargs", + "transformers_continuous_batching_config", + ] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=1e-6, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + # Parameters that control the model and reference model + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` " + "argument of the `GRPOTrainer` is provided as a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`. Also applied to " + "reward-model and reward-tokenizer loads." + }, + ) + router_aux_loss_coef: float = field( + default=0.001, + metadata={ + "help": "Coefficient of the load-balancing auxiliary loss. Only has an effect when training a " + "Mixture-of-Experts (MoE) model; for other models it does nothing. The auxiliary loss is added to the " + "training loss with this weight. Set to `0.0` to disable it." + }, + ) + disable_dropout: bool = field( + default=False, + metadata={ + "help": "Whether to disable dropout in the model. This is useful for training with a reference model, as " + "it prevents the model from generating different logprobs for the same input." + }, + ) + cast_lm_head_to_fp32: bool = field( + default=False, + metadata={ + "help": "Whether to cast the language modeling head of the policy and reference, models to float32." + "As recommended by the [ScaleRL](https://huggingface.co/papers/2510.13786) recipe. This flag is only " + "supported when the model has untied word embedding and language modeling head layers i.e. " + "`tie_word_embeddings` in the model config is False." + }, + ) + + # Parameters that control the data preprocessing + # The default value remove_unused_columns is overwritten from the parent class, because in GRPO we usually rely on + # additional columns to compute the reward + remove_unused_columns: bool | None = field( + default=False, + metadata={ + "help": "Whether to only keep the column 'prompt' in the dataset. If you use a custom reward function " + "that requires any column other than 'prompts' and 'completions', you should keep this to `False`." + }, + ) + num_generations: int | None = field( + default=8, + metadata={ + "help": "Number of generations to sample. The effective batch size (num_processes * per_device_batch_size " + "* gradient_accumulation_steps) must be evenly divisible by this value." + }, + ) + num_generations_eval: int | None = field( + default=None, + metadata={ + "help": "Number of generations to sample during evaluation. This allows using fewer generations during " + "evaluation to save computation. If `None`, uses the value of `num_generations`." + }, + ) + max_completion_length: int | None = field( + default=256, + metadata={"help": "Maximum length of the generated completion."}, + ) + ds3_gather_for_generation: bool = field( + default=True, + metadata={ + "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for " + "generation, improving generation speed. However, disabling this option allows training models that " + "exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation. Disabling this option " + "is not compatible with vLLM generation." + }, + ) + shuffle_dataset: bool | None = field( + default=True, + metadata={"help": "Whether to shuffle the training dataset."}, + ) + pad_to_multiple_of: int | None = field( + default=None, + metadata={"help": "If set, the prompts ids and completions ids will be padded to a multiple of this value."}, + ) + + # Parameters that control generation + generation_batch_size: int | None = field( + default=None, + metadata={ + "help": "Batch size to use for generation. If `None`, it defaults to the effective training batch size: " + "`per_device_train_batch_size * num_processes * steps_per_generation`." + }, + ) + steps_per_generation: int | None = field( + default=None, + metadata={"help": "Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`."}, + ) + temperature: float = field( + default=1.0, + metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."}, + ) + top_p: float = field( + default=1.0, + metadata={ + "help": "Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. " + "Set to 1.0 to consider all tokens." + }, + ) + top_k: int = field( + default=0, + metadata={ + "help": "Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, " + "top-k-filtering is disabled and all tokens are considered." + }, + ) + min_p: float | None = field( + default=None, + metadata={ + "help": "Minimum token probability, which will be scaled by the probability of the most likely token. It " + "must be a value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range." + }, + ) + generation_kwargs: dict | None = field( + default=None, + metadata={ + "help": "Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or " + "`SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the " + "generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that " + "conflict with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them." + }, + ) + chat_template_kwargs: dict | None = field( + default=None, + metadata={ + "help": "Additional keyword arguments to pass to the `apply_chat_template` function when generating " + "completions." + }, + ) + repetition_penalty: float = field( + default=1.0, + metadata={ + "help": "Float that penalizes new tokens based on whether they appear in the prompt and the generated " + "text so far. Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model " + "to repeat tokens." + }, + ) + cache_implementation: str | None = field( + default=None, + metadata={"help": "Implementation of the cache method for faster generation when use_vllm is set to False."}, + ) + + # Parameters that control generation acceleration powered by vLLM + use_vllm: bool = field( + default=False, + metadata={ + "help": "Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for " + "generation instead of the default model.generate(). Requires `vllm` to be installed." + }, + ) + vllm_mode: str = field( + default="colocate", + metadata={ + "help": "Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or " + "`'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure " + "a TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same " + "process and share the training GPUs. This avoids the need for a separate server but may cause resource " + "contention with training." + }, + ) + vllm_model_impl: str = field( + default="vllm", + metadata={ + "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: " + "Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for " + "model implementation." + }, + ) + vllm_enable_sleep_mode: bool = field( + default=False, + metadata={ + "help": "Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory " + "usage low, but waking the engine adds host–device transfer latency." + }, + ) + vllm_structured_outputs_regex: str | None = field( + default=None, + metadata={"help": "Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled."}, + ) + + # Parameters that control the vLLM server (only used when `vllm_mode` is `"server"`) + vllm_server_base_url: str | None = field( + default=None, + metadata={ + "help": "Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` " + "and `vllm_server_port` are ignored." + }, + ) + vllm_server_host: str = field( + default="0.0.0.0", + metadata={"help": "Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."}, + ) + vllm_server_port: int = field( + default=8000, + metadata={"help": "Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."}, + ) + vllm_server_timeout: float = field( + default=240.0, + metadata={ + "help": "Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up " + "after the timeout, a `ConnectionError` is raised." + }, + ) + vllm_group_port: int = field( + default=51216, + metadata={ + "help": "Port number for the weight update group. This is used to communicate with the vLLM server. " + "Unless the port is occupied, there is no need to change it.", + }, + ) + + # Parameters that control colocated vLLM execution (only used when `vllm_mode` is `"colocate"`) + vllm_gpu_memory_utilization: float = field( + default=0.3, + metadata={ + "help": "Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set " + "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when " + "launching the vLLM server via the `--vllm_gpu_memory_utilization` flag." + }, + ) + vllm_max_model_length: int | None = field( + default=None, + metadata={ + "help": "Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus " + "`max_completion_length`; if omitted, it is inferred from the model config." + }, + ) + vllm_tensor_parallel_size: int = field( + default=1, + metadata={ + "help": "Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set " + "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when " + "launching the vLLM server via the `--vllm_tensor_parallel_size` flag." + }, + ) + + # Parameters that control the training + beta: float = field( + default=0.0, + metadata={ + "help": "KL coefficient. If `0.0` (default), the reference model is not loaded, reducing memory usage and " + "improving training speed. [DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement " + "learning](https://huggingface.co/papers/2501.12948) use a value of `0.001`." + }, + ) + num_iterations: int = field( + default=1, + metadata={"help": "Number of iterations per batch (denoted as μ in the algorithm)."}, + ) + epsilon: float = field( + default=0.2, + metadata={"help": "Epsilon value for clipping."}, + ) + delta: float | None = field( + default=None, + metadata={ + "help": "Enables the upper clipping bound in two-sided GRPO loss when set to a float. If `None` " + "(default), standard GRPO clipping is used. Recommended to be greater than `1 + ε` when enabled. This " + "method is introduced in the [INTELLECT-2 tech report](https://huggingface.co/papers/2505.07291)." + }, + ) + epsilon_high: float | None = field( + default=None, + metadata={ + "help": "Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the " + "lower-bound specified in argument `epsilon`. Paper DAPO recommends `0.28`. " + "When used with `loss_type='cispo'`, this corresponds to the ε_max param specified in the " + "[ScaleRL paper](https://huggingface.co/papers/2510.13786) and the recommended value is `5.0`." + }, + ) + sapo_temperature_neg: float = field( + default=1.05, + metadata={ + "help": "Temperature for tokens with non-positive advantage scores used in the `sapo` loss function. " + "This parameter is introduced in the [Soft Adaptive Policy Optimization " + "paper](https://huggingface.co/papers/2511.20347)." + }, + ) + sapo_temperature_pos: float = field( + default=1.0, + metadata={ + "help": "Temperature for tokens with positive advantage scores used in the `sapo` loss function. " + "This parameter is introduced in the [Soft Adaptive Policy Optimization " + "paper](https://huggingface.co/papers/2511.20347)." + }, + ) + vespo_k_pos: float = field( + default=2.0, + metadata={ + "help": "k parameter for positive advantages, it is the power exponent in the VESPO loss. Controls how " + "aggressively we down-weight samples with low importance weights (when the importance sampling ratio < 1)." + }, + ) + vespo_lambda_pos: float = field( + default=3.0, + metadata={ + "help": "lambda parameter for positive advantages, it is the decay factor in the VESPO loss. Controls " + "how aggressively we down-weight samples with high importance weights (when the importance sampling ratio " + "> 1)." + }, + ) + vespo_k_neg: float = field( + default=3.0, + metadata={ + "help": "k parameter for negative advantages, it is the power exponent in the VESPO loss. Controls how " + "aggressively we down-weight samples with low importance weights (when the importance sampling ratio < 1)." + }, + ) + vespo_lambda_neg: float = field( + default=2.0, + metadata={ + "help": "lambda parameter for negative advantages, it is the exponential decay factor in the VESPO loss. " + "Controls how aggressively we down-weight samples with high importance weights (when the importance " + "sampling ratio > 1)." + }, + ) + importance_sampling_level: str = field( + default="token", + metadata={ + "help": "Controls whether importance sampling ratios are computed at the `'token'` or `'sequence'` level. " + "`'token'` keeps the raw per-token log-probability ratios (one weight per token). `'sequence'` averages " + "the log-probability ratios across valid tokens to produce a single ratio per sequence. The GSPO paper " + "shows that sequence-level sampling often yields more stable training and better alignment with " + "sequence-level rewards." + }, + ) + reward_weights: list[float] | None = field( + default=None, + metadata={ + "help": "Weights for each reward function. Must match the number of reward functions. If `None`, all " + "rewards are weighted equally with weight `1.0`." + }, + ) + multi_objective_aggregation: str = field( + default="sum_then_normalize", + metadata={ + "help": "Method to aggregate multiple reward functions. Supported values are: " + "`'sum_then_normalize'` (default): First sums the weighted rewards from each reward function, then " + "applies reward scaling/normalization as specified by `scale_rewards` (see `scale_rewards` for details). " + "`'normalize_then_sum'`: First normalizes/scales each reward function across generations (within each " + "group), then sums the normalized rewards using the specified weights. The aggregated reward is then " + "normalized at the batch level when forming advantages. This is the suggested approach from the paper " + "GDPO: Group reward-Decoupled Normalization Policy Optimization for Multi-reward RL Optimization." + }, + ) + scale_rewards: str = field( + default="group", + metadata={ + "help": "Specifies the scaling strategy for rewards. Supported values are: " + "`True` or `group'` (default): rewards are scaled by the standard deviation within each group, ensuring " + "unit variance within a group. " + "`'batch'`: rewards are scaled by the standard deviation across the entire batch, as recommended in the " + "PPO Lite paper. " + "`False` or `'none'`: no scaling is applied. The Dr. GRPO paper recommends not scaling rewards, as " + "scaling by the standard deviation introduces a question-level difficulty bias." + }, + ) + loss_type: str = field( + default="dapo", + metadata={ + "help": "Specifies the loss formulation to use. Supported values are 'grpo', 'dapo', 'bnpo', and " + "'dr_grpo'. " + "'grpo': Aggregates token-level losses by normalizing over sequence length. Not recommended due to length " + "bias—this approach tends to prefer shorter completions with positive advantages and longer ones with " + "negative advantages. " + "'dapo' (default): Aggregates token-level losses by normalizing with the number of active token in the " + "global accumulated batch. This method was introduced in the DAPO paper to eliminate length bias. " + "'dr_grpo': Aggregates token-level losses by normalizing with a global constant. This method was " + "introduced in the Dr. GRPO paper to eliminate length bias. The value of the constant corresponds to " + "`max_completion_length`. " + "'bnpo': Aggregates token-level losses by normalizing with the number of active token in the local batch. " + "Note that normalization is performed over the local batch only, so results may slightly vary depending " + "on the local batch size, despite a constant effective batch size. When using " + "`per_device_train_batch_size==1`, the loss is equivalent to the GRPO loss." + "'cispo': Clips the importance sampling weights instead of the advantage scaled importance weights. " + "The clipped weights are then multiplied with the advantages and policy model's log probs. " + "Individual token losses are aggregated by normalizing with the number of active tokens in " + "the global accumulated batch. This method was introduced in the " + "[MiniMax-M1 paper](https://huggingface.co/papers/2506.13585). " + "'sapo': Soft Adaptive Policy Optimization loss, as introduced in the " + "[Soft Adaptive Policy Optimization paper](https://huggingface.co/papers/2511.20347). " + "Replaces hard clipping with a smooth, temperature-controlled gate that adaptively attenuates " + "off-policy updates while preserving useful learning signals." + "'luspo': Length-Unbiased Sequence Policy Optimization loss. A sequence-level loss that scales each " + "sequence's loss by its length. This is a modification of GSPO and requires " + "`importance_sampling_level='sequence'`. Introduced in the [LUSPO " + "paper](https://huggingface.co/papers/2602.05261)." + "'vespo': Variational Sequence-Level Soft Policy Optimization. Replaces hard clipping with a smooth, " + "asymmetric Gamma weighting function applied directly to sequence-level importance weights. Introduced in " + "the [VESPO paper](https://huggingface.co/papers/2602.10693)." + }, + ) + mask_truncated_completions: bool = field( + default=False, + metadata={ + "help": "When enabled, truncated completions are excluded from the loss calculation, preventing them from " + "being incorrectly penalized and introducing noise during training. According to the DAPO paper, this is " + "a good practice for training stability." + }, + ) + sync_ref_model: bool = field( + default=False, + metadata={ + "help": "Whether to synchronize the reference model with the active model every `ref_model_sync_steps` " + "steps, using the `ref_model_mixup_alpha` parameter." + }, + ) + ref_model_mixup_alpha: float = field( + default=0.6, + metadata={ + "help": "α parameter from the TR-DPO paper, which controls the mix between the current policy and the " + "previous reference policy during updates. The reference policy is updated according to the equation: " + "`π_ref = α * π_θ + (1 - α) * π_ref_prev`. To use this parameter, you must set `sync_ref_model=True`." + }, + ) + ref_model_sync_steps: int = field( + default=512, + metadata={ + "help": "τ parameter from the TR-DPO paper, which determines how frequently the current policy is " + "synchronized with the reference policy. To use this parameter, you must set `sync_ref_model=True`." + }, + ) + top_entropy_quantile: float = field( + default=1.0, + metadata={ + "help": "ρ parameter from Beyond the 80/20 Rule. Keeps in the policy loss term only the top-ρ quantile of " + "tokens by entropy of the probability distribution at each sequence position, improving results. Range: " + "[0.0-1.0]. A value of `0.0` masks all but the highest entropy token; `1.0` keeps all tokens. The paper " + "recommends a value of `0.2`. If used with `mask_truncated_completions=True`, only tokens from " + "non-truncated completions are considered." + }, + ) + max_tool_calling_iterations: int | None = field( + default=None, + metadata={ + "help": "Maximum number of tool-calling turns when training an agent. If `None`, there is no limit and " + "generation stops when the model generates a response turn with no tool calls or when the total " + "response length reaches `max_model_length`." + }, + ) + vllm_importance_sampling_correction: bool = field( + default=True, + metadata={ + "help": "Whether to apply Importance Sampling (IS) to correct for the mismatch between vLLM " + "completion logprobs and recomputed training logprobs. If set to `False`, no IS is applied " + "regardless of `vllm_importance_sampling_mode`. When `True`, the selected mode determines how " + "IS ratios are computed and constrained." + }, + ) + vllm_importance_sampling_mode: str = field( + default="sequence_mask", + metadata={ + "help": "Specifies how Importance Sampling (IS) is performed when " + "vllm_importance_sampling_correction=True. Modes are defined along two orthogonal " + "dimensions: (1) constraint, which determines how to handle ratios outside the bounds " + "[C_min, C_max]—either truncation (clip to range, ρ ← clamp(ρ, C_min, C_max)) or " + "masking (set ratios above C_max or below C_min to zero); and (2) granularity, which determines whether " + "ratios are computed per token or as a single sequence-level ratio applied to all tokens. " + "Supported options are: 'token_truncate', 'token_mask', 'sequence_truncate', and " + "'sequence_mask'." + }, + ) + vllm_importance_sampling_clip_max: float | None = field( + default=3.0, + metadata={ + "help": "Importance sampling upper bound C_max used by `vllm_importance_sampling_mode`. For '*_truncate' " + "modes, ratios are clipped from above at C_max. For '*_mask' modes, ratios larger than C_max are set to " + "zero." + }, + ) + vllm_importance_sampling_clip_min: float | None = field( + default=None, + metadata={ + "help": "Importance sampling lower bound C_min used by `vllm_importance_sampling_mode`. For `*_truncate` " + "modes, ratios are clipped from below at C_min. For `*_mask` modes, ratios below C_min are set to " + "zero. To strictly mask ratios below C_min without upper bound, set `vllm_importance_sampling_clip_max=None`." + }, + ) + off_policy_mask_threshold: float | None = field( + default=None, + metadata={ + "help": "Threshold for off-policy sequence masking. If `None`, off-policy sequence masking is disabled. " + "When set, sequences with negative advantages and high KL divergence are masked out to stabilize " + "training. This parameter corresponds to the `delta` threshold in Equation 9 of the [DeepSeek-V3.2 " + "paper](https://huggingface.co/papers/2512.02556). It expects a positive value (e.g., 0.5)." + }, + ) + use_bias_correction_kl: bool = field( + default=False, + metadata={ + "help": "Whether to use the unbiased KL divergence estimator with importance sampling correction. This " + "corrects the KL divergence estimate by multiplying it with the importance sampling ratio. " + "This is described in the [DeepSeek-V3.2 paper](https://huggingface.co/papers/2512.02556)." + }, + ) + + # Parameters that control the logging + log_completions: bool = field( + default=False, + metadata={ + "help": "Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. If `rich` is " + "installed, it prints the sample. If `wandb` logging is enabled, it logs it to `wandb`." + }, + ) + num_completions_to_print: int | None = field( + default=None, + metadata={"help": "Number of completions to print with `rich`. If `None`, all completions are logged."}, + ) + log_unique_prompts: bool = field( + default=False, + metadata={ + "help": "Whether to log unique prompts. If `True`, only unique prompts are logged. If `False`, all " + "prompts are logged." + }, + ) + log_completions_hub_repo: str | None = field( + default=None, + metadata={ + "help": "Hugging Face Hub repository to save the completions. Should be a complete repository name like " + "`'username/reponame'` or `'orgname/reponame'`, or just `'reponame'` in which case the repository will " + "be created in the currently-logged-in Hugging Face user's namespace. Note that this repository will be " + "public unless you set `hub_private_repo=True` or your organization's default is to create private " + "repositories." + }, + ) + + # Parameters that control generation acceleration powered by transformers continuous batching + use_transformers_continuous_batching: bool = field( + default=False, + metadata={ + "help": "Whether to use transformers' continuous batching engine for generating completions. Requires " + "transformers>=5.8.0." + }, + ) + transformers_continuous_batching_config: dict | None = field( + default=None, + metadata={"help": "Keyword arguments for `transformers.generation.ContinuousBatchingConfig`."}, + ) + + # Deprecated parameters + use_transformers_paged: bool = field( + default=False, + metadata={"help": "Deprecated. Use `use_transformers_continuous_batching` instead."}, + ) + vllm_importance_sampling_cap: float | None = field( + default=None, + metadata={ + "help": "Deprecated, use `vllm_importance_sampling_clip_max` instead. " + "Importance sampling cap C used by `vllm_importance_sampling_mode`. For '*_truncate' modes, " + "ratios are clipped from above at C. For '*_mask' modes, ratios larger than C are set to zero." + }, + ) + + def __post_init__(self): + super().__post_init__() + + if self.use_transformers_paged: + warnings.warn( + "`use_transformers_paged` is deprecated and will be removed in v2.0.0. Use " + "`use_transformers_continuous_batching` instead.", + FutureWarning, + stacklevel=3, + ) + self.use_transformers_continuous_batching = True + + if self.parallelism_config is not None and ( + self.parallelism_config.cp_enabled or self.parallelism_config.sp_enabled + ): + raise ValueError( + "GRPOTrainer does not support sequence-dim parallelism (`parallelism_config.cp_size > 1` or " + "`parallelism_config.sp_size > 1`) yet. GRPO builds model inputs after generation inside the trainer, " + "so Transformers' context-parallel / Ulysses sequence-parallel input sharding cannot be applied to the " + "raw generation batch. Set both `cp_size=1` and `sp_size=1`, or disable `parallelism_config`." + ) + + self.scale_rewards = {True: "group", False: "none"}.get(self.scale_rewards, self.scale_rewards) + + if self.log_completions_hub_repo is not None and not self.log_completions: + raise ValueError( + "log_completions_hub_repo is set, but log_completions is False. Enable log_completions to upload " + "completions to the Hub, or unset log_completions_hub_repo." + ) + + num_processes = self.world_size + # The current default effective batch size + if self.generation_batch_size is None and self.steps_per_generation is None: + self.steps_per_generation = self.gradient_accumulation_steps + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + elif self.generation_batch_size is not None and self.steps_per_generation is None: + # Just ensure the value is divisible by the global batch size + if self.generation_batch_size % (self.per_device_train_batch_size * num_processes) != 0: + raise ValueError( + f"generation_batch_size ({self.generation_batch_size}) must be divisible by the global batch size " + f"({self.per_device_train_batch_size * num_processes})." + ) + self.steps_per_generation = self.generation_batch_size // ( + self.per_device_train_batch_size * num_processes + ) + elif self.generation_batch_size is None and self.steps_per_generation is not None: + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + else: + raise ValueError( + "'generation_batch_size' and 'steps_per_generation' can not be both configured at the same time" + ) + + if self.do_eval and self.eval_strategy != "no": + # Determine the number of generations to use for evaluation + num_generations = self.num_generations_eval or self.num_generations + + # Just ensure the value is divisible by the global batch size + if (self.per_device_eval_batch_size * num_processes) % num_generations != 0: + raise ValueError( + f"The global eval batch size ({self.per_device_eval_batch_size} * {num_processes}) must be " + f"divisible by the number of generations used for evaluation ({num_generations})." + ) + + # The generation batch must contain full prompt groups (no partials), so it must be divisible by + # num_generations. + if self.generation_batch_size % self.num_generations != 0: + raise ValueError( + f"generation_batch_size ({self.generation_batch_size}) must be divisible by num_generations " + f"({self.num_generations})." + ) + + if self.num_generations < 2: + raise ValueError( + "GRPO requires at least 2 generations per prompt to calculate the advantages. You provided " + f"{self.num_generations}, which is less than the minimum required." + ) + + if self.vllm_importance_sampling_cap is not None: + warnings.warn( + "The `vllm_importance_sampling_cap` argument is deprecated and will be removed in v2.0.0. " + "Use `vllm_importance_sampling_clip_max` instead.", + FutureWarning, + stacklevel=2, + ) + self.vllm_importance_sampling_clip_max = self.vllm_importance_sampling_cap + + if ( + self.vllm_importance_sampling_clip_min is not None + and self.vllm_importance_sampling_clip_max is not None + and self.vllm_importance_sampling_clip_min >= self.vllm_importance_sampling_clip_max + ): + raise ValueError( + f"vllm_importance_sampling_clip_min ({self.vllm_importance_sampling_clip_min}) must be less than " + f"vllm_importance_sampling_clip_max ({self.vllm_importance_sampling_clip_max})." + ) + + if ( + self.vllm_importance_sampling_correction + and self.vllm_importance_sampling_mode in ("token_truncate", "sequence_truncate") + and self.vllm_importance_sampling_clip_min is None + and self.vllm_importance_sampling_clip_max is None + ): + raise ValueError( + "At least one of `vllm_importance_sampling_clip_min` or `vllm_importance_sampling_clip_max` " + "must be set when `vllm_importance_sampling_mode` is a `*_truncate` mode." + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/grpo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/grpo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..a7a673e878481fbee95567bf1e705913638cfc8c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/grpo_trainer.py @@ -0,0 +1,2887 @@ +# Copyright 2020-2026 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 asyncio +import atexit +import copy +import importlib.resources as pkg_resources +import inspect +import math +import os +import sys +import textwrap +import time +import warnings +from collections import defaultdict, deque +from collections.abc import Callable +from contextlib import nullcontext +from pathlib import Path +from typing import Any, Protocol + +import numpy as np +import pandas as pd +import torch +import torch.utils.data +import transformers +from accelerate.logging import get_logger +from accelerate.utils import gather, gather_object, is_peft_model, set_seed +from datasets import Dataset, IterableDataset +from huggingface_hub import CommitScheduler, DatasetCard, DatasetCardData, create_repo +from packaging.version import Version +from torch import nn +from torch.utils.data import Sampler +from transformers import ( + AutoModelForSequenceClassification, + AutoProcessor, + AutoTokenizer, + GenerationConfig, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, + is_trackio_available, + is_wandb_available, +) +from transformers.utils import is_peft_available, is_rich_available + +from ..chat_template_utils import ( + add_response_schema, + get_training_chat_template, + is_chat_template_prefix_preserving, + parse_response, + supports_tool_calling, +) +from ..data_utils import apply_chat_template, is_conversational, prepare_multimodal_messages +from ..distributed import DistributedBackend +from ..extras.profiling import profiling_context, profiling_decorator +from ..generation.vllm_generation import VLLMGeneration +from ..import_utils import is_jmespath_available, is_liger_kernel_available +from ..models import prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation +from ..models.utils import _ForwardRedirection, disable_gradient_checkpointing +from .base_trainer import _BaseTrainer +from .callbacks import SyncRefModelCallback +from .grpo_config import GRPOConfig +from .utils import ( + RepeatSampler, + create_model_from_path, + disable_dropout_in_model, + entropy_from_logits, + get_config_model_id, + identity, + nanmax, + nanmin, + nanstd, + pad, + print_prompt_completions_sample, + selective_log_softmax, + shuffle_sequence_dict, + shutdown_event_loop_in_daemon, + split_pixel_values_by_grid, + split_tensor_dict, + start_event_loop_in_daemon, + unsplit_pixel_values_by_grid, + use_adapter, +) + + +if is_peft_available(): + import peft + from peft import LoraConfig, PeftConfig, PeftModel, get_peft_model + from peft.tuners.tuners_utils import BaseTunerLayer + +if is_liger_kernel_available(): + from liger_kernel.chunked_loss import LigerFusedLinearGRPOLoss + + +if is_wandb_available(): + import wandb + +if is_trackio_available(): + import trackio + + +logger = get_logger(__name__) + +# A reward function can be a string, interpreted as a model ID and loaded as a pretrained model, a pretrained model, or +# a callable that returns a list of floats (the rewards). The callable receives prompts, completions, and additional +# arguments from the trainer (refer to the trainer's source for details). To ensure forward compatibility, it should +# accept **kwargs. +RewardFunc = str | PreTrainedModel | Callable[..., list[float | None]] + +# What we call a rollout function is a callable that takes prompts (list) and the trainer instance as parameters and +# returns a dict of generation results. Those results must include "prompt_ids", "completion_ids", and "logprobs" +# fields. Any extra fields (per-completion) are forwarded to the reward functions. +RolloutFunc = Callable[[list[str], "GRPOTrainer"], dict[str, Any]] + + +class _SupportsReset(Protocol): + def reset(self, **kwargs) -> str | None: ... + + +EnvironmentFactory = Callable[[], _SupportsReset] + + +class GRPOTrainer(_BaseTrainer): + """ + Trainer for the Group Relative Policy Optimization (GRPO) method. This algorithm was initially proposed in the + paper [DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language + Models](https://huggingface.co/papers/2402.03300). + + Example: + + ```python + from trl import GRPOTrainer + from trl.rewards import accuracy_reward + from datasets import load_dataset + + dataset = load_dataset("trl-lib/DeepMath-103K", split="train") + + trainer = GRPOTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", + reward_funcs=accuracy_reward, + train_dataset=dataset, + ) + trainer.train() + ``` + + Args: + model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]): + Model to be trained. Can be either: + + - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using `.from_pretrained` (where `` is derived from the model + config) with the keyword arguments in `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported. + - A [`~peft.PeftModel`] object. Only causal language models are supported. + reward_funcs (`RewardFunc | list[RewardFunc]`): + Reward functions to be used for computing the rewards. To compute the rewards, we call all the reward + functions with the prompts and completions and sum the rewards. Can be either: + + - A single reward function, such as: + - A string: The *model ID* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using [`~transformers.AutoModelForSequenceClassification.from_pretrained`] with `num_labels=1` and the + keyword arguments in `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object: Only sequence classification models are supported. + - A custom reward function: The function is provided with the prompts and the generated completions, + plus any additional columns in the dataset. It should return a list of rewards. Custom reward + functions can be either synchronous or asynchronous and can also return `None` when the reward is + not applicable to those samples. This is useful for multi-task training where different reward + functions apply to different types of samples. When a reward function returns `None` for a sample, + that reward function is excluded from the reward calculation for that sample. For more details, see + [Using a custom reward + function](#using-a-custom-reward-function). + + The trainer's state is also passed to the reward function. The trainer's state is an instance of + [`~transformers.TrainerState`] and can be accessed by accessing the `trainer_state` argument to the + reward function's signature. + - A list of reward functions, where each item can independently be any of the above types. Mixing different + types within the list (e.g., a string model ID and a custom reward function) is allowed. + args ([`GRPOConfig`], *optional*): + Configuration for this trainer. If `None`, a default configuration is used. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + Dataset to use for training. It must include a column `"prompt"`. Any additional columns in the dataset is + ignored. The format of the samples can be either: + + - [Standard](dataset_formats#standard): Each sample contains plain text. + - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role + and content). + eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`): + Dataset to use for evaluation. It must meet the same requirements as `train_dataset`. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. The padding side must be set to "left". If `None`, the + processing class is loaded from the model's name with [`~transformers.AutoProcessor.from_pretrained`]. A + padding token, `tokenizer.pad_token`, must be set. If the processing class has not set a padding token, + `tokenizer.eos_token` will be used as the default. + reward_processing_classes ([`~transformers.PreTrainedTokenizerBase`] or `list[PreTrainedTokenizerBase]`, *optional*): + Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either: + + - A single processing class: Used when `reward_funcs` contains only one reward function. + - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`. + If set to `None`, or if an element of the list corresponding to a [`~transformers.PreTrainedModel`] is + `None`, the tokenizer for the model is automatically loaded using + [`~transformers.AutoTokenizer.from_pretrained`]. For elements in `reward_funcs` that are custom reward + functions (not [`~transformers.PreTrainedModel`]), the corresponding entries in `reward_processing_classes` + are ignored. + callbacks (list of [`~transformers.TrainerCallback`], *optional*): + List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed + in [here](https://huggingface.co/docs/transformers/main_classes/callback). + + If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`] + method. + optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`): + A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your + model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration used to wrap the model. If `None`, the model is not wrapped. + tools (list of `Callable`, *optional*): + A list of callable tool functions (sync or async) that the model can invoke during generation. Each tool + should be a standard Python function with properly type-hinted arguments and return values, and a + Google-style docstring describing its purpose, arguments, and return value. For more details, see: + https://huggingface.co/docs/transformers/en/chat_extras#passing-tools. The model uses the function's name, + type hints, and docstring to determine how to call it. Ensure that the model's chat template supports tool + use and that it has been fine-tuned for tool calling. + rollout_func (`RolloutFunc`, *optional*): + Function to use for generating completions. It receives the list of prompts allocated to the current + process and the trainer instance. It must return a dict with `"prompt_ids"`, `"completion_ids"`, and + `"logprobs"` fields, and can optionally return `"logprob_token_ids"` (same shape as `"logprobs"`). Any + other fields are forwarded to the reward functions. The function receives the raw per-process prompt slice + with no duplication; it is responsible for returning the correct number of completions per prompt (see + `num_generations` / `num_generations_eval` on the trainer). This feature is experimental and may change or + be removed at any time without prior notice. + environment_factory (`EnvironmentFactory`, *optional*): + A callable that creates and returns an environment instance. The environment class should define methods + that can be invoked as tools during generation. Each method should comply with the same requirements as the + `tools` described above. If `environment_factory` is provided, an instance of the environment is created + for each generation in the batch, allowing for parallel and independent interactions. The environment must + also implement a callable `reset` method that can be used to reset state between generations. The `reset` + method should return either `None` or a string: when it returns a string, that string is appended to the + last user message before generation. This feature is experimental and may change or be removed at any time + without prior notice. + """ + + _tag_names = ["trl", "grpo"] + _name = "GRPO" + _paper = { + "title": "DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models", + "id": "2402.03300", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @article{shao2024deepseekmath, + title = {{DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models}}, + author = {Zhihong Shao and Peiyi Wang and Qihao Zhu and Runxin Xu and Junxiao Song and Mingchuan Zhang and Y. K. Li and Y. Wu and Daya Guo}, + year = 2024, + eprint = {arXiv:2402.03300}, + }"""), + } + + def __init__( + self, + model: "str | PreTrainedModel | PeftModel", + reward_funcs: RewardFunc | list[RewardFunc], + args: GRPOConfig | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + peft_config: "PeftConfig | None" = None, + tools: list[Callable] | None = None, + rollout_func: RolloutFunc | None = None, + environment_factory: EnvironmentFactory | None = None, + ): + # Args + if args is None: + model_name = model if isinstance(model, str) else get_config_model_id(model.config) + model_name = model_name.split("/")[-1] + args = GRPOConfig(f"{model_name}-GRPO") + + # Model + if isinstance(model, str): + model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + model = create_model_from_path(model, **model_init_kwargs) + else: + if args.model_init_kwargs is not None: + logger.warning( + "You passed `model_init_kwargs` to the `GRPOConfig`, but your model is already instantiated. " + "The `model_init_kwargs` will be ignored." + ) + # Non-quantized models do not have the `is_loaded_in_{8,4}bit` attributes, whereas quantized models do + _is_quantized_model = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False) + + # Some models (SmolVLM/Idefics3) don't support `logits_to_keep` argument and error out if we pass it + # Inspect the forward method before we wrap the model with PEFT + self.model_kwarg_keys = ( + inspect.signature(model.forward).parameters.keys() + if not hasattr(model, "get_base_model") + else inspect.signature(model.get_base_model().forward).parameters.keys() + ) + + # Processing class + if processing_class is None: + processing_class = AutoProcessor.from_pretrained( + get_config_model_id(model.config), + truncation_side="left", + padding_side="left", + trust_remote_code=args.trust_remote_code, + ) + + if args.use_transformers_continuous_batching and isinstance(processing_class, ProcessorMixin): + raise ValueError( + "`use_transformers_continuous_batching` does not support multimodal models. Use `use_vllm` instead." + ) + + # Handle pad token for processors or tokenizers + if isinstance(processing_class, ProcessorMixin): + self._tokenizer = processing_class.tokenizer + self._is_vlm = True + elif isinstance(processing_class, PreTrainedTokenizerBase): + self._tokenizer = processing_class + self._is_vlm = False + else: + raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`") + + if self._tokenizer.pad_token is None: + self._tokenizer.pad_token = self._tokenizer.eos_token + + # Resolve vision placeholder token IDs once. Used by the forward pass to rebuild mm_token_type_ids + # when tool responses inject images into the completion (see _generate forward_kwargs block). + self._image_pad_token_id = None + self._video_pad_token_id = None + if self._is_vlm: + for candidate in ("<|image_pad|>", "<|image|>"): + tid = self._tokenizer.convert_tokens_to_ids(candidate) + if tid != self._tokenizer.unk_token_id: + self._image_pad_token_id = tid + break + tid = self._tokenizer.convert_tokens_to_ids("<|video_pad|>") + if tid != self._tokenizer.unk_token_id: + self._video_pad_token_id = tid + + # PEFT + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge " + "and unload the existing adapter, save the resulting base model, and then pass that base model along " + "with the new `peft_config` to the trainer." + ) + # Create PEFT model + # ZeRO-3 + PEFT for non-quantized models: + # - PEFT's default autocast_adapter_dtype=True upcasts LoRA adapter params to fp32 even when the base model is bf16. + # - ZeRO-3's _allgather_params_coalesced allocates output buffers using the dtype of the first persistent parameter, + # so mixed-dtype persistent_parameters (bf16 base + fp32 LoRA) cause a TypeError on the first optimizer step. + # - Passing autocast_adapter_dtype=False keeps adapter params in the base model dtype (bf16), fixing the mismatch. + # - This is safe: the fp32 upcast is a QLoRA-specific concern (low-bit quantized base models), not needed for + # non-quantized bf16 training. + # - See: + # - TRL issue: https://github.com/huggingface/trl/issues/6089 + # - Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/8072 + # - autocast_adapter_dtype was introduced in PEFT 0.12.0; before, no upcast existed: no need to pass the kwarg + get_peft_model_kwargs = {} + if ( + args.deepspeed_plugin is not None + and args.deepspeed_plugin.zero_stage == 3 + and not _is_quantized_model + and Version(peft.__version__) >= Version("0.12.0") + ): + get_peft_model_kwargs["autocast_adapter_dtype"] = False + model = get_peft_model(model, peft_config, **get_peft_model_kwargs) + + elif is_peft_model(model) and args.beta != 0.0: + # If the model is a PEFT model with a pretrained adapter, we need to create a "ref" adapter that is a copy + # of the "default" adapter, so that we can use it as the reference model during GRPO training. PEFT only + # supports one adapter per model when the LoRA config uses `target_parameters` (see peft#3340), so in that + # case we skip the "ref" adapter and compute the reference log probs with adapters disabled, i.e. with the + # base model. + default_config = model.peft_config["default"] + if isinstance(default_config, LoraConfig) and default_config.target_parameters: + logger.warning( + "PEFT can't add a frozen reference adapter alongside one that uses `target_parameters` " + "(peft#3340), so the reference log probs are computed from the base model (adapters disabled). " + "If you wrapped the model only to apply LoRA, pass a `peft_config` to the trainer instead; if you " + "wrapped it deliberately (pretrained adapter or custom init), note that the base model matches " + "your adapter only when it's freshly zero-initialized. If it is, this warning is safe to ignore." + ) + else: + model.add_adapter("ref", default_config) + for name, param in model.named_parameters(): + if ".default." in name: + ref_name = name.replace(".default.", ".ref.") + ref_param = model.get_parameter(ref_name) + ref_param.data.copy_(param.data) + + # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally + # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489 + if is_peft_model(model) and args.gradient_checkpointing: + model.enable_input_require_grads() + + # When using QLoRA, the PEFT adapter weights are converted to bf16 to follow the recommendations from the + # original paper (see https://huggingface.co/papers/2305.14314, paragraph 3). Normally, this can be done by + # passing `autocast_adapter_dtype=False` to `get_peft_model`, but this option is not yet supported for + # quantized models. See: https://github.com/huggingface/peft/issues/2889 + if _is_quantized_model: + for param in model.parameters(): + if param.requires_grad: + param.data = param.data.to(torch.bfloat16) + + # Reward functions + if not isinstance(reward_funcs, list): + reward_funcs = [reward_funcs] + self.reward_func_names = [] + for i, reward_func in enumerate(reward_funcs): + if isinstance(reward_func, str): + model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + reward_funcs[i] = AutoModelForSequenceClassification.from_pretrained( + reward_func, num_labels=1, **model_init_kwargs + ) + if isinstance(reward_funcs[i], nn.Module): # Use Module over PretrainedModel for compat w/ compiled models + self.reward_func_names.append(get_config_model_id(reward_funcs[i].config).split("/")[-1]) + else: + self.reward_func_names.append(reward_funcs[i].__name__) + self.reward_funcs = reward_funcs + + # Reward weights + if args.reward_weights is not None: + if len(args.reward_weights) != len(reward_funcs): + raise ValueError( + f"Number of reward weights ({len(args.reward_weights)}) must match number of reward " + f"functions ({len(reward_funcs)})" + ) + self.reward_weights = torch.tensor(args.reward_weights, dtype=torch.float32) + else: + self.reward_weights = torch.ones(len(reward_funcs), dtype=torch.float32) + + # Reward processing class + if reward_processing_classes is None: + reward_processing_classes = [None] * len(reward_funcs) + elif not isinstance(reward_processing_classes, list): + reward_processing_classes = [reward_processing_classes] + if len(reward_processing_classes) != len(reward_funcs): + raise ValueError( + f"The number of reward processing classes ({len(reward_processing_classes)}) must match the number of " + f"reward functions ({len(reward_funcs)})." + ) + + for i, (reward_processing_class, reward_func) in enumerate( + zip(reward_processing_classes, reward_funcs, strict=True) + ): + if isinstance(reward_func, PreTrainedModel): + if reward_processing_class is None: + reward_processing_class = AutoTokenizer.from_pretrained( + get_config_model_id(reward_func.config), trust_remote_code=args.trust_remote_code + ) + if reward_processing_class.pad_token_id is None: + reward_processing_class.pad_token = reward_processing_class.eos_token + # The reward model computes the reward for the latest non-padded token in the input sequence. + # So it's important to set the pad token ID to the padding token ID of the processing class. + reward_func.config.pad_token_id = reward_processing_class.pad_token_id + reward_processing_classes[i] = reward_processing_class + + self.reward_processing_classes = reward_processing_classes + + # Rollout function + if rollout_func is not None and os.environ.get("TRL_EXPERIMENTAL_SILENCE", "0") != "1": + warnings.warn( + "You are using 'rollout_func', which is an experimental feature. This API may change or be removed at " + "any time without prior notice. Silence this warning by setting environment variable " + "TRL_EXPERIMENTAL_SILENCE=1.", + UserWarning, + stacklevel=2, + ) + self.rollout_func = rollout_func + if environment_factory is not None and os.environ.get("TRL_EXPERIMENTAL_SILENCE", "0") != "1": + warnings.warn( + "You are using 'environment_factory', which is an experimental feature. This API may change or be " + "removed at any time without prior notice. Silence this warning by setting environment variable " + "TRL_EXPERIMENTAL_SILENCE=1.", + UserWarning, + stacklevel=2, + ) + + # Tools + if tools: + if not Version(transformers.__version__) >= Version("5.0.0"): + raise ImportError( + "Using tools with GRPOTrainer requires transformers version 5.0.0 or higher. Please upgrade " + "transformers with `pip install --upgrade transformers` to use this feature." + ) + if environment_factory: + if not Version(transformers.__version__) >= Version("5.2.0"): + raise ImportError( + "Using `environment_factory` with GRPOTrainer requires transformers version 5.2.0 or higher. " + "Please install transformers from the main branch with `pip install " + "git+https://github.com/huggingface/transformers.git@main` to use this feature." + ) + if tools or environment_factory: + if not is_jmespath_available(): + raise ImportError( + "Using tools with GRPOTrainer requires the jmespath library for response parsing. Please install " + "it with `pip install jmespath` to use this feature." + ) + if not supports_tool_calling(processing_class): + raise ValueError( + "The provided chat template does not support tool calling. The template must be able to render a " + "full tool-calling conversation (user -> assistant with tool_calls -> tool)." + ) + + # Create the environments and extract their methods to be used as tools. We create one environment per rollout + generation_batch_size = args.per_device_train_batch_size * args.steps_per_generation + if environment_factory is not None: + self.environments = [environment_factory() for _ in range(generation_batch_size)] + environment_methods = [[] for _ in range(generation_batch_size)] + for i, environment in enumerate(self.environments): + has_reset = False + for name, member in inspect.getmembers(environment, predicate=inspect.ismethod): + if name == "reset": + has_reset = True + elif not name.startswith("_"): + environment_methods[i].append(member) + if not has_reset: + raise ValueError( + "Each environment instance returned by `environment_factory` must define a callable `reset` " + ) + else: + self.environments = None + + tools = tools or [] + self._sync_tool_dicts = [{} for _ in range(generation_batch_size)] + self._async_tool_dicts = [{} for _ in range(generation_batch_size)] + for i in range(generation_batch_size): + for tool in tools + (environment_methods[i] if self.environments is not None else []): + if inspect.iscoroutinefunction(tool): + self._async_tool_dicts[i][tool.__name__] = tool + else: + self._sync_tool_dicts[i][tool.__name__] = tool + + self.tools = tools + (environment_methods[0] if self.environments is not None else []) + + # Check for async functions to start an event loop on a daemon thread + self._has_async_funcs = any(inspect.iscoroutinefunction(func) for func in self.reward_funcs + self.tools) + + if self._has_async_funcs: + self.async_loop_thread, self.async_loop, self.async_loop_ready_event = start_event_loop_in_daemon( + name="GRPOTrainer-AsyncLoop" + ) + # wait until the event loop is running in the daemon thread + self.async_loop_ready_event.wait() + atexit.register(shutdown_event_loop_in_daemon, self.async_loop_thread, self.async_loop) + + # At the time of initial implementation, most tokenizers do not have built-in support for response schemas. + # While waiting for broader adoption, we provide this utility function to manually set the response schema for + # known chat templates. `response_schema` lives on the (inner) tokenizer, since `parse_response` is a tokenizer + # method that reads `self.response_schema`. + if self.tools and getattr(self._tokenizer, "response_schema", None) is None: + processing_class = add_response_schema(processing_class) + # In multi-turn training, the chat template *must* be prefix-preserving. If the tokenizer's original template + # isn't, we replace it at initialization with a training-safe, prefix-preserving template. + if self.tools and not is_chat_template_prefix_preserving(processing_class): + self.chat_template = get_training_chat_template(processing_class) + else: + self.chat_template = None + + # Training arguments + self.max_completion_length = args.max_completion_length # = |o_i| in the GRPO paper + self.num_generations = args.num_generations # = G in the GRPO paper + self.max_tool_calling_iterations = args.max_tool_calling_iterations or sys.maxsize + self.num_generations_eval = args.num_generations_eval or self.num_generations + self.chat_template_kwargs = args.chat_template_kwargs or {} + self.temperature = args.temperature + self.top_p = args.top_p + self.top_k = args.top_k + self.min_p = args.min_p + self.repetition_penalty = args.repetition_penalty + self.use_transformers_continuous_batching = args.use_transformers_continuous_batching + if self.use_transformers_continuous_batching: + if not Version(transformers.__version__) >= Version("5.8.0"): + raise ImportError( + "Using `use_transformers_continuous_batching` requires transformers>=5.8.0. " + "Please upgrade with `pip install --upgrade transformers`." + ) + from transformers.generation import ContinuousBatchingConfig + + cb_kwargs = dict(args.transformers_continuous_batching_config or {}) + # The transformers default (0.9) leaves almost no VRAM for the training backward pass; + # use a training-aware default unless the user has set it explicitly. + cb_kwargs.setdefault("max_memory_percent", 0.5) + self.continuous_batching_config = ContinuousBatchingConfig(**cb_kwargs) + else: + self.continuous_batching_config = None + self.pad_to_multiple_of = args.pad_to_multiple_of + self.use_vllm = args.use_vllm + self.vllm_mode = args.vllm_mode + self.vllm_gpu_memory_utilization = args.vllm_gpu_memory_utilization # only applies to colocation mode + self.vllm_tensor_parallel_size = args.vllm_tensor_parallel_size # only applies to colocation mode + self.vllm_importance_sampling_correction = args.vllm_importance_sampling_correction + self.vllm_importance_sampling_mode = args.vllm_importance_sampling_mode + self.vllm_importance_sampling_clip_max = args.vllm_importance_sampling_clip_max + self.vllm_importance_sampling_clip_min = args.vllm_importance_sampling_clip_min + self.use_liger_kernel = args.use_liger_kernel + self.loss_type = args.loss_type + self.multi_objective_aggregation = args.multi_objective_aggregation + + # MoE load-balancing auxiliary loss, applied to Mixture-of-Experts models (no effect otherwise) + text_config = model.config.get_text_config() + is_moe = getattr(text_config, "output_router_logits", None) is not None + self.aux_loss_enabled = is_moe and args.router_aux_loss_coef != 0.0 + self.router_aux_loss_coef = args.router_aux_loss_coef + self.scale_rewards = args.scale_rewards + self.importance_sampling_level = args.importance_sampling_level + self.off_policy_mask_threshold = args.off_policy_mask_threshold + if self.use_liger_kernel and self.off_policy_mask_threshold is not None: + raise ValueError("Liger kernel does not support off-policy sequence masking yet.") + if self.use_liger_kernel and is_peft_model(model): + # The Liger fused GRPO loss multiplies the hidden states by `lm_head.weight` directly. When the LM head is + # targeted by a PEFT adapter (`"lm_head"` in `target_modules`), `lm_head.weight` is the frozen base weight + # and the trainable adapter parameters live in separate submodules that Liger never sees. The head adapter + # would silently receive no gradient, so the model trains as if `lm_head` were frozen. Fail loudly rather + # than train a silently-frozen head. + output_embeddings = model.get_output_embeddings() + if isinstance(output_embeddings, BaseTunerLayer): + raise ValueError( + "`use_liger_kernel=True` is incompatible with applying a PEFT adapter to `lm_head`. The Liger " + "fused GRPO loss reads `lm_head.weight` directly, so the adapter on the head is ignored and never " + "trained. Either remove `'lm_head'` from your `target_modules`, or set `use_liger_kernel=False`." + ) + self.mask_truncated_completions = args.mask_truncated_completions + self.top_entropy_quantile = args.top_entropy_quantile + if self.use_liger_kernel and self.top_entropy_quantile < 1.0: + raise NotImplementedError( + "Liger Kernels don't currently support masking token positions based on entropy." + ) + if self.use_liger_kernel and self.importance_sampling_level not in ("token", "sequence"): + raise ValueError( + f"Unknown importance sampling level: {self.importance_sampling_level}. " + "Possible values are 'token' and 'sequence'." + ) + + # Datasets + self.shuffle_dataset = args.shuffle_dataset + + if train_dataset is None: + raise ValueError("`train_dataset` is required") + elif ( + isinstance(train_dataset, IterableDataset) + or isinstance(eval_dataset, IterableDataset) + or ( + isinstance(eval_dataset, dict) and any(isinstance(ds, IterableDataset) for ds in eval_dataset.values()) + ) + ): + # See https://github.com/huggingface/trl/issues/3213 + raise NotImplementedError( + "Iterable datasets are not yet supported in GRPOTrainer. Please use a standard dataset instead." + ) + + if args.loss_type == "luspo" and args.importance_sampling_level != "sequence": + logger.warning( + "When using `'luspo'` loss, `importance_sampling_level` should be set to `'sequence'` to mirror the " + "paper's setup." + ) + + if args.loss_type == "vespo" and args.importance_sampling_level != "token": + logger.warning( + "VESPO computes sequence-level importance weights internally. `importance_sampling_level` should be " + "set to `'token'` (the default)." + ) + + if self.loss_type == "vespo" and self.use_vllm and self.vllm_importance_sampling_correction: + if self.vllm_importance_sampling_mode not in ["token_truncate", "token_mask"]: + raise ValueError( + f"VESPO loss requires `vllm_importance_sampling_mode` to be either 'token_truncate' or " + f"'token_mask'. Got: {self.vllm_importance_sampling_mode}." + ) + + # Multi-step + self.num_iterations = args.num_iterations # = 𝜇 in the GRPO paper + self.epsilon_low = args.epsilon + self.epsilon_high = args.epsilon_high if args.epsilon_high is not None else args.epsilon + # Tracks the number of iterations (forward + backward passes), including those within a grad accum cycle + self._step = 0 + # Buffer the batch to reuse generated outputs across multiple updates. For more details, see + # `_get_train_sampler` and `_prepare_inputs`. + self._buffered_inputs = None + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=identity, # No data collation is needed in GRPO + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + callbacks=callbacks, + optimizers=optimizers, + # In Trainer, `training_step` scales the loss by `gradient_accumulation_steps` only if `compute_loss_func` + # is None. For DAPO, loss scaling instead depends on the total number of completions tokens across the + # global accumulated batch. To control scaling ourselves, we must disable Trainer’s built-in scaling. The + # simplest (though a bit hacky) way is to set `compute_loss_func` to any non-None value, which bypasses + # that behavior without rewriting `training_step`. + compute_loss_func="non-None value to disable scaling", + ) + + # Reference model + self.beta = args.beta + if self.beta == 0.0: + # If beta is 0.0, the reference model is not needed + self.ref_model = None + elif is_peft_model(model): + # If PEFT is used, the reference model is not needed since the adapter can be disabled + # to revert to the initial model. + self.ref_model = None + else: + # For deepspeed, fsdp or non-distributed models, create a reference model from scratch + model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if self.args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + self.ref_model = create_model_from_path(get_config_model_id(self.model.config), **model_init_kwargs) + + # Disable dropout in the models + if args.disable_dropout: + disable_dropout_in_model(model) + if self.ref_model is not None: + disable_dropout_in_model(self.ref_model) + + # Cast LM Head To FP32 + if args.cast_lm_head_to_fp32: + + def _cast_lm_head_to_fp32(target_model: PreTrainedModel): + """Cast lm_head to fp32 while preserving embedding output dtype if tied.""" + + def cast_inputs_to_fp32(module, inputs): + # Preserve other positional args and kwargs untouched + if not inputs: + return inputs + return (inputs[0].to(torch.float32),) + inputs[1:] + + original_dtype_local = target_model.lm_head.weight.dtype + target_model.lm_head = target_model.lm_head.float() + target_model.lm_head.register_forward_pre_hook(cast_inputs_to_fp32) + + if target_model.config.tie_word_embeddings: + + def cast_outputs_to_original_dtype(module, args, output): + return output.to(original_dtype_local) + + # Only cast activations; weights are now fp32 (intentional for numerical stability of logits) + target_model.model.embed_tokens.register_forward_hook(cast_outputs_to_original_dtype) + + _cast_lm_head_to_fp32(model) + if self.ref_model is not None: + _cast_lm_head_to_fp32(self.ref_model) + + # Liger loss + if self.use_liger_kernel: + if not is_liger_kernel_available(): + raise ImportError( + "Liger is required to use `use_liger_kernel` as the GRPO loss. Run `pip install liger-kernel`." + ) + # redirect the model.module forward to the model forward to ensure pre-forward hooks are called + self._forward_redirection = _ForwardRedirection() + + self.liger_grpo_loss = LigerFusedLinearGRPOLoss( + beta=self.beta, + epsilon_low=self.epsilon_low, + epsilon_high=self.epsilon_high, + temperature=self.temperature, + use_ref_model=self.beta != 0.0, + loss_type=self.loss_type, + max_completion_length=self.max_completion_length, + importance_sampling_level=self.importance_sampling_level, + delta=args.delta, + use_bias_correction_kl=args.use_bias_correction_kl, + sapo_temperature_pos=args.sapo_temperature_pos, + sapo_temperature_neg=args.sapo_temperature_neg, + vespo_k_pos=args.vespo_k_pos, + vespo_lambda_pos=args.vespo_lambda_pos, + vespo_k_neg=args.vespo_k_neg, + vespo_lambda_neg=args.vespo_lambda_neg, + ) + + # Initialize the metrics + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + self._total_train_tokens = 0 + self._current_train_step_time = 0.0 + self.log_completions = args.log_completions + self.log_unique_prompts = args.log_unique_prompts + self.num_completions_to_print = args.num_completions_to_print + # Keep logs sized to the generation batch to record only outputs from the latest model update. + self._logs = { + "images": deque(maxlen=args.generation_batch_size), + "prompt": deque(maxlen=args.generation_batch_size), + "completion": deque(maxlen=args.generation_batch_size), + "rewards": defaultdict(lambda: deque(maxlen=args.generation_batch_size)), + "advantages": deque(maxlen=args.generation_batch_size), + "extra": defaultdict(lambda: deque(maxlen=args.generation_batch_size)), + } + # Buffers for user-logged data from reward functions, flushed after gathering + self._pending_extra_logs = defaultdict(list) + self._pending_metrics = defaultdict(list) + + # Ensure each process receives a unique seed to prevent duplicate completions when generating with + # transformers if num_generations exceeds per_device_train_batch_size. We could skip it if we use vLLM, but + # it's safer to set it in all cases. + set_seed(args.seed, device_specific=True) + + if self.use_vllm: + # Initialize vLLM generation backend + self.vllm_generation = VLLMGeneration( + model=self.model, + accelerator=self.accelerator, + processing_class=self.processing_class, + # vLLM configuration + mode=args.vllm_mode, + structured_outputs_regex=args.vllm_structured_outputs_regex, + # Server mode configuration + server_base_url=args.vllm_server_base_url, + server_host=args.vllm_server_host, + server_port=args.vllm_server_port, + group_port=args.vllm_group_port, + server_timeout=args.vllm_server_timeout, + # Colocate mode configuration + tensor_parallel_size=args.vllm_tensor_parallel_size, + gpu_memory_utilization=args.vllm_gpu_memory_utilization, + max_model_length=args.vllm_max_model_length, + max_num_seqs=args.per_device_train_batch_size + * args.vllm_tensor_parallel_size + * args.steps_per_generation, + enable_sleep_mode=args.vllm_enable_sleep_mode, + model_impl=args.vllm_model_impl, + # Generation configuration + repetition_penalty=self.repetition_penalty, + temperature=self.temperature, + top_p=self.top_p, + top_k=self.top_k, + min_p=self.min_p, + max_completion_length=self.max_completion_length, + logprobs=0, # we only need the generated token logprobs for the importance sampling correction + generation_kwargs=args.generation_kwargs, + ) + self._last_loaded_step = -1 # tag to avoid useless loading during grad accumulation + else: + generation_kwargs = { + "max_new_tokens": self.max_completion_length, + "do_sample": True, + "pad_token_id": self._tokenizer.pad_token_id, + "bos_token_id": self._tokenizer.bos_token_id, + "eos_token_id": self._tokenizer.eos_token_id, + "temperature": self.temperature, + "top_p": self.top_p, + "top_k": self.top_k, + "min_p": self.min_p, + "repetition_penalty": self.repetition_penalty, + "cache_implementation": args.cache_implementation, + } + if args.generation_kwargs is not None: + generation_kwargs.update(args.generation_kwargs) + self.generation_config = GenerationConfig(**generation_kwargs, disable_compile=True) + # Keep training-specific generation kwargs to overwrite model's original generation config + self.generation_kwargs = generation_kwargs + + # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the + # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set + # self.model_accepts_loss_kwargs to False to enable scaling. + self.model_accepts_loss_kwargs = False + self._dist = DistributedBackend(self.accelerator) + + # Add tags to the model + self.model.add_model_tags(self._tag_names) + + if self.ref_model is not None: + if self.is_deepspeed_enabled: + self.ref_model = prepare_deepspeed(self.ref_model, self.accelerator) + elif self.is_fsdp_enabled: + self.ref_model = prepare_fsdp(self.ref_model, self.accelerator) + else: + self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True) + + if args.sync_ref_model: + if self.beta == 0.0: + raise ValueError( + "You passed `sync_ref_model=True` while `beta=0.0`, which means the reference model is not used " + "during training. Consequently, GRPOTrainer does not create a `ref_model` instance, and there is " + "nothing to synchronize. Please set `sync_ref_model=False`, or set `beta` to a non-zero value." + ) + if is_peft_model(model): + raise NotImplementedError( + "You passed `sync_ref_model=True` while using a PEFT model, which is currently not supported. " + "With PEFT, GRPOTrainer does not keep a separate reference model in memory; instead, it recovers " + "reference behavior by temporarily disabling the adapter. As a result, there is no standalone " + "`ref_model` instance to synchronize. Use `sync_ref_model=False`, or opt for full fine-tuning if " + "you need a synced reference model. If you need `sync_ref_model` to work with PEFT, please open a " + "feature request at https://github.com/huggingface/trl/issues." + ) + self.add_callback(SyncRefModelCallback(ref_model=self.ref_model, accelerator=self.accelerator)) + + for i, reward_func in enumerate(self.reward_funcs): + if isinstance(reward_func, PreTrainedModel): + if self.is_deepspeed_enabled: + self.reward_funcs[i] = prepare_deepspeed(reward_func, self.accelerator) + else: + # set device placement to True to make `prepare_model` move `reward_func` to device when using fsdp + self.reward_funcs[i] = self.accelerator.prepare_model( + reward_func, evaluation_mode=True, device_placement=True + ) + + if self.accelerator.is_main_process and self.log_completions: + os.makedirs(os.path.join(self.args.output_dir, "completions"), exist_ok=True) + if self.args.log_completions_hub_repo is not None: + repo_id = self.args.log_completions_hub_repo + create_repo(repo_id, private=self.args.hub_private_repo, repo_type="dataset", exist_ok=True) + template_path = pkg_resources.files("trl").joinpath("templates/completions_dataset_card.md") + card_data = DatasetCardData( + pretty_name="TRL Completion logs", + tags=["trl", "trl-logs", "completions"], + ) + card = DatasetCard.from_template( + card_data=card_data, + template_path=str(template_path), + repo_id=repo_id, + hub_model_id=self.args.hub_model_id, + ) + card.push_to_hub(repo_id) + self.commit_scheduler = CommitScheduler( + repo_id=repo_id, + repo_type="dataset", + folder_path=f"{self.args.output_dir}/completions", + every=2, # minutes + allow_patterns=["*.parquet"], + ) + + def _set_signature_columns_if_needed(self): + # If `self.args.remove_unused_columns` is True, non-signature columns are removed. + # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids" + # and "attention_mask"). In GRPOTrainer, we preprocess data, so using the model's signature columns doesn't + # work. Instead, we set them to the columns expected by the `training_step` method, hence the override. + if self._signature_columns is None: + self._signature_columns = ["prompt", "image", "images"] + + # This method overrides `Trainer.get_train_dataloader` to support our custom batching strategy. + # Instead of returning a standard per-step batch (i.e., `per_device_batch_size), our dataloader loads an + # *generation* batch (i.e., `per_device_batch_size × steps_per_generation`). This allows us to generate completions + # once every steps_per_generation step—rather than once per accumulation step—which is significantly more + # efficient. The only change from the original implementation is multiplying the batch size by + # `steps_per_generation`. Thus, `_prepare_inputs` is called with this *generation* batch, and it handles the + # splitting internally. + # Maintenance note: This method is a copy-paste of the original `Trainer.get_train_dataloader` with only one line + # modification. + def get_train_dataloader(self): + return self._get_dataloader( + dataset=self.train_dataset, + description="Training", + batch_size=self._train_batch_size * self.args.steps_per_generation, # < this is the change + sampler_fn=self._get_train_sampler, + is_training=True, + ) + + def _get_train_sampler(self, dataset: Dataset | None = None) -> Sampler: + # Returns a sampler that + # 1. ensures each prompt is repeated across multiple processes. This guarantees that identical prompts are + # distributed to different GPUs, allowing rewards to be computed and normalized correctly within each prompt + # group. Using the same seed across processes ensures consistent prompt assignment, preventing discrepancies + # in group formation. + # 2. repeats the batch multiple times to allow reusing generations across multiple updates. Refer to + # _prepare_inputs to see how the generations are stored and reused. + + # In the following figure, the values are the prompt indices. The first row shows the first sampled batch, the + # second row shows the second sampled batch, and so on. + # + # | GPU 0 | GPU 1 | + # + # global_step step <-───> num_generations=2 + # <-───────> per_device_train_batch_size=3 + # grad_accum ▲ ▲ 0 0 0 0 1 1 2 2 <- Generate for the first `steps_per_generation` (prompts 0 to 11); store the completions; use the first slice to compute the loss + # =2 ▼ | 0 1 3 3 4 4 5 5 <- Take the stored generations and use the second slice to compute the loss + # | + # | 1 2 6 6 7 7 8 8 <- Take the stored generations and use the third slice to compute the loss + # steps_per_gen=4 ▼ 1 3 9 9 10 10 11 11 <- Take the stored generations and use the fourth slice to compute the loss + # + # 2 4 12 12 13 13 14 14 <- Generate for the second `steps_per_generation` (prompts 12 to 23); store the completions; use the first slice to compute the loss + # 2 5 15 15 16 16 17 17 <- Take the stored generations and use the second slice to compute the loss + # ... + if dataset is None: + dataset = self.train_dataset + return RepeatSampler( + data_source=dataset, + mini_repeat_count=self.num_generations, + batch_size=self.args.generation_batch_size // self.num_generations, + repeat_count=self.num_iterations * self.args.steps_per_generation, + shuffle=self.shuffle_dataset, + seed=self.args.seed, + ) + + def _get_eval_sampler(self, eval_dataset) -> Sampler: + # See _get_train_sampler for an explanation of the sampler. + return RepeatSampler( + data_source=eval_dataset, + mini_repeat_count=self.num_generations_eval, + seed=self.args.seed, + ) + + @profiling_decorator + def _get_last_hidden_state( + self, + unwrapped_model, + input_ids, + attention_mask, + logits_to_keep, + pixel_values=None, + image_grid_thw=None, + pixel_attention_mask=None, + image_sizes=None, + image_position_ids=None, + ): + if is_peft_model(unwrapped_model): + unwrapped_model = unwrapped_model.base_model.model + + # Build model inputs - check if the model supports logits_to_keep (some models and VLMs don't) + model_inputs = {"input_ids": input_ids, "attention_mask": attention_mask} + + # For Qwen models: + if image_grid_thw is not None and pixel_values is not None: + model_inputs["image_grid_thw"] = image_grid_thw + # For Gemma, SmolVLM2, LLaVa-Next etc.: + if pixel_values is not None: + model_inputs["pixel_values"] = pixel_values + # For SmolVLM2 + if pixel_attention_mask is not None: + model_inputs["pixel_attention_mask"] = pixel_attention_mask + # For LLaVa-Next + if image_sizes is not None: + model_inputs["image_sizes"] = image_sizes + if image_position_ids is not None: + model_inputs["image_position_ids"] = image_position_ids + + # Only add logits_to_keep if the model supports it + if "logits_to_keep" in self.model_kwarg_keys: + # We add 1 to `logits_to_keep` because the last logits of the sequence is later excluded + model_inputs["logits_to_keep"] = logits_to_keep + 1 + + model_inputs["use_cache"] = False # only used in generation; set False to suppress warnings + + # `base_model` gives the backbone model (skipping `lm_head`) — text decoder for LMs, multimodal wrapper for + # VLMs (so vision-token injection runs before the text decoder). `get_decoder()` won't do: on VLMs it + # returns just the text stack and feeds image-placeholder IDs through it. + # Pre-5.0 transformers VLMs set `base_model_prefix = ""` so `base_model is self` (re-runs `lm_head`). + # Fall back to `.model` there. + if self._is_vlm and Version(transformers.__version__) < Version("5.0.0"): + backbone = unwrapped_model.model + else: + backbone = unwrapped_model.base_model + last_hidden_state = backbone(**model_inputs).last_hidden_state + # Exclude the last value: it corresponds to the next token pred + last_hidden_state = last_hidden_state[:, :-1, :] # (B, L-1, H) + # Only keep the last logits_to_keep. For model that support logits_to_keep, this is a no-op. + last_hidden_state = last_hidden_state[:, -logits_to_keep:, :] # (B, logits_to_keep, H) + return last_hidden_state + + def get_high_entropy_mask(self, entropies: torch.Tensor, mask: torch.Tensor, threshold: float) -> torch.Tensor: + """ + Returns a binary mask identifying tokens whose entropy exceeds a given quantile threshold. + + Args: + entropies (`torch.Tensor`): + Tensor of shape (batch_size, seq_len) with per-token entropy values. + mask (`torch.Tensor`): + Binary mask of the same shape as `entropies`, where `1` indicates valid tokens and `0` padding. + threshold (`float`): + Quantile threshold between `0.0` and `1.0` to select high-entropy tokens. + + Returns: + `torch.Tensor`: + Boolean mask of shape (batch_size, seq_len), where `True` indicates tokens with entropy >= threshold + and `False` otherwise. + """ + local = entropies[mask.bool()].float() + + # Use a negative pad_value as a sentinel because entropy values are always >= 0. + # This guarantees that the sentinel cannot collide with any real entropy value. + pad_value = -1e9 + + # Pad across processes so that every rank has the same tensor length + padded = self.accelerator.pad_across_processes(local, dim=0, pad_index=pad_value) + gathered = self.accelerator.gather(padded) + + # Drop sentinel values (safe because no entropy can be negative) + gathered = gathered[gathered != pad_value] + + if gathered.numel() == 0: + return torch.zeros_like(entropies, dtype=torch.bool) + + entropy_threshold = torch.quantile(gathered, threshold) + masked_entropies = entropies * mask.float() + entropy_mask = masked_entropies >= entropy_threshold + return entropy_mask & mask.bool() # ensure padding tokens are always masked out + + @profiling_decorator + def _get_per_token_logps_and_entropies( + self, + model, + input_ids, + attention_mask, + logits_to_keep, + batch_size=None, + compute_entropy=False, + compute_aux_loss=False, + pixel_values=None, + image_grid_thw=None, + num_images=None, + pixel_attention_mask=None, + image_sizes=None, + token_type_ids=None, + mm_token_type_ids=None, + image_position_ids=None, + ) -> tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None]: + """Compute log-probs, (optionally) entropies, and (optionally) the MoE load-balancing aux loss.""" + batch_size = batch_size or input_ids.size(0) # Chunk inputs into smaller batches to reduce memory peak + all_logps = [] + all_entropies = [] + all_aux_losses = [] + for start in range(0, input_ids.size(0), batch_size): + input_ids_batch = input_ids[start : start + batch_size] + attention_mask_batch = attention_mask[start : start + batch_size] + + # Build model inputs + model_inputs = {"input_ids": input_ids_batch, "attention_mask": attention_mask_batch} + if image_grid_thw is not None and pixel_values is not None: + rows_per_image = image_grid_thw.prod(dim=-1) + rows_per_sample = torch.split(rows_per_image, num_images) + rows_per_sample = torch.stack([s.sum() for s in rows_per_sample]) + cum_rows = torch.cat([torch.tensor([0], device=rows_per_sample.device), rows_per_sample.cumsum(0)]) + row_start, row_end = cum_rows[start].item(), cum_rows[start + batch_size].item() + model_inputs["pixel_values"] = pixel_values[row_start:row_end] + cum_imgs = torch.tensor([0] + num_images).cumsum(0) + img_start, img_end = cum_imgs[start], cum_imgs[start + batch_size] + model_inputs["image_grid_thw"] = image_grid_thw[img_start:img_end] + elif image_position_ids is not None and pixel_values is not None: + cum_imgs = torch.tensor([0] + num_images).cumsum(0) + img_start, img_end = cum_imgs[start], cum_imgs[start + batch_size] + model_inputs["pixel_values"] = pixel_values[img_start:img_end] + model_inputs["image_position_ids"] = image_position_ids[img_start:img_end] + elif pixel_values is not None: + model_inputs["pixel_values"] = pixel_values[start : start + batch_size] + if pixel_attention_mask is not None: + model_inputs["pixel_attention_mask"] = pixel_attention_mask[start : start + batch_size] + if image_sizes is not None: + model_inputs["image_sizes"] = image_sizes[start : start + batch_size] + if token_type_ids is not None: + model_inputs["token_type_ids"] = token_type_ids[start : start + batch_size] + if mm_token_type_ids is not None: + model_inputs["mm_token_type_ids"] = mm_token_type_ids[start : start + batch_size] + + # Only add logits_to_keep if the model supports it + if "logits_to_keep" in self.model_kwarg_keys: + # We add 1 to `logits_to_keep` because the last logits of the sequence is later excluded + model_inputs["logits_to_keep"] = logits_to_keep + 1 + + model_inputs["use_cache"] = False # only used in generation; set False to suppress warnings + + # MoE models: request router logits so the model returns `outputs.aux_loss`. VLM wrappers honor this only + # as a forward kwarg (not from the model config), so it must be passed here. + if compute_aux_loss: + model_inputs["output_router_logits"] = True + + outputs = model(**model_inputs) + logits = outputs.logits + # Exclude the last value: it corresponds to the next token pred + logits = logits[:, :-1, :] # (B, L-1, H) + # Only keep the last logits_to_keep. For model that support logits_to_keep, this is a no-op. + logits = logits[:, -logits_to_keep:, :] # (B, logits_to_keep, H) + # Divide logits by sampling temperature. + # See https://huggingface.co/blog/the_n_implementation_details_of_rlhf_with_ppo#policy-training-implementation-details + logits.div_(self.temperature) + completion_ids = input_ids_batch[:, -logits_to_keep:] + logps = selective_log_softmax(logits, completion_ids) # compute logprobs + all_logps.append(logps) + + if compute_entropy: + with torch.no_grad(): + entropies = entropy_from_logits(logits) + all_entropies.append(entropies) + + if compute_aux_loss: + all_aux_losses.append(outputs.aux_loss) + + logps = torch.cat(all_logps, dim=0) + entropies = torch.cat(all_entropies, dim=0) if compute_entropy else None + aux_loss = torch.stack(all_aux_losses).mean() if compute_aux_loss else None + return logps, entropies, aux_loss + + def training_step(self, model, inputs, num_items_in_batch): + time_before = time.perf_counter() + output = super().training_step(model, inputs, num_items_in_batch) + self._step += 1 + time_after = time.perf_counter() + self._current_train_step_time += time_after - time_before + if self._step % self.current_gradient_accumulation_steps == 0: + self._metrics["train"]["step_time"].append(self._current_train_step_time) + self._current_train_step_time = 0.0 + return output + + @profiling_decorator + def _prepare_inputs(self, generation_batch: dict[str, torch.Tensor | Any]) -> dict[str, torch.Tensor | Any]: + # Prepares inputs for model training/evaluation by managing completion generation and batch handling. + # During training: + # - Receives the local generation batch (Per-GPU batch size × steps per generation) + # from the modified training dataloader instead of the standard local batch + # - Generates completions once for the entire generation batch and splits it into batches of size + # `per_device_train_batch_size` + # - Buffers these completions and returns the appropriate slice for the current accumulation step + # - Optimizes by regenerating completions only periodically (every steps_per_generation * num_iterations) + # During evaluation: + # - The input is treated as a standard local batch (no accumulation, no multiple iterations) + # - Completions are generated for each batch without buffering or reuse + # Returns a single local batch in both cases. + + mode = "train" if self.model.training else "eval" + if mode == "train": + generate_every = self.args.steps_per_generation * self.num_iterations + if self._step % generate_every == 0 or self._buffered_inputs is None: + # self._buffered_inputs=None can occur when resuming from a checkpoint + generation_batch = self._generate_and_score_completions(generation_batch) + generation_batch = split_pixel_values_by_grid(generation_batch) + generation_batch = shuffle_sequence_dict(generation_batch) + generation_batches = split_tensor_dict(generation_batch, self.args.steps_per_generation) + self._buffered_inputs = [unsplit_pixel_values_by_grid(batch) for batch in generation_batches] + inputs = self._buffered_inputs[self._step % self.args.steps_per_generation] + else: + # In evaluation, there is neither batch grouping for generation, nor multiple iterations, hence + # local generation batch == local eval batch + inputs = self._generate_and_score_completions(generation_batch) + return inputs + + def _log_completion_extra(self, column: str, values: list): + """ + Log extra columns to the completions table. Called from reward functions via the `log_extra` kwarg. + + Args: + column (`str`): + Name of the column to add. + values (`list`): + Values for the column, one per sample in the batch. + """ + self._pending_extra_logs[column].extend(values) + + def _log_metric(self, name: str, value: float): + """ + Log a scalar metric from a reward function. Called via the `log_metric` kwarg. Values are averaged over each + logging step and reported alongside built-in metrics like `kl` and `entropy`. + + Args: + name (`str`): + Name of the metric. + value (`float`): + Scalar value for this batch. + """ + self._pending_metrics[name].append(value) + + @profiling_decorator + def _calculate_rewards(self, inputs, prompts, completions, completion_ids_list): + device = self.accelerator.device + rewards_per_func = torch.zeros(len(prompts), len(self.reward_funcs), device=device) + + # Repeat all input columns (but "prompt", "completion", and "completion_ids") to match the num of generations + keys = [key for key in inputs[0] if key not in ["prompt", "completion", "completion_ids"]] + reward_kwargs = {key: [example[key] for example in inputs] for key in keys} + + # This allows for dynamic reward shaping based on training progress. + reward_kwargs["trainer_state"] = self.state + + # Allow reward functions to log extra columns to the completions table. + reward_kwargs["log_extra"] = self._log_completion_extra + + # Allow reward functions to log additional scalar metrics. + reward_kwargs["log_metric"] = self._log_metric + + async_funcs_info = [] # async custom functions for asyncio.gather + + for i, (reward_func, reward_processing_class, reward_func_name) in enumerate( + zip(self.reward_funcs, self.reward_processing_classes, self.reward_func_names, strict=True) + ): + if isinstance(reward_func, nn.Module): # Module (no PretrainedModel) for compat with compiled models + with profiling_context(self, reward_func_name): + if is_conversational(inputs[0]): + messages = [{"messages": p + c} for p, c in zip(prompts, completions, strict=True)] + texts = [ + apply_chat_template(x, reward_processing_class, **self.chat_template_kwargs)["text"] + for x in messages + ] + else: + texts = [p + c for p, c in zip(prompts, completions, strict=True)] + reward_inputs = reward_processing_class( + text=texts, return_tensors="pt", padding=True, padding_side="right", add_special_tokens=False + ) + reward_inputs = super()._prepare_inputs(reward_inputs) + with torch.inference_mode(): + rewards_per_func[:, i] = reward_func(**reward_inputs).logits[:, 0] # Shape (B*G,) + elif inspect.iscoroutinefunction(reward_func): # Separate async reward funcs to run them in parallel later + async_funcs_info.append((i, reward_func, reward_func_name)) + else: + # Run synchronous reward function + with profiling_context(self, reward_func_name): + if self.environments is not None: + reward_kwargs["environments"] = self.environments + output_reward_func = reward_func( + prompts=prompts, completions=completions, completion_ids=completion_ids_list, **reward_kwargs + ) + # Convert None values to NaN + output_reward_func = [reward if reward is not None else torch.nan for reward in output_reward_func] + rewards_per_func[:, i] = torch.tensor(output_reward_func, dtype=torch.float32, device=device) + + # Execute async custom functions in parallel using asyncio.gather + if async_funcs_info: + + async def _invoke_async(index, func, func_name): + with profiling_context(self, func_name): + output = await func( + prompts=prompts, completions=completions, completion_ids=completion_ids_list, **reward_kwargs + ) + output = [r if r is not None else torch.nan for r in output] + return index, output + + async def _run_async_funcs(): + coros = [_invoke_async(i, func, func_name) for (i, func, func_name) in async_funcs_info] + return await asyncio.gather(*coros) + + async_results = asyncio.run_coroutine_threadsafe(_run_async_funcs(), self.async_loop).result() + for idx, output_reward_func in async_results: + rewards_per_func[:, idx] = torch.tensor(output_reward_func, dtype=torch.float32, device=device) + + # If all reward functions return None for a given row, issue a detailed warning + if torch.isnan(rewards_per_func).all(dim=1).any(): + nan_row_idx = torch.isnan(rewards_per_func).all(dim=1).nonzero(as_tuple=True)[0][0] + row_reward_kwargs = { + key: value[nan_row_idx] + for key, value in reward_kwargs.items() + if key not in ("trainer_state", "log_extra", "log_metric") + } + row_reward_kwargs["prompt"] = prompts[nan_row_idx] + row_reward_kwargs["completion"] = completions[nan_row_idx] + logger.warning( + f"All reward functions returned None for the following kwargs:\n{row_reward_kwargs}\n" + "Please ensure that at least one reward function returns a valid reward." + ) + + # Gather the reward per function: this part is crucial, because the rewards are normalized per group and the + # completions may be distributed across processes + rewards_per_func = gather(rewards_per_func) + return rewards_per_func + + def _tokenize_prompts(self, prompts: list): + """Tokenize prompts and extract images/multimodal fields for generation.""" + if is_conversational({"prompt": prompts[0]}): + # Normalize string content to content blocks for VLM processors that don't handle plain strings. + if self._is_vlm: + prompts = [prepare_multimodal_messages(prompt) for prompt in prompts] + + # Extract images from messages for VLM support + images = [] + has_images = False + for prompt in prompts: + prompt_images = [] + for message in prompt: + if isinstance(message["content"], list): + for part in message["content"]: + if part["type"] == "image": + prompt_images.append(part["image"]) + has_images = True + images.append(prompt_images if prompt_images else None) + images = images if has_images else None + + # Workaround for a bug in transformers 5.3.0 where some processors (e.g. Qwen2.5-VL) crash on + # batched unpadded input (transformers#44514). + # Fixed in transformers 5.4.0 (transformers#44563). + needs_padding_workaround = Version("5.3.0") <= Version(transformers.__version__) < Version("5.4.0") + tokenized = self.processing_class.apply_chat_template( + conversation=prompts, + tools=self.tools or None, # `or None`: Llama bug: it renders tool boilerplate for tools=[] + chat_template=self.chat_template, + add_generation_prompt=True, + tokenize=True, + return_dict=True, + **({"padding": True} if needs_padding_workaround else {}), + **self.chat_template_kwargs, + ) + if needs_padding_workaround: + # Unpad input_ids: remove padding tokens using attention_mask to get per-sequence lists + prompt_ids = [ + [tok for tok, m in zip(ids, mask, strict=True) if m] + for ids, mask in zip(tokenized["input_ids"], tokenized["attention_mask"], strict=True) + ] + else: + prompt_ids = tokenized["input_ids"] + # For VLMs, the processor returns extra multimodal fields (pixel_values, image_grid_thw, etc.) + multimodal_fields = {k: v for k, v in tokenized.items() if k not in ("input_ids", "attention_mask")} + else: + prompt_ids = self.processing_class(text=prompts)["input_ids"] + images = None + multimodal_fields = {} + return prompt_ids, images, multimodal_fields + + def _generate_single_turn(self, prompt_ids, images, multimodal_fields): + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + + # Generate completions using either vLLM or regular generation + if self.use_vllm: + # Sync weights if training step changed + if self.state.global_step != self._last_loaded_step: + with profiling_context(self, "sync_weights"): + self.vllm_generation.sync_weights() + self._last_loaded_step = self.state.global_step + + # Generate using vLLM with raw token IDs + num_generations = self.num_generations if mode == "train" else self.num_generations_eval + _, completion_ids, logprobs, _ = self.vllm_generation.generate( + prompts=prompt_ids, + images=images, + num_generations=num_generations, + profiler=profiling_context(self, "vLLM.generate"), + ) + # vLLM returns per-token top-k logprobs; keep only the top-1 (sampled token) logprob + logprobs = [[lp[0] for lp in seq] for seq in logprobs] + + elif self.use_transformers_continuous_batching: + with ( + profiling_context(self, "transformers.generate_batch"), + unwrap_model_for_generation( + self.model_wrapped, self.accelerator, gather_deepspeed3_params=self.args.ds3_gather_for_generation + ) as unwrapped_model, + torch.no_grad(), + self._dist.summon_full_params(self.model_wrapped, recurse=False), + ): + # Cast to the appropriate dtype based on training configuration + if self.args.bf16: + unwrapped_model.to(torch.bfloat16) + elif self.args.fp16: + unwrapped_model.to(torch.float16) + if self.args.cast_lm_head_to_fp32: + unwrapped_model.lm_head.to(torch.float32) + all_outputs = unwrapped_model.generate_batch( + prompt_ids, + generation_config=self.generation_config, + continuous_batching_config=self.continuous_batching_config, + progress_bar=False, + ) + unwrapped_model.train() + completion_ids = [output.generated_tokens for output in all_outputs.values()] + logprobs = None + + else: + # Regular generation path: left-pad token IDs into tensors + prompt_tensors = [torch.tensor(ids) for ids in prompt_ids] + padded_ids = pad(prompt_tensors, padding_value=self._tokenizer.pad_token_id, padding_side="left") + attention_mask = pad([torch.ones_like(t) for t in prompt_tensors], padding_value=0, padding_side="left") + generate_inputs = {"input_ids": padded_ids, "attention_mask": attention_mask} + # For VLMs, include multimodal fields as tensors (pixel_values, image_grid_thw, etc.) + for k, v in multimodal_fields.items(): + if isinstance(v, torch.Tensor): + generate_inputs[k] = v + elif isinstance(v, list) and v and isinstance(v[0], list): + # Per-token field (e.g., token_type_ids): left-pad like input_ids + generate_inputs[k] = pad([torch.tensor(x) for x in v], padding_value=0, padding_side="left") + else: + generate_inputs[k] = torch.tensor(np.array(v)) + generate_inputs = super()._prepare_inputs(generate_inputs) + + with ( + profiling_context(self, "transformers.generate"), + unwrap_model_for_generation( + self.model_wrapped, + self.accelerator, + gather_deepspeed3_params=self.args.ds3_gather_for_generation, + generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762 + ) as unwrapped_model, + torch.no_grad(), + self._dist.summon_full_params(self.model_wrapped, recurse=False), + ): + prompt_completion_ids = unwrapped_model.generate( + **generate_inputs, generation_config=self.generation_config + ) + # Compute prompt length and extract completion ids + prompt_length = generate_inputs["input_ids"].size(1) + completion_ids = prompt_completion_ids[:, prompt_length:] + + # Mask everything after the first EOS token + is_eos = completion_ids == self._tokenizer.eos_token_id + eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device) + eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)] + sequence_indices = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1) + completion_mask = (sequence_indices <= eos_idx.unsqueeze(1)).int() + completion_ids = [ + c[m].tolist() for c, m in zip(completion_ids.cpu(), completion_mask.bool().cpu(), strict=True) + ] + logprobs = None # not used in this case + + return completion_ids, logprobs + + def _get_tool_suffix_ids(self, tool_messages): + """Get token IDs for tool result formatting by using a minimal dummy conversation.""" + # Use the real tool name instead of a dummy: some templates (e.g. GPT-OSS) derive the tool response + # header from the assistant's tool call name. + dummy_tool_calls = [{"type": "function", "function": {"name": tool_messages[0]["name"], "arguments": {}}}] + dummy_messages = [ + {"role": "user", "content": "dummy"}, + { + "role": "assistant", + # "content" is required here because VLM processors crash on tokenize=True without it + # (KeyError in processing_utils.py). See huggingface/transformers#45290. + "content": "", + "tool_calls": dummy_tool_calls, + }, + ] + if self._is_vlm: + dummy_messages = prepare_multimodal_messages(dummy_messages) + tool_messages = prepare_multimodal_messages(tool_messages) + + prefix_ids = self.processing_class.apply_chat_template( + dummy_messages, + add_generation_prompt=False, + tokenize=True, + chat_template=self.chat_template, + return_dict=False, + **self.chat_template_kwargs, + ) + full_ids = self.processing_class.apply_chat_template( + dummy_messages + tool_messages, + add_generation_prompt=True, + tokenize=True, + chat_template=self.chat_template, + return_dict=False, + **self.chat_template_kwargs, + ) + # VLM processors return batched output (list of lists), unbatch for single conversation + if self._is_vlm: + prefix_ids = prefix_ids[0] + full_ids = full_ids[0] + + # Some chat templates (notably Qwen3/Qwen3.5) render "...<|im_end|>\n" after an assistant/tool block. + # When we compute `suffix_ids` by slicing `full_ids`, we must align the slicing boundary to + # EOS (not EOS + newline). Templates that don't use EOS as end-of-turn (e.g. Gemma uses + # ) skip this trimming. + eos_positions = [i for i, tok_id in enumerate(prefix_ids) if tok_id == self._tokenizer.eos_token_id] + if eos_positions: + prefix_ids = prefix_ids[: eos_positions[-1] + 1] + + if full_ids[: len(prefix_ids)] != prefix_ids: + raise ValueError("Unexpected tokenization: the EOS-trimmed prefix IDs are not a prefix of the full IDs.") + return full_ids[len(prefix_ids) :] + + def _tool_call_loop(self, prompts, prompt_ids, completion_ids, completions, logprobs, images, multimodal_fields): + # Tool execution loop: execute tools, then regenerate completions with tool results appended to the prompt + tool_calls = [completion[0].get("tool_calls") for completion in completions] + idxs_with_tool = [idx for idx, tool_call in enumerate(tool_calls) if tool_call] + tool_calls = [tool_calls[idx] for idx in idxs_with_tool] + tool_mask = [[1] * len(ids) for ids in completion_ids] # 0 for tool result tokens, 1 elsewhere + # Collect images from multimodal tool responses for the forward pass + tool_images = [[] for _ in completion_ids] + tool_call_count = 0 + tool_failure_count = 0 + iteration_num = 0 + + while idxs_with_tool and iteration_num < self.max_tool_calling_iterations: + prompt_completion_tools = [prompts[i] for i in idxs_with_tool] # select only prompts that need tool calls + # Snapshot state so we can rollback tool results that would exceed max_completion_length + completions_len_before = [len(completions[i]) for i in idxs_with_tool] + tool_images_len_before = [len(tool_images[i]) for i in idxs_with_tool] + prompts_len_before = [len(prompts[i]) for i in idxs_with_tool] + + # Call the tools, and build the new prompt for generation + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + tool_call_list = tool_calls[idx] + prompt_completion_tool = prompt_completion_tools[idx] + sync_tool_dict = self._sync_tool_dicts[idx_with_tool] + async_tool_dict = self._async_tool_dicts[idx_with_tool] + # Append the last assistant message (which triggered tool_calls) to the prompt + prompt_completion_tool.append(completions[idx_with_tool][-1]) + async_coros = [] + tool_call_results = [] + for tool_call in tool_call_list: + tool_call_count += 1 + if tool_call["type"] == "function": + function = tool_call["function"] + name = function["name"] + try: + if name in sync_tool_dict: + tool_call_results.append((name, sync_tool_dict[name](**function["arguments"]))) + elif name in async_tool_dict: + async_coros.append((name, async_tool_dict[name](**function["arguments"]))) + else: + raise ValueError(f"Tool {name} not found.") + except Exception as e: + tool_failure_count += 1 + result = {"error": str(e)} + tool_call_results.append((name, result)) + else: + tool_failure_count += 1 + name = tool_call.get("name", "unknown") + tool_call_results.append((name, {"error": f"Unsupported tool call type: {tool_call['type']}"})) + + if async_coros: + + async def _run_async_tools(async_coros): + coros = [coro for _, coro in async_coros] + results = await asyncio.gather(*coros, return_exceptions=True) + return [(name, result) for (name, _), result in zip(async_coros, results, strict=False)] + + async_results = asyncio.run_coroutine_threadsafe( + _run_async_tools(async_coros), self.async_loop + ).result() + + for name, result in async_results: + if isinstance(result, Exception): + tool_failure_count += 1 + tool_call_results.append((name, {"error": str(result)})) + else: + tool_call_results.append((name, result)) + + for name, result in tool_call_results: + # Support multimodal tool responses: if the tool returns a list of content blocks + # (e.g., [{"type": "image", "image": ...}, {"type": "text", "text": "..."}]), + # pass them through directly so _tokenize_prompts can extract images for VLMs. + content = result if isinstance(result, list) else str(result) + tool_message = {"role": "tool", "name": name, "content": content} + # Collect images from multimodal tool responses + if isinstance(content, list): + for part in content: + if isinstance(part, dict) and part.get("type") == "image": + tool_images[idx_with_tool].append(part["image"]) + prompt_completion_tool.append(tool_message) + completions[idx_with_tool].append(tool_message) + + # Build token IDs by concatenation: prompt + completion + tool_suffix. + prompt_completion_tool_ids = [] + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + # Extract trailing tool messages from completions + tool_messages = [] + for message in reversed(completions[idx_with_tool]): + if message["role"] == "tool": + tool_messages.insert(0, message) + else: + break + suffix_ids = self._get_tool_suffix_ids(tool_messages) + prompt_completion_tool_ids.append( + prompt_ids[idx_with_tool] + completion_ids[idx_with_tool] + suffix_ids + ) + + # Drop tool results whose addition would push the sequence past max_completion_length (the completion + # budget) or past the backend context ceiling (vLLM and transformers will error out on inputs longer than + # the model's max length). The sample exits the loop with its completion as-is, and the tool + # messages/images appended this iteration are rolled back so completions and tool_images stay consistent + # with completion_ids. + if self.use_vllm and self.vllm_mode == "colocate": + max_model_len = self.vllm_generation.llm.llm_engine.model_config.max_model_len + else: + config = self.model.config.text_config if self._is_vlm else self.model.config + max_model_len = config.max_position_embeddings + overlong = [ + len(pct) - len(prompt_ids[i]) > self.max_completion_length or len(pct) >= max_model_len + for i, pct in zip(idxs_with_tool, prompt_completion_tool_ids, strict=True) + ] + for idx in range(len(idxs_with_tool)): + if overlong[idx]: + idx_with_tool = idxs_with_tool[idx] + del completions[idx_with_tool][completions_len_before[idx] :] + del tool_images[idx_with_tool][tool_images_len_before[idx] :] + del prompts[idx_with_tool][prompts_len_before[idx] :] + # Keep only non-overlong items for further processing + idxs_with_tool = [idx for idx, o in zip(idxs_with_tool, overlong, strict=True) if not o] + prompt_completion_tool_ids = [ + pct for pct, o in zip(prompt_completion_tool_ids, overlong, strict=True) if not o + ] + if not idxs_with_tool: + break # all overlong, exit tool loop + + # Filter images and multimodal fields to match the current subset (index into full batch). + # Merge tool response images so the model can see visual feedback during generation. + merged_images = images + if any(imgs for imgs in tool_images): + if merged_images is None: + merged_images = [imgs if imgs else None for imgs in tool_images] + else: + merged_images = [ + (existing or []) + new for existing, new in zip(merged_images, tool_images, strict=True) + ] + loop_images = [merged_images[i] for i in idxs_with_tool] if merged_images else None + if multimodal_fields: + loop_multimodal_fields = {} + for k, v in multimodal_fields.items(): + selected = [v[i] for i in idxs_with_tool] + # Per-token fields (e.g. token_type_ids) need zero-padding to match extended prompt length + if isinstance(selected[0], list): + selected = [ + s + [0] * (len(pct) - len(s)) + for s, pct in zip(selected, prompt_completion_tool_ids, strict=True) + ] + loop_multimodal_fields[k] = selected + else: + loop_multimodal_fields = {} + + # Generate new completions after tool execution (using concatenated IDs, no re-tokenization) + post_tool_ids, post_tool_logprobs = self._generate_single_turn( + prompt_completion_tool_ids, loop_images, loop_multimodal_fields + ) + + # Truncate so that pct[len(prompt_ids[idx]) :] + post_tool does not exceed max_completion_length. + # The pre-regen check guarantees len(completion_tool_ids) <= max_completion_length, so any + # excess can only come from post_tool_ids. post_tool_ids is model-generated text and never + # contains image tokens, so a plain slice is safe. + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + completion_tool_length = len(prompt_completion_tool_ids[idx]) - len(prompt_ids[idx_with_tool]) + excess_length = completion_tool_length + len(post_tool_ids[idx]) - self.max_completion_length + if excess_length > 0: + new_len = len(post_tool_ids[idx]) - excess_length + post_tool_ids[idx] = post_tool_ids[idx][:new_len] + if logprobs is not None: + post_tool_logprobs[idx] = post_tool_logprobs[idx][:new_len] + + # Update tool_mask: the tool result should be 0 and the post-tool 1 + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + prompt_completion_tool_length = len(prompt_completion_tool_ids[idx]) + prompt_length = len(prompt_ids[idx_with_tool]) + completion_length = len(completion_ids[idx_with_tool]) + post_tool_length = len(post_tool_ids[idx]) + tool_length = prompt_completion_tool_length - prompt_length - completion_length + tool_mask[idx_with_tool] += [0] * tool_length + [1] * post_tool_length + if logprobs is not None: + logprobs[idx_with_tool] += [0.0] * tool_length + post_tool_logprobs[idx] + + # Update completion_ids with the new completions (after tool execution) + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + prompt_length = len(prompt_ids[idx_with_tool]) + pct = prompt_completion_tool_ids[idx] # = prompt-completion-tool + completion_ids[idx_with_tool] = pct[prompt_length:] + post_tool_ids[idx] + + # Decode post-tool completions. + post_tool_completions = [parse_response(self._tokenizer, ids) if ids else {} for ids in post_tool_ids] + + # Add post-tool completions to the existing completions + for idx in range(len(idxs_with_tool)): + idx_with_tool = idxs_with_tool[idx] + if post_tool_completions[idx]: # {} if post-tool completions completely truncated + completions[idx_with_tool].append(post_tool_completions[idx]) + + # Check for further tool calls + tool_calls = [completion.get("tool_calls") for completion in post_tool_completions] + idxs_with_tool = [idx for idx, tool_call in zip(idxs_with_tool, tool_calls, strict=True) if tool_call] + tool_calls = [tool_call for tool_call in tool_calls if tool_call] + iteration_num += 1 + + return tool_mask, completions, completion_ids, logprobs, tool_call_count, tool_failure_count, tool_images + + def _generate(self, prompts: list): + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + + # Copy the prompts to avoid modifying the original list + prompts = copy.deepcopy(prompts) + + if self.rollout_func is not None: + # Keep vLLM weights in sync for custom rollouts that rely on vLLM utilities. + if self.use_vllm and self.state.global_step != self._last_loaded_step: + with profiling_context(self, "sync_weights"): + self.vllm_generation.sync_weights() + self._last_loaded_step = self.state.global_step + + # Pass prompts to rollout_func preserving structured messages. + # Chat templating must happen inside rollout_func, at the backend boundary, so that + # multimodal content (images, typed content blocks) is not lost before rollout logic runs. + output = self.rollout_func(prompts, self) + required_keys = {"prompt_ids", "completion_ids", "logprobs"} + missing_keys = required_keys - output.keys() + if missing_keys: + missing_keys_list = sorted(missing_keys) + raise ValueError(f"rollout_func must return keys {missing_keys_list} in its output dict.") + extra_fields = {k: v for k, v in output.items() if k not in required_keys} + prompt_ids, completion_ids, logprobs = output["prompt_ids"], output["completion_ids"], output["logprobs"] + images = None + multimodal_fields = {} + else: + prompt_ids, images, multimodal_fields = self._tokenize_prompts(prompts) + completion_ids, logprobs = self._generate_single_turn(prompt_ids, images, multimodal_fields) + extra_fields = {} + + # Decode completions. It's important to use `parse_response` when possible, because it handles tool calls. + if is_conversational({"prompt": prompts[0]}): + if ( + Version(transformers.__version__) >= Version("5.0.0") # parse_response added in v5 + and hasattr(self._tokenizer, "response_schema") # attribute not set by default for now + and self._tokenizer.response_schema is not None # only works if the tokenizer has a schema + ): + completions = [[parse_response(self._tokenizer, ids)] for ids in completion_ids] + else: + contents = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + completions = [[{"role": "assistant", "content": content}] for content in contents] + else: + completions = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + + # Extract tool calls from the completions and (possibly) execute them + tool_images = [] + if self.tools: + ( + tool_mask, + completions, + completion_ids, + logprobs, + tool_call_count, + tool_failure_count, + tool_images, + ) = self._tool_call_loop( + prompts, prompt_ids, completion_ids, completions, logprobs, images, multimodal_fields + ) + # Merge tool response images into the images list for the forward pass + if any(imgs for imgs in tool_images): + if images is None: + images = [imgs if imgs else None for imgs in tool_images] + else: + images = [(existing or []) + new for existing, new in zip(images, tool_images, strict=True)] + else: + # Support custom env_mask from rollout_func (e.g., for environment feedback masking) + # Internally treated as tool_mask - marks model tokens (1) vs external tokens (0) + tool_mask = extra_fields.pop("env_mask", None) + + # Get completion length per sequence, used for logging + prompt_lengths = torch.tensor([len(ids) for ids in prompt_ids], device=device) + if tool_mask is not None: # count only model-generated tokens (tool_mask=1) + completion_lengths = torch.tensor([sum(mask) for mask in tool_mask], device=device) + else: + completion_lengths = torch.tensor([len(ids) for ids in completion_ids], device=device) + agg_prompt_lengths = self.accelerator.gather(prompt_lengths) + agg_completion_lengths = self.accelerator.gather(completion_lengths) + total_prompt_tokens = agg_prompt_lengths.sum() + total_completion_tokens = agg_completion_lengths.sum() # = num_items_in_batch, required for the DAPO loss + + # Log the metrics + if mode == "train": + self.state.num_input_tokens_seen += (total_prompt_tokens + total_completion_tokens).item() + self._metrics[mode]["num_tokens"] = [self.state.num_input_tokens_seen] + + # Log completion lengths, mean, min, max + self._metrics[mode]["completions/mean_length"].append(agg_completion_lengths.float().mean().item()) + self._metrics[mode]["completions/min_length"].append(agg_completion_lengths.float().min().item()) + self._metrics[mode]["completions/max_length"].append(agg_completion_lengths.float().max().item()) + + # Identify sequences that terminated with EOS and log their lengths + eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id] + is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids], device=device) + agg_is_truncated = self.accelerator.gather(is_truncated) + self._metrics[mode]["completions/clipped_ratio"].append(agg_is_truncated.float().mean().item()) + term_completion_lengths = agg_completion_lengths[~agg_is_truncated] + if len(term_completion_lengths) == 0: # edge case where no terminated sequences are found + term_completion_lengths = torch.zeros(1, device=device) + self._metrics[mode]["completions/mean_terminated_length"].append(term_completion_lengths.float().mean().item()) + self._metrics[mode]["completions/min_terminated_length"].append(term_completion_lengths.float().min().item()) + self._metrics[mode]["completions/max_terminated_length"].append(term_completion_lengths.float().max().item()) + + if self.tools: + agg_tool_call_count = self.accelerator.gather(torch.tensor(tool_call_count, device=device)).sum() + tool_call_frequency = (agg_tool_call_count / len(agg_prompt_lengths)).item() + self._metrics[mode]["tools/call_frequency"].append(tool_call_frequency) + agg_tool_failure_count = self.accelerator.gather(torch.tensor(tool_failure_count, device=device)).sum() + failure_frequency = ( + (agg_tool_failure_count / agg_tool_call_count).item() if agg_tool_call_count > 0 else 0.0 + ) + self._metrics[mode]["tools/failure_frequency"].append(failure_frequency) + + return ( + prompt_ids, + completion_ids, + tool_mask, + completions, + total_completion_tokens, + logprobs, + extra_fields, + images, + tool_images, + ) + + def _generate_and_score_completions( + self, inputs: list[dict[str, torch.Tensor | Any]] + ) -> dict[str, torch.Tensor | Any]: + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + + prompts = [x["prompt"] for x in inputs] + + if self.environments: + for prompt, environment, reset_kwargs in zip(prompts, self.environments, inputs, strict=True): + observation = environment.reset(**reset_kwargs) + if observation is None: + continue + if isinstance(observation, list) and isinstance(prompt[-1]["content"], str): + prompt[-1]["content"] = [{"type": "text", "text": prompt[-1]["content"]}] + if isinstance(observation, str) and isinstance(prompt[-1]["content"], list): + observation = [{"type": "text", "text": observation}] + prompt[-1]["content"] += observation + + if "images" in inputs[0]: + images = [example.get("images") for example in inputs] + elif "image" in inputs[0]: + images = [[example.get("image")] if example.get("image") is not None else None for example in inputs] + else: + images = None + # Transformers requires at least one image in the batch, otherwise it throws an error + if images is not None and all(img_list == [] for img_list in images): + images = None + + # If the prompts are conversational and the inputs contain images, we need to convert the prompts from + # [{"role": "user", "content": "What color is the sky?"}] to + # [{"role": "user", "content": [{"type": "image", "image": }, {"type": "text", "text": "What color is the sky?"}]}] + if images is not None: + if not is_conversational(inputs[0]): + raise ValueError( + "Multimodal training requires conversational prompts. It looks like the dataset contains " + "non-conversational inputs, likely because a chat template was applied before passing the dataset " + "to the trainer. Please provide the raw conversational prompts and let the trainer apply the chat " + "template internally." + ) + prompts = [ + prepare_multimodal_messages(prompt, images=image_list) + for prompt, image_list in zip(prompts, images, strict=True) + ] + + dataset_images = images # preserve dataset images before _generate may overwrite + ( + prompt_ids_list, + completion_ids_list, + tool_mask_list, + completions, + num_items_in_batch, + sampling_per_token_logps_list, + extra_fields, + images, + tool_images, + ) = self._generate(prompts) + if images is None: + images = dataset_images # restore dataset images (rollout_func path returns None) + + # Convert lists of token IDs to padded tensors + prompt_ids = [torch.tensor(ids) for ids in prompt_ids_list] + prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids] + prompt_ids = pad( + prompt_ids, + padding_value=self._tokenizer.pad_token_id, + padding_side="left", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + prompt_mask = pad( + prompt_mask, padding_value=0, padding_side="left", pad_to_multiple_of=self.pad_to_multiple_of + ).to(device=device) + completion_ids = [torch.tensor(ids) for ids in completion_ids_list] + completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids] + completion_ids = pad( + completion_ids, + padding_value=self._tokenizer.pad_token_id, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + completion_mask = pad( + completion_mask, padding_value=0, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of + ).to(device=device) + if sampling_per_token_logps_list is not None: + sampling_per_token_logps = [torch.tensor(logps) for logps in sampling_per_token_logps_list] + sampling_per_token_logps = pad( + sampling_per_token_logps, + padding_value=0.0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + else: + sampling_per_token_logps = None + if tool_mask_list is not None: + tool_mask = [torch.tensor(mask) for mask in tool_mask_list] + tool_mask = pad( + tool_mask, padding_value=1, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of + ).to(device=device) + else: + tool_mask = None + + # If mask_truncated_completions is enabled, zero out truncated completions for attention and loss masking + if self.mask_truncated_completions: + eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id] + is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device) + # Mask completion_mask for attention masking + completion_mask = completion_mask * (~is_truncated).unsqueeze(1).int() + # Also mask tool_mask for consistency in multi-turn training + if tool_mask is not None: + tool_mask = tool_mask * (~is_truncated).unsqueeze(1).int() + + # Concatenate prompt_mask with completion_mask for logit computation + prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1) # (B, P+C) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) # (B, P+C) + + logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens + batch_size = self.args.per_device_train_batch_size if mode == "train" else self.args.per_device_eval_batch_size + + num_images = [len(img_list) if img_list else 0 for img_list in images] if images is not None else None + + # Get forward_kwargs for models with multimodal inputs. + # When tool images are present (from _tool_call_loop), use image_processor directly and build + # mm_token_type_ids from prompt_completion_ids. Otherwise, use the full processor pipeline + # which returns model-specific keys (image_sizes, pixel_attention_mask, etc.). + if self.tools and any(imgs for imgs in tool_images) and self._is_vlm: + flat_images = [img for img_list in images if img_list for img in img_list] + image_inputs = self.processing_class.image_processor(images=flat_images, return_tensors="pt") + image_inputs = super()._prepare_inputs(image_inputs) + forward_kwargs = dict(image_inputs) + elif images is not None: + prompts_text = [ + apply_chat_template( + {"prompt": prompt}, self.processing_class, tools=self.tools, **self.chat_template_kwargs + )["prompt"] + for prompt in prompts + ] + prompt_inputs = self.processing_class(images=images, text=prompts_text, padding=True, return_tensors="pt") + prompt_inputs = super()._prepare_inputs(prompt_inputs) + forward_kwargs = {k: v for k, v in prompt_inputs.items() if k not in ["input_ids", "attention_mask"]} + else: + forward_kwargs = {} + + # If token_type_ids are used, extend them with zeros for the completion part + if "token_type_ids" in forward_kwargs: + token_type_ids = forward_kwargs["token_type_ids"] + if self.pad_to_multiple_of is not None: + # Needed only with pad_to_multiple_of: otherwise prompt_ids and token_type_ids must have equal len + padding_size = prompt_ids.size(1) - token_type_ids.size(1) + if padding_size > 0: + token_type_ids = torch.cat( + [token_type_ids.new_zeros((token_type_ids.size(0), padding_size)), token_type_ids], dim=1 + ) + forward_kwargs["token_type_ids"] = torch.cat( + [token_type_ids, token_type_ids.new_zeros(completion_ids.shape)], dim=1 + ) + # If mm_token_type_ids are used, extend them with zeros for the completion part + if "mm_token_type_ids" in forward_kwargs: + mm_token_type_ids = forward_kwargs["mm_token_type_ids"] + if self.pad_to_multiple_of is not None: + # Needed only with pad_to_multiple_of: otherwise prompt_ids and mm_token_type_ids must have equal len + padding_size = prompt_ids.size(1) - mm_token_type_ids.size(1) + if padding_size > 0: + mm_token_type_ids = torch.cat( + [mm_token_type_ids.new_zeros((mm_token_type_ids.size(0), padding_size)), mm_token_type_ids], + dim=1, + ) + forward_kwargs["mm_token_type_ids"] = torch.cat( + [mm_token_type_ids, mm_token_type_ids.new_zeros(completion_ids.shape)], dim=1 + ) + + # For VLM tool images: build token type IDs from the full prompt_completion_ids. + # This must happen AFTER the token_type_ids/mm_token_type_ids extension blocks above, + # because our version already covers the full sequence (images are in the completion, + # not just the prompt). + if self.tools and any(imgs for imgs in tool_images) and self._is_vlm: + mm_ids = torch.zeros_like(prompt_completion_ids) + if self._image_pad_token_id is not None: + mm_ids[prompt_completion_ids == self._image_pad_token_id] = 1 + if self._video_pad_token_id is not None: + mm_ids[prompt_completion_ids == self._video_pad_token_id] = 2 + + # Use the same key the model expects: token_type_ids for models like Gemma, + # mm_token_type_ids for models like Qwen. + image_grid_thw = forward_kwargs.get("image_grid_thw") + if image_grid_thw is not None: + forward_kwargs["mm_token_type_ids"] = mm_ids + else: + forward_kwargs["token_type_ids"] = mm_ids + + # Truncation safety (Qwen-style models with image_grid_thw only): if + # max_completion_length truncated some image tokens, the number of image pad tokens + # in input_ids won't match pixel_values features. Check per-sample and drop ALL + # images for any sample with a mismatch (safe fallback). + if image_grid_thw is not None and num_images is not None: + merge_length = getattr(self.processing_class.image_processor, "merge_size", 2) ** 2 + img_offset = 0 + has_mismatch = False + for b in range(mm_ids.shape[0]): + sample_tokens = (mm_ids[b] == 1).sum().item() + sample_features = 0 + for i in range(num_images[b]): + grid_idx = img_offset + i + if grid_idx < image_grid_thw.shape[0]: + sample_features += image_grid_thw[grid_idx].prod().item() // merge_length + if sample_tokens != sample_features: + has_mismatch = True + break + img_offset += num_images[b] + + if has_mismatch: + # Drop all images: safer than partial trim which is error-prone + forward_kwargs.pop("pixel_values", None) + forward_kwargs.pop("image_grid_thw", None) + mm_ids.zero_() + forward_kwargs["mm_token_type_ids"] = mm_ids + num_images = None + + # When gradient checkpointing is enabled with use_reentrant=True (non default), calling the model inside a + # torch.no_grad() block triggers a harmless PyTorch warning ("None of the inputs have requires_grad=True"). + # Temporarily disable checkpointing to avoid this warning during inference. + with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs): + # If the generation and optimization steps are misaligned—i.e., if generation does not occur at the end of + # a full optimizer step (when gradient_accumulation_steps is not a multiple of generate_every)—then the + # samples may come from an earlier version of the model. In that case, we need to track old_per_token_logps + # for importance sampling. If the steps are aligned, importance sampling isn't necessary and we set + # old_per_token_logps to None. + # When using vLLM, we always compute old_per_token_logps for importance sampling, it was shown that the + # distribution mismatch between vLLM and the training model can be large and harm the training. + generate_every = self.args.steps_per_generation * self.num_iterations # generation frequency + if self.args.gradient_accumulation_steps % generate_every != 0 or ( + self.use_vllm and self.vllm_importance_sampling_correction + ): + old_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids + ) + else: + old_per_token_logps = None + + # Compute the importance sampling ratio when using vLLM, to correct for potential distribution mismatch + if self.use_vllm and self.vllm_importance_sampling_correction: + mask = completion_mask if tool_mask is None else completion_mask * tool_mask + per_token_logps_diff = (old_per_token_logps - sampling_per_token_logps) * mask + + sequence_level_is = self.vllm_importance_sampling_mode in ["sequence_mask", "sequence_truncate"] + if sequence_level_is: + per_sequence_logps_diff = per_token_logps_diff.sum(dim=-1, keepdim=True) + logps_diff = per_sequence_logps_diff + else: + logps_diff = per_token_logps_diff + + vllm_importance_sampling_ratio = torch.exp(logps_diff) + + # vllm_importance_sampling_ratio.shape: + # token_* modes: (B, T) (per-token ratio) + # sequence_* modes: (B, 1) (per-sequence ratio) + + if self.vllm_importance_sampling_mode in ["sequence_truncate", "token_truncate"]: + vllm_importance_sampling_ratio = torch.clamp( + vllm_importance_sampling_ratio, + min=self.vllm_importance_sampling_clip_min, + max=self.vllm_importance_sampling_clip_max, + ) + elif self.vllm_importance_sampling_mode in ["sequence_mask", "token_mask"]: + min_val = ( + self.vllm_importance_sampling_clip_min + if self.vllm_importance_sampling_clip_min is not None + else -math.inf + ) + max_val = ( + self.vllm_importance_sampling_clip_max + if self.vllm_importance_sampling_clip_max is not None + else math.inf + ) + + invalid_mis_mask = (vllm_importance_sampling_ratio < min_val) | ( + vllm_importance_sampling_ratio > max_val + ) + vllm_importance_sampling_ratio = vllm_importance_sampling_ratio.masked_fill( + invalid_mis_mask, value=0.0 + ) + else: + raise ValueError( + f"Unknown vLLM importance sampling level: {self.vllm_importance_sampling_mode}. Possible values are 'token_truncate', 'token_mask', 'sequence_truncate', and 'sequence_mask'." + ) + + # Compute the per-token log probabilities for the reference model + if self.beta != 0.0: + if self.ref_model is not None: + ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.ref_model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size=batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids + ) + else: + # When training a PEFT adapter, how we obtain the reference depends on the setup: + # - New adapter: disabling adapters yields the base model. + # - Re-training an existing adapter: an initial copy is loaded under the name "ref". + model = self.accelerator.unwrap_model(self.model) + with use_adapter(model, adapter_name="ref" if "ref" in model.peft_config else None): + ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size=batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids + ) + else: + ref_per_token_logps = None + + # Decode + prompts_text = self.processing_class.batch_decode(prompt_ids, skip_special_tokens=True) + completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + + # Merge extra_fields from rollout_func into inputs for reward functions + if extra_fields: + for i, inp in enumerate(inputs): + for key, values in extra_fields.items(): + if isinstance(values, list) and i < len(values): + inp[key] = values[i] + elif not isinstance(values, list): + inp[key] = values + + # Calculate rewards for each reward function. rewards_per_func aggregates rewards across all processes. This is + # important because rewards will be normalized per group, and completions are distributed. We will later slice + # rewards_per_func to extract each process's subset. + rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list) + num_generations = self.num_generations if mode == "train" else self.num_generations_eval + + # A completion for which every reward function returned None is unscorable. nansum would collapse it to 0, + # which both biases the per-group baseline and hands the completion a spurious advantage. Mark these rows NaN + # so they're excluded from the (nan-aware) baseline below; their advantage is forced to 0 afterwards. + unscorable_mask = torch.isnan(rewards_per_func).all(dim=1) + + if self.multi_objective_aggregation == "sum_then_normalize": + # Apply weights to each reward function's output and sum + rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1) + rewards[unscorable_mask] = torch.nan + mean_grouped_rewards = torch.nanmean(rewards.view(-1, num_generations), dim=1) + mean_grouped_rewards = mean_grouped_rewards.repeat_interleave(num_generations, dim=0) + if self.scale_rewards in ["group", "none"]: + # If self.scale_rewards = "none", we'll only use std_rewards to check for zero std for logging + if num_generations > 1: + std_rewards = nanstd(rewards.view(-1, num_generations), dim=1) + std_rewards = std_rewards.repeat_interleave(num_generations, dim=0) + else: # doesn't occur during training, but could occur in eval when num_generations_eval=1 + std_rewards = torch.zeros_like(rewards) + elif self.scale_rewards == "batch": + # Compute global std + if rewards.numel() > 1: + std_rewards = nanstd(rewards).expand_as(rewards) + else: # doesn't occur during training, but could occur in eval when num_generations_eval=batch_size=1 + std_rewards = torch.zeros_like(rewards) + else: + raise ValueError( + f"Invalid value for scale_rewards: {self.scale_rewards}. Must be one of 'batch', 'group', or 'none'." + ) + + advantages = rewards - mean_grouped_rewards + if self.scale_rewards != "none": + advantages = advantages / (std_rewards + 1e-4) + is_std_zero = torch.isclose(std_rewards, torch.zeros_like(std_rewards)) # for logging + + elif self.multi_objective_aggregation == "normalize_then_sum": + grouped = rewards_per_func.view(-1, num_generations, len(self.reward_funcs)) + mean_k = torch.nanmean(grouped, dim=1, keepdim=True) + std_k = nanstd(grouped, dim=1, keepdim=True) if num_generations > 1 else torch.zeros_like(mean_k) + reward_k = (grouped - mean_k) / (std_k + 1e-4) + reward_k = reward_k.view(-1, len(self.reward_funcs)) + rewards = (reward_k * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1) + rewards[unscorable_mask] = torch.nan + std_rewards = nanstd(rewards).expand_as(rewards) if rewards.numel() > 1 else torch.zeros_like(rewards) + advantages = (rewards - torch.nanmean(rewards)) / (std_rewards + 1e-4) + is_std_zero = torch.isclose(std_rewards, torch.zeros_like(std_rewards)) # for logging + + else: + raise ValueError( + f"Invalid multi_objective_aggregation: {self.multi_objective_aggregation}. Must be " + "'sum_then_normalize' or 'normalize_then_sum'." + ) + + # Unscorable completions (every reward func returned None) carry no learning signal: their reward is NaN here, + # so zero their advantage to keep them from moving the policy. + advantages = torch.nan_to_num(advantages, nan=0.0) + + # Slice to keep only the local part of the data + process_slice = slice( + self.accelerator.process_index * len(prompts), + (self.accelerator.process_index + 1) * len(prompts), + ) + all_process_advantages = advantages.clone() # keep the aggregated advantages for logging + advantages = advantages[process_slice] + + # Calculate mean reward per function, but only for samples where the function was applied (non-NaN values) + for i, reward_func_name in enumerate(self.reward_func_names): + mean_rewards = torch.nanmean(rewards_per_func[:, i]).item() + self._metrics[mode][f"rewards/{reward_func_name}/mean"].append(mean_rewards) + std_func_rewards = nanstd(rewards_per_func[:, i]).item() + self._metrics[mode][f"rewards/{reward_func_name}/std"].append(std_func_rewards) + rewards = (rewards_per_func * self.reward_weights.to(rewards_per_func.device).unsqueeze(0)).nansum(dim=1) + rewards[unscorable_mask] = torch.nan # exclude unscorable rows from the logged reward stats + self._metrics[mode]["reward"].append(torch.nanmean(rewards).item()) + self._metrics[mode]["reward_std"].append(nanstd(rewards).item()) + self._metrics[mode]["frac_reward_zero_std"].append(is_std_zero.float().mean().item()) + + # Log prompt and completion texts + self._logs["prompt"].extend(gather_object(prompts_text)) + self._logs["completion"].extend(gather_object(completions_text)) + for i, name in enumerate(self.reward_func_names): + self._logs["rewards"][name].extend(rewards_per_func[:, i].tolist()) + self._logs["advantages"].extend(all_process_advantages.tolist()) + + # Flush user-logged extra columns (from log_extra), gathering across processes. + # Keys must be sorted so that all ranks call gather_object in the same order, otherwise values + # get mis-attributed across columns (dict insertion order may differ between processes). + for column in sorted(self._pending_extra_logs): + self._logs["extra"][column].extend(gather_object(self._pending_extra_logs[column])) + self._pending_extra_logs.clear() + + # Flush user-logged metrics (from log_metric), averaging across processes. + # Keys must be sorted so that all ranks call accelerator.gather in the same order, otherwise values + # get mis-attributed across metrics (dict insertion order may differ between processes). + for name in sorted(self._pending_metrics): + values = self._pending_metrics[name] + local_mean = sum(values) / len(values) + global_mean = self.accelerator.gather(torch.tensor(local_mean, device=device)).mean().item() + self._metrics[mode][name].append(global_mean) + self._pending_metrics.clear() + + if images is not None: + self._logs["images"].extend(gather_object(images)) + + if self.use_vllm and self.vllm_importance_sampling_correction: + delta = torch.abs(old_per_token_logps - sampling_per_token_logps) + mask = completion_mask.bool() if tool_mask is None else (completion_mask * tool_mask).bool() + delta = delta[mask] + mean_delta = torch.mean(delta) if delta.numel() > 0 else torch.tensor(0.0, device=device) + max_delta = torch.max(delta) if delta.numel() > 0 else torch.tensor(0.0, device=device) + self._metrics[mode]["sampling/sampling_logp_difference/mean"].append( + self.accelerator.gather(mean_delta).mean().item() + ) + self._metrics[mode]["sampling/sampling_logp_difference/max"].append( + self.accelerator.gather(max_delta).max().item() + ) + if sequence_level_is: + flat_is_ratio = vllm_importance_sampling_ratio.flatten() + else: + flat_is_ratio = vllm_importance_sampling_ratio[mask] + + min_importance_sampling_ratio = ( + torch.min(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device) + ) + mean_importance_sampling_ratio = ( + torch.mean(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device) + ) + max_importance_sampling_ratio = ( + torch.max(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device) + ) + self._metrics[mode]["sampling/importance_sampling_ratio/min"].append( + nanmin(self.accelerator.gather(min_importance_sampling_ratio)).item() + ) + self._metrics[mode]["sampling/importance_sampling_ratio/mean"].append( + self.accelerator.gather(mean_importance_sampling_ratio).nanmean().item() + ) + self._metrics[mode]["sampling/importance_sampling_ratio/max"].append( + nanmax(self.accelerator.gather(max_importance_sampling_ratio)).item() + ) + + output = { + "prompt_ids": prompt_ids, + "prompt_mask": prompt_mask, + "completion_ids": completion_ids, + "completion_mask": completion_mask, + "advantages": advantages, + "num_items_in_batch": num_items_in_batch, + } + if old_per_token_logps is not None: + output["old_per_token_logps"] = old_per_token_logps + if self.use_vllm and self.vllm_importance_sampling_correction: + output["importance_sampling_ratio"] = vllm_importance_sampling_ratio + if sampling_per_token_logps is not None: + output["sampling_per_token_logps"] = sampling_per_token_logps + if ref_per_token_logps is not None: + output["ref_per_token_logps"] = ref_per_token_logps + if "pixel_values" in forward_kwargs: + output["pixel_values"] = forward_kwargs["pixel_values"] + if "image_grid_thw" in forward_kwargs: + output["image_grid_thw"] = forward_kwargs["image_grid_thw"] + if "pixel_attention_mask" in forward_kwargs: + output["pixel_attention_mask"] = forward_kwargs["pixel_attention_mask"] + if "image_sizes" in forward_kwargs: + output["image_sizes"] = forward_kwargs["image_sizes"] + if "token_type_ids" in forward_kwargs: + output["token_type_ids"] = forward_kwargs["token_type_ids"] + if "mm_token_type_ids" in forward_kwargs: + output["mm_token_type_ids"] = forward_kwargs["mm_token_type_ids"] + if "image_position_ids" in forward_kwargs: + output["image_position_ids"] = forward_kwargs["image_position_ids"] + if images is not None: + output["num_images"] = num_images + if tool_mask is not None: + output["tool_mask"] = tool_mask + return output + + def compute_liger_loss(self, unwrapped_model, inputs): + # Compute the per-token log probabilities for the model + prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"] + completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"] + input_ids = torch.cat([prompt_ids, completion_ids], dim=1) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens + + # Get the last hidden state of the model + last_hidden_state = self._get_last_hidden_state( + unwrapped_model, + input_ids, + attention_mask, + logits_to_keep, + inputs.get("pixel_values"), + inputs.get("image_grid_thw"), + inputs.get("pixel_attention_mask"), + inputs.get("image_sizes"), + inputs.get("image_position_ids"), + ) + + # Apply tool_mask (from env_mask) for loss computation in multi-turn training scenarios + loss_mask = completion_mask if "tool_mask" not in inputs else completion_mask * inputs["tool_mask"] + lm_head_weight = unwrapped_model.lm_head.weight + lm_head_bias = unwrapped_model.lm_head.bias + # Liger reads `lm_head` directly instead of through `model.forward()`, so its ZeRO-3 gather hook never fires + # and the fused matmul gets an empty shard. Gather the weight/bias ourselves for the call (the weight grad is + # computed during this forward, so it isn't needed in the backward). Skip it when already gathered: with tied + # embeddings `embed_tokens` keeps the weight `AVAILABLE`, and re-partitioning on exit breaks its tracking. + deepspeed_plugin = self.accelerator.state.deepspeed_plugin + gather_ctx = nullcontext() + if deepspeed_plugin is not None and deepspeed_plugin.zero_stage == 3: + from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus + + params = [lm_head_weight] if lm_head_bias is None else [lm_head_weight, lm_head_bias] + if any(p.ds_status != ZeroParamStatus.AVAILABLE for p in params): + import deepspeed + + gather_ctx = deepspeed.zero.GatheredParameters(params, modifier_rank=None) + with gather_ctx: + loss, metrics = self.liger_grpo_loss( + _input=last_hidden_state, + lin_weight=lm_head_weight, + selected_token_ids=completion_ids, + # The attention_mask parameter in liger loss is actually used as a loss mask (not model attention) + attention_mask=loss_mask, + advantages=inputs["advantages"], + bias=lm_head_bias, + old_per_token_logps=inputs.get("old_per_token_logps"), + ref_per_token_logps=inputs.get("ref_per_token_logps"), + vllm_is_ratio=inputs.get("importance_sampling_ratio"), + ) + # Extract metrics from the liger_grpo_loss output + # KL divergence is the first metric when beta is non-zero + mean_kl = metrics[0] if self.beta != 0.0 else None + clip_ratio = metrics[-1] + + mode = "train" if self.model.training else "eval" + if self.beta != 0.0: + self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).mean().item()) + self._metrics[mode]["clip_ratio"].append(self.accelerator.gather(clip_ratio).mean().item()) + normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval + return loss / normalizer + + @profiling_decorator + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + if return_outputs: + raise ValueError("The GRPOTrainer does not support returning outputs") + if self.use_liger_kernel: + # Compute the loss using the liger grpo loss + unwrapped_model = self.accelerator.unwrap_model(model) + return self._forward_redirection(model, unwrapped_model, self.compute_liger_loss, unwrapped_model, inputs) + return self._compute_loss(model, inputs) + + @staticmethod + def get_off_policy_mask( + advantages: torch.Tensor, + per_token_logps: torch.Tensor, + sampling_per_token_logps: torch.Tensor, + mask: torch.Tensor, + off_policy_threshold: float, + ) -> torch.Tensor: + """ + Computes the Off-Policy Sequence Mask from DeepSeek-V3.2 paper. Returns a (B, 1) tensor where 1.0 indicates + "Keep" and 0.0 indicates "Drop". + """ + # forward KL div: log(pi_old) - log(pi_theta) + kl_div = sampling_per_token_logps - per_token_logps.detach() + # Sequence-level Mean KL (ignoring prompt+padding) + seq_kl_sum = (kl_div * mask).sum(dim=1, keepdim=True) + avg_seq_kl = seq_kl_sum / mask.sum(dim=1, keepdim=True).clamp(min=1.0) + # Keep if (Advantage >= 0) OR (KL <= delta) + is_pos_adv = advantages >= 0 + is_low_kl = avg_seq_kl <= off_policy_threshold + return (is_pos_adv | is_low_kl).to(dtype=mask.dtype) # (B, 1) + + @staticmethod + @torch.no_grad() + def get_gamma_weights( + advantages: torch.Tensor, + log_ratio_per_token: torch.Tensor, + mask: torch.Tensor, + importance_sampling_ratio: torch.Tensor | None, # (B, T) + k_pos: float = 2.0, + lambda_pos: float = 3.0, + k_neg: float = 3.0, + lambda_neg: float = 2.0, + ) -> torch.Tensor: + """ + Computes the Gamma weights for the VESPO loss. For reference: + φ(w) = e^λ × w^k × e^{-λw} is the gamma weighting (normalized so φ(1)=1) + with w = sequence-level importance sampling ratio + note: we will compute φ(w) in log space + + φ(w) is detached via @torch.no_grad(), only acts as gradient scaling coefficient + + VESPO loss = -φ(w) × A × log_prob, gradient naturally gives φ(w) × A × ∇log π + """ + # reducing clamp range directly to log(1e-8) ~ -18.42, to avoid recomputing log_w=log(w.clamp(min=1e-8)) later + # This is solely for matching truthfully the original implementation, otherwise keeping -20 could be fine. + lower_clamp = math.log(1e-8) + + # Sequence-level log ratio Σ log(π_θ/π_old) (not a mean like for `log_importance_weights`) + log_ratio_clamped = torch.clamp(log_ratio_per_token, -20.0, 20.0) + seq_log_ratio = torch.sum(log_ratio_clamped * mask, dim=-1, keepdim=True) # (B, 1) + + # Apply token-level TIS or MIS correction (in log space) + if importance_sampling_ratio is not None: + log_is_ratio = torch.clamp(torch.log(importance_sampling_ratio), lower_clamp, 20.0) + # log(w) = log(π_θ/π_old) + log(π_old/π_sampler) + seq_log_ratio += torch.sum(log_is_ratio, dim=-1, keepdim=True) + + log_w_seq = torch.clamp(seq_log_ratio, lower_clamp, 20.0) + w_seq = torch.exp(log_w_seq) + + # compute k and lambda based on advantage sign + is_nonneg_adv = advantages >= 0 + k_seq = torch.where(is_nonneg_adv, k_pos, k_neg) + lambda_seq = torch.where(is_nonneg_adv, lambda_pos, lambda_neg).clamp(min=1e-4) + + # log(φ(w)) = λ + k × log(w) - λ × w + log_phi = lambda_seq + k_seq * log_w_seq - lambda_seq * w_seq + phi_seq = torch.exp(log_phi).nan_to_num(nan=0.0, posinf=0.0, neginf=0.0) + + return phi_seq # (B, 1) + + def _compute_loss(self, model, inputs): + # Compute the per-token log probabilities for the model + prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"] + completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"] + input_ids = torch.cat([prompt_ids, completion_ids], dim=1) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens + mask = completion_mask if "tool_mask" not in inputs else completion_mask * inputs["tool_mask"] + + # Compute the per_token_logps and the entropy at each position in the completion + per_token_logps, entropies, aux_loss = self._get_per_token_logps_and_entropies( + model, + input_ids, + attention_mask, + logits_to_keep, + compute_entropy=True, + compute_aux_loss=self.aux_loss_enabled, + pixel_values=inputs.get("pixel_values"), + image_grid_thw=inputs.get("image_grid_thw"), + num_images=inputs.get("num_images"), + pixel_attention_mask=inputs.get("pixel_attention_mask"), + image_sizes=inputs.get("image_sizes"), + token_type_ids=inputs.get("token_type_ids"), + mm_token_type_ids=inputs.get("mm_token_type_ids"), + image_position_ids=inputs.get("image_position_ids"), + ) + + if self.top_entropy_quantile < 1.0: + entropy_mask = self.get_high_entropy_mask(entropies, mask, 1 - self.top_entropy_quantile) + else: + entropy_mask = None + + # Compute the loss + advantages = inputs["advantages"] + # In the base GRPO implementation, advantages are expected to have shape (B,). To support subclasses that + # provide advantages with shape (B, T) (e.g., MiniLLM), we *conditionally* unsqueeze the tensor. + if advantages.dim() == 1: + advantages = advantages.unsqueeze(1) + # When num_iterations == 1 and steps_per_generation <= gradient_accumulation_steps, + # old_per_token_logps == per_token_logps. In this case we can skip its computation + # (see _generate_and_score_completions) and instead use per_token_logps.detach(). + # The exception is when using vLLM, where we always compute old_per_token_logps + # for importance sampling + old_per_token_logps = inputs.get("old_per_token_logps") + old_per_token_logps = per_token_logps.detach() if old_per_token_logps is None else old_per_token_logps + + if self.off_policy_mask_threshold is not None: + # OPSM should use inference-time logprobs to detect both sources of off-policyness: + # 1. Drift from gradient updates (always present) + # 2. Drift from training-inference mismatch (when using vLLM) + # When using vLLM, prioritize sampling_per_token_logps, otherwise use old_per_token_logps + sampling_per_token_logps = inputs.get("sampling_per_token_logps", old_per_token_logps) + + off_policy_mask = self.get_off_policy_mask( + advantages=advantages, + per_token_logps=per_token_logps, + sampling_per_token_logps=sampling_per_token_logps, + mask=mask, + off_policy_threshold=self.off_policy_mask_threshold, + ) + + log_ratio = per_token_logps - old_per_token_logps + if self.importance_sampling_level == "token": + log_importance_weights = log_ratio + elif self.importance_sampling_level == "sequence": + log_importance_weights = (log_ratio * mask).sum(-1) / mask.sum(-1).clamp(min=1.0) + log_importance_weights = log_importance_weights.unsqueeze(-1) + else: + raise ValueError( + f"Unknown importance sampling level: {self.importance_sampling_level}. Possible values are 'token' " + "and 'sequence'." + ) + + coef_1 = torch.exp(log_importance_weights) + + # Compute the KL divergence between the model and the reference model + if self.beta != 0.0: + ref_per_token_logps = inputs["ref_per_token_logps"] + per_token_kl = ( + torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1 + ) + # Importance sampling correction for the KL divergence + if self.args.use_bias_correction_kl: + per_token_kl = per_token_kl * coef_1 + + # From here, log_importance_weights (and all subsequent tensors, coef_1, coef_2, etc.) shape depends on + # importance_sampling_level: "token" level: (B, T); "sequence" level: (B, 1) + if self.loss_type == "cispo": + clamped_ratios = torch.clamp(coef_1, max=self.epsilon_high).detach() + per_token_loss = -clamped_ratios * advantages * per_token_logps + elif self.loss_type in ["grpo", "bnpo", "dr_grpo", "dapo", "luspo"]: + coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high) + # Two-sided clipping + if self.args.delta is not None: + coef_1 = torch.clamp(coef_1, max=self.args.delta) + + per_token_loss1 = coef_1 * advantages + per_token_loss2 = coef_2 * advantages + per_token_loss = -torch.min(per_token_loss1, per_token_loss2) + elif self.loss_type == "sapo": + temperatures = torch.where(advantages > 0, self.args.sapo_temperature_pos, self.args.sapo_temperature_neg) + soft_coef_1 = torch.sigmoid(temperatures * (coef_1 - 1)) * 4 / temperatures + per_token_loss = -soft_coef_1 * advantages + elif self.loss_type == "vespo": + phi_seq = self.get_gamma_weights( + advantages=advantages, + log_ratio_per_token=log_ratio, + mask=mask, + importance_sampling_ratio=inputs.get("importance_sampling_ratio"), + k_pos=self.args.vespo_k_pos, + lambda_pos=self.args.vespo_lambda_pos, + k_neg=self.args.vespo_k_neg, + lambda_neg=self.args.vespo_lambda_neg, + ) + per_token_loss = -phi_seq * advantages * per_token_logps + else: + raise ValueError(f"Unknown loss type: {self.loss_type}") + + if self.off_policy_mask_threshold is not None: + per_token_loss = per_token_loss * off_policy_mask + + if entropy_mask is not None: + per_token_loss = per_token_loss * entropy_mask + + if self.use_vllm and self.vllm_importance_sampling_correction and self.loss_type != "vespo": + per_token_loss = per_token_loss * inputs["importance_sampling_ratio"] + + if self.beta != 0.0: + per_token_loss = per_token_loss + self.beta * per_token_kl + + mode = "train" if self.model.training else "eval" + if self.loss_type in ["grpo", "sapo"]: + loss = ((per_token_loss * mask).sum(-1) / mask.sum(-1).clamp(min=1.0)).mean() + normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval + loss = loss / normalizer + elif self.loss_type == "bnpo": + loss = (per_token_loss * mask).sum() / mask.sum().clamp(min=1.0) + normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval + loss = loss / normalizer + elif self.loss_type == "dr_grpo": + loss = (per_token_loss * mask).sum() / (per_token_loss.size(0) * self.max_completion_length) + normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 # no accum in eval + loss = loss / normalizer + elif self.loss_type in ["cispo", "dapo", "vespo"]: + normalizer = inputs["num_items_in_batch"] / self.accelerator.num_processes + loss = (per_token_loss * mask).sum() / normalizer + elif self.loss_type == "luspo": + # Unless importance_sampling_level="token" (not recommended here), per_token_loss is expected to be (B, 1) + loss = (per_token_loss * mask.sum(1, keepdim=True)).mean() + normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 + loss = loss / normalizer + else: + raise ValueError(f"Unknown loss type: {self.loss_type}") + + # The policy loss above is scaled for gradient accumulation (HF auto-scaling is off here), so scale aux too + if self.aux_loss_enabled: + normalizer = self.current_gradient_accumulation_steps if mode == "train" else 1.0 + loss = loss + self.router_aux_loss_coef * aux_loss / normalizer + self._metrics[mode]["aux_loss"].append(self.accelerator.gather_for_metrics(aux_loss).mean().item()) + + # Log the metrics + completion_token_count = mask.sum().clamp(min=1.0) + + def masked_batch_mean(x): + if x.shape[1] == 1: # when importance_sampling_level == "sequence" + return x.mean() + else: + return (x * mask).sum() / completion_token_count + + if self.beta != 0.0: + mean_kl = masked_batch_mean(per_token_kl) + self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item()) + + mean_entropy = masked_batch_mean(entropies) + self._metrics[mode]["entropy"].append(self.accelerator.gather(mean_entropy).nanmean().item()) + + if self.loss_type in ["grpo", "bnpo", "dr_grpo", "dapo", "luspo"]: + # Compute the clipped probability ratios + is_low_clipped = (coef_1 < 1 - self.epsilon_low) & (advantages < 0) + is_high_clipped = (coef_1 > 1 + self.epsilon_high) & (advantages > 0) + is_region_clipped = is_low_clipped | is_high_clipped + + low_clip = masked_batch_mean(is_low_clipped.float()) + high_clip = masked_batch_mean(is_high_clipped.float()) + clip_ratio = masked_batch_mean(is_region_clipped.float()) + + gathered_low_clip = self.accelerator.gather(low_clip) + self._metrics[mode]["clip_ratio/low_mean"].append(gathered_low_clip.nanmean().item()) + self._metrics[mode]["clip_ratio/low_min"].append(nanmin(gathered_low_clip).item()) + gathered_high_clip = self.accelerator.gather(high_clip) + self._metrics[mode]["clip_ratio/high_mean"].append(gathered_high_clip.nanmean().item()) + self._metrics[mode]["clip_ratio/high_max"].append(nanmax(gathered_high_clip).item()) + gathered_clip_ratio = self.accelerator.gather(clip_ratio) + self._metrics[mode]["clip_ratio/region_mean"].append(gathered_clip_ratio.nanmean().item()) + elif self.loss_type == "cispo": + is_cispo_clipped = (coef_1 > self.epsilon_high) & (advantages > 0) + cispo_clip_ratio = masked_batch_mean(is_cispo_clipped.float()) + gathered_cispo_clip_ratio = self.accelerator.gather(cispo_clip_ratio) + self._metrics[mode]["cispo_clip_ratio"].append(gathered_cispo_clip_ratio.nanmean().item()) + elif self.loss_type == "vespo": + gathered_phi_seq = self.accelerator.gather(phi_seq) + self._metrics[mode]["vespo/phi_seq_mean"].append(gathered_phi_seq.nanmean().item()) + + return loss + + # During eval, Trainer calls prediction_step. If no labels are present in the inputs, it only runs forward and + # returns logits. We override prediction_step to force compute_loss, because this trainer doesn't involve labels. + def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys: list[str] | None = None): + inputs = self._prepare_inputs(inputs) + with torch.no_grad(): + with self.compute_loss_context_manager(): + loss = self.compute_loss(model, inputs) + loss = loss.mean().detach() + return loss, None, None + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + # Average the metrics + metrics = {} + for key, val in self._metrics[mode].items(): + # Filter out NaN values before averaging. A reward function that returns None for all samples + # in a batch produces NaN for that batch's metric. With logging_steps > 1, a naive sum()/len() + # would let a single NaN contaminate valid data from other batches. Only return None when no + # valid values remain (e.g. JSON loggers crash on float NaN). + valid = [v for v in val if not math.isnan(v)] + metrics[key] = sum(valid) / len(valid) if valid else None + + # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs` + # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() + + if self.accelerator.is_main_process and self.log_completions: + if is_rich_available(): + print_prompt_completions_sample( + self._logs["prompt"], + self._logs["completion"], + self._logs["rewards"], + self._logs["advantages"], + self.state.global_step, + self.num_completions_to_print, + extra=dict(self._logs["extra"]), + ) + + logging_backends = [] + if self.args.report_to and "wandb" in self.args.report_to and wandb.run is not None: + logging_backends.append(wandb) + if self.args.report_to and "trackio" in self.args.report_to: + logging_backends.append(trackio) + + table = { + "step": [self.state.global_step] * len(self._logs["prompt"]), + "prompt": self._logs["prompt"], + "completion": self._logs["completion"], + **self._logs["rewards"], + **self._logs["extra"], + "advantage": self._logs["advantages"], + } + + df_base = pd.DataFrame(table) + df_base.to_parquet( + os.path.join( + self.args.output_dir, + "completions", + f"completions_{self.state.global_step:05d}.parquet", + ) + ) + + images_raw = self._logs["images"] or [] + + for logging_backend in logging_backends: + if images_raw: + images = [] + for image_list in self._logs["images"]: + if image_list: + images.append([logging_backend.Image(image) for image in image_list]) + else: + images.append([]) + df = pd.concat( + [df_base, pd.Series(images, name="image")], + axis=1, + copy=False, + ) + else: + df = df_base + + if self.log_unique_prompts: + df = df.drop_duplicates(subset=["prompt"]) + + logging_backend.log({"completions": logging_backend.Table(dataframe=df)}) + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/kto_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/kto_config.py new file mode 100644 index 0000000000000000000000000000000000000000..849648a8f74f245df98cab016a7b87fa1b628f93 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/kto_config.py @@ -0,0 +1,36 @@ +# Copyright 2020-2026 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 warnings +from dataclasses import dataclass + +from ..import_utils import suppress_experimental_warning + + +with suppress_experimental_warning(): + from ..experimental.kto import KTOConfig as _KTOConfig + + +@dataclass +class KTOConfig(_KTOConfig): + def __post_init__(self): + warnings.warn( + "The `KTOConfig` is now located in `trl.experimental`. Please update your imports to " + "`from trl.experimental.kto import KTOConfig`. For more information, see " + "https://github.com/huggingface/trl/issues/4223. Promoting KTO to the stable API is a high-priority task. " + "Until then, this current path (`from trl import KTOConfig`) will remain, but API changes may occur.", + FutureWarning, + stacklevel=3, + ) + super().__post_init__() diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/kto_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/kto_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..110e29f0a8062efe09a87cddf2a7574d4f8d999e --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/kto_trainer.py @@ -0,0 +1,36 @@ +# Copyright 2020-2026 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 warnings +from dataclasses import dataclass + +from ..import_utils import suppress_experimental_warning + + +with suppress_experimental_warning(): + from ..experimental.kto import KTOTrainer as _KTOTrainer + + +@dataclass +class KTOTrainer(_KTOTrainer): + def __init__(self, *args, **kwargs): + warnings.warn( + "The `KTOTrainer` is now located in `trl.experimental`. Please update your imports to " + "`from trl.experimental.kto import KTOTrainer`. For more information, see " + "https://github.com/huggingface/trl/issues/4223. Promoting KTO to the stable API is a high-priority task. " + "Until then, this current path (`from trl import KTOTrainer`) will remain, but API changes may occur.", + FutureWarning, + stacklevel=2, + ) + super().__init__(*args, **kwargs) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/model_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/model_config.py new file mode 100644 index 0000000000000000000000000000000000000000..c64d7a9ccade1cc7adb27dbd73742ee888714fb1 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/model_config.py @@ -0,0 +1,178 @@ +# Copyright 2020-2026 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. + +from dataclasses import dataclass, field + + +@dataclass +class ModelConfig: + """ + Configuration class for the models. + + 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: + model_name_or_path (`str`, *optional*): + Model checkpoint for weights initialization. + model_revision (`str`, *optional*, defaults to `"main"`): + Specific model version to use. It can be a branch name, a tag name, or a commit id. + dtype (`Literal["auto", "bfloat16", "float16", "float32"]`, *optional*, defaults to `"float32"`): + Override the default `torch.dtype` and load the model under this dtype. Possible values are + + - `"bfloat16"`: `torch.bfloat16` + - `"float16"`: `torch.float16` + - `"float32"`: `torch.float32` + - `"auto"`: Automatically derive the dtype from the model's weights. + + attn_implementation (`str`, *optional*): + Which attention implementation to use. More information in the [Kernels Hub Integrations + Guide](kernels_hub). + use_peft (`bool`, *optional*, defaults to `False`): + Whether to use PEFT for training. + lora_r (`int`, *optional*, defaults to `16`): + LoRA R value. + lora_alpha (`int`, *optional*, defaults to `32`): + LoRA alpha. + lora_dropout (`float`, *optional*, defaults to `0.05`): + LoRA dropout. + lora_target_modules (`str | list[str]`, *optional*): + LoRA target modules. + lora_target_parameters (`str | list[str]`, *optional*): + List of target parameters for LoRA. + lora_modules_to_save (`list[str]`, *optional*): + Model layers to unfreeze & train. + lora_task_type (`str`, *optional*, defaults to `"CAUSAL_LM"`): + Task type to pass for LoRA (use `"SEQ_CLS"` for reward modeling). + use_rslora (`bool`, *optional*, defaults to `False`): + Whether to use Rank-Stabilized LoRA, which sets the adapter scaling factor to `lora_alpha/√r`, instead of + the original default value of `lora_alpha/r`. + use_dora (`bool`, *optional*, defaults to `False`): + Enable [Weight-Decomposed Low-Rank Adaptation (DoRA)](https://huggingface.co/papers/2402.09353). This + technique decomposes the updates of the weights into two parts, magnitude and direction. Direction is + handled by normal LoRA, whereas the magnitude is handled by a separate learnable parameter. This can + improve the performance of LoRA, especially at low ranks. Right now, DoRA only supports linear and Conv2D + layers. DoRA introduces a bigger overhead than pure LoRA, so it is recommended to merge weights for + inference. + load_in_8bit (`bool`, *optional*, defaults to `False`): + Whether to use 8 bit precision for the base model. Works only with LoRA. + load_in_4bit (`bool`, *optional*, defaults to `False`): + Whether to use 4 bit precision for the base model. Works only with LoRA. + bnb_4bit_quant_type (`str`, *optional*, defaults to `"nf4"`): + Quantization type (`"fp4"` or `"nf4"`). + use_bnb_nested_quant (`bool`, *optional*, defaults to `False`): + Whether to use nested quantization. + bnb_4bit_quant_storage (`str`, *optional*): + Quantization storage dtype. + """ + + model_name_or_path: str | None = field( + default=None, + metadata={"help": "Model checkpoint for weights initialization."}, + ) + model_revision: str = field( + default="main", + metadata={"help": "Specific model version to use. It can be a branch name, a tag name, or a commit id."}, + ) + dtype: str | None = field( + default="float32", + metadata={ + "help": "Override the default `torch.dtype` and load the model under this dtype. It defaults to `'float32'`.", + "choices": ["auto", "bfloat16", "float16", "float32"], + }, + ) + attn_implementation: str | None = field( + default=None, + metadata={ + "help": "Which attention implementation to use. You can run `--attn_implementation=flash_attention_2`, in " + "which case you must install this manually by running `pip install flash-attn --no-build-isolation`." + }, + ) + use_peft: bool = field( + default=False, + metadata={"help": "Whether to use PEFT for training."}, + ) + lora_r: int = field( + default=16, + metadata={"help": "LoRA R value."}, + ) + lora_alpha: int = field( + default=32, + metadata={"help": "LoRA alpha."}, + ) + lora_dropout: float = field( + default=0.05, + metadata={"help": "LoRA dropout."}, + ) + lora_target_modules: list[str] | None = field( + default=None, + metadata={"help": "LoRA target modules."}, + ) + lora_target_parameters: list[str] | None = field( + default=None, + metadata={"help": "List of target parameters for LoRA."}, + ) + lora_modules_to_save: list[str] | None = field( + default=None, + metadata={"help": "Model layers to unfreeze & train."}, + ) + lora_task_type: str = field( + default="CAUSAL_LM", + metadata={"help": "Task type to pass for LoRA (use 'SEQ_CLS' for reward modeling)."}, + ) + use_rslora: bool = field( + default=False, + metadata={ + "help": "Whether to use Rank-Stabilized LoRA, which sets the adapter scaling factor to `lora_alpha/√r`, " + "instead of the original default value of `lora_alpha/r`." + }, + ) + use_dora: bool = field( + default=False, + metadata={ + "help": "Enable Weight-Decomposed Low-Rank Adaptation (DoRA). This technique decomposes the updates of " + "the weights into two parts, magnitude and direction. Direction is handled by normal LoRA, whereas the " + "magnitude is handled by a separate learnable parameter. This can improve the performance of LoRA, " + "especially at low ranks. Right now, DoRA only supports linear and Conv2D layers. DoRA introduces a " + "bigger overhead than pure LoRA, so it is recommended to merge weights for inference." + }, + ) + load_in_8bit: bool = field( + default=False, + metadata={"help": "Whether to use 8 bit precision for the base model. Works only with LoRA."}, + ) + load_in_4bit: bool = field( + default=False, + metadata={"help": "Whether to use 4 bit precision for the base model. Works only with LoRA."}, + ) + bnb_4bit_quant_type: str = field( + default="nf4", + metadata={"help": "Quantization type.", "choices": ["fp4", "nf4"]}, + ) + use_bnb_nested_quant: bool = field( + default=False, + metadata={"help": "Whether to use nested quantization."}, + ) + bnb_4bit_quant_storage: str | None = field( + default=None, + metadata={"help": "Quantization storage dtype"}, + ) + + def __post_init__(self): + if self.load_in_8bit and self.load_in_4bit: + raise ValueError("You can't use 8 bit and 4 bit precision at the same time") + + if hasattr(self.lora_target_modules, "__len__") and len(self.lora_target_modules) == 1: + self.lora_target_modules = self.lora_target_modules[0] diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/reward_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/reward_config.py new file mode 100644 index 0000000000000000000000000000000000000000..af36bca3df5e9f79f86248890139b4251f580124 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/reward_config.py @@ -0,0 +1,183 @@ +# Copyright 2020-2026 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 warnings +from dataclasses import dataclass, field +from typing import Any + +from .base_config import _BaseConfig + + +@dataclass +class RewardConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`RewardTrainer`]. + + This class includes only the parameters that are specific to Reward training. For a full list of training + arguments, please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this + class may differ from those in [`~transformers.TrainingArguments`]. + + 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: + > Parameters that control the model + + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model` + argument of the [`RewardTrainer`] is provided as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForSequenceClassification.from_pretrained`] and + [`~transformers.AutoTokenizer.from_pretrained`]. + chat_template_path (`str`, *optional*): + If specified, sets the model's chat template. This can either be the path to a tokenizer (local directory + or Hugging Face Hub model) or a direct path to a Jinja template file. When using a Jinja file, you must + ensure that any special tokens referenced in the template are added to the tokenizer and that the model's + embedding layer is resized accordingly. + disable_dropout (`bool`, *optional*, defaults to `True`): + Whether to disable dropout in the model. + + > Parameters that control the data preprocessing + + dataset_num_proc (`int`, *optional*): + Number of processes to use for processing the dataset. + eos_token (`str`, *optional*): + Token used to indicate the end of a turn or sequence. If `None`, it defaults to + `processing_class.eos_token`. + max_length (`int` or `None`, *optional*, defaults to `1024`): + Maximum length of the tokenized sequence. Samples are filtered out if either chosen or rejected sequence + exceeds this value. If `None`, no filtering is applied. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + + > Parameters that control the training + + center_rewards_coefficient (`float`, *optional*): + Coefficient to incentivize the reward model to output mean-zero rewards (proposed by + https://huggingface.co/papers/2312.09244, Eq. 2). Recommended value: `0.01`. + activation_offloading (`bool`, *optional*, defaults to `False`): + Whether to offload the activations to the CPU. + + > Deprecated parameters + + pad_token: + + + + Parameter `pad_token` is deprecated and will be removed in version v2.0.0. Set `tokenizer.pad_token` + directly and pass it as `processing_class` to the trainer instead. + + + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `1e-4` instead of `5e-5`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=1e-4, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + # Parameters that control the model + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument of " + "the `RewardTrainer` is provided as a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForSequenceClassification.from_pretrained` and `AutoTokenizer.from_pretrained`." + }, + ) + chat_template_path: str | None = field( + default=None, + metadata={ + "help": "If specified, sets the model's chat template. This can either be the path to a tokenizer (local " + "directory or Hugging Face Hub model) or a direct path to a Jinja template file. When using a Jinja file, " + "you must ensure that any special tokens referenced in the template are added to the tokenizer and " + "that the model's embedding layer is resized accordingly." + }, + ) + disable_dropout: bool = field( + default=True, + metadata={"help": "Whether to disable dropout in the model."}, + ) + + # Parameters that control the data preprocessing + dataset_num_proc: int | None = field( + default=None, + metadata={"help": "Number of processes to use for processing the dataset."}, + ) + eos_token: str | None = field( + default=None, + metadata={ + "help": "Token used to indicate the end of a turn or sequence. If `None`, it defaults to `processing_class.eos_token`." + }, + ) + max_length: int | None = field( + default=1024, + metadata={ + "help": "Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from " + "the right. If `None`, no truncation is applied." + }, + ) + pad_to_multiple_of: int | None = field( + default=None, + metadata={"help": "If set, the sequences will be padded to a multiple of this value."}, + ) + + # Parameters that control the training + center_rewards_coefficient: float | None = field( + default=None, + metadata={ + "help": "Coefficient to incentivize the reward model to output mean-zero rewards (proposed by " + "https://huggingface.co/papers/2312.09244, Eq. 2). Recommended value: `0.01`." + }, + ) + activation_offloading: bool = field( + default=False, + metadata={"help": "Whether to offload the activations to the CPU."}, + ) + + # Deprecated parameters + pad_token: str | None = field( + default=None, + metadata={ + "help": "Deprecated. Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead." + }, + ) + + def __post_init__(self): + super().__post_init__() + if self.pad_token is not None: + warnings.warn( + "`pad_token` is deprecated and will be removed in v2.0.0. " + "Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead.", + FutureWarning, + stacklevel=3, + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/reward_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/reward_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..cfa6254f97c06a47ac8253db40b70448a4941f21 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/reward_trainer.py @@ -0,0 +1,757 @@ +# Copyright 2020-2026 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 contextlib +import json +import logging +import os +import re +import warnings +from collections import defaultdict +from collections.abc import Callable +from contextlib import contextmanager +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import torch +import torch.nn as nn +import transformers +from accelerate import PartialState +from accelerate.logging import get_logger +from accelerate.utils import is_peft_model +from datasets import Dataset, IterableDataset +from packaging.version import Version +from transformers import ( + AutoModelForSequenceClassification, + AutoTokenizer, + DataCollator, + PreTrainedModel, + PreTrainedTokenizerBase, + TrainerCallback, + set_seed, +) +from transformers.data.data_collator import DataCollatorMixin +from transformers.modeling_layers import GenericForSequenceClassification +from transformers.trainer_utils import EvalPrediction +from transformers.utils import is_peft_available + +from ..chat_template_utils import clone_chat_template +from ..data_utils import is_conversational +from ..models import get_act_offloading_ctx_manager +from .base_trainer import _BaseTrainer +from .reward_config import RewardConfig +from .utils import create_model_from_path, disable_dropout_in_model, get_config_model_id, pad + + +if is_peft_available(): + import peft + from peft import PeftConfig, PeftModel, get_peft_model + + +logger = get_logger(__name__) + + +# Loading a CausalLM checkpoint into AutoModelForSequenceClassification triggers harmless warnings: +# - MISSING score.weight : the new seq-clf head was not in the checkpoint and is randomly initialized. +# - UNEXPECTED lm_head.weight: the causal LM head is in the checkpoint but absent from seq-clf (>= 4.57.0 only). +# Both are expected consequences of intentional cross-architecture loading. We suppress them to avoid +# confusing users. + + +# Old approach using logging filter (for transformers < 4.57.0) +# Note: in transformers < 4.57.0, only the MISSING score.weight warning is emitted; lm_head.weight is not reported. +@contextmanager +def _suppress_seqcls_cross_arch_keys(logger: logging.Logger): + pattern = re.compile( + r"^Some weights of \S+ were not initialized from the model checkpoint at \S+ and are newly initialized: " + r"\[.*\]\nYou should probably TRAIN this model on a down-stream task to be able to use it for predictions and " + r"inference\.$" + ) + + class _Filter(logging.Filter): + def filter(self, record: logging.LogRecord) -> bool: + return not pattern.search(record.getMessage()) + + f = _Filter() + logger.addFilter(f) + try: + yield + finally: + logger.removeFilter(f) + + +# New approach using scoped override (for transformers >= 4.57.0) +@contextmanager +def _ignore_seqcls_cross_arch_keys(): + # Scoped override: ignore the expected seq-clf head key (newly added) and the causal LM head + # key (present in the checkpoint but absent from seq-clf). + old_missing = getattr(GenericForSequenceClassification, "_keys_to_ignore_on_load_missing", None) + old_unexpected = getattr(GenericForSequenceClassification, "_keys_to_ignore_on_load_unexpected", None) + + merged_missing = list(old_missing) if old_missing is not None else [] + if r"^score\.weight$" not in merged_missing: + merged_missing.append(r"^score\.weight$") + + merged_unexpected = list(old_unexpected) if old_unexpected is not None else [] + if r"^lm_head\." not in merged_unexpected: + merged_unexpected.append(r"^lm_head\.") + + GenericForSequenceClassification._keys_to_ignore_on_load_missing = merged_missing + GenericForSequenceClassification._keys_to_ignore_on_load_unexpected = merged_unexpected + try: + yield + finally: + GenericForSequenceClassification._keys_to_ignore_on_load_missing = old_missing + GenericForSequenceClassification._keys_to_ignore_on_load_unexpected = old_unexpected + + +# Version-aware wrapper that chooses the appropriate approach +@contextmanager +def suppress_seqcls_warning(): + # Use the new approach for transformers >= 4.57.0, old approach for earlier versions + # The old approach is needed for 4.56.2 to avoid meta tensor issues with device_map=None + if Version(transformers.__version__) >= Version("4.57.0"): + with _ignore_seqcls_cross_arch_keys(): + yield + else: + # Get the transformers logger + transformers_logger = logging.getLogger("transformers.modeling_utils") + with _suppress_seqcls_cross_arch_keys(transformers_logger): + yield + + +def get_dataset_column_names(dataset: Dataset | IterableDataset) -> list[str]: + return list(next(iter(dataset)).keys()) if dataset.column_names is None else dataset.column_names + + +@dataclass +class DataCollatorForPreference(DataCollatorMixin): + """ + Data collator used for preference data. Inputs are dynamically padded to the maximum length of a batch. + + This collator expects each example in the input list to be a dictionary containing the `"chosen_ids"` and + `"rejected_ids"` keys. The collator returns a dictionary containing the following keys: + - `"input_ids"`: Tensor of input IDs, padded to the maximum length of the batch. The first half of the batch + corresponds to the `"chosen_ids"` and the second half to the `"rejected_ids"`. + - `"attention_mask"`: Tensor of attention mask, padded to the maximum length of the batch. + + Optionally, the examples can contain a `"margin"` key, in which case the returned dictionary will also contain a + `"margin"` key with a tensor of margins. + + Args: + pad_token_id (`int`): + Token ID to use for padding. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + return_tensors (`str`, *optional*, defaults to `"pt"`): + Type of Tensor to return. Only `"pt"` is currently supported. + + Examples: + ```python + >>> from trl.trainer.reward_trainer import DataCollatorForPreference + + >>> collator = DataCollatorForPreference(pad_token_id=0) + >>> examples = [ + ... {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5]}, + ... {"chosen_ids": [6, 7], "rejected_ids": [8]}, + ... ] + >>> collator(examples) + {'input_ids': tensor([[1, 2, 3], + [6, 7, 0], + [4, 5, 0], + [8, 0, 0]]), + 'attention_mask': tensor([[1, 1, 1], + [1, 1, 0], + [1, 1, 0], + [1, 0, 0]])} + + >>> examples = [ + ... {"chosen_ids": [1, 2, 3], "rejected_ids": [4, 5], "margin": 0.5}, + ... {"chosen_ids": [6, 7], "rejected_ids": [8], "margin": 0.0}, + ... ] + >>> collator(examples) + {'input_ids': tensor([[1, 2, 3], + [6, 7, 0], + [4, 5, 0], + [8, 0, 0]]), + 'attention_mask': tensor([[1, 1, 1], + [1, 1, 0], + [1, 1, 0], + [1, 0, 0]]), + 'margin': tensor([0.5, 0.0])} + ``` + """ + + pad_token_id: int + pad_to_multiple_of: int | None = None + return_tensors: str = "pt" + + def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]: + # Convert to tensor + chosen_ids = [torch.tensor(example["chosen_ids"]) for example in examples] + rejected_ids = [torch.tensor(example["rejected_ids"]) for example in examples] + if "margin" in examples[0]: + margins = torch.tensor([example["margin"] for example in examples], dtype=torch.float) + input_ids = chosen_ids + rejected_ids + attention_mask = [torch.ones_like(ids) for ids in input_ids] + + output = {} + + # Pad + output["input_ids"] = pad( + input_ids, + padding_value=self.pad_token_id, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + output["attention_mask"] = pad( + attention_mask, + padding_value=0, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + if "margin" in examples[0]: + output["margin"] = margins + return output + + +class RewardTrainer(_BaseTrainer): + """ + Trainer for Outcome-supervised Reward Models (ORM). + + This class is a wrapper around the [`~transformers.Trainer`] class and inherits all of its attributes and methods. + + Example: + + ```python + from trl import RewardTrainer + from datasets import load_dataset + + dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train") + + trainer = RewardTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", + train_dataset=dataset, + ) + trainer.train() + ``` + + Args: + model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]): + Model to be trained. Can be either: + + - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using `AutoModelForSequenceClassification.from_pretrained` with the keyword arguments in + `args.model_init_kwargs`. + - A sequence classification [`~transformers.PreTrainedModel`] object. + - A sequence classification [`~peft.PeftModel`] object. + args ([`RewardConfig`], *optional*): + Configuration for this trainer. If `None`, a default configuration is used. + data_collator ([`~transformers.DataCollator`], *optional*): + Function to use to form a batch from a list of elements of the processed `train_dataset` or `eval_dataset`. + Will default to [`~trainer.reward_trainer.DataCollatorForPreference`]. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + Dataset to use for training. This trainer supports [preference](#preference) type (both implicit and + explicit prompt). The format of the samples can be either: + + - [Standard](dataset_formats#standard): Each sample contains plain text. + - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role + and content). + + The trainer also supports processed datasets (tokenized) as long as they contain `chosen_ids` and + `rejected_ids` fields. + eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`): + Dataset to use for evaluation. It must meet the same requirements as `train_dataset`. + processing_class ([`~transformers.PreTrainedTokenizerBase`], *optional*): + Tokenizer used to process the data. If `None`, the tokenizer is loaded from the model's name with + [`~transformers.AutoTokenizer.from_pretrained`]. A padding token, `processing_class.pad_token`, must be + set. If the processing class has not set a padding token, `processing_class.eos_token` will be used as the + default. + compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*): + The function that will be used to compute metrics at evaluation. Must take a + [`~transformers.EvalPrediction`] and return a dictionary string to metric values. When passing + [`RewardConfig`] with `batch_eval_metrics` set to `True`, your `compute_metrics` function must take a + boolean `compute_result` argument. This will be triggered after the last eval batch to signal that the + function needs to calculate and return the global summary statistics rather than accumulating the + batch-level statistics. + callbacks (list of [`~transformers.TrainerCallback`], *optional*): + List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed + in [here](https://huggingface.co/docs/transformers/main_classes/callback). + + If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`] + method. + optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`): + A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your + model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`. + optimizer_cls_and_kwargs (`tuple[Type[torch.optim.Optimizer], Dict[str, Any]]`, *optional*): + A tuple containing the optimizer class and keyword arguments to use. Overrides `optim` and `optim_args` in + `args`. Incompatible with the `optimizers` argument. + + Unlike `optimizers`, this argument avoids the need to place model parameters on the correct devices before + initializing the Trainer. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`, *optional*): + A function that preprocess the logits right before caching them at each evaluation step. Must take two + tensors, the logits and the labels, and return the logits once processed as desired. The modifications made + by this function will be reflected in the predictions received by `compute_metrics`. + + Note that the labels (second parameter) will be `None` if the dataset does not have them. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration used to wrap the model. If `None`, the model is not wrapped. Note that if the loaded + model is a causal LM, it's highly recommended to set `modules_to_save=["score"]` in the PEFT configuration + to ensure that the reward head is properly trained. + """ + + _tag_names = ["trl", "reward-trainer"] + _name = "Reward" + _template_file = "rm_model_card.md" + + def __init__( + self, + model: "str | PreTrainedModel | PeftModel", + args: RewardConfig | None = None, + data_collator: DataCollator | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | None = None, + compute_metrics: Callable[[EvalPrediction], dict] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, Any]] | None = None, + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + peft_config: "PeftConfig | None" = None, + ): + # Args + if args is None: + model_name = model if isinstance(model, str) else get_config_model_id(model.config) + model_name = model_name.split("/")[-1] + args = RewardConfig(f"{model_name}-Reward") + + if train_dataset is None: + raise ValueError("`train_dataset` is required") + elif isinstance(train_dataset, IterableDataset): + # IterableDataset requires dispatch_batches=False because Accelerate's dispatch mode may try to concatenate + # batches from multiple processes, leading to mismatch errors. + if args.accelerator_config.dispatch_batches is True: + logger.warning( + "You are using an `IterableDataset` for training with `dispatch_batches=True`. `dispatch_batches` " + "is forced to `False` when using an `IterableDataset`. To remove this warning, unset " + "`dispatch_batches` in `RewardConfig` or set it to `False`." + ) + args.accelerator_config.dispatch_batches = False + + # Model + # As AutoModelForSequenceClassification.from_pretrained() will add a random head for the model, set_seed must + # be done before loading the model to ensure reproducibility. + set_seed(args.seed) + if isinstance(model, str): + model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs["num_labels"] = 1 # the only output of the model is the reward score + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + with suppress_seqcls_warning(): + model = create_model_from_path(model, AutoModelForSequenceClassification, **model_init_kwargs) + else: + if args.model_init_kwargs is not None: + logger.warning( + "You passed `model_init_kwargs` to the `RewardConfig`, but your model is already instantiated. " + "The `model_init_kwargs` will be ignored." + ) + # Validate that the model has num_labels = 1 (required for reward models) + if getattr(model.config, "num_labels", None) != 1: + raise ValueError( + f"The model has `num_labels={model.config.num_labels}`, but reward models require `num_labels=1` " + "to output a single scalar reward per sequence. Please instantiate your model with `num_labels=1` " + "or pass a model name as a string to have it configured automatically." + ) + # Non-quantized models do not have the `is_loaded_in_{8,4}bit` attributes, whereas quantized models do + _is_quantized_model = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False) + + # Processing class + if processing_class is None: + processing_class = AutoTokenizer.from_pretrained( + get_config_model_id(model.config), trust_remote_code=args.trust_remote_code + ) + + # Handle pad token for processors or tokenizers + if args.eos_token is not None: + if args.eos_token not in processing_class.get_vocab(): + raise ValueError( + f"The specified `eos_token` ('{args.eos_token}') is not found in the vocabulary of the given " + f"`processing_class` ({processing_class.__class__.__name__}). Ensure that the `eos_token` exists " + "in the vocabulary before using it as an EOS token." + ) + processing_class.eos_token = args.eos_token + + if args.chat_template_path is not None: + if os.path.isfile(args.chat_template_path) and args.chat_template_path.endswith((".jinja", ".j2")): + with open(args.chat_template_path, encoding="utf-8") as chat_template_file: + processing_class.chat_template = chat_template_file.read() + added_tokens = [] + else: + model, processing_class, added_tokens = clone_chat_template( + model, processing_class, args.chat_template_path + ) + else: + added_tokens = [] + + # PEFT + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge " + "and unload the existing adapter, save the resulting base model, and then pass that base model along " + "with the new `peft_config` to the trainer." + ) + if added_tokens: + # Ensure that the added tokens are trainable + if peft_config.trainable_token_indices is None: + peft_config.trainable_token_indices = {"embed_tokens": added_tokens} + elif "embed_tokens" not in peft_config.trainable_token_indices: + peft_config.trainable_token_indices["embed_tokens"] = added_tokens + else: + peft_config.trainable_token_indices["embed_tokens"].extend(added_tokens) + # Ensure that the lm_head is trainable + if peft_config.modules_to_save is None or "lm_head" not in peft_config.modules_to_save: + logger.warning( + "Cloning chat template added new tokens to the tokenizer, but 'lm_head' is not in PEFT's " + "`modules_to_save`. As a result, the model may not learn to generate outputs with these new " + "tokens, leading to degraded generation quality. To fix this, add " + "`modules_to_save=['lm_head']` to your PEFT configuration." + ) + + if peft_config.modules_to_save is None: + peft_config.modules_to_save = ["lm_head"] + else: + peft_config.modules_to_save.append("lm_head") + # Create PEFT model + # ZeRO-3 + PEFT for non-quantized models: + # - PEFT's default autocast_adapter_dtype=True upcasts LoRA adapter params to fp32 even when the base model is bf16. + # - ZeRO-3's _allgather_params_coalesced allocates output buffers using the dtype of the first persistent parameter, + # so mixed-dtype persistent_parameters (bf16 base + fp32 LoRA) cause a TypeError on the first optimizer step. + # - Passing autocast_adapter_dtype=False keeps adapter params in the base model dtype (bf16), fixing the mismatch. + # - This is safe: the fp32 upcast is a QLoRA-specific concern (low-bit quantized base models), not needed for + # non-quantized bf16 training. + # - See: + # - TRL issue: https://github.com/huggingface/trl/issues/6089 + # - Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/8072 + # - autocast_adapter_dtype was introduced in PEFT 0.12.0; before, no upcast existed: no need to pass the kwarg + get_peft_model_kwargs = {} + if ( + args.deepspeed_plugin is not None + and args.deepspeed_plugin.zero_stage == 3 + and not _is_quantized_model + and Version(peft.__version__) >= Version("0.12.0") + ): + get_peft_model_kwargs["autocast_adapter_dtype"] = False + model = get_peft_model(model, peft_config, **get_peft_model_kwargs) + + # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally + # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489 + if is_peft_model(model) and args.gradient_checkpointing: + model.enable_input_require_grads() + + # When using QLoRA, the PEFT adapter weights are converted to bf16 to follow the recommendations from the + # original paper (see https://huggingface.co/papers/2305.14314, paragraph 3). Normally, this can be done by + # passing `autocast_adapter_dtype=False` to `get_peft_model`, but this option is not yet supported for + # quantized models. See: https://github.com/huggingface/peft/issues/2889 + if _is_quantized_model: + for param in model.parameters(): + if param.requires_grad: + param.data = param.data.to(torch.bfloat16) + + # Disable dropout in the model + if args.disable_dropout: + disable_dropout_in_model(model) + + # Pad token (needed for SequenceClassification models) + # If not provided, use the one from the processing class or the eos token if the processing class does not have + # a pad token. + pad_token = args.pad_token or processing_class.pad_token or processing_class.eos_token + if pad_token not in processing_class.get_vocab(): + raise ValueError( + f"The specified `pad_token` ('{pad_token}') is not found in the vocabulary of the given " + f"`processing_class` ({processing_class.__class__.__name__}). Ensure that the `pad_token` exists " + "in the vocabulary before using it as a padding token." + ) + processing_class.pad_token = pad_token + # SequenceClassification models need `config.pad_token_id` to locate the last non-pad token. + model.config.pad_token_id = processing_class.pad_token_id + + # Data collator + if data_collator is None: + data_collator = DataCollatorForPreference( + pad_token_id=processing_class.pad_token_id, + pad_to_multiple_of=args.pad_to_multiple_of, + ) + + # Dataset + train_dataset = self._prepare_dataset(train_dataset, processing_class, args, "train") + if eval_dataset is not None: + if isinstance(eval_dataset, dict): + eval_dataset = { + key: self._prepare_dataset(dataset, processing_class, args, key) + for key, dataset in eval_dataset.items() + } + else: + eval_dataset = self._prepare_dataset(eval_dataset, processing_class, args, "eval") + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + optimizer_cls_and_kwargs=optimizer_cls_and_kwargs, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + # During evaluation, Trainer calls compute_loss() only if can_return_loss is True and label_names is empty. + self.can_return_loss = True + self.label_names = [] + + # Initialize activation offloading context + if self.args.activation_offloading: + self.maybe_activation_offload_context = get_act_offloading_ctx_manager(model=self.model) + else: + self.maybe_activation_offload_context = contextlib.nullcontext() + + # Initialize the metrics + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + self._total_train_tokens = 0 + + # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the + # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set + # self.model_accepts_loss_kwargs to False to enable scaling. + self.model_accepts_loss_kwargs = False + + # Add tags to the model + self.model.add_model_tags(self._tag_names) + + def _prepare_dataset( + self, + dataset: Dataset | IterableDataset, + processing_class: PreTrainedTokenizerBase, + args: RewardConfig, + dataset_name: str, + ) -> Dataset | IterableDataset: + # If the dataset is already preprocessed (tokenized), skip the processing steps. + column_names = get_dataset_column_names(dataset) + is_processed = "chosen_ids" in column_names and "rejected_ids" in column_names + has_legacy_processed_columns = "chosen_input_ids" in column_names and "rejected_input_ids" in column_names + if has_legacy_processed_columns and not is_processed: + warnings.warn( + "Detected legacy dataset columns `chosen_input_ids`/`rejected_input_ids`; they are deprecated and " + "will not be supported in v1. Please migrate to `chosen_ids`/`rejected_ids`.", + FutureWarning, + stacklevel=2, + ) + dataset = dataset.rename_column("chosen_input_ids", "chosen_ids") + dataset = dataset.rename_column("rejected_input_ids", "rejected_ids") + is_processed = True + + # Build the kwargs for the `map` function + map_kwargs = {} + if isinstance(dataset, Dataset): # IterableDataset does not support num_proc + map_kwargs["num_proc"] = args.dataset_num_proc + + with PartialState().main_process_first(): + if not is_processed: + # Add EOS token if needed: non-conversational only + first_example = next(iter(dataset)) + if not is_conversational(first_example): + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Adding EOS to {dataset_name} dataset" + + def add_eos(example, eos_token): + if not example["chosen"].endswith(eos_token): + example["chosen"] = example["chosen"] + eos_token + if "rejected" in example and not example["rejected"].endswith(eos_token): + example["rejected"] = example["rejected"] + eos_token + return example + + dataset = dataset.map( + add_eos, + fn_kwargs={"eos_token": processing_class.eos_token}, + **map_kwargs, + ) + + # Tokenize the dataset + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset" + + def tokenize_fn(example, processing_class): + tools = example.get("tools") + tools = json.loads(tools) if isinstance(tools, str) else tools + if "prompt" in example: # explicit prompt case + example["chosen"] = example["prompt"] + example["chosen"] + example["rejected"] = example["prompt"] + example["rejected"] + + if is_conversational(example): + chosen_ids = processing_class.apply_chat_template( + example["chosen"], + tools=tools, + return_dict=True, + **example.get("chat_template_kwargs", {}), + )["input_ids"] + rejected_ids = processing_class.apply_chat_template( + example["rejected"], + tools=tools, + return_dict=True, + **example.get("chat_template_kwargs", {}), + )["input_ids"] + output = {"chosen_ids": chosen_ids, "rejected_ids": rejected_ids} + else: + output = { + "chosen_ids": processing_class(text=example["chosen"])["input_ids"], + "rejected_ids": processing_class(text=example["rejected"])["input_ids"], + } + return output + + dataset = dataset.map(tokenize_fn, fn_kwargs={"processing_class": processing_class}, **map_kwargs) + + # Filter samples that are longer than `max_length` + if args.max_length is not None: + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Filtering {dataset_name} >{args.max_length} tokens" + dataset = dataset.filter( + lambda example: len(example["chosen_ids"]) <= args.max_length + and len(example["rejected_ids"]) <= args.max_length, + **map_kwargs, + ) + + return dataset + + def _set_signature_columns_if_needed(self): + # If `self.args.remove_unused_columns` is True, non-signature columns are removed. + # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids" + # and "attention_mask"). + if self._signature_columns is None: + self._signature_columns = ["chosen_ids", "rejected_ids", "margin"] + + def evaluate( + self, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + ignore_keys: list[str] | None = None, + metric_key_prefix: str = "eval", + ) -> dict[str, float]: + # When a dataset is passed directly to `evaluate` (e.g. a held-out test set), preprocess it the same way + # `__init__` does, so that `evaluate` accepts the same dataset types as the trainer. `_prepare_dataset` is + # idempotent: it skips datasets that are already tokenized. A `str` selects a dataset that was already prepared + # at init time, so it's left untouched. + if eval_dataset is not None and not isinstance(eval_dataset, str): + if isinstance(eval_dataset, dict): + eval_dataset = { + key: self._prepare_dataset(dataset, self.processing_class, self.args, key) + for key, dataset in eval_dataset.items() + } + else: + eval_dataset = self._prepare_dataset(eval_dataset, self.processing_class, self.args, "eval") + return super().evaluate( + eval_dataset=eval_dataset, ignore_keys=ignore_keys, metric_key_prefix=metric_key_prefix + ) + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + mode = "train" if self.model.training else "eval" + + # If not set, defaults from model config and may warn since cache isn't compatible with gradient checkpointing + inputs["use_cache"] = False + outputs = model(**inputs) + + # Split the rewards into chosen and rejected + rewards_chosen, rewards_rejected = torch.chunk(outputs.logits.squeeze(-1), chunks=2) + + # Calculate loss, optionally modulate with margin + if "margin" in inputs: + loss = -nn.functional.logsigmoid(rewards_chosen - rewards_rejected - inputs["margin"]).mean() + else: + loss = -nn.functional.logsigmoid(rewards_chosen - rewards_rejected).mean() + + if self.args.center_rewards_coefficient is not None: + loss += self.args.center_rewards_coefficient * torch.mean((rewards_chosen + rewards_rejected) ** 2) + + if mode == "train": + num_tokens_in_batch = self.accelerator.gather_for_metrics(inputs["attention_mask"].sum()).sum().item() + self._total_train_tokens += num_tokens_in_batch + self._metrics[mode]["num_tokens"] = [self._total_train_tokens] + + # Compute min, mean, max, accuracy and margin + with torch.no_grad(): + all_rewards = self.accelerator.gather(outputs.logits) + self._metrics[mode]["min_reward"].append(all_rewards.min().item()) + self._metrics[mode]["mean_reward"].append(all_rewards.mean().item()) + self._metrics[mode]["max_reward"].append(all_rewards.max().item()) + + mean_accuracy = (rewards_chosen > rewards_rejected).float().mean() + mean_accuracy = self.accelerator.gather_for_metrics(mean_accuracy).mean().item() + self._metrics[mode]["accuracy"].append(mean_accuracy) + + mean_margin = (rewards_chosen - rewards_rejected).mean() + mean_margin = self.accelerator.gather_for_metrics(mean_margin).mean() + self._metrics[mode]["margin"].append(mean_margin.item()) + + return (loss, outputs) if return_outputs else loss + + # Override training step to add activation offloading context. + def training_step(self, *args, **kwargs): + with self.maybe_activation_offload_context: + return super().training_step(*args, **kwargs) + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} # average the metrics + + # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs` + # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/rloo_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/rloo_config.py new file mode 100644 index 0000000000000000000000000000000000000000..5cd2bb565ac2d8f600d5113cfa00bcddaaf9b952 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/rloo_config.py @@ -0,0 +1,668 @@ +# Copyright 2020-2026 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 warnings +from dataclasses import dataclass, field +from typing import Any + +from .base_config import _BaseConfig + + +@dataclass +class RLOOConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`RLOOTrainer`]. + + This class includes only the parameters that are specific to RLOO training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + 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: + > Parameters that control the model and reference model + + model_init_kwargs (`str`, `dict[str, Any]`, *optional*): + Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model` + argument of the [`RLOOTrainer`] is provided as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and + [`~transformers.AutoProcessor.from_pretrained`]. Also applied to reward-model and reward-tokenizer loads. + router_aux_loss_coef (`float`, *optional*, defaults to `0.001`): + Coefficient of the load-balancing auxiliary loss. Only has an effect when training a Mixture-of-Experts + (MoE) model; for other models it does nothing. The auxiliary loss is added to the training loss with this + weight. Set to `0.0` to disable it. + disable_dropout (`bool`, *optional*, defaults to `False`): + Whether to disable dropout in the model. This is useful for training with a reference model, as it prevents + the model from generating different logprobs for the same input. + + > Parameters that control the data preprocessing + + remove_unused_columns (`bool`, *optional*, defaults to `False`): + Whether to only keep the column `"prompt"` in the dataset. If you use a custom reward function that + requires any column other than `"prompts"` and `"completions"`, you should keep this to `False`. + num_generations (`int`, *optional*, defaults to `2`): + Number of generations per prompt to sample. The effective batch size (num_processes * per_device_batch_size + * gradient_accumulation_steps) must be evenly divisible by this value. + num_generations_eval (`int` or `None`, *optional*): + Number of generations to sample during evaluation. This allows using fewer generations during evaluation to + save computation. If `None`, uses the value of `num_generations`. + max_completion_length (`int` or `None`, *optional*, defaults to `256`): + Maximum length of the generated completion. + ds3_gather_for_generation (`bool`, *optional*, defaults to `True`): + This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for generation, + improving generation speed. However, disabling this option allows training models that exceed the VRAM + capacity of a single GPU, albeit at the cost of slower generation. Disabling this option is not compatible + with vLLM generation. + shuffle_dataset (`bool`, *optional*, defaults to `True`): + Whether to shuffle the training dataset. + pad_to_multiple_of (`int`, *optional*): + If set, the prompts ids and completions ids will be padded to a multiple of this value. + + > Parameters that control generation + + generation_batch_size (`int`, *optional*): + Batch size to use for generation. If `None`, it defaults to the effective training batch size: + `per_device_train_batch_size * num_processes * steps_per_generation`. In other words, there is one + generation batch processed per optimization step. Mutually exclusive with `steps_per_generation`. + steps_per_generation (`int`, *optional*): + Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`. Mutually exclusive + with `generation_batch_size`. + temperature (`float`, defaults to `1.0`): + Temperature for sampling. The higher the temperature, the more random the completions. + top_p (`float`, *optional*, defaults to `1.0`): + Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. Set to + `1.0` to consider all tokens. + top_k (`int`, *optional*, defaults to `0`): + Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, top-k-filtering is + disabled and all tokens are considered. + min_p (`float`, *optional*): + Minimum token probability, which will be scaled by the probability of the most likely token. It must be a + value between `0.0` and `1.0`. Typical values are in the `0.01-0.2` range. + generation_kwargs (`dict[str, Any]`, *optional*): + Additional keyword arguments to pass to [`~transformers.GenerationConfig`] (if using transformers) or + `SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the + generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that conflict + with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them. + chat_template_kwargs (`dict[str, Any]`, *optional*): + Additional keyword arguments to pass to the `apply_chat_template` function when generating completions. + repetition_penalty (`float`, *optional*, defaults to `1.0`): + Float that penalizes new tokens based on whether they appear in the prompt and the generated text so far. + Values > `1.0` encourage the model to use new tokens, while values < `1.0` encourage the model to repeat + tokens. + cache_implementation (`str`, *optional*): + Implementation of the cache method for faster generation when `use_vllm` is set to `False`. + + > Parameters that control generation acceleration powered by vLLM + + use_vllm (`bool`, *optional*, defaults to `False`): + Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for generation + instead of the default model.generate(). Requires `vllm` to be installed. + vllm_mode (`str`, *optional*, defaults to `"colocate"`): + Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `"server"` or + `"colocate"`. + + - `"server"`: The trainer will send generation requests to a separate vLLM server. Make sure a TRL vLLM + server is running (start with `trl vllm-serve`). + - `"colocate"`: vLLM will run in the same process and share the training GPUs. This avoids the need for a + separate server but may cause resource contention with training. + vllm_model_impl (`str`, *optional*, defaults to `"vllm"`): + Model implementation to use for vLLM. Must be one of `"transformers"` or `"vllm"`. `"transformers"`: Use + the `transformers` backend for model implementation. `"vllm"`: Use the `vllm` library for model + implementation. + vllm_structured_outputs_regex (`str`, *optional*): + Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled. + + > Parameters that control the vLLM server (only used when `vllm_mode` is `"server"`) + + vllm_server_base_url (`str`, *optional*): + Base URL for the vLLM server (e.g., `"http://localhost:8000"`). If provided, `vllm_server_host` and + `vllm_server_port` are ignored. + vllm_server_host (`str`, *optional*, defaults to `"0.0.0.0"`): + Host of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided. + vllm_server_port (`int`, *optional*, defaults to `8000`): + Port of the vLLM server to connect to. Ignored if `vllm_server_base_url` is provided. + vllm_server_timeout (`float`, *optional*, defaults to `240.0`): + Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up after the + timeout, a `ConnectionError` is raised. + vllm_group_port (`int`, *optional*, defaults to `51216`): + Port number for the weight update group. This is used to communicate with the vLLM server. Unless the port + is occupied, there is no need to change it. + + > Parameters that control colocated vLLM execution (only used when `vllm_mode` is `"colocate"`) + + vllm_gpu_memory_utilization (`float`, *optional*, defaults to `0.3`): + Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set to + `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when + launching the vLLM server via the `--vllm_gpu_memory_utilization` flag. + vllm_max_model_length (`int`, *optional*): + Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus + `max_completion_length`; if omitted, it is inferred from the model config. + vllm_tensor_parallel_size (`int`, *optional*, defaults to `1`): + Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set to + `"colocate"`. If you are using `vllm_mode="server"`, this parameter must be passed separately when + launching the vLLM server via the `--vllm_tensor_parallel_size` flag. + vllm_enable_sleep_mode (`bool`, *optional*, defaults to `False`): + Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory usage low, but + waking the engine adds host–device transfer latency. + + > Parameters that control generation acceleration powered by transformers continuous batching + + use_transformers_continuous_batching (`bool`, *optional*, defaults to `False`): + Whether to use transformers' continuous batching engine for generating completions. Requires + `transformers>=5.8.0`. + transformers_continuous_batching_config (`dict`, *optional*): + Keyword arguments for [`~transformers.generation.ContinuousBatchingConfig`]. + + > Parameters that control the training + + beta (`float`, *optional*, defaults to `0.05`): + KL coefficient. If `0.0`, the reference model is not loaded, reducing memory usage and improving training + speed. + num_iterations (`int`, *optional*, defaults to `1`): + Number of iterations per batch (denoted as μ in the algorithm). + epsilon (`float`, *optional*, defaults to `0.2`): + Epsilon value for clipping. + epsilon_high (`float`, *optional*): + Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the lower-bound + specified in argument `epsilon`. Paper [DAPO](https://huggingface.co/papers/2503.14476) recommends `0.28`. + reward_weights (`list[float]`, *optional*): + Weights for each reward function. Must match the number of reward functions. If `None`, all rewards are + weighted equally with weight `1.0`. + normalize_advantages (`bool`, *optional*, defaults to `False`): + Whether to normalize advantages. Normalization is done per generation batch to have mean `0.0` and standard + deviation of `1.0`. + reward_clip_range (`tuple[float, float]`, *optional*): + Clip range for rewards as (min, max). If `None`, no clipping is applied. + mask_truncated_completions (`bool`, *optional*, defaults to `False`): + When enabled, truncated completions are excluded from the loss calculation, preventing them from being + incorrectly penalized and introducing noise during training. According to the + [DAPO](https://huggingface.co/papers/2503.14476) paper, this is a good practice for training stability. + sync_ref_model (`bool`, *optional*, defaults to `False`): + Whether to synchronize the reference model with the active model every `ref_model_sync_steps` steps, using + the `ref_model_mixup_alpha` parameter. This synchronization originates from the + [TR-DPO](https://huggingface.co/papers/2404.09656) paper. + ref_model_mixup_alpha (`float`, *optional*, defaults to `0.6`): + α parameter from the [TR-DPO](https://huggingface.co/papers/2404.09656) paper, which controls the mix + between the current policy and the previous reference policy during updates. The reference policy is + updated according to the equation: `π_ref = α * π_θ + (1 - α) * π_ref_prev`. To use this parameter, you + must set `sync_ref_model=True`. + ref_model_sync_steps (`int`, *optional*, defaults to `512`): + τ parameter from the [TR-DPO](https://huggingface.co/papers/2404.09656) paper, which determines how + frequently the current policy is synchronized with the reference policy. To use this parameter, you must + set `sync_ref_model=True`. + + > Parameters that control the logging + + log_completions (`bool`, *optional*, defaults to `False`): + Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. If `rich` is installed, + it prints the sample. If `wandb` and/or `trackio` logging is enabled, it logs it to `wandb` and/or + `trackio`. + num_completions_to_print (`int`, *optional*): + Number of completions to print with `rich`. If `None`, all completions are logged. + log_unique_prompts (`bool`, *optional*, defaults to `False`): + Whether to log unique prompts. If `True`, only unique prompts are logged. If `False`, all prompts are + logged. + + > Deprecated parameters + + use_transformers_paged: + + + + Parameter `use_transformers_paged` is deprecated and will be removed in version v2.0.0. Use + `use_transformers_continuous_batching` instead. + + + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `1e-6` instead of `5e-5`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + [ + "model_init_kwargs", + "transformers_continuous_batching_config", + ] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=1e-6, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + # Parameters that control the model and reference model + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `transformers.AutoModelForCausalLM.from_pretrained`, used when the `model` " + "argument of the `RLOOTrainer` is provided as a string." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`. Also applied to " + "reward-model and reward-tokenizer loads." + }, + ) + router_aux_loss_coef: float = field( + default=0.001, + metadata={ + "help": "Coefficient of the load-balancing auxiliary loss. Only has an effect when training a " + "Mixture-of-Experts (MoE) model; for other models it does nothing. The auxiliary loss is added to the " + "training loss with this weight. Set to `0.0` to disable it." + }, + ) + disable_dropout: bool = field( + default=False, + metadata={ + "help": "Whether to disable dropout in the model. This is useful for training with a reference model, as " + "it prevents the model from generating different logprobs for the same input." + }, + ) + + # Parameters that control the data preprocessing + # The default value remove_unused_columns is overwritten from the parent class, because in RLOO we usually rely on + # additional columns to compute the reward + remove_unused_columns: bool | None = field( + default=False, + metadata={ + "help": "Whether to only keep the column 'prompt' in the dataset. If you use a custom reward function " + "that requires any column other than 'prompts' and 'completions', you should keep this to `False`." + }, + ) + num_generations: int | None = field( + default=2, + metadata={ + "help": "Number of generations to sample. The effective batch size (num_processes * per_device_batch_size " + "* gradient_accumulation_steps) must be evenly divisible by this value." + }, + ) + num_generations_eval: int | None = field( + default=None, + metadata={ + "help": "Number of generations to sample during evaluation. This allows using fewer generations during " + "evaluation to save computation. If `None`, uses the value of `num_generations`." + }, + ) + max_completion_length: int | None = field( + default=256, + metadata={"help": "Maximum length of the generated completion."}, + ) + ds3_gather_for_generation: bool = field( + default=True, + metadata={ + "help": "This setting applies to DeepSpeed ZeRO-3. If enabled, the policy model weights are gathered for " + "generation, improving generation speed. However, disabling this option allows training models that " + "exceed the VRAM capacity of a single GPU, albeit at the cost of slower generation. Disabling this option " + "is not compatible with vLLM generation." + }, + ) + shuffle_dataset: bool | None = field( + default=True, + metadata={"help": "Whether to shuffle the training dataset."}, + ) + pad_to_multiple_of: int | None = field( + default=None, + metadata={"help": "If set, the prompts ids and completions ids will be padded to a multiple of this value."}, + ) + + # Parameters that control generation + generation_batch_size: int | None = field( + default=None, + metadata={ + "help": "Batch size to use for generation. If `None`, it defaults to the effective training batch size: " + "`per_device_train_batch_size * num_processes * steps_per_generation`." + }, + ) + steps_per_generation: int | None = field( + default=None, + metadata={"help": "Number of steps per generation. If `None`, it defaults to `gradient_accumulation_steps`."}, + ) + temperature: float = field( + default=1.0, + metadata={"help": "Temperature for sampling. The higher the temperature, the more random the completions."}, + ) + top_p: float = field( + default=1.0, + metadata={ + "help": "Float that controls the cumulative probability of the top tokens to consider. Must be in (0, 1]. " + "Set to 1.0 to consider all tokens." + }, + ) + top_k: int = field( + default=0, + metadata={ + "help": "Number of highest probability vocabulary tokens to keep for top-k-filtering. If `0`, " + "top-k-filtering is disabled and all tokens are considered." + }, + ) + min_p: float | None = field( + default=None, + metadata={ + "help": "Minimum token probability, which will be scaled by the probability of the most likely token. It " + "must be a value between 0.0 and 1.0. Typical values are in the 0.01-0.2 range." + }, + ) + generation_kwargs: dict | None = field( + default=None, + metadata={ + "help": "Additional keyword arguments to pass to `GenerationConfig` (if using transformers) or " + "`SamplingParams` (if using vLLM) when sampling completions. This can be used to further customize the " + "generation behavior, such as setting `suppress_tokens`, `num_beams`, etc. If it contains keys that " + "conflict with the other generation parameters (like `min_p`, `top_p`, etc.), they will override them." + }, + ) + chat_template_kwargs: dict | None = field( + default=None, + metadata={ + "help": "Additional keyword arguments to pass to the `apply_chat_template` function when generating " + "completions." + }, + ) + repetition_penalty: float = field( + default=1.0, + metadata={ + "help": "Float that penalizes new tokens based on whether they appear in the prompt and the generated " + "text so far. Values > 1.0 encourage the model to use new tokens, while values < 1.0 encourage the model " + "to repeat tokens." + }, + ) + cache_implementation: str | None = field( + default=None, + metadata={"help": "Implementation of the cache method for faster generation when use_vllm is set to False."}, + ) + + # Parameters that control generation acceleration powered by vLLM + use_vllm: bool = field( + default=False, + metadata={ + "help": "Whether to use vLLM for generating completions. If set to `True`, the trainer will use vLLM for " + "generation instead of the default model.generate(). Requires `vllm` to be installed." + }, + ) + vllm_mode: str = field( + default="colocate", + metadata={ + "help": "Mode to use for vLLM integration when `use_vllm` is set to `True`. Must be one of `'server'` or " + "`'colocate'`. `'server'`: The trainer will send generation requests to a separate vLLM server. Make sure " + "a TRL vLLM server is running (start with `trl vllm-serve`). `'colocate'`: vLLM will run in the same " + "process and share the training GPUs. This avoids the need for a separate server but may cause resource " + "contention with training." + }, + ) + vllm_model_impl: str = field( + default="vllm", + metadata={ + "help": "Model implementation to use for vLLM. Must be one of `transformers` or `vllm`. `transformers`: " + "Use the `transformers` backend for model implementation. `vllm`: Use the `vllm` library for " + "model implementation." + }, + ) + vllm_enable_sleep_mode: bool = field( + default=False, + metadata={ + "help": "Enable vLLM sleep mode to offload weights/cache during the optimizer step. Keeps GPU memory " + "usage low, but waking the engine adds host–device transfer latency." + }, + ) + vllm_structured_outputs_regex: str | None = field( + default=None, + metadata={"help": "Regex for vLLM structured outputs. If `None` (default), structured outputs is disabled."}, + ) + + # Parameters that control the vLLM server (only used when `vllm_mode` is `"server"`) + vllm_server_base_url: str | None = field( + default=None, + metadata={ + "help": "Base URL for the vLLM server (e.g., 'http://localhost:8000'). If provided, `vllm_server_host` " + "and `vllm_server_port` are ignored." + }, + ) + vllm_server_host: str = field( + default="0.0.0.0", + metadata={"help": "Host of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."}, + ) + vllm_server_port: int = field( + default=8000, + metadata={"help": "Port of the vLLM server to connect to. Ignored if vllm_server_base_url is provided."}, + ) + vllm_server_timeout: float = field( + default=240.0, + metadata={ + "help": "Total timeout duration in seconds to wait for the vLLM server to be up. If the server is not up " + "after the timeout, a `ConnectionError` is raised." + }, + ) + vllm_group_port: int = field( + default=51216, + metadata={ + "help": "Port number for the weight update group. This is used to communicate with the vLLM server. " + "Unless the port is occupied, there is no need to change it.", + }, + ) + + # Parameters that control colocated vLLM execution (only used when `vllm_mode` is `"colocate"`) + vllm_gpu_memory_utilization: float = field( + default=0.3, + metadata={ + "help": "Control the GPU memory utilization for vLLM. This setting only applies when `vllm_mode` is set " + "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when " + "launching the vLLM server via the `--vllm_gpu_memory_utilization` flag." + }, + ) + vllm_max_model_length: int | None = field( + default=None, + metadata={ + "help": "Context window for vLLM. Set it to at least the maximum prompt length in the dataset plus " + "`max_completion_length`; if omitted, it is inferred from the model config." + }, + ) + vllm_tensor_parallel_size: int = field( + default=1, + metadata={ + "help": "Control the tensor parallel size for vLLM. This setting only applies when `vllm_mode` is set " + "to `'colocate'`. If you are using `vllm_mode='server'`, this parameter must be passed separately when " + "launching the vLLM server via the `--vllm_tensor_parallel_size` flag." + }, + ) + + # Parameters that control the training + beta: float = field( + default=0.05, + metadata={ + "help": "KL coefficient. If `0.0`, the reference model is not loaded, reducing memory usage and improving " + "training speed." + }, + ) + num_iterations: int = field( + default=1, + metadata={"help": "Number of iterations per batch (denoted as μ in the algorithm)."}, + ) + epsilon: float = field( + default=0.2, + metadata={"help": "Epsilon value for clipping."}, + ) + epsilon_high: float | None = field( + default=None, + metadata={ + "help": "Upper-bound epsilon value for clipping. If not specified, it defaults to the same value as the " + "lower-bound specified in argument `epsilon`. Paper DAPO recommends `0.28`." + }, + ) + reward_weights: list[float] | None = field( + default=None, + metadata={ + "help": "Weights for each reward function. Must match the number of reward functions. If `None`, all " + "rewards are weighted equally with weight `1.0`." + }, + ) + normalize_advantages: bool = field( + default=False, + metadata={ + "help": "Whether to normalize advantages. Normalization is done per generation batch to have mean `0.0` " + "and standard deviation of `1.0`." + }, + ) + reward_clip_range: tuple[float, float] | None = field( + default=None, + metadata={"help": "Clip range for rewards as (min, max). If None, no clipping is applied."}, + ) + mask_truncated_completions: bool = field( + default=False, + metadata={ + "help": "When enabled, truncated completions are excluded from the loss calculation, preventing them from " + "being incorrectly penalized and introducing noise during training. According to the DAPO paper, this is " + "a good practice for training stability." + }, + ) + sync_ref_model: bool = field( + default=False, + metadata={ + "help": "Whether to synchronize the reference model with the active model every `ref_model_sync_steps` " + "steps, using the `ref_model_mixup_alpha` parameter." + }, + ) + ref_model_mixup_alpha: float = field( + default=0.6, + metadata={ + "help": "α parameter from the TR-DPO paper, which controls the mix between the current policy and the " + "previous reference policy during updates. The reference policy is updated according to the equation: " + "`π_ref = α * π_θ + (1 - α) * π_ref_prev`. To use this parameter, you must set `sync_ref_model=True`." + }, + ) + ref_model_sync_steps: int = field( + default=512, + metadata={ + "help": "τ parameter from the TR-DPO paper, which determines how frequently the current policy is " + "synchronized with the reference policy. To use this parameter, you must set `sync_ref_model=True`." + }, + ) + + # Parameters that control the logging + log_completions: bool = field( + default=False, + metadata={ + "help": "Whether to log a sample of (prompt, completion) pairs every `logging_steps` steps. If `rich` is " + "installed, it prints the sample. If `wandb` logging is enabled, it logs it to `wandb`." + }, + ) + num_completions_to_print: int | None = field( + default=None, + metadata={"help": "Number of completions to print with `rich`. If `None`, all completions are logged."}, + ) + log_unique_prompts: bool = field( + default=False, + metadata={ + "help": "Whether to log unique prompts. If `True`, only unique prompts are logged. If `False`, all " + "prompts are logged." + }, + ) + + # Parameters that control generation acceleration powered by transformers continuous batching + use_transformers_continuous_batching: bool = field( + default=False, + metadata={ + "help": "Whether to use transformers' continuous batching engine for generating completions. Requires " + "transformers>=5.8.0." + }, + ) + transformers_continuous_batching_config: dict | None = field( + default=None, + metadata={"help": "Keyword arguments for `transformers.generation.ContinuousBatchingConfig`."}, + ) + + # Deprecated parameters + use_transformers_paged: bool = field( + default=False, + metadata={"help": "Deprecated. Use `use_transformers_continuous_batching` instead."}, + ) + + def __post_init__(self): + super().__post_init__() + + if self.use_transformers_paged: + warnings.warn( + "`use_transformers_paged` is deprecated and will be removed in v2.0.0. Use " + "`use_transformers_continuous_batching` instead.", + FutureWarning, + stacklevel=3, + ) + self.use_transformers_continuous_batching = True + + if self.parallelism_config is not None and ( + self.parallelism_config.cp_enabled or self.parallelism_config.sp_enabled + ): + raise ValueError( + "RLOOTrainer does not support sequence-dim parallelism (`parallelism_config.cp_size > 1` or " + "`parallelism_config.sp_size > 1`) yet. RLOO builds model inputs after generation inside the trainer, " + "so Transformers' context-parallel / Ulysses sequence-parallel input sharding cannot be applied to the " + "raw generation batch. Set both `cp_size=1` and `sp_size=1`, or disable `parallelism_config`." + ) + + num_processes = self.world_size + # The current default effective batch size + if self.generation_batch_size is None and self.steps_per_generation is None: + self.steps_per_generation = self.gradient_accumulation_steps + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + elif self.generation_batch_size is not None and self.steps_per_generation is None: + # Just ensure the value is divisible by the global batch size + if self.generation_batch_size % (self.per_device_train_batch_size * num_processes) != 0: + raise ValueError( + f"generation_batch_size ({self.generation_batch_size}) must be divisible by the global batch size " + f"({self.per_device_train_batch_size * num_processes})." + ) + self.steps_per_generation = self.generation_batch_size // ( + self.per_device_train_batch_size * num_processes + ) + elif self.generation_batch_size is None and self.steps_per_generation is not None: + self.generation_batch_size = self.per_device_train_batch_size * num_processes * self.steps_per_generation + else: + raise ValueError( + "'generation_batch_size' and 'steps_per_generation' can not be both configured at the same time" + ) + + if self.do_eval and self.eval_strategy != "no": + # Determine the number of generations to use for evaluation + num_generations = self.num_generations_eval or self.num_generations + + # Just ensure the value is divisible by the global batch size + if (self.per_device_eval_batch_size * num_processes) % num_generations != 0: + raise ValueError( + f"The global eval batch size ({self.per_device_eval_batch_size} * {num_processes}) must be " + f"divisible by the number of generations used for evaluation ({num_generations})." + ) + + # The generation batch must contain full prompt groups (no partials), so it must be divisible by + # num_generations. + if self.generation_batch_size % self.num_generations != 0: + raise ValueError( + f"generation_batch_size ({self.generation_batch_size}) must be divisible by num_generations " + f"({self.num_generations})." + ) + + if self.num_generations < 2: + raise ValueError( + "RLOO requires at least 2 generations per prompt to calculate the advantages. You provided " + f"{self.num_generations}, which is less than the minimum required." + ) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/rloo_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/rloo_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..5e316481efd4f330b069ff259512c462c055ca56 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/rloo_trainer.py @@ -0,0 +1,1638 @@ +# Copyright 2020-2026 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 asyncio +import atexit +import copy +import inspect +import math +import textwrap +import time +from collections import defaultdict, deque +from collections.abc import Callable +from pathlib import Path +from typing import Any + +import numpy as np +import pandas as pd +import torch +import torch.utils.data +import transformers +from accelerate.logging import get_logger +from accelerate.utils import gather, gather_object, is_peft_model, set_seed +from datasets import Dataset, IterableDataset +from packaging.version import Version +from torch import nn +from torch.utils.data import Sampler +from transformers import ( + AutoModelForSequenceClassification, + AutoProcessor, + AutoTokenizer, + GenerationConfig, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainerCallback, + is_trackio_available, + is_wandb_available, +) +from transformers.utils import is_peft_available, is_rich_available + +from ..data_utils import apply_chat_template, is_conversational, prepare_multimodal_messages +from ..distributed import DistributedBackend +from ..extras.profiling import profiling_context, profiling_decorator +from ..generation.vllm_generation import VLLMGeneration +from ..models import prepare_deepspeed, prepare_fsdp, unwrap_model_for_generation +from ..models.utils import disable_gradient_checkpointing +from .base_trainer import _BaseTrainer +from .callbacks import SyncRefModelCallback +from .rloo_config import RLOOConfig +from .utils import ( + RepeatSampler, + create_model_from_path, + disable_dropout_in_model, + entropy_from_logits, + get_config_model_id, + identity, + nanmax, + nanmin, + nanstd, + pad, + print_prompt_completions_sample, + selective_log_softmax, + shuffle_sequence_dict, + shutdown_event_loop_in_daemon, + split_pixel_values_by_grid, + split_tensor_dict, + start_event_loop_in_daemon, + unsplit_pixel_values_by_grid, + use_adapter, +) + + +if is_peft_available(): + import peft + from peft import LoraConfig, PeftConfig, PeftModel, get_peft_model + + +if is_wandb_available(): + import wandb + +if is_trackio_available(): + import trackio + + +logger = get_logger(__name__) + +# A reward function can be a string, interpreted as a model ID and loaded as a pretrained model, a pretrained model, or +# a callable that returns a list of floats (the rewards). The callable receives prompts, completions, and additional +# arguments from the trainer (refer to the trainer's source for details). To ensure forward compatibility, it should +# accept **kwargs. +RewardFunc = str | PreTrainedModel | Callable[..., list[float | None]] + + +class RLOOTrainer(_BaseTrainer): + """ + Trainer for the Reinforce Leave One Out (RLOO) method. This algorithm was initially proposed in the paper [Back to + Basics: Revisiting REINFORCE Style Optimization for Learning from Human Feedback in + LLMs](https://huggingface.co/papers/2402.14740). + + Example: + + ```python + from trl import RLOOTrainer + from trl.rewards import accuracy_reward + from datasets import load_dataset + + dataset = load_dataset("trl-lib/DeepMath-103K", split="train") + + trainer = RLOOTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", + reward_funcs=accuracy_reward, + train_dataset=dataset, + ) + trainer.train() + ``` + + Args: + model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]): + Model to be trained. Can be either: + + - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using `.from_pretrained` (where `` is derived from the model + config) with the keyword arguments in `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported. + - A [`~peft.PeftModel`] object. Only causal language models are supported. + reward_funcs (`RewardFunc | list[RewardFunc]`): + Reward functions to be used for computing the rewards. To compute the rewards, we call all the reward + functions with the prompts and completions and sum the rewards. Can be either: + + - A single reward function, such as: + - A string: The *model ID* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using [`~transformers.AutoModelForSequenceClassification.from_pretrained`] with `num_labels=1` and the + keyword arguments in `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object: Only sequence classification models are supported. + - A custom reward function: The function is provided with the prompts and the generated completions, + plus any additional columns in the dataset. It should return a list of rewards. Custom reward + functions can be either synchronous or asynchronous and can also return `None` when the reward is + not applicable to those samples. This is useful for multi-task training where different reward + functions apply to different types of samples. When a reward function returns `None` for a sample, + that reward function is excluded from the reward calculation for that sample. For more details, see + [Using a custom reward + function](#using-a-custom-reward-function). + + The trainer's state is also passed to the reward function. The trainer's state is an instance of + [`~transformers.TrainerState`] and can be accessed by accessing the `trainer_state` argument to the + reward function's signature. + - A list of reward functions, where each item can independently be any of the above types. Mixing different + types within the list (e.g., a string model ID and a custom reward function) is allowed. + args ([`RLOOConfig`], *optional*): + Configuration for this trainer. If `None`, a default configuration is used. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + Dataset to use for training. It must include a column `"prompt"`. Any additional columns in the dataset is + ignored. The format of the samples can be either: + + - [Standard](dataset_formats#standard): Each sample contains plain text. + - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role + and content). + eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`): + Dataset to use for evaluation. It must meet the same requirements as `train_dataset`. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. The padding side must be set to "left". If `None`, the + processing class is loaded from the model's name with [`~transformers.AutoProcessor.from_pretrained`]. A + padding token, `tokenizer.pad_token`, must be set. If the processing class has not set a padding token, + `tokenizer.eos_token` will be used as the default. + reward_processing_classes ([`~transformers.PreTrainedTokenizerBase`] or `list[PreTrainedTokenizerBase]`, *optional*): + Processing classes corresponding to the reward functions specified in `reward_funcs`. Can be either: + + - A single processing class: Used when `reward_funcs` contains only one reward function. + - A list of processing classes: Must match the order and length of the reward functions in `reward_funcs`. + If set to `None`, or if an element of the list corresponding to a [`~transformers.PreTrainedModel`] is + `None`, the tokenizer for the model is automatically loaded using + [`~transformers.AutoTokenizer.from_pretrained`]. For elements in `reward_funcs` that are custom reward + functions (not [`~transformers.PreTrainedModel`]), the corresponding entries in `reward_processing_classes` + are ignored. + callbacks (list of [`~transformers.TrainerCallback`], *optional*): + List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed + in [here](https://huggingface.co/docs/transformers/main_classes/callback). + + If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`] + method. + optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`): + A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your + model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration used to wrap the model. If `None`, the model is not wrapped. + """ + + _tag_names = ["trl", "rloo"] + _name = "RLOO" + _paper = { + "title": "Back to Basics: Revisiting REINFORCE-Style Optimization for Learning from Human Feedback in LLMs", + "id": "2402.14740", + # docstyle-ignore + "citation": textwrap.dedent("""\ + @inproceedings{ahmadian2024back, + title = {{Back to Basics: Revisiting REINFORCE-Style Optimization for Learning from Human Feedback in LLMs}}, + author = {Arash Ahmadian and Chris Cremer and Matthias Gall{\'{e}} and Marzieh Fadaee and Julia Kreutzer and Olivier Pietquin and Ahmet {\"{U}}st{\"{u}}n and Sara Hooker}, + year = 2024, + booktitle = {Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), {ACL} 2024, Bangkok, Thailand, August 11-16, 2024}, + pages = {12248--12267}, + publisher = {Association for Computational Linguistics}, + editor = {Lun{-}Wei Ku and Andre Martins and Vivek Srikumar}, + }"""), + } + + def __init__( + self, + model: "str | PreTrainedModel | PeftModel", + reward_funcs: RewardFunc | list[RewardFunc], + args: RLOOConfig | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + reward_processing_classes: PreTrainedTokenizerBase | list[PreTrainedTokenizerBase] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + peft_config: "PeftConfig | None" = None, + ): + # Args + if args is None: + model_name = model if isinstance(model, str) else get_config_model_id(model.config) + model_name = model_name.split("/")[-1] + args = RLOOConfig(f"{model_name}-RLOO") + + # Model + if isinstance(model, str): + model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + model = create_model_from_path(model, **model_init_kwargs) + else: + if args.model_init_kwargs is not None: + logger.warning( + "You passed `model_init_kwargs` to the `RLOOConfig`, but your model is already instantiated. " + "The `model_init_kwargs` will be ignored." + ) + # Non-quantized models do not have the `is_loaded_in_{8,4}bit` attributes, whereas quantized models do + _is_quantized_model = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False) + + # Some models (SmolVLM/Idefics3) don't support `logits_to_keep` argument and error out if we pass it + # Inspect the forward method before we wrap the model with PEFT + self.model_kwarg_keys = ( + inspect.signature(model.forward).parameters.keys() + if not hasattr(model, "get_base_model") + else inspect.signature(model.get_base_model().forward).parameters.keys() + ) + + # Processing class + if processing_class is None: + processing_class = AutoProcessor.from_pretrained( + get_config_model_id(model.config), + truncation_side="left", + padding_side="left", + trust_remote_code=args.trust_remote_code, + ) + + if args.use_transformers_continuous_batching and isinstance(processing_class, ProcessorMixin): + raise ValueError( + "`use_transformers_continuous_batching` does not support multimodal models. Use `use_vllm` instead." + ) + + # Handle pad token for processors or tokenizers + if isinstance(processing_class, ProcessorMixin): + self._tokenizer = processing_class.tokenizer + elif isinstance(processing_class, PreTrainedTokenizerBase): + self._tokenizer = processing_class + else: + raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`") + + if self._tokenizer.pad_token is None: + self._tokenizer.pad_token = self._tokenizer.eos_token + + # PEFT + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge " + "and unload the existing adapter, save the resulting base model, and then pass that base model along " + "with the new `peft_config` to the trainer." + ) + # Create PEFT model + # ZeRO-3 + PEFT for non-quantized models: + # - PEFT's default autocast_adapter_dtype=True upcasts LoRA adapter params to fp32 even when the base model is bf16. + # - ZeRO-3's _allgather_params_coalesced allocates output buffers using the dtype of the first persistent parameter, + # so mixed-dtype persistent_parameters (bf16 base + fp32 LoRA) cause a TypeError on the first optimizer step. + # - Passing autocast_adapter_dtype=False keeps adapter params in the base model dtype (bf16), fixing the mismatch. + # - This is safe: the fp32 upcast is a QLoRA-specific concern (low-bit quantized base models), not needed for + # non-quantized bf16 training. + # - See: + # - TRL issue: https://github.com/huggingface/trl/issues/6089 + # - Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/8072 + # - autocast_adapter_dtype was introduced in PEFT 0.12.0; before, no upcast existed: no need to pass the kwarg + get_peft_model_kwargs = {} + if ( + args.deepspeed_plugin is not None + and args.deepspeed_plugin.zero_stage == 3 + and not _is_quantized_model + and Version(peft.__version__) >= Version("0.12.0") + ): + get_peft_model_kwargs["autocast_adapter_dtype"] = False + model = get_peft_model(model, peft_config, **get_peft_model_kwargs) + + elif is_peft_model(model): + # If the model is a PEFT model with a pretrained adapter, we need to create a "ref" adapter that is a copy + # of the "default" adapter, so that we can use it as the reference model during the training. PEFT only + # supports one adapter per model when the LoRA config uses `target_parameters` (see peft#3340), so in that + # case we skip the "ref" adapter and compute the reference log probs with adapters disabled, i.e. with the + # base model. + default_config = model.peft_config["default"] + if isinstance(default_config, LoraConfig) and default_config.target_parameters: + logger.warning( + "PEFT can't add a frozen reference adapter alongside one that uses `target_parameters` " + "(peft#3340), so the reference log probs are computed from the base model (adapters disabled). " + "If you wrapped the model only to apply LoRA, pass a `peft_config` to the trainer instead; if you " + "wrapped it deliberately (pretrained adapter or custom init), note that the base model matches " + "your adapter only when it's freshly zero-initialized. If it is, this warning is safe to ignore." + ) + else: + model.add_adapter("ref", default_config) + for name, param in model.named_parameters(): + if ".default." in name: + ref_name = name.replace(".default.", ".ref.") + ref_param = model.get_parameter(ref_name) + ref_param.data.copy_(param.data) + + # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally + # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489 + if is_peft_model(model) and args.gradient_checkpointing: + model.enable_input_require_grads() + + # When using QLoRA, the PEFT adapter weights are converted to bf16 to follow the recommendations from the + # original paper (see https://huggingface.co/papers/2305.14314, paragraph 3). Normally, this can be done by + # passing `autocast_adapter_dtype=False` to `get_peft_model`, but this option is not yet supported for + # quantized models. See: https://github.com/huggingface/peft/issues/2889 + if _is_quantized_model: + for param in model.parameters(): + if param.requires_grad: + param.data = param.data.to(torch.bfloat16) + + # Reward functions + if not isinstance(reward_funcs, list): + reward_funcs = [reward_funcs] + self.reward_func_names = [] + for i, reward_func in enumerate(reward_funcs): + if isinstance(reward_func, str): + model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + reward_funcs[i] = AutoModelForSequenceClassification.from_pretrained( + reward_func, num_labels=1, **model_init_kwargs + ) + if isinstance(reward_funcs[i], nn.Module): # Use Module over PretrainedModel for compat w/ compiled models + self.reward_func_names.append(get_config_model_id(reward_funcs[i].config).split("/")[-1]) + else: + self.reward_func_names.append(reward_funcs[i].__name__) + self.reward_funcs = reward_funcs + + self._has_async_funcs = any(inspect.iscoroutinefunction(func) for func in self.reward_funcs) + if self._has_async_funcs: + self.async_loop_thread, self.async_loop, self.async_loop_ready_event = start_event_loop_in_daemon( + name="RLOOTrainer-AsyncRewardLoop" + ) + # wait until the event loop is running in the daemon thread + self.async_loop_ready_event.wait() + atexit.register(shutdown_event_loop_in_daemon, self.async_loop_thread, self.async_loop) + + # Reward weights + if args.reward_weights is not None: + if len(args.reward_weights) != len(reward_funcs): + raise ValueError( + f"Number of reward weights ({len(args.reward_weights)}) must match number of reward " + f"functions ({len(reward_funcs)})" + ) + self.reward_weights = torch.tensor(args.reward_weights, dtype=torch.float32) + else: + self.reward_weights = torch.ones(len(reward_funcs), dtype=torch.float32) + + # Reward processing class + if reward_processing_classes is None: + reward_processing_classes = [None] * len(reward_funcs) + elif not isinstance(reward_processing_classes, list): + reward_processing_classes = [reward_processing_classes] + if len(reward_processing_classes) != len(reward_funcs): + raise ValueError( + f"The number of reward processing classes ({len(reward_processing_classes)}) must match the number of " + f"reward functions ({len(reward_funcs)})." + ) + + for i, (reward_processing_class, reward_func) in enumerate( + zip(reward_processing_classes, reward_funcs, strict=True) + ): + if isinstance(reward_func, PreTrainedModel): + if reward_processing_class is None: + reward_processing_class = AutoTokenizer.from_pretrained( + get_config_model_id(reward_func.config), trust_remote_code=args.trust_remote_code + ) + if reward_processing_class.pad_token_id is None: + reward_processing_class.pad_token = reward_processing_class.eos_token + # The reward model computes the reward for the latest non-padded token in the input sequence. + # So it's important to set the pad token ID to the padding token ID of the processing class. + reward_func.config.pad_token_id = reward_processing_class.pad_token_id + reward_processing_classes[i] = reward_processing_class + + self.reward_processing_classes = reward_processing_classes + + # Training arguments + self.max_completion_length = args.max_completion_length + self.num_generations = args.num_generations + self.num_generations_eval = args.num_generations_eval or self.num_generations + self.chat_template_kwargs = args.chat_template_kwargs or {} + self.temperature = args.temperature + self.top_p = args.top_p + self.top_k = args.top_k + self.min_p = args.min_p + self.repetition_penalty = args.repetition_penalty + self.use_transformers_continuous_batching = args.use_transformers_continuous_batching + if self.use_transformers_continuous_batching: + if not Version(transformers.__version__) >= Version("5.8.0"): + raise ImportError( + "Using `use_transformers_continuous_batching` requires transformers>=5.8.0. " + "Please upgrade with `pip install --upgrade transformers`." + ) + from transformers.generation import ContinuousBatchingConfig + + cb_kwargs = dict(args.transformers_continuous_batching_config or {}) + # The transformers default (0.9) leaves almost no VRAM for the training backward pass; + # use a training-aware default unless the user has set it explicitly. + cb_kwargs.setdefault("max_memory_percent", 0.5) + self.continuous_batching_config = ContinuousBatchingConfig(**cb_kwargs) + else: + self.continuous_batching_config = None + self.pad_to_multiple_of = args.pad_to_multiple_of + self.use_vllm = args.use_vllm + self.vllm_mode = args.vllm_mode + self.vllm_gpu_memory_utilization = args.vllm_gpu_memory_utilization # only applies to colocation mode + self.vllm_tensor_parallel_size = args.vllm_tensor_parallel_size # only applies to colocation mode + self.normalize_advantages = args.normalize_advantages + self.mask_truncated_completions = args.mask_truncated_completions + self.reward_clip_range = args.reward_clip_range + + # Datasets + self.shuffle_dataset = args.shuffle_dataset + + if train_dataset is None: + raise ValueError("`train_dataset` is required") + elif ( + isinstance(train_dataset, IterableDataset) + or isinstance(eval_dataset, IterableDataset) + or ( + isinstance(eval_dataset, dict) and any(isinstance(ds, IterableDataset) for ds in eval_dataset.values()) + ) + ): + # See https://github.com/huggingface/trl/issues/3213 + raise NotImplementedError( + "Iterable datasets are not yet supported in RLOOTrainer. Please use a standard dataset instead." + ) + + # Multi-step + self.num_iterations = args.num_iterations + self.epsilon_low = args.epsilon + self.epsilon_high = args.epsilon_high if args.epsilon_high is not None else args.epsilon + + # MoE load-balancing auxiliary loss, applied to Mixture-of-Experts models (no effect otherwise) + text_config = model.config.get_text_config() + is_moe = getattr(text_config, "output_router_logits", None) is not None + self.aux_loss_enabled = is_moe and args.router_aux_loss_coef != 0.0 + self.router_aux_loss_coef = args.router_aux_loss_coef + # Tracks the number of iterations (forward + backward passes), including those within a grad accum cycle + self._step = 0 + # Buffer the batch to reuse generated outputs across multiple updates. For more details, see + # `_get_train_sampler` and `_prepare_inputs`. + self._buffered_inputs = None + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=identity, # No data collation is needed in RLOO + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + callbacks=callbacks, + optimizers=optimizers, + ) + + # Reference model + self.beta = args.beta + if self.beta == 0.0: + # If beta is 0.0, the reference model is not needed + self.ref_model = None + elif is_peft_model(model): + # If PEFT is used, the reference model is not needed since the adapter can be disabled + # to revert to the initial model. + self.ref_model = None + else: + # For deepspeed, fsdp or non-distributed models, create a reference model from scratch + model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if self.args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + self.ref_model = create_model_from_path(get_config_model_id(self.model.config), **model_init_kwargs) + + # Disable dropout in the models + if args.disable_dropout: + disable_dropout_in_model(model) + if self.ref_model is not None: + disable_dropout_in_model(self.ref_model) + + # Initialize the metrics + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + self._total_train_tokens = 0 + self._current_train_step_time = 0.0 + self.log_completions = args.log_completions + self.log_unique_prompts = args.log_unique_prompts + self.num_completions_to_print = args.num_completions_to_print + # Keep logs sized to the generation batch to record only outputs from the latest model update. + self._logs = { + "images": deque(maxlen=args.generation_batch_size), + "prompt": deque(maxlen=args.generation_batch_size), + "completion": deque(maxlen=args.generation_batch_size), + "rewards": defaultdict(lambda: deque(maxlen=args.generation_batch_size)), + "advantages": deque(maxlen=args.generation_batch_size), + "extra": defaultdict(lambda: deque(maxlen=args.generation_batch_size)), + } + # Buffers for user-logged data from reward functions, flushed after gathering + self._pending_extra_logs = defaultdict(list) + self._pending_metrics = defaultdict(list) + + # Ensure each process receives a unique seed to prevent duplicate completions when generating with + # transformers if num_generations exceeds per_device_train_batch_size. We could skip it if we use vLLM, but + # it's safer to set it in all cases. + set_seed(args.seed, device_specific=True) + + if self.use_vllm: + # Initialize vLLM generation backend + self.vllm_generation = VLLMGeneration( + model=self.model, + accelerator=self.accelerator, + processing_class=self.processing_class, + # vLLM configuration + mode=args.vllm_mode, + structured_outputs_regex=args.vllm_structured_outputs_regex, + # Server mode configuration + server_base_url=args.vllm_server_base_url, + server_host=args.vllm_server_host, + server_port=args.vllm_server_port, + group_port=args.vllm_group_port, + server_timeout=args.vllm_server_timeout, + # Colocate mode configuration + tensor_parallel_size=args.vllm_tensor_parallel_size, + gpu_memory_utilization=args.vllm_gpu_memory_utilization, + max_model_length=args.vllm_max_model_length, + max_num_seqs=args.per_device_train_batch_size + * args.vllm_tensor_parallel_size + * args.steps_per_generation, + enable_sleep_mode=args.vllm_enable_sleep_mode, + model_impl=args.vllm_model_impl, + # Generation configuration + repetition_penalty=self.repetition_penalty, + temperature=self.temperature, + top_p=self.top_p, + top_k=self.top_k, + min_p=self.min_p, + max_completion_length=self.max_completion_length, + logprobs=None, # we don't need logprobs from vLLM in RLOO + generation_kwargs=args.generation_kwargs, + ) + self._last_loaded_step = -1 # tag to avoid useless loading during grad accumulation + else: + generation_kwargs = { + "max_new_tokens": self.max_completion_length, + "do_sample": True, + "pad_token_id": self._tokenizer.pad_token_id, + "bos_token_id": self._tokenizer.bos_token_id, + "eos_token_id": self._tokenizer.eos_token_id, + "temperature": self.temperature, + "top_p": self.top_p, + "top_k": self.top_k, + "min_p": self.min_p, + "repetition_penalty": self.repetition_penalty, + "cache_implementation": args.cache_implementation, + } + if args.generation_kwargs is not None: + generation_kwargs.update(args.generation_kwargs) + self.generation_config = GenerationConfig(**generation_kwargs, disable_compile=True) + # Keep training-specific generation kwargs to overwrite model's original generation config + self.generation_kwargs = generation_kwargs + + # Gradient accumulation requires scaled loss. Normally, loss scaling in the parent class depends on whether the + # model accepts loss-related kwargs. Since we compute our own loss, this check is irrelevant. We set + # self.model_accepts_loss_kwargs to False to enable scaling. + self.model_accepts_loss_kwargs = False + self._dist = DistributedBackend(self.accelerator) + + # Add tags to the model + self.model.add_model_tags(self._tag_names) + + if self.ref_model is not None: + if self.is_deepspeed_enabled: + self.ref_model = prepare_deepspeed(self.ref_model, self.accelerator) + elif self.is_fsdp_enabled: + self.ref_model = prepare_fsdp(self.ref_model, self.accelerator) + else: + self.ref_model = self.accelerator.prepare_model(self.ref_model, evaluation_mode=True) + + if args.sync_ref_model: + if self.beta == 0.0: + raise ValueError( + "You passed `sync_ref_model=True` while `beta=0.0`, which means the reference model is not used " + "during training. Consequently, RLOOTrainer does not create a `ref_model` instance, and there is " + "nothing to synchronize. Please set `sync_ref_model=False`, or set `beta` to a non-zero value." + ) + if is_peft_model(model): + raise NotImplementedError( + "You passed `sync_ref_model=True` while using a PEFT model, which is currently not supported. " + "With PEFT, RLOOTrainer does not keep a separate reference model in memory; instead, it recovers " + "reference behavior by temporarily disabling the adapter. As a result, there is no standalone " + "`ref_model` instance to synchronize. Use `sync_ref_model=False`, or opt for full fine-tuning if " + "you need a synced reference model. If you need `sync_ref_model` to work with PEFT, please open a " + "feature request at https://github.com/huggingface/trl/issues." + ) + self.add_callback(SyncRefModelCallback(ref_model=self.ref_model, accelerator=self.accelerator)) + + for i, reward_func in enumerate(self.reward_funcs): + if isinstance(reward_func, PreTrainedModel): + if self.is_deepspeed_enabled: + self.reward_funcs[i] = prepare_deepspeed(reward_func, self.accelerator) + else: + # set device placement to True to make `prepare_model` move `reward_func` to device when using fsdp + self.reward_funcs[i] = self.accelerator.prepare_model( + reward_func, evaluation_mode=True, device_placement=True + ) + + def _set_signature_columns_if_needed(self): + # If `self.args.remove_unused_columns` is True, non-signature columns are removed. + # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids" + # and "attention_mask"). In RLOOTrainer, we preprocess data, so using the model's signature columns doesn't + # work. Instead, we set them to the columns expected by the `training_step` method, hence the override. + if self._signature_columns is None: + self._signature_columns = ["prompt", "image", "images"] + + # This method overrides `Trainer.get_train_dataloader` to support our custom batching strategy. + # Instead of returning a standard per-step batch (i.e., `per_device_batch_size), our dataloader loads an + # *generation* batch (i.e., `per_device_batch_size × steps_per_generation`). This allows us to generate completions + # once every steps_per_generation step—rather than once per accumulation step—which is significantly more + # efficient. The only change from the original implementation is multiplying the batch size by + # `steps_per_generation`. Thus, `_prepare_inputs` is called with this *generation* batch, and it handles the + # splitting internally. + # Maintenance note: This method is a copy-paste of the original `Trainer.get_train_dataloader` with only one line + # modification. + def get_train_dataloader(self): + return self._get_dataloader( + dataset=self.train_dataset, + description="Training", + batch_size=self._train_batch_size * self.args.steps_per_generation, # < this is the change + sampler_fn=self._get_train_sampler, + is_training=True, + ) + + def _get_train_sampler(self, dataset: Dataset | None = None) -> Sampler: + # Returns a sampler that + # 1. ensures each prompt is repeated across multiple processes. This guarantees that identical prompts are + # distributed to different GPUs, allowing rewards to be computed and normalized correctly within each prompt + # group. Using the same seed across processes ensures consistent prompt assignment, preventing discrepancies + # in group formation. + # 2. repeats the batch multiple times to allow reusing generations across multiple updates. Refer to + # _prepare_inputs to see how the generations are stored and reused. + + # In the following figure, the values are the prompt indices. The first row shows the first sampled batch, the + # second row shows the second sampled batch, and so on. + # + # | GPU 0 | GPU 1 | + # + # global_step step <-───> num_generations=2 + # <-───────> per_device_train_batch_size=3 + # grad_accum ▲ ▲ 0 0 0 0 1 1 2 2 <- Generate for the first `steps_per_generation` (prompts 0 to 11); store the completions; use the first slice to compute the loss + # =2 ▼ | 0 1 3 3 4 4 5 5 <- Take the stored generations and use the second slice to compute the loss + # | + # | 1 2 6 6 7 7 8 8 <- Take the stored generations and use the third slice to compute the loss + # steps_per_gen=4 ▼ 1 3 9 9 10 10 11 11 <- Take the stored generations and use the fourth slice to compute the loss + # + # 2 4 12 12 13 13 14 14 <- Generate for the second `steps_per_generation` (prompts 12 to 23); store the completions; use the first slice to compute the loss + # 2 5 15 15 16 16 17 17 <- Take the stored generations and use the second slice to compute the loss + # ... + if dataset is None: + dataset = self.train_dataset + return RepeatSampler( + data_source=dataset, + mini_repeat_count=self.num_generations, + batch_size=self.args.generation_batch_size // self.num_generations, + repeat_count=self.num_iterations * self.args.steps_per_generation, + shuffle=self.shuffle_dataset, + seed=self.args.seed, + ) + + def _get_eval_sampler(self, eval_dataset) -> Sampler: + # See _get_train_sampler for an explanation of the sampler. + return RepeatSampler( + data_source=eval_dataset, + mini_repeat_count=self.num_generations_eval, + seed=self.args.seed, + ) + + @profiling_decorator + def _get_per_token_logps_and_entropies( + self, + model, + input_ids, + attention_mask, + logits_to_keep, + batch_size=None, + compute_entropy=False, + compute_aux_loss=False, + pixel_values=None, + image_grid_thw=None, + num_images=None, + pixel_attention_mask=None, + image_sizes=None, + token_type_ids=None, + mm_token_type_ids=None, + image_position_ids=None, + ) -> tuple[torch.Tensor, torch.Tensor | None, torch.Tensor | None]: + """Compute log-probs, (optionally) entropies, and (optionally) the MoE load-balancing aux loss.""" + batch_size = batch_size or input_ids.size(0) # Chunk inputs into smaller batches to reduce memory peak + all_logps = [] + all_entropies = [] + all_aux_losses = [] + for start in range(0, input_ids.size(0), batch_size): + input_ids_batch = input_ids[start : start + batch_size] + attention_mask_batch = attention_mask[start : start + batch_size] + + # Build model inputs + model_inputs = {"input_ids": input_ids_batch, "attention_mask": attention_mask_batch} + if image_grid_thw is not None and pixel_values is not None: + rows_per_image = image_grid_thw.prod(dim=-1) + rows_per_sample = torch.split(rows_per_image, num_images) + rows_per_sample = torch.stack([s.sum() for s in rows_per_sample]) + cum_rows = torch.cat([torch.tensor([0], device=rows_per_sample.device), rows_per_sample.cumsum(0)]) + row_start, row_end = cum_rows[start].item(), cum_rows[start + batch_size].item() + model_inputs["pixel_values"] = pixel_values[row_start:row_end] + cum_imgs = torch.tensor([0] + num_images).cumsum(0) + img_start, img_end = cum_imgs[start], cum_imgs[start + batch_size] + model_inputs["image_grid_thw"] = image_grid_thw[img_start:img_end] + elif image_position_ids is not None and pixel_values is not None: + cum_imgs = torch.tensor([0] + num_images).cumsum(0) + img_start, img_end = cum_imgs[start], cum_imgs[start + batch_size] + model_inputs["pixel_values"] = pixel_values[img_start:img_end] + model_inputs["image_position_ids"] = image_position_ids[img_start:img_end] + elif pixel_values is not None: + model_inputs["pixel_values"] = pixel_values[start : start + batch_size] + if pixel_attention_mask is not None: + model_inputs["pixel_attention_mask"] = pixel_attention_mask[start : start + batch_size] + if image_sizes is not None: + model_inputs["image_sizes"] = image_sizes[start : start + batch_size] + if token_type_ids is not None: + model_inputs["token_type_ids"] = token_type_ids[start : start + batch_size] + if mm_token_type_ids is not None: + model_inputs["mm_token_type_ids"] = mm_token_type_ids[start : start + batch_size] + + # Only add logits_to_keep if the model supports it + if "logits_to_keep" in self.model_kwarg_keys: + # We add 1 to `logits_to_keep` because the last logits of the sequence is later excluded + model_inputs["logits_to_keep"] = logits_to_keep + 1 + + model_inputs["use_cache"] = False # only used in generation; set False to suppress warnings + + # MoE models: request router logits so the model returns `outputs.aux_loss`. VLM wrappers honor this only + # as a forward kwarg (not from the model config), so it must be passed here. + if compute_aux_loss: + model_inputs["output_router_logits"] = True + + outputs = model(**model_inputs) + logits = outputs.logits + # Exclude the last value: it corresponds to the next token pred + logits = logits[:, :-1, :] # (B, L-1, H) + # Only keep the last logits_to_keep. For model that support logits_to_keep, this is a no-op. + logits = logits[:, -logits_to_keep:, :] # (B, logits_to_keep, H) + # Divide logits by sampling temperature. + # See https://huggingface.co/blog/the_n_implementation_details_of_rlhf_with_ppo#policy-training-implementation-details + logits.div_(self.temperature) + completion_ids = input_ids_batch[:, -logits_to_keep:] + logps = selective_log_softmax(logits, completion_ids) # compute logprobs + all_logps.append(logps) + + if compute_entropy: + with torch.no_grad(): + entropies = entropy_from_logits(logits) + all_entropies.append(entropies) + + if compute_aux_loss: + all_aux_losses.append(outputs.aux_loss) + + logps = torch.cat(all_logps, dim=0) + entropies = torch.cat(all_entropies, dim=0) if compute_entropy else None + aux_loss = torch.stack(all_aux_losses).mean() if compute_aux_loss else None + return logps, entropies, aux_loss + + def training_step(self, model, inputs, num_items_in_batch): + time_before = time.perf_counter() + output = super().training_step(model, inputs, num_items_in_batch) + self._step += 1 + time_after = time.perf_counter() + self._current_train_step_time += time_after - time_before + if self._step % self.current_gradient_accumulation_steps == 0: + self._metrics["train"]["step_time"].append(self._current_train_step_time) + self._current_train_step_time = 0.0 + return output + + @profiling_decorator + def _prepare_inputs(self, generation_batch: dict[str, torch.Tensor | Any]) -> dict[str, torch.Tensor | Any]: + # Prepares inputs for model training/evaluation by managing completion generation and batch handling. + # During training: + # - Receives the local generation batch (Per-GPU batch size × steps per generation) + # from the modified training dataloader instead of the standard local batch + # - Generates completions once for the entire generation batch and splits it into batches of size + # `per_device_train_batch_size` + # - Buffers these completions and returns the appropriate slice for the current accumulation step + # - Optimizes by regenerating completions only periodically (every steps_per_generation * num_iterations) + # During evaluation: + # - The input is treated as a standard local batch (no accumulation, no multiple iterations) + # - Completions are generated for each batch without buffering or reuse + # Returns a single local batch in both cases. + + mode = "train" if self.model.training else "eval" + if mode == "train": + generate_every = self.args.steps_per_generation * self.num_iterations + if self._step % generate_every == 0 or self._buffered_inputs is None: + # self._buffered_inputs=None can occur when resuming from a checkpoint + generation_batch = self._generate_and_score_completions(generation_batch) + generation_batch = split_pixel_values_by_grid(generation_batch) + generation_batch = shuffle_sequence_dict(generation_batch) + generation_batches = split_tensor_dict(generation_batch, self.args.steps_per_generation) + self._buffered_inputs = [unsplit_pixel_values_by_grid(batch) for batch in generation_batches] + inputs = self._buffered_inputs[self._step % self.args.steps_per_generation] + else: + # In evaluation, there is neither batch grouping for generation, nor multiple iterations, hence + # local generation batch == local eval batch + inputs = self._generate_and_score_completions(generation_batch) + return inputs + + def _log_completion_extra(self, column: str, values: list): + """ + Log extra columns to the completions table. Called from reward functions via the `log_extra` kwarg. + + Args: + column (`str`): + Name of the column to add. + values (`list`): + Values for the column, one per sample in the batch. + """ + self._pending_extra_logs[column].extend(values) + + def _log_metric(self, name: str, value: float): + """ + Log a scalar metric from a reward function. Called via the `log_metric` kwarg. Values are averaged over each + logging step and reported alongside built-in metrics like `kl` and `entropy`. + + Args: + name (`str`): + Name of the metric. + value (`float`): + Scalar value for this batch. + """ + self._pending_metrics[name].append(value) + + @profiling_decorator + def _calculate_rewards(self, inputs, prompts, completions, completion_ids_list): + device = self.accelerator.device + rewards_per_func = torch.zeros(len(prompts), len(self.reward_funcs), device=device) + + # Repeat all input columns (but "prompt", "completion", and "completion_ids") to match the num of generations + keys = [key for key in inputs[0] if key not in ["prompt", "completion", "completion_ids"]] + reward_kwargs = {key: [example[key] for example in inputs] for key in keys} + + # This allows for dynamic reward shaping based on training progress. + reward_kwargs["trainer_state"] = self.state + + # Allow reward functions to log extra columns to the completions table. + reward_kwargs["log_extra"] = self._log_completion_extra + + # Allow reward functions to log additional scalar metrics. + reward_kwargs["log_metric"] = self._log_metric + + async_funcs_info = [] # async custom functions for asyncio.gather + + for i, (reward_func, reward_processing_class, reward_func_name) in enumerate( + zip(self.reward_funcs, self.reward_processing_classes, self.reward_func_names, strict=True) + ): + if isinstance(reward_func, nn.Module): # Module (no PretrainedModel) for compat with compiled models + with profiling_context(self, reward_func_name): + if is_conversational(inputs[0]): + messages = [{"messages": p + c} for p, c in zip(prompts, completions, strict=True)] + texts = [ + apply_chat_template(x, reward_processing_class, **self.chat_template_kwargs)["text"] + for x in messages + ] + else: + texts = [p + c for p, c in zip(prompts, completions, strict=True)] + reward_inputs = reward_processing_class( + text=texts, return_tensors="pt", padding=True, padding_side="right", add_special_tokens=False + ) + reward_inputs = super()._prepare_inputs(reward_inputs) + with torch.inference_mode(): + rewards_per_func[:, i] = reward_func(**reward_inputs).logits[:, 0] # Shape (B*G,) + elif inspect.iscoroutinefunction(reward_func): # Separate async reward funcs to run them in parallel later + async_funcs_info.append((i, reward_func, reward_func_name)) + else: + # Run synchronous reward function + with profiling_context(self, reward_func_name): + output_reward_func = reward_func( + prompts=prompts, completions=completions, completion_ids=completion_ids_list, **reward_kwargs + ) + # Convert None values to NaN + output_reward_func = [reward if reward is not None else torch.nan for reward in output_reward_func] + rewards_per_func[:, i] = torch.tensor(output_reward_func, dtype=torch.float32, device=device) + + # Execute async custom functions in parallel using asyncio.gather + if async_funcs_info: + + async def _invoke_async(index, func, func_name): + with profiling_context(self, func_name): + output = await func( + prompts=prompts, completions=completions, completion_ids=completion_ids_list, **reward_kwargs + ) + output = [r if r is not None else torch.nan for r in output] + return index, output + + async def _run_async_funcs(): + coros = [_invoke_async(i, func, func_name) for (i, func, func_name) in async_funcs_info] + return await asyncio.gather(*coros) + + async_results = asyncio.run_coroutine_threadsafe(_run_async_funcs(), self.async_loop).result() + for idx, output_reward_func in async_results: + rewards_per_func[:, idx] = torch.tensor(output_reward_func, dtype=torch.float32, device=device) + + # If all reward functions return None for a given row, issue a detailed warning + if torch.isnan(rewards_per_func).all(dim=1).any(): + nan_row_idx = torch.isnan(rewards_per_func).all(dim=1).nonzero(as_tuple=True)[0][0] + row_reward_kwargs = { + key: value[nan_row_idx] + for key, value in reward_kwargs.items() + if key not in ("trainer_state", "log_extra", "log_metric") + } + row_reward_kwargs["prompt"] = prompts[nan_row_idx] + row_reward_kwargs["completion"] = completions[nan_row_idx] + logger.warning( + f"All reward functions returned None for the following kwargs:\n{row_reward_kwargs}\n" + "Please ensure that at least one reward function returns a valid reward." + ) + + # Gather the reward per function: this part is crucial, because the rewards are normalized per group and the + # completions may be distributed across processes + rewards_per_func = gather(rewards_per_func) + return rewards_per_func + + def _tokenize_prompts(self, prompts: list): + """Tokenize prompts and extract images/multimodal fields for generation.""" + if is_conversational({"prompt": prompts[0]}): + # Extract images from messages for VLM support + images = [] + has_images = False + for prompt in prompts: + prompt_images = [] + for message in prompt: + if isinstance(message["content"], list): + for part in message["content"]: + if part["type"] == "image": + prompt_images.append(part["image"]) + has_images = True + images.append(prompt_images if prompt_images else None) + images = images if has_images else None + + # Workaround for a bug in transformers 5.3.0 where some processors (e.g. Qwen2.5-VL) crash on + # batched unpadded input (transformers#44514). + # Fixed in transformers 5.4.0 (transformers#44563). + needs_padding_workaround = Version("5.3.0") <= Version(transformers.__version__) < Version("5.4.0") + tokenized = self.processing_class.apply_chat_template( + conversation=prompts, + add_generation_prompt=True, + tokenize=True, + return_dict=True, + **({"padding": True} if needs_padding_workaround else {}), + **self.chat_template_kwargs, + ) + if needs_padding_workaround: + # Unpad input_ids: remove padding tokens using attention_mask to get per-sequence lists + prompt_ids = [ + [tok for tok, m in zip(ids, mask, strict=True) if m] + for ids, mask in zip(tokenized["input_ids"], tokenized["attention_mask"], strict=True) + ] + else: + prompt_ids = tokenized["input_ids"] + # For VLMs, the processor returns extra multimodal fields (pixel_values, image_grid_thw, etc.) + multimodal_fields = {k: v for k, v in tokenized.items() if k not in ("input_ids", "attention_mask")} + else: + prompt_ids = self.processing_class(text=prompts)["input_ids"] + images = None + multimodal_fields = {} + return prompt_ids, images, multimodal_fields + + def _generate_single_turn(self, prompt_ids, images, multimodal_fields): + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + + # Generate completions using either vLLM or regular generation + if self.use_vllm: + # Sync weights if training step changed + if self.state.global_step != self._last_loaded_step: + with profiling_context(self, "sync_weights"): + self.vllm_generation.sync_weights() + self._last_loaded_step = self.state.global_step + + # Generate using vLLM (note: RLOO doesn't use logprobs from generation, so we ignore them) + num_generations = self.num_generations if mode == "train" else self.num_generations_eval + _, completion_ids, _, _ = self.vllm_generation.generate( + prompts=prompt_ids, + images=images, + num_generations=num_generations, + profiler=profiling_context(self, "vLLM.generate"), + ) + + elif self.use_transformers_continuous_batching: + with ( + profiling_context(self, "transformers.generate_batch"), + unwrap_model_for_generation( + self.model_wrapped, self.accelerator, gather_deepspeed3_params=self.args.ds3_gather_for_generation + ) as unwrapped_model, + torch.no_grad(), + self._dist.summon_full_params(self.model_wrapped, recurse=False), + ): + # Cast to the appropriate dtype based on training configuration + if self.args.bf16: + unwrapped_model.to(torch.bfloat16) + elif self.args.fp16: + unwrapped_model.to(torch.float16) + all_outputs = unwrapped_model.generate_batch( + prompt_ids, + generation_config=self.generation_config, + continuous_batching_config=self.continuous_batching_config, + progress_bar=False, + ) + unwrapped_model.train() + completion_ids = [output.generated_tokens for output in all_outputs.values()] + + else: + # Regular generation path: left-pad token IDs into tensors + prompt_tensors = [torch.tensor(ids) for ids in prompt_ids] + padded_ids = pad(prompt_tensors, padding_value=self._tokenizer.pad_token_id, padding_side="left") + attention_mask = pad([torch.ones_like(t) for t in prompt_tensors], padding_value=0, padding_side="left") + generate_inputs = {"input_ids": padded_ids, "attention_mask": attention_mask} + # For VLMs, include multimodal fields as tensors (pixel_values, image_grid_thw, etc.) + for k, v in multimodal_fields.items(): + if isinstance(v, torch.Tensor): + generate_inputs[k] = v + elif isinstance(v, list) and v and isinstance(v[0], list): + # Per-token field (e.g., token_type_ids): left-pad like input_ids + generate_inputs[k] = pad([torch.tensor(x) for x in v], padding_value=0, padding_side="left") + else: + generate_inputs[k] = torch.tensor(np.array(v)) + generate_inputs = super()._prepare_inputs(generate_inputs) + + with ( + profiling_context(self, "transformers.generate"), + unwrap_model_for_generation( + self.model_wrapped, + self.accelerator, + gather_deepspeed3_params=self.args.ds3_gather_for_generation, + generation_kwargs=self.generation_kwargs, # Override model.generation_config with generation_kwargs to fix transformers#42762 + ) as unwrapped_model, + torch.no_grad(), + self._dist.summon_full_params(self.model_wrapped, recurse=False), + ): + prompt_completion_ids = unwrapped_model.generate( + **generate_inputs, generation_config=self.generation_config + ) + # Compute prompt length and extract completion ids + prompt_length = generate_inputs["input_ids"].size(1) + completion_ids = prompt_completion_ids[:, prompt_length:] + + # Mask everything after the first EOS token + is_eos = completion_ids == self._tokenizer.eos_token_id + eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device) + eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)] + sequence_indices = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1) + completion_mask = (sequence_indices <= eos_idx.unsqueeze(1)).int() + completion_ids = [ + c[m].tolist() for c, m in zip(completion_ids.cpu(), completion_mask.bool().cpu(), strict=True) + ] + + return completion_ids + + def _generate(self, prompts: list): + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + + # Copy the prompts to avoid modifying the original list + prompts = copy.deepcopy(prompts) + + prompt_ids, images, multimodal_fields = self._tokenize_prompts(prompts) + completion_ids = self._generate_single_turn(prompt_ids, images, multimodal_fields) + + # Decode completions. It's important to use `parse_response` when possible, because it handles tool calls. + if is_conversational({"prompt": prompts[0]}): + contents = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + completions = [[{"role": "assistant", "content": content}] for content in contents] + else: + completions = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + + # Get completion length per sequence, used for logging + prompt_lengths = torch.tensor([len(ids) for ids in prompt_ids], device=device) + completion_lengths = torch.tensor([len(ids) for ids in completion_ids], device=device) + agg_prompt_lengths = self.accelerator.gather(prompt_lengths) + agg_completion_lengths = self.accelerator.gather(completion_lengths) + total_prompt_tokens = agg_prompt_lengths.sum() + total_completion_tokens = agg_completion_lengths.sum() # = num_items_in_batch, required for the DAPO loss + + # Log the metrics + if mode == "train": + self.state.num_input_tokens_seen += (total_prompt_tokens + total_completion_tokens).item() + self._metrics[mode]["num_tokens"] = [self.state.num_input_tokens_seen] + + # Log completion lengths, mean, min, max + self._metrics[mode]["completions/mean_length"].append(agg_completion_lengths.float().mean().item()) + self._metrics[mode]["completions/min_length"].append(agg_completion_lengths.float().min().item()) + self._metrics[mode]["completions/max_length"].append(agg_completion_lengths.float().max().item()) + + # Identify sequences that terminated with EOS and log their lengths + eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id] + is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids], device=device) + agg_is_truncated = self.accelerator.gather(is_truncated) + self._metrics[mode]["completions/clipped_ratio"].append(agg_is_truncated.float().mean().item()) + term_completion_lengths = agg_completion_lengths[~agg_is_truncated] + if len(term_completion_lengths) == 0: # edge case where no terminated sequences are found + term_completion_lengths = torch.zeros(1, device=device) + self._metrics[mode]["completions/mean_terminated_length"].append(term_completion_lengths.float().mean().item()) + self._metrics[mode]["completions/min_terminated_length"].append(term_completion_lengths.float().min().item()) + self._metrics[mode]["completions/max_terminated_length"].append(term_completion_lengths.float().max().item()) + + return prompt_ids, completion_ids, completions + + def _generate_and_score_completions( + self, inputs: list[dict[str, torch.Tensor | Any]] + ) -> dict[str, torch.Tensor | Any]: + device = self.accelerator.device + mode = "train" if self.model.training else "eval" + + prompts = [x["prompt"] for x in inputs] + + if "images" in inputs[0]: + images = [example.get("images") for example in inputs] + elif "image" in inputs[0]: + images = [[example.get("image")] if example.get("image") is not None else None for example in inputs] + else: + images = None + # Transformers requires at least one image in the batch, otherwise it throws an error + if images is not None and all(img_list == [] for img_list in images): + images = None + + # If the prompts are conversational and the inputs contain images, we need to convert the prompts from + # [{"role": "user", "content": "What color is the sky?"}] to + # [{"role": "user", "content": [{"type": "image", "image": }, {"type": "text", "text": "What color is the sky?"}]}] + if images is not None: + if not is_conversational(inputs[0]): + raise ValueError( + "Multimodal training requires conversational prompts. It looks like the dataset contains " + "non-conversational inputs, likely because a chat template was applied before passing the dataset " + "to the trainer. Please provide the raw conversational prompts and let the trainer apply the chat " + "template internally." + ) + prompts = [ + prepare_multimodal_messages(prompt, images=image_list) + for prompt, image_list in zip(prompts, images, strict=True) + ] + + prompt_ids_list, completion_ids_list, completions = self._generate(prompts) + + # Convert lists of token IDs to padded tensors + prompt_ids = [torch.tensor(ids) for ids in prompt_ids_list] + prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids] + prompt_ids = pad( + prompt_ids, + padding_value=self._tokenizer.pad_token_id, + padding_side="left", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + prompt_mask = pad( + prompt_mask, padding_value=0, padding_side="left", pad_to_multiple_of=self.pad_to_multiple_of + ).to(device=device) + completion_ids = [torch.tensor(ids) for ids in completion_ids_list] + completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids] + completion_ids = pad( + completion_ids, + padding_value=self._tokenizer.pad_token_id, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ).to(device=device) + completion_mask = pad( + completion_mask, padding_value=0, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of + ).to(device=device) + + # If mask_truncated_completions is enabled, zero out truncated completions in completion_mask + if self.mask_truncated_completions: + eos_and_pad = [self._tokenizer.eos_token_id, self._tokenizer.pad_token_id] + # Mask completion_mask for attention masking + is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device) + completion_mask = completion_mask * (~is_truncated).unsqueeze(1).int() + + # Concatenate prompt_mask with completion_mask for logit computation + prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1) # (B, P+C) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) # (B, P+C) + + logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens + batch_size = self.args.per_device_train_batch_size if mode == "train" else self.args.per_device_eval_batch_size + + num_images = [len(img_list) if img_list else 0 for img_list in images] if images is not None else None + + # Get forward_kwargs for models with multimodal inputs + if images is not None: + prompts_text = [ + apply_chat_template({"prompt": prompt}, self.processing_class, **self.chat_template_kwargs)["prompt"] + for prompt in prompts + ] + prompt_inputs = self.processing_class(images=images, text=prompts_text, padding=True, return_tensors="pt") + prompt_inputs = super()._prepare_inputs(prompt_inputs) + forward_kwargs = {k: v for k, v in prompt_inputs.items() if k not in ["input_ids", "attention_mask"]} + else: + forward_kwargs = {} + + # If token_type_ids are used, extend them with zeros for the completion part + if "token_type_ids" in forward_kwargs: + token_type_ids = forward_kwargs["token_type_ids"] + if self.pad_to_multiple_of is not None: + # Needed only with pad_to_multiple_of: otherwise prompt_ids and token_type_ids must have equal len + padding_size = prompt_ids.size(1) - token_type_ids.size(1) + if padding_size > 0: + token_type_ids = torch.cat( + [token_type_ids.new_zeros((token_type_ids.size(0), padding_size)), token_type_ids], dim=1 + ) + forward_kwargs["token_type_ids"] = torch.cat( + [token_type_ids, token_type_ids.new_zeros(completion_ids.shape)], dim=1 + ) + # If mm_token_type_ids are used, extend them with zeros for the completion part + if "mm_token_type_ids" in forward_kwargs: + mm_token_type_ids = forward_kwargs["mm_token_type_ids"] + if self.pad_to_multiple_of is not None: + # Needed only with pad_to_multiple_of: otherwise prompt_ids and mm_token_type_ids must have equal len + padding_size = prompt_ids.size(1) - mm_token_type_ids.size(1) + if padding_size > 0: + mm_token_type_ids = torch.cat( + [mm_token_type_ids.new_zeros((mm_token_type_ids.size(0), padding_size)), mm_token_type_ids], + dim=1, + ) + forward_kwargs["mm_token_type_ids"] = torch.cat( + [mm_token_type_ids, mm_token_type_ids.new_zeros(completion_ids.shape)], dim=1 + ) + + # When gradient checkpointing is enabled with use_reentrant=True (non default), calling the model inside a + # torch.no_grad() block triggers a harmless PyTorch warning ("None of the inputs have requires_grad=True"). + # Temporarily disable checkpointing to avoid this warning during inference. + with torch.no_grad(), disable_gradient_checkpointing(self.model, self.args.gradient_checkpointing_kwargs): + # Compute the per-token log probabilities for the current model + old_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids + ) + old_logps = (old_per_token_logps * completion_mask).sum(1) # mask out padding and tokens after EOS + + # Compute the per-token log probabilities for the reference model + if self.beta != 0.0: + if self.ref_model is not None: + ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.ref_model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size=batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids + ) + else: + # When training a PEFT adapter, how we obtain the reference depends on the setup: + # - New adapter: disabling adapters yields the base model. + # - Re-training an existing adapter: an initial copy is loaded under the name "ref". + model = self.accelerator.unwrap_model(self.model) + with use_adapter(model, adapter_name="ref" if "ref" in model.peft_config else None): + ref_per_token_logps, _, _ = self._get_per_token_logps_and_entropies( + self.model, + prompt_completion_ids, + attention_mask, + logits_to_keep, + batch_size=batch_size, + num_images=num_images, + **forward_kwargs, # may contain pixel_values, image_grid_thw, pixel_attention_mask, image_sizes, image_position_ids + ) + else: + ref_per_token_logps = None + + # Decode + prompts_text = self.processing_class.batch_decode(prompt_ids, skip_special_tokens=True) + completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True) + + # Calculate rewards for each reward function. rewards_per_func aggregates rewards across all processes. This is + # important because rewards will be normalized per group, and completions are distributed. We will later slice + # rewards_per_func to extract each process's subset. + rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list) + num_generations = self.num_generations if mode == "train" else self.num_generations_eval + + # A completion for which every reward function returned None is unscorable. nansum would collapse it to 0, + # which both biases the leave-one-out baseline and hands the completion a spurious advantage. Mark these rows + # NaN so they're excluded from the (nan-aware) baseline below; their advantage is forced to 0 afterwards. + unscorable_mask = torch.isnan(rewards_per_func).all(dim=1) + + # Apply weights to each reward function's output and sum + rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1) + rewards[unscorable_mask] = torch.nan + + # Apply reward clipping if specified + if self.reward_clip_range: + rewards = rewards.clamp(min=self.reward_clip_range[0], max=self.reward_clip_range[1]) + + # Include the KL penalty in the reward + if self.beta != 0.0: + # RLOO uses the first-order log ratio for the per-token KL estimate, following the original RLOO paper + # (Ahmadian et al., 2024, https://huggingface.co/papers/2405.14782). Unlike GRPOTrainer's Schulman + # approximation (always >= 0), this can be negative per token. The divergence is intentional: RLOO applies + # KL as a reward penalty (summed across tokens per sequence), while GRPO adds it to the per-token loss. + per_token_kl = old_per_token_logps - ref_per_token_logps + # Apply sequence-level KL penalty to rewards (sum KL across tokens first, then apply to each sequence) + kl = (per_token_kl * completion_mask).sum(-1) + kl = gather(kl) # rewards are gathered, so kl must be too + rewards = rewards - self.beta * kl + + grouped_rewards = rewards.view(-1, num_generations) + mean_grouped_rewards = torch.nanmean(grouped_rewards, dim=1) + if num_generations > 1: + std_rewards = nanstd(grouped_rewards, dim=1) + else: # doesn't occur during training, but could occur in eval when num_generations_eval=1 + std_rewards = torch.zeros_like(mean_grouped_rewards) + + # RLOO advantages computation. The leave-one-out baseline averages over scorable siblings only: nansum drops + # unscorable rewards and the divisor is (scorable count − 1). A group with a single scorable completion yields + # 0/0 = NaN, and unscorable rows stay NaN; both are zeroed by nan_to_num below. + scorable_counts = (~torch.isnan(grouped_rewards)).sum(dim=1, keepdim=True) # (num_prompts, 1) + grouped_sum = torch.nansum(grouped_rewards, dim=1, keepdim=True) # (num_prompts, 1) + if num_generations > 1: + baselines = (grouped_sum - grouped_rewards) / (scorable_counts - 1) # (num_prompts, num_generations) + baselines = baselines.view(-1) # Flatten back to match rewards shape + advantages = rewards - baselines + else: # this case doesn't occur during training, but could in eval when num_generations_eval=1 + advantages = torch.zeros_like(rewards) + + # Normalize advantages over the scorable subset only (unscorable advantages are still NaN here). + if self.normalize_advantages: + advantages = (advantages - torch.nanmean(advantages)) / (nanstd(advantages) + 1e-4) + + # Unscorable completions carry no learning signal: zero their advantage to keep them from moving the policy. + advantages = torch.nan_to_num(advantages, nan=0.0) + + is_std_zero = torch.isclose(std_rewards, torch.zeros_like(std_rewards)) # for logging + + # Slice to keep only the local part of the data + process_slice = slice( + self.accelerator.process_index * len(prompts), + (self.accelerator.process_index + 1) * len(prompts), + ) + all_process_advantages = advantages.clone() # keep the aggregated advantages for logging + advantages = advantages[process_slice] + + # Calculate and log the mean KL divergence between current and reference model + if self.beta != 0.0: + mean_kl = (per_token_kl * completion_mask).sum() / completion_mask.sum().clamp(min=1.0) + self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item()) + + # Calculate mean reward per function, but only for samples where the function was applied (non-NaN values) + for i, reward_func_name in enumerate(self.reward_func_names): + mean_rewards = torch.nanmean(rewards_per_func[:, i]).item() + self._metrics[mode][f"rewards/{reward_func_name}/mean"].append(mean_rewards) + std_func_rewards = nanstd(rewards_per_func[:, i]).item() + self._metrics[mode][f"rewards/{reward_func_name}/std"].append(std_func_rewards) + rewards = (rewards_per_func * self.reward_weights.to(rewards_per_func.device).unsqueeze(0)).nansum(dim=1) + rewards[unscorable_mask] = torch.nan # exclude unscorable rows from the logged reward stats + self._metrics[mode]["reward"].append(torch.nanmean(rewards).item()) + self._metrics[mode]["reward_std"].append(nanstd(rewards).item()) + self._metrics[mode]["frac_reward_zero_std"].append(is_std_zero.float().mean().item()) + + # Log prompt and completion texts + self._logs["prompt"].extend(gather_object(prompts_text)) + self._logs["completion"].extend(gather_object(completions_text)) + for i, name in enumerate(self.reward_func_names): + self._logs["rewards"][name].extend(rewards_per_func[:, i].tolist()) + self._logs["advantages"].extend(all_process_advantages.tolist()) + + # Flush user-logged extra columns (from log_extra), gathering across processes. + # Keys must be sorted so that all ranks call gather_object in the same order, otherwise values + # get mis-attributed across columns (dict insertion order may differ between processes). + for column in sorted(self._pending_extra_logs): + self._logs["extra"][column].extend(gather_object(self._pending_extra_logs[column])) + self._pending_extra_logs.clear() + + # Flush user-logged metrics (from log_metric), averaging across processes. + # Keys must be sorted so that all ranks call accelerator.gather in the same order, otherwise values + # get mis-attributed across metrics (dict insertion order may differ between processes). + for name in sorted(self._pending_metrics): + values = self._pending_metrics[name] + local_mean = sum(values) / len(values) + global_mean = self.accelerator.gather(torch.tensor(local_mean, device=device)).mean().item() + self._metrics[mode][name].append(global_mean) + self._pending_metrics.clear() + + if images is not None: + self._logs["images"].extend(gather_object(images)) + + output = { + "prompt_ids": prompt_ids, + "prompt_mask": prompt_mask, + "completion_ids": completion_ids, + "completion_mask": completion_mask, + "old_logps": old_logps, + "advantages": advantages, + } + if "pixel_values" in forward_kwargs: + output["pixel_values"] = forward_kwargs["pixel_values"] + if "image_grid_thw" in forward_kwargs: + output["image_grid_thw"] = forward_kwargs["image_grid_thw"] + if "pixel_attention_mask" in forward_kwargs: + output["pixel_attention_mask"] = forward_kwargs["pixel_attention_mask"] + if "image_sizes" in forward_kwargs: + output["image_sizes"] = forward_kwargs["image_sizes"] + if "token_type_ids" in forward_kwargs: + output["token_type_ids"] = forward_kwargs["token_type_ids"] + if "mm_token_type_ids" in forward_kwargs: + output["mm_token_type_ids"] = forward_kwargs["mm_token_type_ids"] + if "image_position_ids" in forward_kwargs: + output["image_position_ids"] = forward_kwargs["image_position_ids"] + if images is not None: + output["num_images"] = num_images + return output + + @profiling_decorator + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + if return_outputs: + raise ValueError("The RLOOTrainer does not support returning outputs") + return self._compute_loss(model, inputs) + + def _compute_loss(self, model, inputs): + # Compute the per-token log probabilities for the model + prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"] + completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"] + input_ids = torch.cat([prompt_ids, completion_ids], dim=1) + attention_mask = torch.cat([prompt_mask, completion_mask], dim=1) + logits_to_keep = completion_ids.size(1) # we only need to compute the logits for the completion tokens + + # Compute the per_token_logps and the entropy at each position in the completion + per_token_logps, entropies, aux_loss = self._get_per_token_logps_and_entropies( + model, + input_ids, + attention_mask, + logits_to_keep, + compute_entropy=True, + compute_aux_loss=self.aux_loss_enabled, + pixel_values=inputs.get("pixel_values"), + image_grid_thw=inputs.get("image_grid_thw"), + num_images=inputs.get("num_images"), + pixel_attention_mask=inputs.get("pixel_attention_mask"), + image_sizes=inputs.get("image_sizes"), + token_type_ids=inputs.get("token_type_ids"), + mm_token_type_ids=inputs.get("mm_token_type_ids"), + image_position_ids=inputs.get("image_position_ids"), + ) + + logps = (per_token_logps * completion_mask).sum(1) # mask out padding and tokens after EOS + old_logps = inputs["old_logps"] + log_ratio = logps - old_logps + + # Compute the loss + advantages = inputs["advantages"] + coef_1 = torch.exp(log_ratio) + coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high) + per_sequence_loss1 = coef_1 * advantages + per_sequence_loss2 = coef_2 * advantages + per_sequence_loss = -torch.min(per_sequence_loss1, per_sequence_loss2) + loss = per_sequence_loss.mean() + + # Log the metrics + mode = "train" if self.model.training else "eval" + + # RLOO returns an unscaled loss (the HF Trainer divides by gradient accumulation), so add the aux term unscaled + if self.aux_loss_enabled: + loss = loss + self.router_aux_loss_coef * aux_loss + self._metrics[mode]["aux_loss"].append(self.accelerator.gather_for_metrics(aux_loss).mean().item()) + + # Entropy + mean_entropy = (entropies * completion_mask).sum() / completion_mask.sum().clamp(min=1.0) + self._metrics[mode]["entropy"].append(self.accelerator.gather(mean_entropy).nanmean().item()) + + # Compute the clipped probability ratios + is_low_clipped = (coef_1 < 1 - self.epsilon_low) & (advantages < 0) + is_high_clipped = (coef_1 > 1 + self.epsilon_high) & (advantages > 0) + is_region_clipped = is_low_clipped | is_high_clipped + gathered_low_clip = self.accelerator.gather(is_low_clipped.float().mean()) + self._metrics[mode]["clip_ratio/low_mean"].append(gathered_low_clip.nanmean().item()) + self._metrics[mode]["clip_ratio/low_min"].append(nanmin(gathered_low_clip).item()) + gathered_high_clip = self.accelerator.gather(is_high_clipped.float().mean()) + self._metrics[mode]["clip_ratio/high_mean"].append(gathered_high_clip.nanmean().item()) + self._metrics[mode]["clip_ratio/high_max"].append(nanmax(gathered_high_clip).item()) + gathered_clip_ratio = self.accelerator.gather(is_region_clipped.float().mean()) + self._metrics[mode]["clip_ratio/region_mean"].append(gathered_clip_ratio.nanmean().item()) + return loss + + # During eval, Trainer calls prediction_step. If no labels are present in the inputs, it only runs forward and + # returns logits. We override prediction_step to force compute_loss, because this trainer doesn't involve labels. + def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys: list[str] | None = None): + inputs = self._prepare_inputs(inputs) + with torch.no_grad(): + with self.compute_loss_context_manager(): + loss = self.compute_loss(model, inputs) + loss = loss.mean().detach() + return loss, None, None + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + # Average the metrics + metrics = {} + for key, val in self._metrics[mode].items(): + # Filter out NaN values before averaging. A reward function that returns None for all samples + # in a batch produces NaN for that batch's metric. With logging_steps > 1, a naive sum()/len() + # would let a single NaN contaminate valid data from other batches. Only return None when no + # valid values remain (e.g. JSON loggers crash on float NaN). + valid = [v for v in val if not math.isnan(v)] + metrics[key] = sum(valid) / len(valid) if valid else None + + # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs` + # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() + + if self.accelerator.is_main_process and self.log_completions: + if is_rich_available(): + print_prompt_completions_sample( + self._logs["prompt"], + self._logs["completion"], + self._logs["rewards"], + self._logs["advantages"], + self.state.global_step, + self.num_completions_to_print, + extra=dict(self._logs["extra"]), + ) + + logging_backends = [] + if self.args.report_to and "wandb" in self.args.report_to and wandb.run is not None: + logging_backends.append(wandb) + if self.args.report_to and "trackio" in self.args.report_to: + logging_backends.append(trackio) + + table = { + "step": [self.state.global_step] * len(self._logs["prompt"]), + "prompt": self._logs["prompt"], + "completion": self._logs["completion"], + **self._logs["rewards"], + **self._logs["extra"], + "advantage": self._logs["advantages"], + } + + df_base = pd.DataFrame(table) + images_raw = self._logs["images"] or [] + + for logging_backend in logging_backends: + if images_raw: + images = [] + for image_list in self._logs["images"]: + images.append([logging_backend.Image(image) for image in image_list]) + df = pd.concat( + [df_base, pd.Series(images, name="image")], + axis=1, + copy=False, + ) + else: + df = df_base + + if self.log_unique_prompts: + df = df.drop_duplicates(subset=["prompt"]) + + logging_backend.log({"completions": logging_backend.Table(dataframe=df)}) + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/sft_config.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/sft_config.py new file mode 100644 index 0000000000000000000000000000000000000000..de1b554bbbe88d8c1693519f517224c223760b59 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/sft_config.py @@ -0,0 +1,336 @@ +# Copyright 2020-2026 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 warnings +from dataclasses import dataclass, field +from typing import Any + +from .base_config import _BaseConfig + + +@dataclass +class SFTConfig(_BaseConfig): + # docstyle-ignore + r""" + Configuration class for the [`SFTTrainer`]. + + This class includes only the parameters that are specific to SFT training. For a full list of training arguments, + please refer to the [`~transformers.TrainingArguments`] documentation. Note that default values in this class may + differ from those in [`~transformers.TrainingArguments`]. + + 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: + > Parameters that control the model + + model_init_kwargs (`dict[str, Any]`, *optional*): + Keyword arguments for [`~transformers.AutoModelForCausalLM.from_pretrained`], used when the `model` + argument of the [`SFTTrainer`] is provided as a string. + trust_remote_code (`bool`, *optional*, defaults to `False`): + Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to + [`~transformers.AutoModelForCausalLM.from_pretrained`] and + [`~transformers.AutoProcessor.from_pretrained`]. + router_aux_loss_coef (`float`, *optional*, defaults to `0.001`): + Coefficient of the load-balancing auxiliary loss. Only has an effect when training a Mixture-of-Experts + (MoE) model; for other models it does nothing. The auxiliary loss is added to the training loss with this + weight. Set to `0.0` to disable it. + chat_template_path (`str`, *optional*): + If specified, sets the model's chat template. This can either be the path to a tokenizer (local directory + or Hugging Face Hub model) or a direct path to a Jinja template file. When using a Jinja file, you must + ensure that any special tokens referenced in the template are added to the tokenizer and that the model's + embedding layer is resized accordingly. + + > Parameters that control the data preprocessing + + dataset_text_field (`str`, *optional*, defaults to `"text"`): + Name of the column that contains text data in the dataset. + dataset_kwargs (`dict[str, Any]`, *optional*): + Dictionary of optional keyword arguments for the dataset preparation. The only supported key is + `skip_prepare_dataset`. When the model is a VLM, `skip_prepare_dataset` is automatically treated as `True` + regardless of the provided value, since preprocessing is done on the fly. + dataset_num_proc (`int`, *optional*): + Number of processes to use for processing the dataset. + eos_token (`str`, *optional*): + Token used to indicate the end of a turn or sequence. If `None`, it defaults to + `processing_class.eos_token`. + max_length (`int` or `None`, *optional*, defaults to `1024`): + Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from the left + or right depending on `truncation_mode`. If `None`, no truncation is applied. When packing is enabled, + this value sets the sequence length. + truncation_mode (`str`, *optional*, defaults to `"keep_start"`): + Truncation mode to use when the sequence exceeds `max_length`. The only supported value is + `"keep_start"`. The `"keep_end"` value is deprecated and will be removed in v2.0.0. + shuffle_dataset (`bool`, *optional*, defaults to `False`): + Whether to shuffle the dataset. + packing (`bool`, *optional*, defaults to `False`): + Whether to group multiple sequences into fixed-length blocks to improve computational efficiency and reduce + padding. Uses `max_length` to define sequence length. + packing_strategy (`str`, *optional*, defaults to `"bfd"`): + Strategy for packing sequences. Can be `"bfd"` (best-fit decreasing, truncates overflow), `"bfd_split"` + (best-fit decreasing, splits overflow sequences), or `"wrapped"` (aggressive, cuts mid-sequence). + padding_free (`bool`, *optional*, defaults to `False`): + Whether to perform forward passes without padding by flattening all sequences in the batch into a single + continuous sequence. This reduces memory usage by eliminating padding overhead. Currently, this is only + supported with the FlashAttention 2 or 3, which can efficiently handle the flattened batch structure. When + packing is enabled with strategy `"bfd"`, padding-free is enabled, regardless of the value of this + parameter. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + eval_packing (`bool`, *optional*): + Whether to pack the eval dataset. If `None`, uses the same value as `packing`. + + > Parameters that control the training + + completion_only_loss (`bool`, *optional*): + Whether to compute loss only on the completion part of the sequence. If set to `True`, loss is computed + only on the completion, which is supported only for [prompt-completion](#prompt-completion) datasets. If + `False`, loss is computed on the entire sequence. If `None` (default), the behavior depends on the dataset: + loss is computed on the completion for [prompt-completion](#prompt-completion) datasets, and on the full + sequence for [language modeling](#language-modeling) datasets. + assistant_only_loss (`bool`, *optional*, defaults to `False`): + Whether to compute loss only on the assistant part of the sequence. If set to `True`, loss is computed only + on the assistant responses, which is supported only for [conversational](#conversational) datasets. If + `False`, loss is computed on the entire sequence. + loss_type (`str`, *optional*, defaults to `"chunked_nll"`): + Type of loss to use. When left unset, it defaults to `"chunked_nll"`, except when `use_liger_kernel=True`, + in which case it defaults to `"nll"`. Possible values are: + + - `"nll"`: standard negative log-likelihood. + - `"dft"`: Dynamic Fine-Tuning, as described in + [this paper](https://huggingface.co/papers/2508.05629). + - `"chunked_nll"`: same math as `"nll"`, but the `lm_head` projection is computed on non-ignored tokens + only (positions with `labels == -100` are dropped before the matmul) and the cross-entropy is processed + in chunks of tokens to reduce peak activation memory. Not compatible with `use_liger_kernel`. + + activation_offloading (`bool`, *optional*, defaults to `False`): + Whether to offload the activations to the CPU. + + > Deprecated parameters + + pad_token: + + + + Parameter `pad_token` is deprecated and will be removed in version v2.0.0. Set `tokenizer.pad_token` + directly and pass it as `processing_class` to the trainer instead. + + + + > [!NOTE] + > These parameters have default values different from [`~transformers.TrainingArguments`]: + > - `logging_steps`: Defaults to `10` instead of `500`. + > - `gradient_checkpointing`: Defaults to `True` instead of `False`. + > - `bf16`: Defaults to `True` if `fp16` is not set, instead of `False`. + > - `learning_rate`: Defaults to `2e-5` instead of `5e-5`. + """ + + _VALID_DICT_FIELDS = _BaseConfig._VALID_DICT_FIELDS + ["model_init_kwargs"] + + # Parameters whose default values are overridden from TrainingArguments + learning_rate: float = field( + default=2e-5, + metadata={"help": "The initial learning rate for AdamW."}, + ) + + # Parameters that control the model + model_init_kwargs: dict[str, Any] | str | None = field( + default=None, + metadata={ + "help": "Keyword arguments for `AutoModelForCausalLM.from_pretrained`, used when the `model` argument of " + "the `SFTTrainer` is provided as a string." + }, + ) + router_aux_loss_coef: float = field( + default=0.001, + metadata={ + "help": "Coefficient of the load-balancing auxiliary loss. Only has an effect when training a " + "Mixture-of-Experts (MoE) model; for other models it does nothing. The auxiliary loss is added to the " + "training loss with this weight. Set to `0.0` to disable it." + }, + ) + trust_remote_code: bool = field( + default=False, + metadata={ + "help": "Whether to allow loading models and tokenizers that ship custom Python code from the Hub. " + "Forwarded to `AutoModelForCausalLM.from_pretrained` and `AutoProcessor.from_pretrained`." + }, + ) + chat_template_path: str | None = field( + default=None, + metadata={ + "help": "If specified, sets the model's chat template. This can either be the path to a tokenizer (local " + "directory or Hugging Face Hub model) or a direct path to a Jinja template file. When using a Jinja file, " + "you must ensure that any special tokens referenced in the template are added to the tokenizer and " + "that the model's embedding layer is resized accordingly." + }, + ) + + # Parameters that control the data preprocessing + dataset_text_field: str = field( + default="text", + metadata={"help": "Name of the column that contains text data in the dataset."}, + ) + dataset_kwargs: dict[str, Any] | None = field( + default=None, + metadata={ + "help": "Dictionary of optional keyword arguments for the dataset preparation. The only supported key is " + "`skip_prepare_dataset`. If the model is a VLM, `skip_prepare_dataset` value is ignored. When the model " + "is a VLM, `skip_prepare_dataset` is automatically treated as `True` regardless of the provided value, " + "since preprocessing is done on the fly." + }, + ) + dataset_num_proc: int | None = field( + default=None, + metadata={"help": "Number of processes to use for processing the dataset."}, + ) + eos_token: str | None = field( + default=None, + metadata={ + "help": "Token used to indicate the end of a turn or sequence. If `None`, it defaults to `processing_class.eos_token`." + }, + ) + max_length: int | None = field( + default=1024, + metadata={ + "help": "Maximum length of the tokenized sequence. Sequences longer than `max_length` are truncated from " + "the left or right depending on the `truncation_mode`. If `None`, no truncation is applied. When packing " + "is enabled, this value sets the sequence length." + }, + ) + truncation_mode: str = field( + default="keep_start", + metadata={ + "help": "Truncation mode to use when the sequence exceeds `max_length`. The only supported value is " + "`'keep_start'`. The `'keep_end'` value is deprecated and will be removed in v2.0.0.", + "choices": ["keep_end", "keep_start"], + }, + ) + shuffle_dataset: bool = field( + default=False, + metadata={"help": "Whether to shuffle the dataset."}, + ) + packing: bool = field( + default=False, + metadata={ + "help": "Whether to group multiple sequences into fixed-length blocks to improve computational efficiency " + "and reduce padding. Uses `max_length` to define sequence length." + }, + ) + packing_strategy: str = field( + default="bfd", + metadata={ + "help": "Strategy for packing sequences. Can be `'bfd'` (best-fit decreasing, truncates overflow), " + "`'bfd_split'` (best-fit decreasing, splits overflow sequences), or `'wrapped'` (aggressive, cuts " + "mid-sequence).", + "choices": ["bfd", "bfd_split", "wrapped"], + }, + ) + padding_free: bool = field( + default=False, + metadata={ + "help": "Whether to perform forward passes without padding by flattening all sequences in the batch into " + "a single continuous sequence. This reduces memory usage by eliminating padding overhead. Currently, this " + "is only supported with the FlashAttention 2 or 3, which can efficiently handle the flattened batch " + "structure. When packing is enabled with strategy `'bfd'`, padding-free is enabled, regardless of the " + "value of this parameter." + }, + ) + pad_to_multiple_of: int | None = field( + default=None, + metadata={"help": "If set, the sequences will be padded to a multiple of this value."}, + ) + eval_packing: bool | None = field( + default=None, + metadata={"help": "Whether to pack the eval dataset. If `None`, uses the same value as `packing`."}, + ) + + # Parameters that control the training + completion_only_loss: bool | None = field( + default=None, + metadata={ + "help": ( + "Whether to compute loss only on the completion part of the sequence. If set to `True`, loss is " + "computed only on the completion, which is supported only for prompt-completion datasets. If `False`, " + "loss is computed on the entire sequence. If `None` (default), the behavior depends on the dataset: " + "loss is computed on the completion for prompt-completion datasets, and on the full sequence for " + "language modeling datasets." + ) + }, + ) + assistant_only_loss: bool = field( + default=False, + metadata={ + "help": ( + "Whether to compute loss only on the assistant part of the sequence. If set to `True`, loss is " + "computed only on the assistant responses, which is supported only for conversational datasets. If `False`, " + "loss is computed on the entire sequence." + ) + }, + ) + loss_type: str | None = field( + default=None, + metadata={ + "help": "Type of loss to use. When left unset, it defaults to `'chunked_nll'`, except when " + "`use_liger_kernel=True`, in which case it defaults to `'nll'`. Possible values are `'nll'` (standard " + "negative log-likelihood), `'dft'` (Dynamic Fine-Tuning, https://huggingface.co/papers/2508.05629), and " + "`'chunked_nll'` (same math as `'nll'`, but the `lm_head` projection is computed on non-ignored tokens " + "only — positions with `labels == -100` are dropped before the matmul — and the cross-entropy is " + "processed in chunks of tokens to reduce peak activation memory; not compatible with `use_liger_kernel`; " + "the patched `lm_head` path covers standard causal LMs and VLMs whose language model exposes a top-level " + "`lm_head`, architectures with a non-standard head are not supported)." + }, + ) + activation_offloading: bool = field( + default=False, + metadata={"help": "Whether to offload the activations to the CPU."}, + ) + + # Deprecated parameters + pad_token: str | None = field( + default=None, + metadata={ + "help": "Deprecated. Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead." + }, + ) + + def __post_init__(self): + super().__post_init__() + if self.pad_token is not None: + warnings.warn( + "`pad_token` is deprecated and will be removed in v2.0.0. " + "Set `tokenizer.pad_token` directly and pass it as `processing_class` to the trainer instead.", + FutureWarning, + stacklevel=3, + ) + if self.truncation_mode == "keep_end": + warnings.warn( + "The `'keep_end'` truncation mode is deprecated and will be removed in v2.0.0. " + "Use `truncation_mode='keep_start'` (the default) instead.", + FutureWarning, + stacklevel=3, + ) + if self.packing_strategy == "bfd-requeue": + warnings.warn( + "The `bfd-requeue` packing strategy has been renamed to `bfd_split`. Please update your configuration accordingly. " + "The `bfd-requeue` strategy is deprecated and will be removed in v2.0.0.", + FutureWarning, + stacklevel=3, + ) + self.packing_strategy = "bfd_split" + + # When unset, default to "chunked_nll" unless `use_liger_kernel=True`, in which case default to "nll". + if self.loss_type is None: + self.loss_type = "nll" if self.use_liger_kernel else "chunked_nll" diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/sft_trainer.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/sft_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..1fbfb53f3c3007679c3150059e863b60c6fc7af0 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/sft_trainer.py @@ -0,0 +1,1833 @@ +# Copyright 2020-2026 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 contextlib +import json +import os +import types +import warnings +from collections import defaultdict +from collections.abc import Callable +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import torch +import torch.nn as nn +import torch.nn.functional as F +import transformers +from accelerate import PartialState +from accelerate.logging import get_logger +from accelerate.utils import is_peft_model +from datasets import Dataset, IterableDataset +from packaging.version import Version +from transformers import ( + AutoProcessor, + DataCollator, + PreTrainedModel, + PreTrainedTokenizerBase, + ProcessorMixin, + TrainingArguments, +) +from transformers.data.data_collator import DataCollatorMixin +from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast +from transformers.trainer_callback import TrainerCallback +from transformers.trainer_utils import EvalPrediction +from transformers.utils import is_peft_available + +from ..chat_template_utils import ( + clone_chat_template, + get_training_chat_template, + has_generation_markers, + is_chat_template_stop_token_trained, +) +from ..data_utils import ( + apply_chat_template, + is_conversational, + is_conversational_from_value, + maybe_convert_to_chatml, + pack_dataset, + prepare_multimodal_messages, +) +from ..models import get_act_offloading_ctx_manager +from .base_trainer import _BaseTrainer +from .sft_config import SFTConfig +from .utils import ( + create_model_from_path, + entropy_from_logits, + flush_left, + get_config_model_id, + pad, + selective_log_softmax, +) + + +_CHUNKED_LM_HEAD_CHUNK_SIZE = 256 + + +if is_peft_available(): + import peft + from peft import PeftConfig, PeftModel, PeftType, get_peft_model + + +@dataclass +class _ChunkedCELMHeadOutput(CausalLMOutputWithPast): + """`CausalLMOutputWithPast` with extra fields populated by the chunked-CE path.""" + + num_correct_tokens: torch.Tensor | None = None + entropy_sum: torch.Tensor | None = None + num_valid_tokens: torch.Tensor | None = None + aux_loss: torch.Tensor | None = None + + +def _maybe_gather_lm_head_ctx(w, b): + # Allgather ZeRO-3 partitioned `lm_head` weight/bias for the chunked matmul. No-op if not ZeRO-3, or if the + # param is already gathered (tied embeddings: `embed_tokens` shares the weight and keeps it `AVAILABLE`, so + # partitioning on our exit would collide with its active-submodule tracking). + from transformers.integrations.deepspeed import is_deepspeed_zero3_enabled + + if not is_deepspeed_zero3_enabled(): + return contextlib.nullcontext() + + import deepspeed + from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus + + params = [w] if b is None else [w, b] + if all(p.ds_status == ZeroParamStatus.AVAILABLE for p in params): + return contextlib.nullcontext() + return deepspeed.zero.GatheredParameters(params) + + +def _chunk(h, w, b, lbl, logit_scale, final_logit_softcapping): + with _maybe_gather_lm_head_ctx(w, b): + logits = h.float() @ w.float().t() + if b is not None: + logits = logits + b.float() + if logit_scale != 1.0: + logits = logits * logit_scale + if final_logit_softcapping is not None: + logits = final_logit_softcapping * torch.tanh(logits / final_logit_softcapping) + log_p = F.log_softmax(logits, dim=-1) + chunk_loss = F.nll_loss(log_p, lbl, reduction="sum") + chunk_correct = (logits.argmax(dim=-1) == lbl).sum().float() + chunk_entropy = -(log_p.exp() * log_p).sum(dim=-1).sum() + return chunk_loss, chunk_correct, chunk_entropy + + +def _chunked_cross_entropy_loss( + hidden_states: torch.Tensor, + lm_head_weight: torch.Tensor, + chunk_size: int, + labels: torch.Tensor | None = None, + shift_labels: torch.Tensor | None = None, + num_items_in_batch: torch.Tensor | int | None = None, + logit_scale: float = 1.0, + final_logit_softcapping: float | None = None, + lm_head_bias: torch.Tensor | None = None, +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Memory-efficient next-token cross-entropy over hidden states and an `lm_head` weight. + + The full `lm_head` projection is never materialized. Positions where labels equal `-100` are dropped before the + matmul, and the remaining tokens are processed in chunks of `chunk_size`. Each chunk's `[chunk_size, vocab_size]` + logits tensor is kept alive only during its own forward/backward pass via gradient checkpointing, so peak + logits-activation memory is `chunk_size * vocab_size` instead of `batch_size * seq_len * vocab_size`. + + At least one of `labels` or `shift_labels` must be provided. Passing `labels` alone is the standard path and + triggers the internal `labels[..., 1:]` / `hidden_states[..., :-1, :]` shift. Passing `shift_labels` skips the + shift and assumes the caller has already aligned labels with hidden states — this is the contract used under + context / sequence parallelism, where labels are shifted before being sharded. If both are provided, `shift_labels` + wins (matching [`~transformers.loss.ForCausalLMLoss`]). + + Args: + hidden_states (`torch.Tensor`): + Base decoder output of shape `(B, S, H)`, i.e. before the `lm_head` projection. + lm_head_weight (`torch.Tensor`): + Weight of the `lm_head` linear layer, shape `(V, H)`. + chunk_size (`int`): + Number of valid tokens processed per chunk. Peak memory scales linearly with this. + labels (`torch.Tensor`, *optional*): + Labels of shape `(B, S)`. Positions equal to `-100` are excluded from both the `lm_head` matmul and the + loss. Mutually exclusive with `shift_labels`. + shift_labels (`torch.Tensor`, *optional*): + Pre-shifted labels of shape `(B, S)`, aligned with `hidden_states` (position `i` predicts + `shift_labels[i]`). Mutually exclusive with `labels`. + num_items_in_batch (`torch.Tensor`, `int` or `None`, *optional*): + Total number of valid tokens across the global batch, as plumbed by [`~transformers.Trainer`]. When + provided, the loss is reduced as `sum / num_items_in_batch`, matching the gradient-accumulation-correct + behavior of HF's default cross-entropy. When `None`, reduction is `mean` over local valid tokens. + logit_scale (`float`, *optional*, defaults to `1.0`): + Multiplier applied to each chunk's logits before the cross-entropy, matching the `logit_scale` behavior of + Cohere-style models. + final_logit_softcapping (`float`, *optional*): + If set, applies `softcap * tanh(logits / softcap)` to each chunk's logits before the cross-entropy, + matching the `final_logit_softcapping` behavior of Gemma-style models. Applied after `logit_scale`. + lm_head_bias (`torch.Tensor`, *optional*): + Bias of the `lm_head` linear layer, shape `(V,)`. Added to each chunk's logits when provided. + + Returns: + `tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]`: scalar loss, number of correctly-predicted + tokens (count), sum of per-token Shannon entropy (in nats), and number of valid (non-`-100`) target tokens — + all over the local batch. Raw sums are returned so callers can reduce correctly across ranks. + """ + if labels is None and shift_labels is None: + raise ValueError("At least one of `labels` or `shift_labels` must be provided.") + + if shift_labels is not None: + hidden = hidden_states.reshape(-1, hidden_states.size(-1)) + labels = shift_labels.reshape(-1) + else: + hidden = hidden_states[..., :-1, :].reshape(-1, hidden_states.size(-1)) + labels = labels[..., 1:].reshape(-1) + + valid = labels != -100 + hidden = hidden[valid] + labels = labels[valid] + n_valid = hidden.size(0) + + correct = hidden.new_zeros((), dtype=torch.float32) + entropy_sum = hidden.new_zeros((), dtype=torch.float32) + n_valid_tensor = torch.tensor(n_valid, device=hidden.device, dtype=torch.long) + if n_valid == 0: + # Whole micro-batch masked (e.g. completion-only loss + truncation). Keep the loss connected + # to the autograd graph through every trainable parameter so `.backward()` succeeds and DDP / + # FSDP gradient sync doesn't hang on a missing param. + with _maybe_gather_lm_head_ctx(lm_head_weight, lm_head_bias): + loss = (hidden_states.float().sum() + lm_head_weight.float().sum()) * 0.0 + if lm_head_bias is not None: + loss = loss + lm_head_bias.float().sum() * 0.0 + return loss, correct, entropy_sum, n_valid_tensor + + loss = hidden.new_zeros((), dtype=torch.float32) + + for start in range(0, n_valid, chunk_size): + h_chunk = hidden[start : start + chunk_size] + lbl_chunk = labels[start : start + chunk_size] + chunk_loss, chunk_correct, chunk_entropy = torch.utils.checkpoint.checkpoint( + _chunk, + h_chunk, + lm_head_weight, + lm_head_bias, + lbl_chunk, + logit_scale, + final_logit_softcapping, + use_reentrant=False, + ) + loss = loss + chunk_loss + correct = correct + chunk_correct + entropy_sum = entropy_sum + chunk_entropy + + if num_items_in_batch is None: + loss = loss / n_valid + else: + if isinstance(num_items_in_batch, torch.Tensor): + num_items_in_batch = num_items_in_batch.to(loss.device) + loss = loss / num_items_in_batch + return loss, correct, entropy_sum, n_valid_tensor + + +def _patch_chunked_ce_lm_head(model: torch.nn.Module, chunk_size: int, is_vlm: bool = False) -> None: + """ + Patch `model.forward` to compute the LM loss via [`_chunked_cross_entropy_loss`]. + + When `labels` (or pre-shifted `shift_labels`, for CP/SP) are provided, the patched forward runs the decoder up to + `last_hidden_state` (skipping the `lm_head` matmul), drops `labels == -100` positions, and computes the + cross-entropy in chunks of `chunk_size` valid tokens. Returns a [`_ChunkedCELMHeadOutput`] with `loss` set, + `logits=None`, and `num_correct_tokens` / `entropy_sum` / `num_valid_tokens` over non-ignored tokens. For MoE + models (`output_router_logits=True`), the load-balancing aux loss is added with the same coefficient and formula as + the model's reference forward. + + Without labels, the original forward runs unchanged — generation and labels-free eval preserve any per-model logits + post-processing (`logit_scale`, `final_logit_softcapping`, `logits_to_keep` slicing). + + Args: + model (`torch.nn.Module`): + Model to patch. For PEFT, pass `peft_model.get_base_model()` rather than the `PeftModel` wrapper, so + prompt-learning variants (PromptTuning, PrefixTuning, PTuning) keep their virtual-token injection in + `PeftModel.forward` before delegating into the patched forward. + chunk_size (`int`): + Number of valid tokens processed per CE chunk. + is_vlm (`bool`): + Set to `True` for VLMs. Only used to read `logit_scale` / `final_logit_softcapping` / + `output_router_logits` from `model.config.text_config` instead of the top-level config. + """ + # VLM scaling configs (`logit_scale`, `final_logit_softcapping`, MoE `output_router_logits`) live on `text_config`; + # text-only models keep them on the top-level config. + text_config = model.config.text_config if is_vlm else model.config + final_logit_softcapping = getattr(text_config, "final_logit_softcapping", None) + logit_scale = getattr(text_config, "logit_scale", 1.0) + original_forward = model.forward + lm_head = model.get_output_embeddings() + + def _chunked_ce_forward( + self: torch.nn.Module, + input_ids: torch.Tensor | None = None, + attention_mask: torch.Tensor | None = None, + labels: torch.Tensor | None = None, + num_items_in_batch: torch.Tensor | int | None = None, + shift_labels: torch.Tensor | None = None, + output_router_logits: bool | None = None, + **kwargs, + ) -> CausalLMOutputWithPast: + # Without labels, fall back to the original forward so generation and labels-free evaluation + # preserve any per-model logits post-processing (e.g. Cohere `logit_scale`, Gemma + # `final_logit_softcapping`, `logits_to_keep` slicing). + if labels is None and shift_labels is None: + # MoE models: request router logits so the model returns `outputs.aux_loss`. VLM wrappers honor this only + # as a forward kwarg (not from the model config), so it must be passed here. + if output_router_logits is not None: + kwargs["output_router_logits"] = output_router_logits + return original_forward(input_ids=input_ids, attention_mask=attention_mask, **kwargs) + + if output_router_logits is None: + output_router_logits = getattr(text_config, "output_router_logits", False) + + kwargs.pop("use_cache", None) + decoder_kwargs = {} + # MoE models: request router logits so the model returns `outputs.aux_loss`. VLM wrappers honor this only + # as a forward kwarg (not from the model config), so it must be passed here. + if output_router_logits: + decoder_kwargs["output_router_logits"] = True + # `base_model` gives the backbone model (skipping `lm_head`) — text decoder for LMs, multimodal wrapper + # for VLMs (so vision-token injection runs before the text decoder). `get_decoder()` won't do: on VLMs it + # returns just the text stack and feeds image-placeholder IDs through it. + # Pre-5.0 transformers VLMs set `base_model_prefix = ""` so `self.base_model is self` (re-runs `lm_head`). + # Fall back to `self.model` there. + if is_vlm and Version(transformers.__version__) < Version("5.0.0"): + backbone = self.model + else: + backbone = self.base_model + outputs: BaseModelOutputWithPast = backbone( + input_ids=input_ids, attention_mask=attention_mask, use_cache=False, **decoder_kwargs, **kwargs + ) + hidden_states = outputs.last_hidden_state + + lm_head_weight = lm_head.weight + lm_head_bias = lm_head.bias + # Under FSDP2, lm_head.weight is a DTensor (Shard(0) or Replicate). Passing it directly + # into the gradient-checkpointed chunk loop causes FSDP2 to re-gather it once per chunk + # during backward recomputation. full_tensor() converts it to a plain tensor once; all + # chunks reference that tensor, so only one all-gather occurs (in full_tensor()'s backward). + if isinstance(lm_head_weight, torch.distributed.tensor.DTensor): + lm_head_weight = lm_head_weight.full_tensor() + if lm_head_bias is not None: + lm_head_bias = lm_head_bias.full_tensor() + loss, num_correct_tokens, entropy_sum, num_valid_tokens = _chunked_cross_entropy_loss( + hidden_states, + lm_head_weight, + chunk_size, + labels=labels, + shift_labels=shift_labels, + num_items_in_batch=num_items_in_batch, + logit_scale=logit_scale, + final_logit_softcapping=final_logit_softcapping, + lm_head_bias=lm_head_bias, + ) + + aux_loss = None + if output_router_logits: + # Mirror the per-family MoE forward: add `router_aux_loss_coef * load_balancing_loss_func(...)` to + # the main loss. Mixtral is the source of truth — every MoE family (Qwen3Moe, GptOss, OLMoE, + # Qwen2Moe, DBRX, JetMoE, PhiMoE, …) pulls this function from mixtral via the modular system, so a + # single import keeps us in lockstep with upstream for every family we test. + from transformers.models.mixtral.modeling_mixtral import load_balancing_loss_func + + if Version(transformers.__version__) < Version("5.0.0") and not is_vlm: + num_experts = self.num_experts + num_experts_per_tok = self.num_experts_per_tok + router_aux_loss_coef = self.router_aux_loss_coef + else: + # Upstream bug AttributeError: 'GptOssConfig' object has no attribute 'num_experts'; see #5754 + if text_config.model_type == "gpt_oss" and Version("5.0.0") <= Version( + transformers.__version__ + ) < Version("5.6.0"): + num_experts = self.num_experts + else: + num_experts = text_config.num_experts + num_experts_per_tok = text_config.num_experts_per_tok + router_aux_loss_coef = text_config.router_aux_loss_coef + aux_loss = load_balancing_loss_func( + outputs.router_logits, num_experts, num_experts_per_tok, attention_mask + ) + loss = loss + router_aux_loss_coef * aux_loss.to(loss.device) + + return _ChunkedCELMHeadOutput( + loss=loss, + logits=None, + past_key_values=outputs.past_key_values, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + num_correct_tokens=num_correct_tokens, + entropy_sum=entropy_sum, + num_valid_tokens=num_valid_tokens, + aux_loss=aux_loss, + ) + + model.forward = types.MethodType(_chunked_ce_forward, model) + + +logger = get_logger(__name__) + + +FLASH_ATTENTION_VARIANTS = { + "flash_attention_2", + "flash_attention_3", + "kernels-community/flash-attn2", + "kernels-community/flash-attn3", + "kernels-community/vllm-flash-attn3", +} + + +def get_dataset_column_names(dataset: Dataset | IterableDataset) -> list[str]: + return list(next(iter(dataset)).keys()) if dataset.column_names is None else dataset.column_names + + +@dataclass +class DataCollatorForLanguageModeling(DataCollatorMixin): + """ + Data collator used for language modeling data. Inputs are dynamically padded to the maximum length of a batch. + + This collator expects each example in the input list to be a dictionary containing at least the `"input_ids"` key. + If the input contains a `"completion_mask"`, it is used to set the labels to `-100` for tokens that are not in the + completion. If `"assistant_masks"` are present, they are used to set the labels to `-100` for tokens that are not + in the assistant part of the sequence. The collator returns a dictionary containing the following keys: + - `"input_ids"`: Tensor of input IDs, padded to the maximum length of the batch. + - `"labels"`: Tensor of labels, padded to the maximum length of the batch. If `completion_only_loss` is set to + `True`, tokens that are not in the completion are set to -100. If `assistant_masks` are present, tokens that are + not in the assistant part of the sequence are set to -100. If `padding_free` is set to `False`, the following key + is also returned: + - `"attention_mask"`: Tensor of attention masks, padded to the maximum length of the batch. + If `padding_free` is set to `True`, the following key is also returned: + - `"position_ids"`: Tensor of position IDs, padded to the maximum length of the batch. + + Args: + pad_token_id (`int`): + Token ID to use for padding. + max_length (`int`, *optional*): + Maximum length of the sequences in the batch. Sequences longer than `max_length` are truncated to + `max_length`. + truncation_mode (`str`, *optional*, defaults to `"keep_start"`): + Truncation mode to use when the sequence exceeds `max_length`. Possible values are `"keep_end"` and + `"keep_start"`. + completion_only_loss (`bool`, *optional*, defaults to `True`): + When the input contains a completion mask (`completion_mask`), the labels are set to -100 for the tokens + that are no in the completion. + padding_free (`bool`, *optional*, defaults to `False`): + If set to `True`, the sequences will be flattened into a single sequence, and the position IDs will be + generated accordingly and returned instead of the attention mask. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + return_tensors (`str`, *optional*, defaults to `"pt"`): + Type of Tensor to return. Only `"pt"` is currently supported. + + Examples: + ```python + >>> from trl.trainer.sft_trainer import DataCollatorForLanguageModeling + + >>> collator = DataCollatorForLanguageModeling(pad_token_id=0) + >>> examples = [{"input_ids": [1, 2, 3]}, {"input_ids": [4, 5]}] + >>> collator(examples) + {'input_ids': tensor([[ 1, 2, 3], + [ 4, 5, 0]]), + 'attention_mask': tensor([[ 1, 1, 1], + [ 1, 1, 0]]), + 'labels': tensor([[ 1, 2, 3], + [ 4, 5, -100]])} + + >>> # With completion mask + >>> examples = [ + ... {"input_ids": [1, 2, 3], "completion_mask": [0, 1, 1]}, + ... {"input_ids": [4, 5], "completion_mask": [0, 1]}, + ... ] + >>> collator(examples) + {'input_ids': tensor([[ 1, 2, 3], + [ 4, 5, 0]]), + 'attention_mask': tensor([[ 1, 1, 1], + [ 1, 1, 0]]), + 'labels': tensor([[-100, 2, 3], + [-100, 5, -100]])} + + >>> # With padding_free + >>> collator = DataCollatorForLanguageModeling(pad_token_id=0, padding_free=True) + >>> collator(examples) + {'input_ids': tensor([[ 1, 2, 3, 4, 5]]), + 'position_ids': tensor([[0, 1, 2, 0, 1]]), + 'labels': tensor([[1, 2, 3, 4, 5]])} + ``` + """ + + pad_token_id: int + max_length: int | None = None + truncation_mode: str = "keep_start" + completion_only_loss: bool = True + padding_free: bool = False + pad_to_multiple_of: int | None = None + return_tensors: str = "pt" + + def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]: + input_ids = [example["input_ids"] for example in examples] + batch_seq_lengths = [example["seq_lengths"] for example in examples] if "seq_lengths" in examples[0] else None + labels = [example.get("labels", example["input_ids"]) for example in examples] + completion_mask = ( + [example["completion_mask"] for example in examples] + if self.completion_only_loss and "completion_mask" in examples[0] + else None + ) + assistant_masks = ( + [example["assistant_masks"] for example in examples] if "assistant_masks" in examples[0] else None + ) + + # Truncate per sequence if necessary + if self.max_length is not None and not self.padding_free: + if self.truncation_mode == "keep_start": + sl = slice(None, self.max_length) + elif self.truncation_mode == "keep_end": + sl = slice(-self.max_length, None) + else: + raise ValueError( + f"Unsupported truncation mode: {self.truncation_mode}, expected 'keep_start' or 'keep_end'" + ) + input_ids = [ids[sl] for ids in input_ids] + labels = [lbl[sl] for lbl in labels] + if completion_mask is not None: + completion_mask = [m[sl] for m in completion_mask] + if assistant_masks is not None: + assistant_masks = [m[sl] for m in assistant_masks] + + # Convert to tensor + input_ids = [torch.tensor(ids) for ids in input_ids] + labels = [torch.tensor(lbl) for lbl in labels] + if completion_mask is not None: + completion_mask = [torch.tensor(m) for m in completion_mask] + if assistant_masks is not None: + assistant_masks = [torch.tensor(m) for m in assistant_masks] + + # For padding-free, we should NOT create attention_mask as it causes FlashAttention to ignore position_ids and + # compute wrong cu_seq_lens from the all-1s mask + if self.padding_free: + if batch_seq_lengths is not None: + position_ids = self.get_position_ids_from_packed_seq_lengths(batch_seq_lengths) + else: + position_ids = [torch.arange(len(ids)) for ids in input_ids] + else: + attention_mask = [torch.ones_like(ids) for ids in input_ids] + + # If padding_free, flatten everything into a single sequence + output = {} + if self.padding_free: + input_ids = [torch.cat(input_ids, dim=0)] + labels = [torch.cat(labels, dim=0)] + position_ids = [torch.cat(position_ids, dim=0)] + if completion_mask is not None: + completion_mask = [torch.cat(completion_mask, dim=0)] + if assistant_masks is not None: + assistant_masks = [torch.cat(assistant_masks, dim=0)] + + # Pad + output["input_ids"] = pad( + input_ids, + padding_value=self.pad_token_id, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + ) + output["labels"] = pad( + labels, padding_value=-100, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of + ) + if self.padding_free: + output["position_ids"] = pad( + position_ids, padding_value=0, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of + ) + output["labels"][output["position_ids"] == 0] = -100 + else: + output["attention_mask"] = pad( + attention_mask, padding_value=0, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of + ) + if completion_mask is not None: + completion_mask = pad( + completion_mask, padding_value=0, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of + ) + output["labels"][completion_mask == 0] = -100 # mask everything that is not in the completion + if assistant_masks is not None: + assistant_masks = pad( + assistant_masks, padding_value=0, padding_side="right", pad_to_multiple_of=self.pad_to_multiple_of + ) + output["labels"][assistant_masks == 0] = -100 + return output + + @staticmethod + def get_position_ids_from_packed_seq_lengths(batch_seq_lengths: list[list[int]]) -> list[torch.Tensor]: + """ + Get position IDs for packed sequences. + + Args: + batch_seq_lengths (`list[list[int]]`): + A list of lists containing the lengths of each individual document in the packed batch. + + Return: + `list[torch.Tensor]`: + A list of tensors containing the position IDs for each packed sequence. + """ + # Get lengths per row + example_lengths = [sum(seq_lengths) for seq_lengths in batch_seq_lengths] + # Flat list of lengths + batch_seq_lengths = torch.tensor( + [seq_length for seq_lengths in batch_seq_lengths for seq_length in seq_lengths] + ) + position_ids = torch.ones(sum(example_lengths), dtype=batch_seq_lengths.dtype) + position_ids[0] = 0 + # Reset position ids to 0 at the start of each sequence + position_ids[batch_seq_lengths[:-1].cumsum(0)] = -(batch_seq_lengths[:-1] - 1) + position_ids = position_ids.cumsum(0) + # Split back into one tensor per example + return list(position_ids.split(example_lengths)) + + +@dataclass +class DataCollatorForVisionLanguageModeling(DataCollatorMixin): + """ + Data collator for vision-language modeling tasks. + + Unlike text-only datasets, where the collator typically receives pre-tokenized inputs ready for batching, + vision-language data processing involves converting images into pixel values. This conversion is disk-intensive, + making upfront preprocessing of the entire dataset impractical. Therefore, this collator performs tokenization and + image processing on-the-fly to efficiently prepare batches. + + Each input example should be a dictionary containing at least: + - An `"images"` key holding a list of images, or an `"image"` key holding a single image. + - [language modeling](#language-modeling) type: either a `"messages"` key for conversational inputs or a `"text"` + key for standard text inputs. + - [prompt-completion](#prompt-completion) type: keys `"prompt"` and `"completion"` for the prompt and completion. + + The collator outputs a dictionary including: + - `"input_ids"`: Tensor of token IDs. + - `"attention_mask"`: Tensor indicating attention mask. + - `"pixel_values"`: Tensor representing image pixel values. + - `"labels"`: Tensor for training labels. + + Additional keys may be present depending on the processor, such as `"image_grid_thw"` or `"image_position_ids"`. + + Args: + processor ([`~transformers.ProcessorMixin`]): + The processor used to tokenize text and process images. It must be a subclass of + [`~transformers.ProcessorMixin`] and include a `tokenizer` with a defined `pad_token_id`. + max_length (`int`, *optional*): + Maximum sequence length for input tokens. If `None`, no truncation is applied. + completion_only_loss (`bool`, *optional*, defaults to `False`): + Whether to compute loss only on the completion part of the sequence. When `True`, the labels for the prompt + part are set to -100. It requires the dataset type to be prompt-completion. + pad_to_multiple_of (`int`, *optional*): + If set, the sequences will be padded to a multiple of this value. + dataset_text_field (`str`, *optional*, defaults to `"text"`): + Name of the column that contains text data in the dataset. This parameter is only relevant for [standard + datasets format](dataset_formats#standard). + return_tensors (`str`, *optional*, defaults to `"pt"`): + The tensor type to return. Currently, only `"pt"` (PyTorch tensors) is supported. + + Example: + ```python + >>> from trl.trainer.sft_trainer import DataCollatorForVisionLanguageModeling + >>> from transformers import AutoProcessor + + >>> processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-7B-Instruct") + >>> collator = DataCollatorForVisionLanguageModeling(processor) + >>> examples = [ + ... {"images": [Image.open("image_0.png")], "messages": [{"role": "user", "content": "What is this?"}]}, + ... {"images": [Image.open("image_1.png")], "messages": [{"role": "user", "content": "Describe this image."}]}, + ... ] + >>> collator(examples) + {'input_ids': tensor([[151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, + 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 3838, 374, + 419, 30, 151645, 198], + [151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, + 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 74785, 419, + 2168, 13, 151645, 198]]), + 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], + [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]), + 'pixel_values': tensor([[-0.9893, 0.1785, 1.5362, ..., -0.0582, 0.8661, -0.2431], + [-0.2302, 0.9522, -1.1061, ..., 0.0555, 1.3354, -0.6412], + [ 1.2150, 0.9084, 0.7041, ..., 0.2404, -0.8403, -0.5133], + ..., + [ 0.6895, 0.2807, 0.2515, ..., -0.2004, -1.2100, 0.0555], + [ 0.8209, -0.9748, 1.5654, ..., 1.6055, -0.4706, 0.5817], + [-1.0915, 0.4559, 0.9230, ..., 0.5106, 0.0982, -0.1720]]), + 'image_grid_thw': tensor([[1, 4, 4], + [1, 4, 4]]), + 'labels': tensor([[151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, + 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 3838, 374, + 419, 30, 151645, 198], + [151644, 8948, 198, 2610, 525, 264, 10950, 17847, 13, 151645, 198, + 151644, 872, 198, 151652, 151655, 151655, 151655, 151655, 151653, 74785, 419, + 2168, 13, 151645, 198]])} + ``` + """ + + processor: ProcessorMixin + max_length: int | None = None + completion_only_loss: bool = False # default not used in practice; SFTTrainer always passes the relevant value + pad_to_multiple_of: int | None = None + dataset_text_field: str = "text" + return_tensors: str = "pt" + + def torch_call(self, examples: list[dict[str, Any]]) -> dict[str, Any]: + if "messages" in examples[0] or self.dataset_text_field in examples[0]: + if self.completion_only_loss: + raise ValueError( + "The `completion_only_loss` argument is not supported for language modeling datasets." + ) + return self._collate_language_modeling(examples) + elif "prompt" in examples[0] and "completion" in examples[0]: + return self._collate_prompt_completion(examples) + else: + raise KeyError(f"Unexpected input keys in examples: {list(examples[0].keys())}.") + + def _collate_language_modeling(self, examples: list[dict[str, Any]]) -> dict[str, Any]: + if "image" in examples[0]: + for example in examples: + example["images"] = [example.pop("image")] + images = [example["images"] for example in examples] + # Transformers requires at least one image in the batch, otherwise it throws an error + if all(img_list == [] for img_list in images): + images = None + + if "messages" in examples[0]: # conversational case + messages = [ + prepare_multimodal_messages(example["messages"], images=example["images"]) for example in examples + ] + texts = self.processor.apply_chat_template(messages) + elif self.dataset_text_field in examples[0]: # standard case + texts = [example[self.dataset_text_field] for example in examples] + else: + raise KeyError( + "The input examples must contain either 'messages' for conversational data or 'text' for standard " + "data." + ) + + output = self.processor( + images=images, + text=texts, + padding=True, + padding_side="right", + pad_to_multiple_of=self.pad_to_multiple_of, + truncation=self.max_length is not None, + max_length=self.max_length, + return_tensors=self.return_tensors, + add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens + ) + labels = output["input_ids"].clone() + labels[output["attention_mask"] == 0] = -100 + # We mask only padding tokens (-100) in the labels. Vision tokens are left unchanged because their handling in + # loss computation has to be done by the model, and masking them here would be infeasible in practice as vision + # token definitions vary across architectures. + output["labels"] = labels + return output + + def _collate_prompt_completion(self, examples: list[dict[str, Any]]) -> dict[str, Any]: + if self.pad_to_multiple_of is not None: + raise NotImplementedError( + "Padding to a multiple of a value is not yet implemented for vision-language modeling and " + "prompt-completion data." + ) + if "image" in examples[0]: + for example in examples: + example["images"] = [example.pop("image")] + images = [example["images"] for example in examples] + # Transformers requires at least one image in the batch, otherwise it throws an error + if all(img_list == [] for img_list in images): + images = None + if is_conversational(examples[0]): # conversational case + for example in examples: + example["prompt"] = prepare_multimodal_messages(example["prompt"], images=example["images"]) + example["completion"] = prepare_multimodal_messages(example["completion"]) + examples = [apply_chat_template(example, self.processor) for example in examples] + + prompts = [example["prompt"] for example in examples] + completions = [example["completion"] for example in examples] + + processed_prompts = self.processor( + images=images, + text=prompts, + padding=True, + padding_side="left", + return_tensors=self.return_tensors, + add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens + ) + processed_completions = self.processor( + text=completions, + padding=True, + padding_side="right", + return_tensors=self.return_tensors, + add_special_tokens=False, # to avoid adding the BOS, twice see https://huggingface.co/blog/qgallouedec/gotchas-in-tokenizer-behavior#7-chat-template-and-tokenization-dont-compose-due-to-special-tokens + ) + + # Concatenate prompts and completions + prompt_ids, prompt_mask = processed_prompts["input_ids"], processed_prompts["attention_mask"] + completion_ids, completion_mask = processed_completions["input_ids"], processed_completions["attention_mask"] + input_ids = torch.cat((prompt_ids, completion_ids), dim=1) + attention_mask = torch.cat((prompt_mask, completion_mask), dim=1) + completion_mask = torch.cat((torch.zeros_like(prompt_mask), completion_mask), dim=1) + if "token_type_ids" in processed_prompts: # special case for Gemma + prompt_token_type_ids = processed_prompts["token_type_ids"] + completion_token_type_ids = processed_completions["token_type_ids"] + token_type_ids = torch.cat((prompt_token_type_ids, completion_token_type_ids), dim=1) + if "mm_token_type_ids" in processed_prompts: # special case for ERNIE-VL + prompt_mm_token_type_ids = processed_prompts["mm_token_type_ids"] + completion_mm_token_type_ids = processed_completions.get( + "mm_token_type_ids", torch.zeros_like(completion_ids) + ) + mm_token_type_ids = torch.cat((prompt_mm_token_type_ids, completion_mm_token_type_ids), dim=1) + + # Flush left to reduce padding + if "token_type_ids" in processed_prompts and "mm_token_type_ids" in processed_prompts: + attention_mask, input_ids, completion_mask, token_type_ids, mm_token_type_ids = flush_left( + attention_mask, input_ids, completion_mask, token_type_ids, mm_token_type_ids + ) + elif "token_type_ids" in processed_prompts: + attention_mask, input_ids, completion_mask, token_type_ids = flush_left( + attention_mask, input_ids, completion_mask, token_type_ids + ) + elif "mm_token_type_ids" in processed_prompts: + attention_mask, input_ids, completion_mask, mm_token_type_ids = flush_left( + attention_mask, input_ids, completion_mask, mm_token_type_ids + ) + else: + attention_mask, input_ids, completion_mask = flush_left(attention_mask, input_ids, completion_mask) + + # Truncate if necessary + if self.max_length is not None: + input_ids = input_ids[:, : self.max_length] + attention_mask = attention_mask[:, : self.max_length] + completion_mask = completion_mask[:, : self.max_length] + if "token_type_ids" in processed_prompts: + token_type_ids = token_type_ids[:, : self.max_length] + if "mm_token_type_ids" in processed_prompts: + mm_token_type_ids = mm_token_type_ids[:, : self.max_length] + + # Create labels and mask padding tokens + labels = input_ids.clone() + labels[attention_mask == 0] = -100 + if self.completion_only_loss: + labels[completion_mask == 0] = -100 + + # Build the output dictionary + output = processed_prompts # we take processed_prompts because it contains the images + output["input_ids"] = input_ids + output["attention_mask"] = attention_mask + output["labels"] = labels + if "token_type_ids" in processed_prompts: + output["token_type_ids"] = token_type_ids + if "mm_token_type_ids" in processed_prompts: + output["mm_token_type_ids"] = mm_token_type_ids + return output + + +def dft_loss(outputs, labels, num_items_in_batch=None): + """ + DFT loss function, as presented in [On the Generalization of SFT: A Reinforcement Learning Perspective with Reward + Rectification](https://huggingface.co/papers/2508.05629) + """ + labels = nn.functional.pad(labels, (0, 1), value=-100) + shift_labels = labels[..., 1:] + loss_mask = shift_labels != -100 + shift_labels[~loss_mask] = 0 + logprobs = selective_log_softmax(outputs.logits, shift_labels) + per_token_loss = -logprobs.exp().detach() * logprobs + if num_items_in_batch is None: + num_items_in_batch = loss_mask.sum() + loss = (per_token_loss * loss_mask).sum() / num_items_in_batch + return loss + + +class SFTTrainer(_BaseTrainer): + """ + Trainer for Supervised Fine-Tuning (SFT) method. + + This class is a wrapper around the [`~transformers.Trainer`] class and inherits all of its attributes and methods. + + Example: + + ```python + from trl import SFTTrainer + from datasets import load_dataset + + dataset = load_dataset("roneneldan/TinyStories", split="train[:1%]") + + trainer = SFTTrainer( + model="Qwen/Qwen2.5-0.5B-Instruct", + train_dataset=dataset, + ) + trainer.train() + ``` + + Args: + model (`str` or [`~transformers.PreTrainedModel`] or [`~peft.PeftModel`]): + Model to be trained. Can be either: + + - A string, being the *model id* of a pretrained model hosted inside a model repo on huggingface.co, or a + path to a *directory* containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `'./my_model_directory/'`. The model is loaded + using `.from_pretrained` (where `` is derived from the model + config) with the keyword arguments in `args.model_init_kwargs`. + - A [`~transformers.PreTrainedModel`] object. Only causal language models are supported. + - A [`~peft.PeftModel`] object. Only causal language models are supported. + args ([`SFTConfig`], *optional*): + Configuration for this trainer. If `None`, a default configuration is used. + data_collator ([`~transformers.DataCollator`], *optional*): + Function to use to form a batch from a list of elements of the processed `train_dataset` or `eval_dataset`. + Will default to [`~trainer.sft_trainer.DataCollatorForLanguageModeling`] if the model is a language model + and [`~trainer.sft_trainer.DataCollatorForVisionLanguageModeling`] if the model is a vision-language model. + Custom collators must truncate sequences before padding; the trainer does not apply post-collation + truncation. + train_dataset ([`~datasets.Dataset`] or [`~datasets.IterableDataset`]): + Dataset to use for training. This trainer supports both [language modeling](#language-modeling) type and + [prompt-completion](#prompt-completion) type. The format of the samples can be either: + + - [Standard](dataset_formats#standard): Each sample contains plain text. + - [Conversational](dataset_formats#conversational): Each sample contains structured messages (e.g., role + and content). + + The trainer also supports processed datasets (tokenized) as long as they contain an `input_ids` field. + eval_dataset ([`~datasets.Dataset`], [`~datasets.IterableDataset`] or `dict[str, Dataset | IterableDataset]`): + Dataset to use for evaluation. It must meet the same requirements as `train_dataset`. + processing_class ([`~transformers.PreTrainedTokenizerBase`], [`~transformers.ProcessorMixin`], *optional*): + Processing class used to process the data. If `None`, the processing class is loaded from the model's name + with [`~transformers.AutoProcessor.from_pretrained`]. A padding token, `tokenizer.pad_token`, must be set. + If the processing class has not set a padding token, `tokenizer.eos_token` will be used as the default. + compute_loss_func (`Callable`, *optional*): + A function that accepts the raw model outputs, labels, and the number of items in the entire accumulated + batch (batch_size * gradient_accumulation_steps) and returns the loss. For example, see the default [loss + function](https://github.com/huggingface/transformers/blob/052e652d6d53c2b26ffde87e039b723949a53493/src/transformers/trainer.py#L3618) + used by [`Trainer`]. + compute_metrics (`Callable[[EvalPrediction], dict]`, *optional*): + The function that will be used to compute metrics at evaluation. Must take a + [`~transformers.EvalPrediction`] and return a dictionary string to metric values. When passing + [`SFTConfig`] with `batch_eval_metrics` set to `True`, your `compute_metrics` function must take a boolean + `compute_result` argument. This will be triggered after the last eval batch to signal that the function + needs to calculate and return the global summary statistics rather than accumulating the batch-level + statistics. + callbacks (list of [`~transformers.TrainerCallback`], *optional*): + List of callbacks to customize the training loop. Will add those to the list of default callbacks detailed + in [here](https://huggingface.co/docs/transformers/main_classes/callback). + + If you want to remove one of the default callbacks used, use the [`~transformers.Trainer.remove_callback`] + method. + optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *optional*, defaults to `(None, None)`): + A tuple containing the optimizer and the scheduler to use. Will default to an instance of `AdamW` on your + model and a scheduler given by [`~transformers.get_linear_schedule_with_warmup`] controlled by `args`. + optimizer_cls_and_kwargs (`tuple[Type[torch.optim.Optimizer], Dict[str, Any]]`, *optional*): + A tuple containing the optimizer class and keyword arguments to use. Overrides `optim` and `optim_args` in + `args`. Incompatible with the `optimizers` argument. + + Unlike `optimizers`, this argument avoids the need to place model parameters on the correct devices before + initializing the Trainer. + preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`, *optional*): + A function that preprocess the logits right before caching them at each evaluation step. Must take two + tensors, the logits and the labels, and return the logits once processed as desired. The modifications made + by this function will be reflected in the predictions received by `compute_metrics`. + + Note that the labels (second parameter) will be `None` if the dataset does not have them. + peft_config ([`~peft.PeftConfig`], *optional*): + PEFT configuration used to wrap the model. If `None`, the model is not wrapped. + formatting_func (`Callable`, *optional*): + Formatting function applied to the dataset before tokenization. Applying the formatting function explicitly + converts the dataset into a [language modeling](#language-modeling) type. + """ + + _tag_names = ["trl", "sft"] + _name = "SFT" + + def __init__( + self, + model: "str | PreTrainedModel | PeftModel", + args: SFTConfig | TrainingArguments | None = None, + data_collator: DataCollator | None = None, + train_dataset: Dataset | IterableDataset | None = None, + eval_dataset: Dataset | IterableDataset | dict[str, Dataset | IterableDataset] | None = None, + processing_class: PreTrainedTokenizerBase | ProcessorMixin | None = None, + compute_loss_func: Callable | None = None, + compute_metrics: Callable[[EvalPrediction], dict] | None = None, + callbacks: list[TrainerCallback] | None = None, + optimizers: tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None] = (None, None), + optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, Any]] | None = None, + preprocess_logits_for_metrics: Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, + peft_config: "PeftConfig | None" = None, + formatting_func: Callable[[dict], str] | None = None, + ): + # Args + if args is None: + model_name = model if isinstance(model, str) else get_config_model_id(model.config) + model_name = model_name.split("/")[-1] + args = SFTConfig(f"{model_name}-SFT") + elif isinstance(args, TrainingArguments) and not isinstance(args, SFTConfig): + dict_args = args.to_dict() + dict_args["hub_token"] = args.hub_token # to_dict hides the hub_token + if Version(transformers.__version__) < Version("5.0.0"): + dict_args.pop("push_to_hub_token") + args = SFTConfig(**dict_args) + + if train_dataset is None: + raise ValueError("`train_dataset` is required") + elif isinstance(train_dataset, IterableDataset): + # IterableDataset requires dispatch_batches=False because Accelerate's dispatch mode may try to concatenate + # batches from multiple processes, leading to mismatch errors. + if args.accelerator_config.dispatch_batches is True: + logger.warning( + "You are using an `IterableDataset` for training with `dispatch_batches=True`. `dispatch_batches` " + "is forced to `False` when using an `IterableDataset`. To remove this warning, unset " + "`dispatch_batches` in `SFTConfig` or set it to `False`." + ) + args.accelerator_config.dispatch_batches = False + + # Model + if isinstance(model, str): + model_init_kwargs = args.model_init_kwargs or {} + # Distributed training requires device_map=None ("auto" fails) + if args.distributed_state.distributed_type in ["MULTI_GPU", "DEEPSPEED"]: + model_init_kwargs["device_map"] = None + model_init_kwargs.setdefault("trust_remote_code", args.trust_remote_code) + model = create_model_from_path(model, **model_init_kwargs) + else: + if args.model_init_kwargs is not None: + logger.warning( + "You passed `model_init_kwargs` to the `SFTConfig`, but your model is already instantiated. " + "The `model_init_kwargs` will be ignored." + ) + # Non-quantized models do not have the `is_loaded_in_{8,4}bit` attributes, whereas quantized models do + _is_quantized_model = getattr(model, "is_loaded_in_4bit", False) or getattr(model, "is_loaded_in_8bit", False) + + # Processing class + if processing_class is None: + processing_class = AutoProcessor.from_pretrained( + get_config_model_id(model.config), trust_remote_code=args.trust_remote_code + ) + + # Handle pad token for processors or tokenizers + if isinstance(processing_class, ProcessorMixin): + self._tokenizer = processing_class.tokenizer + self._is_vlm = True + elif isinstance(processing_class, PreTrainedTokenizerBase): + self._tokenizer = processing_class + self._is_vlm = False + else: + raise TypeError("The `processing_class` must be either a `PreTrainedTokenizerBase` or a `ProcessorMixin`") + + if args.eos_token is not None: + if args.eos_token not in self._tokenizer.get_vocab(): + raise ValueError( + f"The specified `eos_token` ('{args.eos_token}') is not found in the vocabulary of the given " + f"`processing_class` ({processing_class.__class__.__name__}). Ensure that the `eos_token` exists " + "in the vocabulary before using it as an EOS token." + ) + self._tokenizer.eos_token = args.eos_token + + if args.chat_template_path is not None: + if os.path.isfile(args.chat_template_path) and args.chat_template_path.endswith((".jinja", ".j2")): + with open(args.chat_template_path, encoding="utf-8") as chat_template_file: + processing_class.chat_template = chat_template_file.read() + added_tokens = [] + else: + model, processing_class, added_tokens = clone_chat_template( + model, processing_class, args.chat_template_path + ) + else: + added_tokens = [] + + # Catch some wrong configurations related to VLMs + if self._is_vlm and args.packing: + raise ValueError( + "Packing is not supported for vision-language models. Please set `packing=False` in the SFTConfig." + ) + if self._is_vlm and args.padding_free: + raise ValueError( + "Padding-free training is yet not supported for vision-language models. Please set " + "`padding_free=False` in the `SFTConfig`." + ) + if self._is_vlm and args.assistant_only_loss: + raise ValueError( + "Assistant-only loss is not yet supported for vision-language models. Please set " + "`assistant_only_loss=False` in the `SFTConfig`." + ) + if self._is_vlm and args.max_length is not None and args.truncation_mode == "keep_end": + raise ValueError( + "truncation_mode='keep_end' is not supported for vision-language models. Image tokens reside " + "inside the prompt portion of the sequence; depending on the example, keep_end may silently " + "drop them, causing pixel_values to be forwarded to the model with no corresponding visual " + "tokens in input_ids. Use truncation_mode='keep_start' (the default) or set max_length=None." + ) + + # PEFT + if peft_config is not None: + if not is_peft_available(): + raise ImportError( + "You passed `peft_config` but the `peft` library is not installed. " + "Install it with `pip install trl[peft]`." + ) + if not isinstance(peft_config, PeftConfig): + raise TypeError( + f"`peft_config` must be a `peft.PeftConfig` instance (e.g. `peft.LoraConfig`), " + f"got {type(peft_config).__name__}." + ) + if is_peft_model(model): + raise ValueError( + "You passed a `PeftModel` instance together with a `peft_config` to the trainer. Please first merge " + "and unload the existing adapter, save the resulting base model, and then pass that base model along " + "with the new `peft_config` to the trainer." + ) + if added_tokens: + # Ensure that the added tokens are trainable + if peft_config.trainable_token_indices is None: + peft_config.trainable_token_indices = {"embed_tokens": added_tokens} + elif "embed_tokens" not in peft_config.trainable_token_indices: + peft_config.trainable_token_indices["embed_tokens"] = added_tokens + else: + peft_config.trainable_token_indices["embed_tokens"].extend(added_tokens) + # Ensure that the lm_head is trainable + if peft_config.modules_to_save is None or "lm_head" not in peft_config.modules_to_save: + logger.warning( + "Cloning chat template added new tokens to the tokenizer, but 'lm_head' is not in PEFT's " + "`modules_to_save`. As a result, the model may not learn to generate outputs with these new " + "tokens, leading to degraded generation quality. To fix this, add " + "`modules_to_save=['lm_head']` to your PEFT configuration." + ) + + if peft_config.modules_to_save is None: + peft_config.modules_to_save = ["lm_head"] + else: + peft_config.modules_to_save.append("lm_head") + # Create PEFT model + # ZeRO-3 + PEFT for non-quantized models: + # - PEFT's default autocast_adapter_dtype=True upcasts LoRA adapter params to fp32 even when the base model is bf16. + # - ZeRO-3's _allgather_params_coalesced allocates output buffers using the dtype of the first persistent parameter, + # so mixed-dtype persistent_parameters (bf16 base + fp32 LoRA) cause a TypeError on the first optimizer step. + # - Passing autocast_adapter_dtype=False keeps adapter params in the base model dtype (bf16), fixing the mismatch. + # - This is safe: the fp32 upcast is a QLoRA-specific concern (low-bit quantized base models), not needed for + # non-quantized bf16 training. + # - See: + # - TRL issue: https://github.com/huggingface/trl/issues/6089 + # - Upstream issue: https://github.com/deepspeedai/DeepSpeed/issues/8072 + # - autocast_adapter_dtype was introduced in PEFT 0.12.0; before, no upcast existed: no need to pass the kwarg + get_peft_model_kwargs = {} + if ( + args.deepspeed_plugin is not None + and args.deepspeed_plugin.zero_stage == 3 + and not _is_quantized_model + and Version(peft.__version__) >= Version("0.12.0") + ): + get_peft_model_kwargs["autocast_adapter_dtype"] = False + model = get_peft_model(model, peft_config, **get_peft_model_kwargs) + + # PEFT + DeepSpeed ZeRO-3 requires reentrant checkpointing. For more details, see + # https://github.com/huggingface/trl/issues/2514#issuecomment-2692152703 + if ( + is_peft_model(model) + and args.deepspeed_plugin is not None + and args.deepspeed_plugin.zero_stage == 3 + and args.gradient_checkpointing + ): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + use_reentrant = args.gradient_checkpointing_kwargs.get("use_reentrant") + if use_reentrant is False: + logger.warning( + "You are using PEFT with DeepSpeed ZeRO-3 and gradient checkpointing with `use_reentrant=False`. " + "`use_reentrant` is forced to `True` in this configuration to ensure correct training. To remove " + "this warning, unset `use_reentrant` in `gradient_checkpointing_kwargs` or set it to `True`." + ) + args.gradient_checkpointing_kwargs["use_reentrant"] = True + + # When using gradient checkpointing with PEFT, we need to enable input gradients. transformers.Trainer normally + # handles this, but a bug currently prevents it; see https://github.com/huggingface/transformers/issues/42489 + if is_peft_model(model) and args.gradient_checkpointing: + model.enable_input_require_grads() + + # When using QLoRA, the PEFT adapter weights are converted to bf16 to follow the recommendations from the + # original paper (see https://huggingface.co/papers/2305.14314, paragraph 3). Normally, this can be done by + # passing `autocast_adapter_dtype=False` to `get_peft_model`, but this option is not yet supported for + # quantized models. See: https://github.com/huggingface/peft/issues/2889 + if _is_quantized_model: + for param in model.parameters(): + if param.requires_grad: + param.data = param.data.to(torch.bfloat16) + + # In Prompt Tuning a small set of trainable virtual tokens (continuous prompt embeddings) is prepended to the + # input. We store the number of these tokens so we can account for them correctly when calculating accuracy. + self.num_virtual_tokens = 0 + if is_peft_model(model): + if model.active_adapter in model.peft_config: + peft_model_config = model.peft_config[model.active_adapter] + self.num_virtual_tokens = getattr(peft_model_config, "num_virtual_tokens", 0) + + # Data collator + # BFD packing requires padding-free mode; otherwise, the collator outputs padded attention masks, causing + # FlashAttention to ignore position_ids and recompute them incorrectly from the padded attention mask. + self.padding_free = args.padding_free or (args.packing and args.packing_strategy in {"bfd", "bfd_split"}) + use_flash_attention = model.config._attn_implementation in FLASH_ATTENTION_VARIANTS + if self.padding_free: + if data_collator is not None: + raise ValueError("Passing a custom data collator is not supported when using padding-free.") + if args.packing and args.packing_strategy == "wrapped": + logger.warning( + "You are passing `padding_free=True` with the 'wrapped' packing strategy, which is not " + "recommended. Please refer to the documentation to understand why this is not recommended." + ) + if not use_flash_attention: + logger.warning( + "Padding-free training is enabled, but the attention implementation is not set to a supported " + "Flash Attention variant. Padding-free training flattens batches into a single sequence, and only " + "the following implementations are known to reliably support this: " + f"{', '.join(sorted(FLASH_ATTENTION_VARIANTS))}. Using other implementations may lead to " + "unexpected behavior. To ensure compatibility, set `attn_implementation` in the model " + "configuration to one of these supported options or verify that your attention mechanism can " + "handle flattened sequences." + ) + + if args.per_device_train_batch_size == 1 and not args.packing: + logger.warning( + "You are using a per_device_train_batch_size of 1 with padding-free training. Using a batch size " + "of 1 annihilate the benefits of padding-free training. Please consider increasing the batch size " + "to at least 2." + ) + + # Decide whether to use completion-only loss: if not specified, then it is set to True if the dataset format + # is prompt-completion, and False if the dataset format is language modeling. + dataset_sample = next(iter(train_dataset)) + if args.completion_only_loss is None: + self.completion_only_loss = "prompt" in dataset_sample and "completion" in dataset_sample + else: + self.completion_only_loss = args.completion_only_loss + + self._is_vision_dataset = "image" in dataset_sample or "images" in dataset_sample + if self._is_vision_dataset and not self._is_vlm: + raise ValueError( + "The dataset appears to be vision-related (contains 'image' or 'images' keys), but the provided " + "model does not seem to be a vision-language model. Please check your model and dataset." + ) + + if data_collator is None and not self._is_vision_dataset: + # Get the pad token: if not provided, use the one from the processing class or the eos token + # if the processing class does not have a pad token. + pad_token = args.pad_token or self._tokenizer.pad_token or self._tokenizer.eos_token + if pad_token not in self._tokenizer.get_vocab(): + raise ValueError( + f"The specified `pad_token` ('{pad_token}') is not found in the vocabulary of the given " + f"`processing_class` ({processing_class.__class__.__name__}). Ensure that the `pad_token` exists " + "in the vocabulary before using it as a padding token." + ) + self._tokenizer.pad_token = pad_token + data_collator = DataCollatorForLanguageModeling( + pad_token_id=self._tokenizer.pad_token_id, + max_length=None if self.padding_free else args.max_length, + truncation_mode=args.truncation_mode, + completion_only_loss=self.completion_only_loss, + padding_free=self.padding_free, + pad_to_multiple_of=args.pad_to_multiple_of, + ) + elif data_collator is None and self._is_vision_dataset: + data_collator = DataCollatorForVisionLanguageModeling( + processor=processing_class, + max_length=args.max_length, + completion_only_loss=self.completion_only_loss, + pad_to_multiple_of=args.pad_to_multiple_of, + dataset_text_field=args.dataset_text_field, + ) + + if args.packing and args.packing_strategy in {"bfd", "bfd_split"} and not use_flash_attention: + logger.warning( + "You are using packing, but the attention implementation is not set to a supported Flash Attention " + "variant. Packing gathers multiple samples into a single sequence, and only the following " + f"implementations are known to reliably support this: {', '.join(sorted(FLASH_ATTENTION_VARIANTS))}. " + "Using other implementations may lead to cross-contamination between samples. To avoid this, either " + "disable packing by setting `packing=False`, or set `attn_implementation` in the model configuration " + "to one of these supported options." + ) + if args.assistant_only_loss and not is_conversational(dataset_sample): + raise ValueError( + "You set `assistant_only_loss=True`, but the dataset is not conversational. This option is only " + "supported for conversational datasets." + ) + + # When assistant_only_loss is enabled, swap in a training chat template with {% generation %} markers + # if the current template doesn't already have them. + if args.assistant_only_loss and not has_generation_markers(processing_class.chat_template): + self.chat_template = get_training_chat_template(processing_class) + else: + self.chat_template = None + + # A template can define generation markers and still attribute the assistant's end-of-turn token to the next + # message, leaving it out of the assistant mask so the model is never trained to stop. + if args.assistant_only_loss and not is_chat_template_stop_token_trained( + processing_class, chat_template=self.chat_template + ): + logger.warning( + "The chat template does not include the assistant turn's end-of-turn token in the loss mask; " + "the model may not learn to stop." + ) + + # Dataset + if self.padding_free and not args.packing and args.max_length is not None and not self._is_vision_dataset: + raise ValueError( + "When `padding_free=True` without packing, `max_length` is not enforced. Either enable packing " + "(e.g., `packing=True, packing_strategy='bfd'`), provide already truncated inputs, or set " + "`max_length=None`." + ) + # Skip dataset preparation if `skip_prepare_dataset=True` in `dataset_kwargs`, or if it's a VLM, where + # preprocessing (e.g., image-to-pixel conversion) is too costly and done on the fly instead. + skip_prepare_dataset = ( + args.dataset_kwargs is not None + and args.dataset_kwargs.get("skip_prepare_dataset", False) + or self._is_vision_dataset + ) + # Kept on the instance so that `evaluate` can preprocess freshly-passed eval datasets the same way. + self._formatting_func = formatting_func + self._skip_prepare_dataset = skip_prepare_dataset + if not skip_prepare_dataset: + if self.completion_only_loss and formatting_func: + raise ValueError( + "A formatting function was provided while `completion_only_loss=True`, which is incompatible. " + "Using a formatter converts the dataset to a language modeling type, conflicting with " + "completion-only loss. To resolve this, apply your formatting function before passing the " + "dataset, or disable `completion_only_loss` in `SFTConfig`." + ) + train_dataset = self._prepare_dataset( + train_dataset, processing_class, args, args.packing, formatting_func, "train" + ) + if eval_dataset is not None: + packing = args.packing if args.eval_packing is None else args.eval_packing + if isinstance(eval_dataset, dict): + eval_dataset = { + key: self._prepare_dataset(dataset, processing_class, args, packing, formatting_func, key) + for key, dataset in eval_dataset.items() + } + else: + eval_dataset = self._prepare_dataset( + eval_dataset, processing_class, args, packing, formatting_func, "eval" + ) + + # Loss function + if not args.use_liger_kernel: # liger supports dft loss by just passing use_token_scaling=True + if args.loss_type == "nll": + pass # use the default loss + elif args.loss_type == "dft": + if compute_loss_func is not None: + raise ValueError( + "You passed a `compute_loss_func` together with `loss_type='dft'` to the `SFTTrainer`. " + "When using `loss_type='dft'`, the loss function is internally set to the DFT loss, so " + "passing a `compute_loss_func` is not allowed." + ) + compute_loss_func = dft_loss + elif args.loss_type == "chunked_nll": + # Same math as `"nll"` but the `lm_head` matmul is skipped on ignored tokens and the CE is computed in + # chunks of tokens. Implemented by patching the model's forward before `super().__init__` so accelerate + # wraps the patched forward. + # For PEFT, patch the inner causal LM rather than the `PeftModel` wrapper. LoRA / IA³ / + # `modules_to_save` adapters live in the module tree, so they're hit even when we bypass + # `PeftModel.forward`. Prompt-learning variants need `PeftModel.forward` to run first (to inject + # virtual tokens), then it delegates into the patched inner forward. + target = model.get_base_model() if is_peft_model(model) else model + # The chunked path reads the output projection weight directly, which would silently drop the + # adapter delta (and starve its parameters of gradients) if the head itself is a PEFT tuner layer. + if is_peft_model(model): + from peft.tuners.tuners_utils import BaseTunerLayer + + if isinstance(target.get_output_embeddings(), BaseTunerLayer): + raise ValueError( + "`loss_type='chunked_nll'` is not supported when `lm_head` is wrapped by a PEFT adapter " + "(e.g. `target_modules='all-linear'` or explicitly including `'lm_head'`). Either remove " + "`lm_head` from `target_modules`, or switch to `loss_type='nll'`. If this is a real use " + "case for you, please open an issue at https://github.com/huggingface/trl/issues." + ) + _patch_chunked_ce_lm_head(target, chunk_size=_CHUNKED_LM_HEAD_CHUNK_SIZE, is_vlm=self._is_vlm) + else: + raise ValueError( + f"Invalid `loss_type` {args.loss_type} passed. Supported values are 'nll', 'dft', and " + "'chunked_nll'." + ) + elif args.loss_type == "chunked_nll": + raise ValueError("`loss_type='chunked_nll'` is not compatible with `use_liger_kernel=True`.") + + # Transformers explicitly set use_reentrant=True in the past to silence a PyTorch warning, but the default was + # never updated once PyTorch switched to recommending use_reentrant=False. Until that change lands upstream + # (see https://github.com/huggingface/transformers/pull/43203) and is released (most likely in 5.0.0), we + # default to the recommended non-reentrant behavior here, while preserving any user-provided value. + if args.gradient_checkpointing and Version(transformers.__version__) < Version("5.0.0"): + args.gradient_checkpointing_kwargs = args.gradient_checkpointing_kwargs or {} + args.gradient_checkpointing_kwargs.setdefault("use_reentrant", False) + + super().__init__( + model=model, + args=args, + data_collator=data_collator, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=processing_class, + compute_loss_func=compute_loss_func, + compute_metrics=compute_metrics, + callbacks=callbacks, + optimizers=optimizers, + optimizer_cls_and_kwargs=optimizer_cls_and_kwargs, + preprocess_logits_for_metrics=preprocess_logits_for_metrics, + ) + + # Initialize activation offloading context + if self.args.activation_offloading: + self.maybe_activation_offload_context = get_act_offloading_ctx_manager(model=self.model) + else: + self.maybe_activation_offload_context = contextlib.nullcontext() + + # MoE load-balancing auxiliary loss, applied to Mixture-of-Experts models (no effect otherwise) + text_config = model.config.get_text_config() + is_moe = getattr(text_config, "output_router_logits", None) is not None + self.aux_loss_enabled = is_moe and self.args.router_aux_loss_coef != 0.0 + if is_moe: + # The native and chunked forwards add the aux loss from the model config, so keep the config in sync with + # the coef: enable it (and propagate the coef) when non-zero, disable it otherwise. This overrides any + # `output_router_logits` the model was loaded with, so `router_aux_loss_coef=0.0` reliably turns it off. + text_config.output_router_logits = self.aux_loss_enabled + text_config.router_aux_loss_coef = self.args.router_aux_loss_coef + + # Initialize the metrics + self._metrics = {"train": defaultdict(list), "eval": defaultdict(list)} + self._total_train_tokens = 0 + + # Add tags to the model + self.model.add_model_tags(self._tag_names) + + def _tokenize( + self, + processing_class: PreTrainedTokenizerBase | ProcessorMixin, + input: str | list, + **kwargs, + ) -> dict[str, list]: + """Tokenize a single example for dataset preprocessing. + + Dispatches to `apply_chat_template` for conversational input (list of message dicts) and to `__call__` for + non-conversational input (str). For VLMs, normalizes the batch dimension that processors emit even for single + examples. + + Args: + processing_class ([`~transformers.PreTrainedTokenizerBase`] or [`~transformers.ProcessorMixin`]): + The tokenizer or processor to use. + input (`str` or `list`): + A string for non-conversational input, or a list of message dicts for conversational input. + **kwargs: + Forwarded to `apply_chat_template` (e.g. `add_generation_prompt`, `return_assistant_tokens_mask`). + + Returns: + `dict` with at least an `"input_ids"` key mapping to a flat `list[int]`. + """ + if isinstance(input, list): # conversational: list of message dicts + if self._is_vlm: + input = prepare_multimodal_messages(input) + result = processing_class.apply_chat_template( + input, tokenize=True, return_dict=True, chat_template=self.chat_template, **kwargs + ) + else: # non-conversational: plain text string + result = processing_class(text=input) + # VLMs emit a batch dimension even for single examples; unwrap it + if self._is_vlm: + return {k: v[0] for k, v in result.items()} + return result + + def _prepare_dataset( + self, + dataset: Dataset | IterableDataset, + processing_class: PreTrainedTokenizerBase | ProcessorMixin, + args: SFTConfig, + packing: bool, + formatting_func: Callable[[dict], str] | None, + dataset_name: str, + ) -> Dataset | IterableDataset: + if isinstance(dataset, Dataset) and dataset.format["type"] == "custom": + raise ValueError( + "SFTTrainer cannot prepare a dataset that uses `Dataset.with_transform()`. The preparation pipeline " + "calls `Dataset.map()`, which reads through the transform and can bake a random or stateful transform " + "into the tokenized columns. Pass `dataset_kwargs={'skip_prepare_dataset': True}` and make the " + "transform return trainer-ready examples, including tokenized fields, or materialize deterministic " + "transforms with `Dataset.map()` before constructing the trainer." + ) + + # If the dataset is already preprocessed (tokenized), skip the processing steps. + column_names = get_dataset_column_names(dataset) + is_processed = "input_ids" in column_names + + # Build the kwargs for the `map` function + map_kwargs = {} + if isinstance(dataset, Dataset): # IterableDataset does not support num_proc + map_kwargs["num_proc"] = args.dataset_num_proc + + with PartialState().main_process_first(): + # Apply the formatting function if any + if formatting_func is not None and is_processed: + logger.warning( + "You passed a dataset that is already processed (contains an `input_ids` field) together with a " + "formatting function. Therefore `formatting_func` will be ignored. Either remove the " + "`formatting_func` or pass a dataset that is not already processed.", + ) + + if formatting_func is not None and not is_processed: + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Applying formatting function to {dataset_name} dataset" + + def _func(example): + return {"text": formatting_func(example)} + + dataset = dataset.map(_func, batched=False, **map_kwargs) + + if not is_processed: + # Convert the dataset to ChatML if needed + first_example = next(iter(dataset)) + if is_conversational_from_value(first_example): + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Converting {dataset_name} dataset to ChatML" + column_names = get_dataset_column_names(dataset) + dataset = dataset.map( + maybe_convert_to_chatml, + remove_columns="conversations" if "conversations" in column_names else None, + **map_kwargs, + ) + + # Add EOS token if needed: non-conversational only + first_example = next(iter(dataset)) + if not is_conversational(first_example): + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Adding EOS to {dataset_name} dataset" + + def add_eos(example, eos_token): + if "text" in example and not example["text"].endswith(eos_token): # language modeling case + example["text"] = example["text"] + eos_token + elif "completion" in example and not example["completion"].endswith(eos_token): + example["completion"] = example["completion"] + eos_token + return example + + dataset = dataset.map( + add_eos, + fn_kwargs={"eos_token": self._tokenizer.eos_token}, + remove_columns="messages" if "messages" in column_names else None, # renamed to "text" + **map_kwargs, + ) + + # Tokenize the dataset + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Tokenizing {dataset_name} dataset" + + def tokenize_fn(example, processing_class, dataset_text_field, assistant_only_loss): + tools = example.get("tools") + tools = json.loads(tools) if isinstance(tools, str) else tools + if "prompt" in example: # prompt-completion case + output = {} + if is_conversational(example): + prompt_ids = self._tokenize( + processing_class, + example["prompt"], + tools=tools, + add_generation_prompt=True, + **example.get("chat_template_kwargs", {}), + )["input_ids"] + prompt_completion_processed = self._tokenize( + processing_class, + example["prompt"] + example["completion"], + tools=tools, + return_assistant_tokens_mask=assistant_only_loss, + **example.get("chat_template_kwargs", {}), + ) + prompt_completion_ids = prompt_completion_processed["input_ids"] + if "assistant_masks" in prompt_completion_processed: + output["assistant_masks"] = prompt_completion_processed["assistant_masks"] + else: + prompt_ids = self._tokenize(processing_class, example["prompt"])["input_ids"] + prompt_completion_ids = self._tokenize( + processing_class, example["prompt"] + example["completion"] + )["input_ids"] + + # Check if the tokenized prompt starts with the tokenized prompt+completion + if not prompt_completion_ids[: len(prompt_ids)] == prompt_ids: + logger.warning( + "Mismatch between tokenized prompt and the start of tokenized prompt+completion. " + "This may be due to unexpected tokenizer behavior, whitespace issues, or special " + "token handling. Verify that the tokenizer is processing text consistently." + ) + + # Create completion mask + completion_mask = [0] * len(prompt_ids) + [1] * (len(prompt_completion_ids) - len(prompt_ids)) + output["input_ids"] = prompt_completion_ids + output["completion_mask"] = completion_mask + + else: # language modeling case + if is_conversational(example): + processed = self._tokenize( + processing_class, + example["messages"], + tools=tools, + return_assistant_tokens_mask=assistant_only_loss, + **example.get("chat_template_kwargs", {}), + ) + output = {k: processed[k] for k in ("input_ids", "assistant_masks") if k in processed} + else: + output = { + "input_ids": self._tokenize(processing_class, example[dataset_text_field])["input_ids"] + } + + if "assistant_masks" in output and 1 not in output["assistant_masks"]: + raise RuntimeError( + "You're using `assistant_only_loss=True`, but at least one example has no assistant " + "tokens. This usually means the tokenizer's chat template doesn't generate assistant " + "masks — it may be missing the `{% generation %}` keyword. Please check the template and " + "ensure it's correctly configured to support assistant masking." + ) + return output + + dataset = dataset.map( + tokenize_fn, + fn_kwargs={ + "processing_class": processing_class, + "dataset_text_field": args.dataset_text_field, + "assistant_only_loss": args.assistant_only_loss, + }, + **map_kwargs, + ) + + # Pack + if packing: + if args.max_length is None: + raise ValueError("When packing is enabled, `max_length` can't be `None`.") + if isinstance(dataset, Dataset): # `IterableDataset.map` does not support `desc` + map_kwargs["desc"] = f"Packing {dataset_name} dataset" + + columns = ["input_ids"] + if "completion_mask" in get_dataset_column_names(dataset): + columns.append("completion_mask") + if "assistant_masks" in get_dataset_column_names(dataset): + columns.append("assistant_masks") + + dataset = dataset.select_columns(columns) + + # Shuffle the dataset before packing. When using wrapped packing, it's important to shuffle before + # packing as well to avoid correlations between sequences packed together. + if args.shuffle_dataset: + dataset = dataset.shuffle(seed=args.seed) + + # Packing adds new column "seq_lengths" needed for document aware FlashAttention + dataset = pack_dataset(dataset, args.max_length, args.packing_strategy, map_kwargs) + # For Liger kernel, ensure only the essential columns + if args.use_liger_kernel: + collator_expected_keys = {"input_ids", "seq_lengths", "completion_mask", "assistant_masks"} + column_names = get_dataset_column_names(dataset) + dataset = dataset.select_columns(collator_expected_keys.intersection(column_names)) + + if args.shuffle_dataset: + dataset = dataset.shuffle(seed=args.seed) + + return dataset + + def _set_signature_columns_if_needed(self): + # If `self.args.remove_unused_columns` is True, non-signature columns are removed. + # By default, this method sets `self._signature_columns` to the model's expected inputs (usually, "input_ids" + # and "attention_mask"). When using `train_on_completion_only` we add a "completion_mask" column to the + # dataset. So we need to override the default signature columns to include "completion_mask" as well. + if self._signature_columns is None: + if self._is_vision_dataset: + self._signature_columns = ["messages", "prompt", "completion", "image", "images"] + else: + self._signature_columns = ["input_ids", "labels", "seq_lengths", "completion_mask", "assistant_masks"] + + def evaluate( + self, + eval_dataset: Dataset | dict[str, Dataset] | None = None, + ignore_keys: list[str] | None = None, + metric_key_prefix: str = "eval", + ) -> dict[str, float]: + # When a dataset is passed directly to `evaluate` (e.g. a held-out test set), preprocess it the same way + # `__init__` does, so that `evaluate` accepts the same dataset types as the trainer (language modeling, + # prompt-completion, etc.). `_prepare_dataset` is idempotent: it skips datasets that are already tokenized. A + # `str` selects a dataset that was already prepared at init time, so it's left untouched. + if not self._skip_prepare_dataset and eval_dataset is not None and not isinstance(eval_dataset, str): + packing = self.args.packing if self.args.eval_packing is None else self.args.eval_packing + if isinstance(eval_dataset, dict): + eval_dataset = { + key: self._prepare_dataset( + dataset, self.processing_class, self.args, packing, self._formatting_func, key + ) + for key, dataset in eval_dataset.items() + } + else: + eval_dataset = self._prepare_dataset( + eval_dataset, self.processing_class, self.args, packing, self._formatting_func, "eval" + ) + return super().evaluate( + eval_dataset=eval_dataset, ignore_keys=ignore_keys, metric_key_prefix=metric_key_prefix + ) + + def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None): + mode = "train" if self.model.training else "eval" + prediction_loss_only = inputs.pop("_prediction_loss_only", None) + + # Set aside labels as it will be dropped by super().compute_loss() if a custom `compute_loss_func` is used. + # This can be removed when this issue is fixed. + # When using CP or SP, labels are pre-shifted, we must use shift_labels instead. + labels = inputs["labels"] if "shift_labels" not in inputs else None + + # If not set, defaults from model config and may warn since cache isn't compatible with gradient checkpointing + inputs["use_cache"] = False + + # MoE models: request router logits so the model returns `outputs.aux_loss`. VLM wrappers honor this only + # as a forward kwarg (not from the model config), so it must be passed here. + if self.aux_loss_enabled: + inputs["output_router_logits"] = True + + # Request token accuracy from Liger kernel and set token scaling if using DFT loss + if self.args.use_liger_kernel: + # Avoid materializing full logits during eval unless explicitly needed. + # By default, liger kernel only skips logits during training (self.training=True). + # When only loss is needed for eval (no compute_metrics), we can safely skip logits. + # prediction_step communicates whether logits are expected via `_prediction_loss_only`; + # this prevents skipping logits during `predict()` where outputs are requested. + # Keep logits when preprocess_logits_for_metrics is set, even if compute_metrics is None. + # to prevent massive vRAM spikes from the lm_head projection. + # See: https://github.com/huggingface/trl/issues/4679 + inputs["skip_logits"] = ( + self.model.training + or self.args.prediction_loss_only + or ( + self.compute_metrics is None + and self.preprocess_logits_for_metrics is None + and prediction_loss_only is not False + ) + ) + inputs["return_token_accuracy"] = True + inputs["use_token_scaling"] = self.args.loss_type == "dft" + + try: + (loss, outputs) = super().compute_loss( + model, inputs, return_outputs=True, num_items_in_batch=num_items_in_batch + ) + except ValueError as e: + if "Image features and image tokens do not match" in str(e) and self.args.max_length is not None: + raise ValueError( + f"The current `max_length` ({self.args.max_length}) is too short and causes image placeholder " + f"tokens in `input_ids` to be truncated, while the corresponding image features remain intact. " + f"Please increase `max_length` or set it to `None` to disable truncation." + ) from e + raise + + # Compute entropy + if self.args.loss_type == "chunked_nll": + # Use `num_valid_tokens` from the patched forward rather than recomputing from `labels`. Prompt-learning + # PEFT (PromptTuning, P-Tuning) prepends `-100`-padded virtual tokens before delegating into the patched + # forward, so the valid-token count over the padded labels can differ from the un-padded `labels[..., 1:]` + # count by up to one per sequence; using the patched output keeps numerator and denominator aligned. + num_valid = self.accelerator.gather_for_metrics(outputs.num_valid_tokens).sum() + entropy_sum = self.accelerator.gather_for_metrics(outputs.entropy_sum).sum() + entropy = (entropy_sum / num_valid).item() if num_valid > 0 else 0.0 + self._metrics[mode]["entropy"].append(entropy) + elif not self.args.use_liger_kernel: # liger doesn't return logits + with torch.no_grad(): + if "shift_labels" in inputs: + # When using CP or SP, labels are pre-shifted. + shift_logits = outputs.logits + shift_labels = inputs["shift_labels"] + else: + shift_logits = outputs.logits[..., :-1, :] + shift_labels = labels[..., 1:] + + # Prompt Tuning and P-Tuning output logits for virtual tokens but Prefix-Tuning does not. + if ( + self.num_virtual_tokens > 0 + and model.peft_config[model.active_adapter].peft_type != PeftType.PREFIX_TUNING + ): + shift_logits = shift_logits[:, self.num_virtual_tokens :, :] + + per_token_entropy = entropy_from_logits(shift_logits) + predictions = shift_logits.argmax(dim=-1) + mask = shift_labels != -100 + + entropy_sum = (per_token_entropy * mask).sum() + total_tokens = mask.sum() + correct_predictions = (predictions == shift_labels) & mask + correct_tokens = correct_predictions.sum() + + # Gather counts across ranks and weight-average + entropy_sum = self.accelerator.gather_for_metrics(entropy_sum).sum() + total_tokens = self.accelerator.gather_for_metrics(total_tokens).sum() + correct_tokens = self.accelerator.gather_for_metrics(correct_tokens) + entropy = (entropy_sum / total_tokens).item() if total_tokens > 0 else 0.0 + + total_sum = total_tokens.sum() + accuracy = (correct_tokens.sum() / total_sum).item() if total_sum > 0 else 0.0 + self._metrics[mode]["entropy"].append(entropy) + self._metrics[mode]["mean_token_accuracy"].append(accuracy) + + if mode == "train": + # When using padding-free, the attention_mask is not present in the inputs, instead we have cu_seq_lens_q, + # cu_seq_lens_k, and max_length_k, max_length_q and position_ids. + if "attention_mask" in inputs: + num_tokens_in_batch = self.accelerator.gather_for_metrics(inputs["attention_mask"].sum()).sum().item() + elif "position_ids" in inputs: + local_num_tokens = torch.tensor(inputs["position_ids"].size(1), device=inputs["position_ids"].device) + num_tokens_in_batch = self.accelerator.gather_for_metrics(local_num_tokens).sum().item() + else: + raise ValueError("Expected 'attention_mask' or 'position_ids' in inputs.") + self._total_train_tokens += num_tokens_in_batch + self._metrics[mode]["num_tokens"] = [self._total_train_tokens] + + if self.args.loss_type == "chunked_nll": + correct = self.accelerator.gather_for_metrics(outputs.num_correct_tokens).sum() + accuracy = (correct / num_valid).item() if num_valid > 0 else 0.0 + self._metrics[mode]["mean_token_accuracy"].append(accuracy) + elif self.args.use_liger_kernel: + if hasattr(outputs, "token_accuracy") and outputs.token_accuracy is not None: + token_accuracy = self.accelerator.gather_for_metrics(outputs.token_accuracy).mean().item() + self._metrics[mode]["mean_token_accuracy"].append(token_accuracy) + else: + warnings.warn( + "liger-kernel did not return token_accuracy when requested. The mean_token_accuracy metric will " + "not be logged. This is unexpected; please report it to the liger-kernel repository.", + stacklevel=2, + ) + # Log auxiliary loss if enabled (applies to both Liger and non-Liger) + if self.aux_loss_enabled: + aux_loss = outputs.aux_loss + aux_loss = self.accelerator.gather_for_metrics(aux_loss).mean().item() + self._metrics[mode]["aux_loss"].append(aux_loss) + + return (loss, outputs) if return_outputs else loss + + def prediction_step(self, model, inputs, prediction_loss_only, ignore_keys=None): + # Preserve the eval loop intent so compute_loss can decide whether logits are needed. + inputs["_prediction_loss_only"] = prediction_loss_only + return super().prediction_step(model, inputs, prediction_loss_only, ignore_keys=ignore_keys) + + # Override training step to add activation offloading context. + def training_step(self, *args, **kwargs): + with self.maybe_activation_offload_context: + return super().training_step(*args, **kwargs) + + def log(self, logs: dict[str, float], start_time: float | None = None) -> None: + mode = "train" if self.model.training else "eval" + metrics = {key: sum(val) / len(val) for key, val in self._metrics[mode].items()} # average the metrics + + # This method can be called both in training and evaluation. When called in evaluation, the keys in `logs` + # start with "eval_". We need to add the prefix "eval_" to the keys in `metrics` to match the format. + if mode == "eval": + metrics = {f"eval_{key}": val for key, val in metrics.items()} + + logs.update(metrics) + super().log(logs, start_time) + self._metrics[mode].clear() + + # Ensure the model card is saved along with the checkpoint + def _save_checkpoint(self, model, trial): + if self.args.hub_model_id is None: + model_name = Path(self.args.output_dir).name + else: + model_name = self.args.hub_model_id.split("/")[-1] + self.create_model_card(model_name=model_name) + super()._save_checkpoint(model, trial) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/utils.py b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..dedb37dcdab3ca4b89bb490149a3fa0c11d4177c --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/source/trl/trainer/utils.py @@ -0,0 +1,1500 @@ +# Copyright 2020-2026 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 asyncio +import hashlib +import importlib.resources as pkg_resources +import os +import random +import socket +import threading +import types +from collections.abc import Mapping, Sequence, Sized +from contextlib import contextmanager +from importlib.metadata import version +from itertools import accumulate +from typing import TypeVar + +import numpy as np +import pandas as pd +import torch +import torch.nn.functional as F +import transformers +from accelerate import PartialState, logging +from huggingface_hub import ModelCard, ModelCardData +from packaging.version import Version +from torch.utils.data import Sampler +from transformers import ( + AutoConfig, + AutoModelForCausalLM, + AutoModelForImageTextToText, + BitsAndBytesConfig, + PretrainedConfig, + PreTrainedModel, + is_comet_available, + is_trackio_available, +) +from transformers.models.auto.auto_factory import _BaseAutoModelClass +from transformers.utils import ( + is_peft_available, + is_rich_available, + is_torch_xpu_available, +) + +from ..trainer.model_config import ModelConfig + + +if is_rich_available(): + from rich.console import Console + from rich.panel import Panel + from rich.table import Table + from rich.text import Text + +if is_comet_available(): + import comet_ml + +if is_peft_available(): + from peft import LoraConfig, PeftConfig, PeftModel + + +logger = logging.get_logger(__name__) + + +def _is_port_free(port: int, host: str = "127.0.0.1") -> bool: + try: + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: + s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + s.bind((host, port)) + return True + except OSError: + return False + + +def _find_free_port() -> int: + candidates = (29500, 23456, 12355, 12345) + for p in candidates: + if _is_port_free(p): + return p + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: + s.bind(("", 0)) + return s.getsockname()[1] + + +def ensure_master_addr_port(addr: str | None = None, port: int | None = None) -> None: + """ + Ensure `MASTER_ADDR`/`MASTER_PORT` are set safely. + + - Respects existing environment variables. + - Defaults `MASTER_ADDR` to localhost if unset. + - Chooses a free TCP port if `MASTER_PORT` is unset to avoid collisions. + - If `MASTER_PORT` is set to `"0"` or `"auto"`, it is resolved to a free port. + """ + os.environ["MASTER_ADDR"] = os.environ.get("MASTER_ADDR") or addr or "localhost" + + env_port = os.environ.get("MASTER_PORT", "").strip().lower() + if port is None and env_port not in {"", "0", "auto"}: + try: + port = int(env_port) + except ValueError: + pass + + os.environ["MASTER_PORT"] = str(_find_free_port() if port in (None, 0) else port) + + +def pad( + tensors: list[torch.Tensor], + padding_value: int = 0, + padding_side: str = "right", + pad_to_multiple_of: int | None = None, +) -> torch.Tensor: + """ + Pads a list of tensors to the same shape along the first dimension. + + Args: + tensors (`list[torch.Tensor]`): + List of input tensors to pad. + padding_value (`int`): + Value to use for padding. Default is 0. + padding_side (`str`): + Side on which to add padding. Must be 'left' or 'right'. Default is 'right'. + pad_to_multiple_of (`int`, *optional*): + If set will pad the sequence to a multiple of the provided value. + + Returns: + `torch.Tensor`: + A single tensor containing the padded tensors. + + Examples: + ```python + >>> import torch + + >>> pad([torch.tensor([1, 2, 3]), torch.tensor([4, 5])]) + tensor([[1, 2, 3], + [4, 5, 0]]) + + >>> pad([torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6]])]) + tensor([[[1, 2], + [3, 4]], + [[5, 6], + [0, 0]]]) + ``` + """ + # Determine the maximum shape for each dimension + output_shape = np.max([t.shape for t in tensors], 0).tolist() + + # Apply pad_to_multiple_of to the first (sequence) dimension + if pad_to_multiple_of is not None: + remainder = output_shape[0] % pad_to_multiple_of + if remainder != 0: + output_shape[0] += pad_to_multiple_of - remainder + + # Create an output tensor filled with the padding value + output = torch.full((len(tensors), *output_shape), padding_value, dtype=tensors[0].dtype, device=tensors[0].device) + + for i, t in enumerate(tensors): + if padding_side == "left": + seq_start = output_shape[0] - t.shape[0] + elif padding_side == "right": + seq_start = 0 + else: + raise ValueError("padding_side must be 'left' or 'right'") + + # Define the slices + seq_slice = slice(seq_start, seq_start + t.shape[0]) + slices = (seq_slice,) + tuple(slice(0, s) for s in t.shape[1:]) + output[i][slices] = t + + return output + + +def disable_dropout_in_model(model: torch.nn.Module) -> None: + for module in model.modules(): + if isinstance(module, torch.nn.Dropout): + module.p = 0 + + +def get_quantization_config(model_args: ModelConfig) -> BitsAndBytesConfig | None: + if model_args.load_in_4bit: + quantization_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=model_args.dtype, # For consistency with model weights, we use the same value as `dtype` + bnb_4bit_quant_type=model_args.bnb_4bit_quant_type, + bnb_4bit_use_double_quant=model_args.use_bnb_nested_quant, + bnb_4bit_quant_storage=model_args.bnb_4bit_quant_storage, + ) + elif model_args.load_in_8bit: + quantization_config = BitsAndBytesConfig( + load_in_8bit=True, + ) + else: + quantization_config = None + + return quantization_config + + +def get_kbit_device_map() -> dict[str, int] | None: + if torch.cuda.is_available() or is_torch_xpu_available(): + return {"": PartialState().local_process_index} + else: + return None + + +def get_peft_config(model_args: ModelConfig) -> "PeftConfig | None": + if model_args.use_peft is False: + return None + + if not is_peft_available(): + raise ValueError( + "You need to have PEFT library installed in your environment, make sure to install `peft`. " + "Make sure to run `pip install -U peft`." + ) + + peft_config = LoraConfig( + task_type=model_args.lora_task_type, + r=model_args.lora_r, + target_modules=model_args.lora_target_modules, + target_parameters=model_args.lora_target_parameters, + lora_alpha=model_args.lora_alpha, + lora_dropout=model_args.lora_dropout, + bias="none", + use_rslora=model_args.use_rslora, + use_dora=model_args.use_dora, + modules_to_save=model_args.lora_modules_to_save, + ) + + return peft_config + + +def generate_model_card( + base_model: str | None, + model_name: str, + hub_model_id: str, + dataset_name: str | None, + tags: list[str], + wandb_url: str | None, + trackio_url: str | None, + trainer_name: str, + trainer_citation: str | None = None, + template_file: str | None = None, + paper_title: str | None = None, + paper_id: str | None = None, + comet_url: str | None = None, +) -> ModelCard: + """ + Generate a [`~huggingface_hub.ModelCard`] from a template. + + Args: + base_model (`str` or `None`): + Base model name. + model_name (`str`): + Model name. + hub_model_id (`str`): + Hub model ID as `username/model_id`. + dataset_name (`str` or `None`): + Dataset name. + tags (`list[str]`): + Tags. + wandb_url (`str` or `None`): + Weights & Biases run URL. + trackio_url (`str` or `None`): + Trackio Space URL. + comet_url (`str` or `None`): + Comet experiment URL. + trainer_name (`str`): + Trainer name. + trainer_citation (`str` or `None`, defaults to `None`): + Trainer citation as a BibTeX entry. + template_file (`str` *optional*): + Template file name located in the `trl/templates` directory. Defaults to `lm_model_card.md`. + paper_title (`str` or `None`, defaults to `None`): + Paper title. + paper_id (`str` or `None`, defaults to `None`): + ArXiv paper ID as `YYMM.NNNNN`. + + Returns: + [`~huggingface_hub.ModelCard`]: + A ModelCard object. + """ + card_data = ModelCardData( + base_model=base_model, + datasets=dataset_name, + library_name="transformers", + licence="license", + model_name=model_name, + tags=["generated_from_trainer", *tags], + ) + template_file = template_file or "lm_model_card.md" + card = ModelCard.from_template( + card_data, + template_path=str(pkg_resources.files("trl").joinpath(f"templates/{template_file}")), + base_model=base_model, + model_name=model_name, + hub_model_id=hub_model_id, + dataset_name=dataset_name, + wandb_url=wandb_url, + trackio_url=trackio_url, + comet_url=comet_url, + trainer_name=trainer_name, + trainer_citation=trainer_citation, + paper_title=paper_title, + paper_id=paper_id, + trl_version=version("trl"), + transformers_version=version("transformers"), + pytorch_version=version("torch"), + datasets_version=version("datasets"), + tokenizers_version=version("tokenizers"), + ) + return card + + +def get_comet_experiment_url() -> str | None: + """ + If Comet integration is enabled, return the URL of the current Comet experiment; otherwise, return `None`. + """ + if not is_comet_available(): + return None + + if comet_ml.get_running_experiment() is not None: + return comet_ml.get_running_experiment().url + + return None + + +def get_trackio_space_url() -> str | None: + """ + If Trackio integration is enabled, return the URL of the current Trackio Space; otherwise, return `None`. + """ + if not is_trackio_available(): + return None + + from trackio import context_vars + + run = context_vars.current_run.get() + if run is None: + return None + space_id = run._space_id + if space_id is None: + return None + space_id = space_id.replace("/", "-") + project = run.project + name = run.name + return f"https://{space_id}.hf.space?project={project}&runs={name}&sidebar=collapsed" + + +def log_table_to_comet_experiment(name: str, table: pd.DataFrame) -> None: + """ + If Comet integration is enabled logs a table to the Comet experiment if it is currently running. + + Args: + name (`str`): + Table name. + table (`pandas.DataFrame`): + The Pandas DataFrame containing the table to log. + """ + if not is_comet_available(): + raise ModuleNotFoundError("The comet-ml is not installed. Please install it first: pip install comet-ml") + + experiment = comet_ml.get_running_experiment() + if experiment is not None: + experiment.log_table(tabular_data=table, filename=name) + + +def flush_left(mask: torch.Tensor, *tensors: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, ...]: + """ + Shift non-zero elements in the mask and corresponding tensors to the left. + + This function operates on a binary mask and any number of additional tensors with the same dimensions as the mask. + For each row, non-zero values are shifted to the leftmost positions. Then, columns that contain only zeros across + all rows are truncated from the mask and tensors. Visually, this operation can be represented as follows: + + ``` + [[0, 0, x, x, x, x], -> [[x, x, x, x], + [0, x, x, x, 0, 0]] [x, x, x, 0]] + ``` + + Args: + mask (`torch.Tensor`): + 2D tensor (binary mask) with shape `(N, M)`. + *tensors (`torch.Tensor`): + One or more 2D tensors with the same shape as `mask`. These tensors will be processed alongside `mask`, + with non-zero values shifted and excess zero columns truncated in the same manner. + + Returns: + `torch.Tensor`: + Updated binary mask with non-zero values flushed to the left and trailing zero columns removed. + `*torch.Tensor` + Updated tensors, processed in the same way as the mask. + + Example: + ```python + >>> mask = torch.tensor([[0, 0, 1, 1, 1], [0, 1, 1, 0, 0]]) + >>> tensor = torch.tensor([[9, 9, 2, 3, 4], [9, 5, 6, 9, 9]]) + >>> new_mask, new_tensor = flush_left(mask, tensor) + >>> print(new_mask) + tensor([[1, 1, 1], + [1, 1, 0]]) + + >>> print(new_tensor) + tensor([[2, 3, 4], + [5, 6, 0]]) + ``` + """ + _, M = mask.shape + + # Create copy of mask and tensors + mask_copy = mask.clone() + tensors = [t.clone() for t in tensors] + + # Shift non-zero values to the left + first_non_zero = mask_copy.argmax(dim=1) + pos = torch.arange(M, device=mask_copy.device).unsqueeze(0) + idx_roll = (pos + first_non_zero.unsqueeze(1)) % M + mask_roll = mask_copy.gather(1, idx_roll) + rolled_tensors = [t.gather(1, idx_roll) for t in tensors] + + # Truncate trailing columns that are all zeros in mask_roll + col_sums = mask_roll.sum(dim=0) + empty_cols = col_sums == 0 + first_empty_col = int(empty_cols.to(torch.int8).argmax()) if empty_cols.any() else M + flushed_mask = mask_roll[:, :first_empty_col] + flushed_tensors = [t[:, :first_empty_col] for t in rolled_tensors] + + if not flushed_tensors: + return flushed_mask + return flushed_mask, *flushed_tensors + + +def selective_log_softmax(logits, index) -> torch.Tensor: + """ + A memory-efficient implementation of the common `log_softmax -> gather` operation. + + This function is equivalent to the following naive implementation: + ```python + # for index with shape (...): + logps = torch.gather(logits.log_softmax(-1), dim=-1, index=index.unsqueeze(-1)).squeeze(-1) + # for index with shape (..., K): + logps = torch.gather(logits.log_softmax(-1), dim=-1, index=index) + ``` + + Args: + logits (`torch.Tensor`): + Logits tensor of shape `(..., num_classes)`. + index (`torch.Tensor`): + Index tensor of shape `(..., K)` or `(...)`, specifying the positions to gather from the log-softmax + output. When the last case is used, `K` log-probabilities are gathered per position (e.g. for top-K) + + Returns: + `torch.Tensor`: + Gathered log probabilities with the same shape as `index`. + """ + squeeze = index.ndim == logits.ndim - 1 + if squeeze: + index = index.unsqueeze(-1) + + if logits.dtype in [torch.float32, torch.float64]: + selected_logits = torch.gather(logits, dim=-1, index=index) + # loop to reduce peak mem consumption + logsumexp_values = torch.stack([torch.logsumexp(lg, dim=-1) for lg in logits]) + per_token_logps = selected_logits - logsumexp_values.unsqueeze(-1) # log_softmax(x_i) = x_i - logsumexp(x) + else: + # logsumexp approach is unstable with bfloat16, fall back to slightly less efficient approach + per_token_logps = [] + for row_logits, row_labels in zip(logits, index, strict=True): # loop to reduce peak mem consumption + row_logps = F.log_softmax(row_logits, dim=-1) + row_per_token_logps = row_logps.gather(dim=-1, index=row_labels) + per_token_logps.append(row_per_token_logps) + per_token_logps = torch.stack(per_token_logps) + + if squeeze: + per_token_logps = per_token_logps.squeeze(-1) + + return per_token_logps + + +def entropy_from_logits(logits: torch.Tensor, chunk_size: int = 128) -> torch.Tensor: + """ + Compute the Shannon entropy (in nats) for each row of *logits* in a memory-efficient way. + + Instead of materializing the full softmax for all rows at once, the logits are flattened to shape (N, num_classes), + where N is the product of all leading dimensions. Computation is then performed in chunks of size `chunk_size` + along this flattened dimension, reducing peak memory usage. The result is reshaped back to match the input's + leading dimensions. + + Args: + logits (`torch.Tensor`): + Logits tensor of shape `(..., num_classes)`. Entropy is taken along the last axis; all leading dimensions + are preserved in the output. + chunk_size (`int`, *optional*, defaults to `128`): + Number of rows from the flattened logits to process per iteration. Smaller values reduce memory usage at + the cost of more iterations. + + Returns: + `torch.Tensor`: + Entropy values with shape `logits.shape[:-1]`. + """ + original_shape = logits.shape[:-1] # all dims except num_classes + num_classes = logits.shape[-1] + + # Flatten all leading dimensions into one + flat_logits = logits.reshape(-1, num_classes) + + entropies = [] + for chunk in flat_logits.split(chunk_size, dim=0): + logps = F.log_softmax(chunk, dim=-1) + chunk_entropy = -(torch.exp(logps) * logps).sum(-1) + entropies.append(chunk_entropy) + + entropies = torch.cat(entropies, dim=0) + return entropies.reshape(original_shape) + + +def print_prompt_completions_sample( + prompts: list, + completions: list, + rewards: dict[str, list[float]], + advantages: list[float], + step: int, + num_samples: int = None, + extra: dict[str, list] | None = None, +) -> None: + """ + Print out a sample of model completions to the console with multiple reward metrics. + + This function creates a nicely formatted table showing prompt-completion pairs, useful for monitoring model outputs + during training. It requires the `rich` library to be installed. + + Args: + prompts (`list`): + List of prompts. Can be either strings or lists of messages. + completions (`list`): + List of completions corresponding to the prompts. Can be either strings or lists of messages. + rewards (`dict[str, list[float]]`): + Dictionary where keys are reward names and values are lists of rewards. + advantages (`list[float]`): + List of advantages corresponding to the prompts and completions. + step (`int`): + Current training step number, used in the output title. + num_samples (`int`, *optional*): + Number of random samples to display. If `None` (default), all items will be displayed. + extra (`dict[str, list]`, *optional*): + Additional columns to display after the advantage column. Keys are column names and values are lists of + per-completion data (strings or any value convertible to string). Typically populated via `log_extra` in + reward functions. If `None` (default), no extra columns are shown. + + Example: + ```python + >>> from trl.trainer.utils import print_prompt_completions_sample + + >>> prompts = ["The sky is", "The sun is"] + >>> completions = [" blue.", " in the sky."] + >>> rewards = {"Correctness": [0.123, 0.456], "Format": [0.789, 0.101]} + >>> advantages = [0.987, 0.654] + >>> extra = {"source": ["dataset_A", "dataset_B"]} + >>> print_prompt_completions_sample(prompts, completions, rewards, advantages, 42, extra=extra) + ╭────────────────────────────────── Step 42 ───────────────────────────────────╮ + │ ┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┓ │ + │ ┃ Prompt ┃ Completion ┃ Correctness ┃ Format ┃ Advantage ┃ source ┃ │ + │ ┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━┩ │ + │ │ The sky is │ blue. │ 0.12 │ 0.79 │ 0.99 │ dataset_A │ │ + │ ├────────────┼──────────────┼─────────────┼────────┼───────────┼───────────┤ │ + │ │ The sun is │ in the sky. │ 0.46 │ 0.10 │ 0.65 │ dataset_B │ │ + │ └────────────┴──────────────┴─────────────┴────────┴───────────┴───────────┘ │ + ╰──────────────────────────────────────────────────────────────────────────────╯ + ``` + """ + if not is_rich_available(): + raise ImportError( + "The function `print_prompt_completions_sample` requires the `rich` library. Please install it with " + "`pip install rich`." + ) + console = Console() + table = Table(show_header=True, header_style="bold white", expand=True) + + extra = extra or {} + + # Add columns + table.add_column("Prompt", style="bright_yellow") + table.add_column("Completion", style="bright_green") + for reward_name in rewards.keys(): + table.add_column(reward_name, style="bold cyan", justify="right") + table.add_column("Advantage", style="bold magenta", justify="right") + for extra_name in extra.keys(): + table.add_column(extra_name, style="bright_white") + + def format_entry(entry) -> Text: + t = Text() + if isinstance(entry, list) and all(isinstance(m, dict) for m in entry): + for j, msg in enumerate(entry): + role = msg.get("role", "") + if "content" in msg or "reasoning_content" in msg or "thinking" in msg: + # Chat message + t.append(f"{role.upper()}\n", style="bold red") + reasoning = msg.get("reasoning_content") or msg.get("thinking") + if reasoning: + t.append(reasoning, style="italic dim white") + t.append("\n") + if "content" in msg: + t.append(msg["content"]) + elif "name" in msg and "args" in msg: + # Tool call + t.append(f"{role.upper()}\n", style="bold red") + t.append(f"{msg['name']}({msg['args']})") + else: + # Fallback + t.append(str(msg)) + if j < len(entry) - 1: + t.append("\n\n") + else: + t.append(str(entry)) + return t + + # Some basic input validation + if num_samples is not None: + if num_samples >= len(prompts): + num_samples = None + elif num_samples <= 0: + return + + # Subsample data if num_samples is specified + if num_samples is not None: + indices = random.sample(range(len(prompts)), num_samples) + prompts = [prompts[i] for i in indices] + completions = [completions[i] for i in indices] + rewards = {key: [val[i] for i in indices] for key, val in rewards.items()} + advantages = [advantages[i] for i in indices] + extra = {key: [val[i] for i in indices] for key, val in extra.items()} + + for i in range(len(prompts)): + reward_values = [f"{rewards[key][i]:.2f}" for key in rewards.keys()] # 2 decimals + extra_values = [format_entry(extra[key][i]) for key in extra.keys()] + table.add_row( + format_entry(prompts[i]), + format_entry(completions[i]), + *reward_values, + f"{advantages[i]:.2f}", + *extra_values, + ) + table.add_section() # Adds a separator between rows + + panel = Panel(table, expand=False, title=f"Step {step}", border_style="bold white") + console.print(panel) + + +class RepeatSampler(Sampler): + """ + Sampler that repeats the indices of a dataset in a structured manner. + + Args: + data_source (`Sized`): + Dataset to sample from. + mini_repeat_count (`int`): + Number of times to repeat each index per batch. + batch_size (`int`, *optional*, defaults to `1`): + Number of unique indices per batch. + repeat_count (`int`, *optional*, defaults to `1`): + Number of times to repeat the full sampling process. + shuffle (`bool`, *optional*, defaults to `True`): + Whether to shuffle the dataset. + seed (`int`, *optional*): + Random seed for reproducibility (only affects this sampler). + + Example: + ```python + >>> sampler = RepeatSampler(["a", "b", "c", "d", "e", "f", "g"], mini_repeat_count=2, batch_size=3, repeat_count=4) + >>> list(sampler) + [4, 4, 3, 3, 0, 0, + 4, 4, 3, 3, 0, 0, + 4, 4, 3, 3, 0, 0, + 4, 4, 3, 3, 0, 0, + 1, 1, 2, 2, 6, 6, + 1, 1, 2, 2, 6, 6, + 1, 1, 2, 2, 6, 6, + 1, 1, 2, 2, 6, 6] + ``` + + ```txt + mini_repeat_count = 3 + - - - + [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, | + 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, | + 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, | + repeat_count = 2 + 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, | + 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, | + 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, ...] | + --------- --------- --------- --------- + --------- --------- --------- --------- + --------- --------- --------- --------- + batch_size = 12 + ``` + """ + + def __init__( + self, + data_source: Sized, + mini_repeat_count: int, + batch_size: int = 1, + repeat_count: int = 1, + shuffle: bool = True, + seed: int | None = None, + ): + self.data_source = data_source + self.mini_repeat_count = mini_repeat_count + self.batch_size = batch_size + self.repeat_count = repeat_count + self.num_samples = len(data_source) + self.shuffle = shuffle + self.seed = seed + + if shuffle: + self.generator = torch.Generator() # Create a local random generator + if seed is not None: + self.generator.manual_seed(seed) + + def __iter__(self): + if self.shuffle: + # E.g., [2, 4, 3, 1, 0, 6, 5] (num_samples = 7) + indexes = torch.randperm(self.num_samples, generator=self.generator).tolist() + else: + indexes = list(range(self.num_samples)) + + # [2, 4, 3, 1, 0, 6, 5] + # -> [[2, 4, 3], [1, 0, 6], [5]] (batch_size = 3) + indexes = [indexes[i : i + self.batch_size] for i in range(0, len(indexes), self.batch_size)] + + # [[2, 4, 3], [1, 0, 6], [5]] + # -> [[2, 4, 3], [1, 0, 6]] + indexes = [chunk for chunk in indexes if len(chunk) == self.batch_size] + + for chunk in indexes: + for _ in range(self.repeat_count): + for index in chunk: + for _ in range(self.mini_repeat_count): + yield index + + def __len__(self) -> int: + return (self.num_samples // self.batch_size) * self.batch_size * self.mini_repeat_count * self.repeat_count + + +# torch.nanstd doesn't exist, so we define it here +def nanstd(tensor: torch.Tensor, dim: int | tuple[int, ...] | None = None, keepdim: bool = False) -> torch.Tensor: + """ + Compute the standard deviation of a tensor, ignoring NaNs. + + Args: + tensor (`torch.Tensor`): + Input tensor. + dim (`int` or `tuple[int, ...]`, *optional*): + Dimension(s) to reduce. Defaults to all dimensions. + keepdim (`bool`, *optional*, defaults to `False`): + Whether to keep reduced dimensions. + + Returns: + `torch.Tensor`: + Standard deviation of the tensor, ignoring NaNs. + """ + # Compute variance ignoring NaNs + mean = torch.nanmean(tensor, dim=dim, keepdim=True) + variance = torch.nanmean((tensor - mean) ** 2, dim=dim, keepdim=True) + count = torch.sum(~torch.isnan(tensor), dim=dim, keepdim=True) # count of non-NaN values + correction = count / (count - 1) + correction = torch.where(count > 1, correction, torch.full_like(correction, float("nan"))) + variance *= correction # Bessel's correction + std = torch.sqrt(variance) + if keepdim: + return std + if dim is None: + return std.squeeze() + if isinstance(dim, int): + return std.squeeze(dim) + dims = [(d if d >= 0 else d + std.ndim) for d in dim] + for d in sorted(dims, reverse=True): + std = std.squeeze(d) + return std + + +def split_tensor_dict( + tensor_dict: dict[str, torch.Tensor | None], num_chunks: int +) -> list[dict[str, torch.Tensor | None]]: + """ + Splits a dictionary of tensors along the first dimension into `num_chunks` equal parts. + + Example: + ```python + >>> x = torch.arange(12).reshape(6, 2) + >>> y = torch.arange(6).reshape(6, 1) + >>> tensor_dict = {"x": x, "y": y} + >>> split_tensor_dict(tensor_dict, 3) + [ + {"x": tensor([[0, 1], [2, 3]]), "y": tensor([[0], [1]])}, + {"x": tensor([[4, 5], [6, 7]]), "y": tensor([[2], [3]])}, + {"x": tensor([[ 8, 9], [10, 11]]), "y": tensor([[4], [5]])} + ] + ``` + """ + first_tensor = next(tensor for tensor in tensor_dict.values() if tensor is not None) + chunk_size = first_tensor.shape[0] // num_chunks + chunks = [] + for i in range(num_chunks): + chunk_dict = {} + for key, tensor in tensor_dict.items(): + if tensor is not None and (isinstance(tensor, list) or tensor.ndim > 0): + chunk_dict[key] = tensor[i * chunk_size : (i + 1) * chunk_size] + elif tensor is not None and tensor.ndim == 0: + chunk_dict[key] = tensor + else: + chunk_dict[key] = None + chunks.append(chunk_dict) + return chunks + + +def shuffle_sequence_dict(seq_dict: dict[str, Sequence | None]) -> dict[str, Sequence | None]: + """ + Shuffles all sequence-like values in a dictionary along the first dimension in unison. + + Example: + ```python + >>> x = torch.arange(6).reshape(3, 2) + >>> y = ["a", "b", "c"] + >>> seq_dict = {"x": x, "y": y} + >>> shuffle_sequence_dict(seq_dict) + {'x': tensor([[2, 3], + [0, 1], + [4, 5]]), + 'y': ['b', 'a', 'c']} + ``` + """ + # Determine batch size from the first non-None sequence + batch_size = len(next(v for v in seq_dict.values() if v is not None)) + permutation = torch.randperm(batch_size) + + def permute(v: Sequence | None) -> Sequence | None: + if v is None: + return None + if isinstance(v, torch.Tensor) and v.ndim == 0: + return v + if isinstance(v, torch.Tensor) and v.ndim >= 1: + return v[permutation] + return [v[i] for i in permutation] + + return {key: permute(val) for key, val in seq_dict.items()} + + +def nanmin(tensor: torch.Tensor) -> torch.Tensor: + """ + Compute the minimum value of a tensor, ignoring NaNs. This function only supports 1D tensors. + + Args: + tensor (`torch.Tensor`): Input tensor of shape `(N,)`. + + Returns: + `torch.Tensor`: Minimum value of the tensor, ignoring NaNs. Returns NaN if all values are NaN. + """ + if torch.isnan(tensor).all(): + return torch.tensor(float("nan"), dtype=tensor.dtype, device=tensor.device) + return torch.min(tensor[~torch.isnan(tensor)]) + + +def nanmax(tensor: torch.Tensor) -> torch.Tensor: + """ + Compute the maximum value of a tensor, ignoring NaNs. This function only supports 1D tensors. + + Args: + tensor (`torch.Tensor`): Input tensor of shape `(N,)`. + + Returns: + `torch.Tensor`: Maximum value of the tensor, ignoring NaNs. Returns NaN if all values are NaN. + """ + if torch.isnan(tensor).all(): + return torch.tensor(float("nan"), dtype=tensor.dtype, device=tensor.device) + return torch.max(tensor[~torch.isnan(tensor)]) + + +def identity(x): + """Do we really need docs for this?""" + return x + + +def split_pixel_values_by_grid(batch: dict[str, torch.Tensor]) -> dict[str, torch.Tensor | list[torch.Tensor]]: + """ + Splits `batch["pixel_values"]` into a list of tensors, one per sample, based on `batch["num_images"]`. + + For models with `image_grid_thw` (e.g. Qwen), the grid dimensions determine how many rows of `pixel_values` belong + to each image. For models with `image_position_ids` instead (e.g. Gemma), `pixel_values` is indexed directly by + image count. + """ + if "pixel_values" not in batch or "num_images" not in batch: + return batch + + num_images = batch["num_images"] + pixel_values = batch["pixel_values"] # [total, feature_dim] + + if "image_grid_thw" in batch: + lengths = batch["image_grid_thw"].prod(-1).tolist() # [num_images] + if sum(lengths) != pixel_values.size(0): + raise ValueError( + f"Mismatch: sum(lengths) = {sum(lengths)} != pixel_values.size(0) = {pixel_values.size(0)}" + ) + + boundaries = [0, *accumulate(num_images)] + image_grid_thw = batch["image_grid_thw"] # [total, 3] + sections = [sum(lengths[boundaries[i] : boundaries[i + 1]]) for i in range(len(num_images))] + split_pixel_values = list(torch.split(pixel_values, sections, dim=0)) + split_image_grid_thw = list(torch.split(image_grid_thw, num_images, dim=0)) + return {**batch, "pixel_values": split_pixel_values, "image_grid_thw": split_image_grid_thw} + + if "image_position_ids" in batch: + image_position_ids = batch["image_position_ids"] # [total] + split_pixel_values = list(torch.split(pixel_values, num_images, dim=0)) + split_image_position_ids = list(torch.split(image_position_ids, num_images, dim=0)) + return {**batch, "pixel_values": split_pixel_values, "image_position_ids": split_image_position_ids} + + return batch + + +def unsplit_pixel_values_by_grid(batch: dict[str, torch.Tensor | list[torch.Tensor]]) -> dict[str, torch.Tensor]: + """ + Opposite of `split_pixel_values_by_grid`. Merges a list of tensors in `batch["pixel_values"]` back into a single + tensor along the first dimension. + """ + pixel_values = batch.get("pixel_values") + if isinstance(pixel_values, list): + merged = torch.cat(pixel_values, dim=0) + batch = {**batch, "pixel_values": merged} + + image_grid_thw = batch.get("image_grid_thw") + if isinstance(image_grid_thw, list): + merged = torch.cat(image_grid_thw, dim=0) + batch = {**batch, "image_grid_thw": merged} + + image_position_ids = batch.get("image_position_ids") + if isinstance(image_position_ids, list): + merged = torch.cat(image_position_ids, dim=0) + batch = {**batch, "image_position_ids": merged} + + return batch + + +TListOrMapping = TypeVar("TListOrMapping", list, Mapping) + + +# This function is intentionally not used internally. It is provided as a utility for users whose datasets contain +# `None` values inserted by tabular backends (e.g., Arrow/Parquet) for missing keys in nested structures. This +# situation arises when loading datasets created before `datasets` v4.7.0 (which introduced the Json dtype), or when +# datasets created after that version were saved without using the Json feature. In both cases, users can apply this +# function via `dataset = dataset.with_transform(remove_none_values)` before training to strip the spurious `None` +# values. See the migration guide for more details. +def remove_none_values(example: TListOrMapping) -> TListOrMapping: + """ + Recursively removes entries with `None` values from a nested structure (list or dictionary). + + Args: + example (`list` or `Mapping`): + Input nested structure (list or dictionary) from which to remove `None`. + + Examples: + ```python + >>> dataset = dataset.with_transform(remove_none_values) + ``` + ```python + >>> [ + ... { + ... "a": {"aa": None, "ab": 1}, + ... "b": "my_string", + ... } + ... ] + >>> remove_none_values(example) + [{'a': {'ab': 1}, 'b': 'my_string'}] + ``` + """ + if isinstance(example, list): + return [remove_none_values(value) if isinstance(value, (dict, list)) else value for value in example] + elif isinstance(example, Mapping): + return { + key: remove_none_values(value) if isinstance(value, (dict, list)) else value + for key, value in example.items() + if value is not None + } + else: + raise TypeError("Input must be a list or a dictionary.") + + +def create_model_from_path( + model_id: str, architecture: _BaseAutoModelClass | None = None, **kwargs +) -> PreTrainedModel: + """ + Create a model from a given path using the specified initialization arguments. + + Args: + model_id (`str`): + Path to the model. Can be either a local directory or a model identifier from the Hugging Face Hub. + architecture (`_BaseAutoModelClass` or `None`, *optional*): + Model architecture class to instantiate. The model is initialized using the `from_pretrained` method of + this class. If `None`, the architecture will be inferred from the model's configuration. + kwargs (`dict`): + Initialization keyword arguments to pass to the model's `from_pretrained` method. When `'dtype'` is + specified, it can be either a `torch.dtype` or one of the strings: `'bfloat16'`, `'float16'`, `'float32'`, + or `'auto'`. If not explicitly set, `dtype` defaults to `'float32'`. + + Returns: + [`~transformers.PreTrainedModel`]: + The instantiated model. + """ + dtype = kwargs.get("dtype", "float32") + if isinstance(dtype, torch.dtype) or dtype == "auto" or dtype is None: + pass # dtype is already a torch.dtype or "auto" or None + elif isinstance(dtype, str) and dtype in ["bfloat16", "float16", "float32"]: + kwargs["dtype"] = getattr(torch, dtype) + else: + raise ValueError( + "Invalid `dtype` passed to the config. Expected either 'auto' or a string representing " + f"a valid `torch.dtype` (e.g., 'float32'), but got {dtype}." + ) + kwargs["device_map"] = kwargs.get("device_map", "auto") + if architecture is None: + # Best effort to infer architecture from config, but we fall back to AutoModelForCausalLM if we can't find it + config = AutoConfig.from_pretrained(model_id, trust_remote_code=kwargs.get("trust_remote_code", False)) + architecture = getattr(transformers, config.architectures[0], None) + if architecture is None: + # Remote-code checkpoint: the architecture name lives in the dynamic module, not in + # `transformers`. Pick the most specific auto class declared in `config.auto_map`. + auto_map = config.auto_map or {} + for candidate in (AutoModelForImageTextToText, AutoModelForCausalLM): + if candidate.__name__ in auto_map: + architecture = candidate + break + else: + architecture = AutoModelForCausalLM + model = architecture.from_pretrained(model_id, **kwargs) + return model + + +def hash_module(module: torch.nn.Module) -> str: + h = hashlib.sha256() + for _, tensor in sorted(module.state_dict().items()): + tensor = tensor.cpu() + h.update(str(tensor.dtype).encode()) + if tensor.dtype in [torch.bfloat16, torch.float8_e4m3fn, torch.float8_e5m2]: + tensor = tensor.to(torch.float32) + h.update(tensor.numpy().tobytes()) + return h.hexdigest() + + +def get_config_model_id(config: PretrainedConfig) -> str: + """ + Retrieve the model identifier from a given model configuration. + + Args: + config ([`~transformers.PreTrainedConfig`]): + Configuration from which to extract the model identifier. + + Returns: + `str`: + The model identifier associated with the model configuration. + """ + return getattr(config, "_name_or_path", "") + + +@contextmanager +def use_adapter(model: "PeftModel", adapter_name: str | None): + """ + Context manager to temporarily set and reset the active adapter in a PEFT model. + + Args: + model ([`~peft.PeftModel`]): + PEFT model to manage. + adapter_name (`str` or `None`): + Name of the adapter to set as active. If `None`, the context manager will disable all adapters. + + Example: + ```python + >>> from trl.trainer.utils import use_adapter + >>> from peft import AutoPeftModelForCausalLM + >>> import torch + + >>> model = AutoPeftModelForCausalLM.from_pretrained("path/to/model") + >>> input_ids = torch.tensor([[1, 2, 3]]) + >>> with use_adapter(model, "adapter_name"): + ... outputs = model(input_ids) + ``` + """ + + if not is_peft_available(): + raise ImportError( + "You're trying to use a PEFT adapter but PEFT is not installed. Please install it with `pip install peft`." + ) + if adapter_name is None: + with model.disable_adapter(): + yield + else: + previous_adapter = model.active_adapter + model.set_adapter(adapter_name) + try: + yield + finally: + model.set_adapter(previous_adapter) + + +def start_event_loop_in_daemon( + name: str | None = None, +) -> tuple[threading.Thread, asyncio.AbstractEventLoop, threading.Event]: + """ + This function creates a new daemon thread that runs the provided event loop. + + Args: + name (`str`, *optional*): + Name of the thread. If `None`, the default thread naming will be used. + + Returns: + `threading.Thread`: + The thread running the event loop. + `asyncio.AbstractEventLoop`: + The event loop being run in the thread. + `threading.Event`: + An event that is set when the loop is ready. + """ + loop = asyncio.new_event_loop() + loop_ready_event = threading.Event() + + def run_loop(): + asyncio.set_event_loop(loop) + loop_ready_event.set() + loop.run_forever() + + thread = threading.Thread(target=run_loop, name=name, daemon=True) + thread.start() + return thread, loop, loop_ready_event + + +def shutdown_event_loop_in_daemon( + thread: threading.Thread | None, + loop: asyncio.AbstractEventLoop | None, +) -> None: + """ + Shutdown an asyncio event loop running in a separate thread. + + This function stops the event loop and waits for the associated thread to finish execution. + + Args: + thread (`threading.Thread`): + The thread running the event loop. + loop (`asyncio.AbstractEventLoop`): + The asyncio event loop to shut down. + """ + if loop is None or thread is None: + return + loop.call_soon_threadsafe(loop.stop) + thread.join(timeout=5) + + +class _ChunkedLogProbFunction(torch.autograd.Function): + """Compute per-token log-probs and entropy without materializing [N, V] logits. + + Processes the lm_head in chunks and uses online logsumexp + """ + + @staticmethod + def forward( + ctx, + last_hidden: torch.Tensor, # [N, H] + weight: torch.Tensor, # [V, H] + targets: torch.Tensor, # [N] + temperature: float, + chunk_size: int, + final_logit_softcapping: float | None = None, + logit_scale: float = 1.0, + ) -> tuple[torch.Tensor, torch.Tensor]: + device = last_hidden.device + N, _ = last_hidden.shape + vocab, _ = weight.shape + inv_t = 1 / temperature + + # NOTE(@aminediro): always acc in fp32 for stability + max_old = torch.full((N,), float("-inf"), device=device, dtype=torch.float32) + sum_exp = torch.zeros((N,), device=device, dtype=torch.float32) + x_sum_exp = torch.zeros((N,), device=device, dtype=torch.float32) + target_logit = torch.zeros((N,), device=device, dtype=torch.float32) + + # Pre-allocate reusable buffers to avoid per-chunk allocation + mm_buf = torch.empty((N, chunk_size), device=device, dtype=last_hidden.dtype) + logits_buf = torch.empty((N, chunk_size), device=device, dtype=torch.float32) + + for start in range(0, vocab, chunk_size): + end = min(start + chunk_size, vocab) + C = end - start + # using fp16=True, the model's hidden states get cast to float16 by autocast, but the mm_buf is allocated + # with last_hidden.dtype (float16) while w_chunk (the lm_head weights) is not auto casted + w_chunk = weight[start:end].to(last_hidden.dtype) # [C, H] + torch.mm(last_hidden, w_chunk.t(), out=mm_buf[:, :C]) + logits_chunk = logits_buf[:, :C] + logits_chunk.copy_(mm_buf[:, :C]) + + logits_chunk.mul_(logit_scale) + if final_logit_softcapping is not None: + logits_chunk.div_(final_logit_softcapping).tanh_().mul_(final_logit_softcapping) + + logits_chunk.mul_(inv_t) # [N, C] + + # Online logsumexp update + chunk_max = logits_chunk.amax(dim=-1) # [N] + max_new = torch.maximum(max_old, chunk_max) + rescale = torch.exp(max_old - max_new) + chunk_exp = torch.exp(logits_chunk - max_new.unsqueeze(-1)) # [N, C] + + sum_exp = sum_exp * rescale + chunk_exp.sum(dim=-1) + x_sum_exp = x_sum_exp * rescale + (chunk_exp * logits_chunk).sum(dim=-1) + max_old = max_new + + # Gather target logits for labels in this chunk + in_chunk_cond = (targets >= start) & (targets < end) + local_idx = torch.clamp(targets - start, 0, end - start - 1) + # take the new logit if target_idx is in this chunk bounds else 0 + target_logit += logits_chunk[torch.arange(N, device=device), local_idx] * in_chunk_cond + + log_z = max_old + torch.log(sum_exp) + logprobs = target_logit - log_z + entropy = log_z - x_sum_exp / sum_exp + + ctx.save_for_backward(last_hidden, weight, targets, log_z) + ctx.temperature = temperature + ctx.chunk_size = chunk_size + ctx.logit_scale = logit_scale + ctx.final_logit_softcapping = final_logit_softcapping + + return logprobs, entropy + + @staticmethod + def backward(ctx, grad_logprobs: torch.Tensor, grad_entropy: torch.Tensor): # type: ignore + hidden, weight, labels, log_z = ctx.saved_tensors + temperature: float = ctx.temperature + chunk_size: int = ctx.chunk_size + logit_scale: float = ctx.logit_scale + final_logit_softcapping: float = ctx.final_logit_softcapping + inv_t = 1 / temperature + + N, _ = hidden.shape + vocab = weight.shape[0] + + # NOTE(@aminediro): always acc in fp32 even if input is not + grad_hidden = torch.zeros(hidden.shape, device=hidden.device, dtype=torch.float32) + grad_weight = torch.zeros(weight.shape, device=weight.device, dtype=torch.float32) + + # Pre-allocate reusable buffers to avoid per-chunk allocation + mm_buf = torch.empty((N, chunk_size), device=hidden.device, dtype=hidden.dtype) + logits_buf = torch.empty((N, chunk_size), device=hidden.device, dtype=torch.float32) + + g = grad_logprobs.to(torch.float32) # [N] + row_idx = torch.arange(N, device=hidden.device) + + for start in range(0, vocab, chunk_size): + end = min(start + chunk_size, vocab) + C = end - start + w_chunk = weight[start:end] # [C, H] + + torch.mm(hidden, w_chunk.t(), out=mm_buf[:, :C]) + logits_chunk = logits_buf[:, :C] + logits_chunk.copy_(mm_buf[:, :C]) + + logits_chunk.mul_(logit_scale) + if final_logit_softcapping is not None: + tanh_scaled = torch.tanh(logits_chunk / final_logit_softcapping) + logits_chunk.copy_(tanh_scaled * final_logit_softcapping) + + logits_chunk.mul_(inv_t) # [N, C] + probs = torch.exp(logits_chunk - log_z.unsqueeze(-1)) # [N, C] + + # dL/d(logits) = g * (1_[label] - p) + grad_logits = (-g).unsqueeze(-1) * probs # [N, C] + + in_chunk_cond = (labels >= start) & (labels < end) + local_idx = torch.clamp(labels - start, 0, end - start - 1) + # If label in chunk add g to grad else it stays the same + grad_logits[row_idx, local_idx] += g * in_chunk_cond + + grad_logits = grad_logits * inv_t + if final_logit_softcapping is not None: + grad_logits.mul_(1 - tanh_scaled.pow(2)) + + grad_logits = grad_logits * logit_scale + + grad_hidden.add_(grad_logits @ w_chunk.float()) + grad_weight[start:end].add_(grad_logits.t() @ hidden.float()) + + return grad_hidden.to(hidden.dtype), grad_weight.to(weight.dtype), None, None, None, None, None + + +def patch_chunked_lm_head( + model: torch.nn.Module, chunk_size: int, temperature: float, output_router_logits: bool = False +) -> None: + final_logit_softcapping = getattr(model.config, "final_logit_softcapping", None) + + def _chunked_forward( + self: torch.nn.Module, + input_ids: torch.Tensor | None = None, + attention_mask: torch.Tensor | None = None, + labels: torch.Tensor | None = None, + completion_mask: torch.Tensor | None = None, + use_cache: bool = False, + **kwargs, + ) -> dict[str, torch.Tensor]: + assert labels is not None, "requires labels to not be None for logprob computation" + + decoder_kwargs = {"output_router_logits": True} if output_router_logits else {} + outputs = self.model( + input_ids=input_ids, attention_mask=attention_mask, use_cache=use_cache, **decoder_kwargs, **kwargs + ) + # NOTE(@aminediro): supporting Cohere2 models + logit_scale = getattr(self.config, "logit_scale", 1.0) + hidden_states = outputs.last_hidden_state # [B, S+1, H] + + # Shift: predict next token + hidden_states = hidden_states[:, :-1, :] # [B, S-1, H] + labels = labels[:, 1:] # [B, S-1] + + b, s, h = hidden_states.shape + hidden_flat = hidden_states.reshape(b * s, h) + targets_flat = labels.reshape(b * s) + + # Filter to completion tokens only to avoid expensive matmuls on prompt tokens and tool results + valid_mask = None + if completion_mask is not None: + completion_mask = completion_mask[:, 1:] # same shift as labels + valid_mask = completion_mask.bool().reshape(b * s) + hidden_flat = hidden_flat[valid_mask] # [N_valid, H] + targets_flat = targets_flat[valid_mask] # [N_valid] + + logprobs_valid, entropy_valid = _ChunkedLogProbFunction.apply( + hidden_flat, + self.lm_head.weight, + targets_flat, + temperature, + chunk_size, + final_logit_softcapping, + logit_scale, + ) + + if valid_mask is not None: + logprobs = torch.zeros(b * s, device=logprobs_valid.device, dtype=logprobs_valid.dtype) + entropy = torch.zeros(b * s, device=entropy_valid.device, dtype=entropy_valid.dtype) + logprobs[valid_mask] = logprobs_valid + entropy[valid_mask] = entropy_valid + else: + logprobs = logprobs_valid + entropy = entropy_valid + + aux_loss = None + if output_router_logits: + # Mirror the per-family MoE forward: add `router_aux_loss_coef * load_balancing_loss_func(...)` to + # the main loss. Mixtral is the source of truth — every MoE family (Qwen3Moe, GptOss, OLMoE, + # Qwen2Moe, DBRX, JetMoE, PhiMoE, …) pulls this function from mixtral via the modular system, so a + # single import keeps us in lockstep with upstream for every family we test. + from transformers.models.mixtral.modeling_mixtral import load_balancing_loss_func + + if Version(transformers.__version__) < Version("5.0.0"): + num_experts = self.num_experts + num_experts_per_tok = self.num_experts_per_tok + else: + # Upstream bug AttributeError: 'GptOssConfig' object has no attribute 'num_experts'; see #5754 + if self.config.model_type == "gpt_oss" and Version("5.0.0") <= Version( + transformers.__version__ + ) < Version("5.6.0"): + num_experts = self.num_experts + else: + num_experts = self.config.num_experts + num_experts_per_tok = self.config.num_experts_per_tok + # Padding-free packs all real tokens into a single row, so `attention_mask` is None and every token counts. + aux_loss = load_balancing_loss_func( + outputs.router_logits, num_experts, num_experts_per_tok, attention_mask + ) + + return { + "log_probs": logprobs.reshape(b, s), + "entropy": entropy.reshape(b, s), + "aux_loss": aux_loss, + } + + model.forward = types.MethodType(_chunked_forward, model) + + +def compute_flops_per_token(config: PretrainedConfig, seq_len: int) -> int: + """ + Estimate training FLOPs per token for a causal language model (forward + backward). + + Supports dense and MoE architectures. Backward is assumed to cost 2× the forward pass, so total training FLOPs = 3 + × forward FLOPs. The attention-score term uses the non-causal convention (every token attends to the full + `seq_len`, matching PaLM / Megatron / nanoGPT); pass the resulting MFU through [`adjusted_mfu`] for the Llama / + DeepSpeed Ulysses causal-corrected convention. + + Args: + config ([`~transformers.PretrainedConfig`]): + The model configuration. + seq_len (`int`): + The sequence length used for training. + + Returns: + `int`: Estimated training FLOPs per token. + """ + h = config.hidden_size + L = config.num_hidden_layers + V = config.vocab_size + n_heads = config.num_attention_heads + n_kv_heads = config.num_key_value_heads + head_dim = config.head_dim + + # Attention: Q/K/V/O projections + attention score (Q·Kᵀ and attn·V). + qkv_flops = 2 * h * (n_heads * head_dim + 2 * n_kv_heads * head_dim) + o_proj_flops = 2 * n_heads * head_dim * h + attn_score_flops = 2 * 2 * n_heads * head_dim * seq_len + attn_flops = qkv_flops + o_proj_flops + attn_score_flops + + # MoE dispatch: `num_experts_per_tok` is the canonical MoE marker — present on Mixtral, + # Qwen3-MoE, DeepSeek-V2, etc.; absent on dense configs. + num_experts_per_tok = getattr(config, "num_experts_per_tok", None) + if num_experts_per_tok is None: + mlp_flops = 2 * 3 * h * config.intermediate_size + total_layer_flops = L * (attn_flops + mlp_flops) + else: + # Routed experts (gate + up + down, 3 matmuls each) + router. + if Version(transformers.__version__) >= Version("5.1.0"): + num_experts = config.num_local_experts + else: + num_experts = config.num_experts + moe_mlp_flops = num_experts_per_tok * 2 * 3 * h * config.moe_intermediate_size + moe_mlp_flops += 2 * h * num_experts + dense_mlp_flops = 2 * 3 * h * config.intermediate_size # interspersed dense layers + sparse_step = config.decoder_sparse_step + total_layer_flops = sum( + attn_flops + (moe_mlp_flops if layer_idx % sparse_step == 0 else dense_mlp_flops) for layer_idx in range(L) + ) + + embed_flops = 2 * V * h + lm_head_flops = 0 if config.tie_word_embeddings else 2 * V * h + + forward_flops = total_layer_flops + embed_flops + lm_head_flops + return 3 * forward_flops + + +def compute_mfu( + flops_per_token: int, + tokens_per_second: float, + world_size: int, + peak_flops_per_device: float = 989.5e12, +) -> float: + """ + Compute Model FLOPs Utilization (MFU) as a percentage. + + The caller is responsible for correcting `tokens_per_second` for any parallelism dimension that causes the + trainer's token counter to over-count (e.g. context parallelism, sequence parallelism, tensor parallelism — every + rank in those dims sees the same input tokens). + + Args: + flops_per_token (`int`): + Training FLOPs per token (from [`compute_flops_per_token`]). + tokens_per_second (`float`): + Aggregate tokens per second across all devices, after any parallelism corrections. + world_size (`int`): + Number of devices (GPUs). + peak_flops_per_device (`float`, *optional*, defaults to `989.5e12`): + Theoretical peak FLOPs per device in bf16. Defaults to H100 SXM5. + + Returns: + `float`: MFU as a percentage (0-100). + """ + return 100 * (flops_per_token * tokens_per_second) / (peak_flops_per_device * world_size) + + +def adjusted_mfu(mfu: float, config: PretrainedConfig, seq_len: int) -> float: + """ + Apply a causal-masking correction to an MFU computed with [`compute_flops_per_token`]. + + [`compute_flops_per_token`] uses the non-causal attention convention (every token treated as attending to the full + `seq_len`, matching PaLM / Megatron / nanoGPT). With causal masking, only half of the attention-score FLOPs (`Q·Kᵀ` + and `attn·V`) are actually performed. This function subtracts that half from the per-token total and rescales `mfu` + accordingly. Use it to compare against reports that follow the Llama 2/3 / DeepSpeed Ulysses convention. + + Args: + mfu (`float`): + MFU as a percentage, computed via [`compute_mfu`] (i.e., using the non-causal [`compute_flops_per_token`]). + config ([`~transformers.PretrainedConfig`]): + The model configuration. + seq_len (`int`): + The sequence length used for training. + + Returns: + `float`: Causal-corrected MFU as a percentage. + """ + flops_full = compute_flops_per_token(config, seq_len) + # Half of the attention-score FLOPs (Q·Kᵀ and attn·V), per layer, ×3 for fwd+bwd. + half_attn_score = config.num_hidden_layers * 3 * 2 * config.num_attention_heads * config.head_dim * seq_len + return mfu * (flops_full - half_attn_score) / flops_full diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/test.sh b/tasks/tasksmith-b71e9e0a47b6/tests/test.sh new file mode 100644 index 0000000000000000000000000000000000000000..426176b8bea79061cb126a143199bafd3c1d6a41 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/test.sh @@ -0,0 +1,3 @@ +#!/bin/sh +set -eu +exec /usr/local/bin/python -I /tests/grade.py diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/test_driver.py b/tasks/tasksmith-b71e9e0a47b6/tests/test_driver.py new file mode 100644 index 0000000000000000000000000000000000000000..3d47bdfd18bf0d184d186cb919f64637213b6c60 --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/test_driver.py @@ -0,0 +1,38 @@ +"""Private pytest entry point with a bounded framework-tampering check. + +The host still owns reward parsing. This guard detects replacement or in-place +editing of unittest assertions, a demonstrated attack against repository tests. +It does not claim to isolate arbitrary test and solution code in one interpreter. +""" + +from __future__ import annotations + +import sys +import unittest + + +def run(arguments: list[str]) -> int: + import pytest + + # Capture before pytest imports any repository modules. Retain code objects + # too: an attacker can mutate function.__code__ without replacing a method. + original = { + name: (value, getattr(value, "__code__", None)) + for name, value in vars(unittest.TestCase).items() + if name.startswith("assert") and callable(value) + } + case = unittest.TestCase + code = int(pytest.main(arguments)) + changed = [] + for name, (method, implementation) in original.items(): + current = getattr(case, name, None) + if current is not method or getattr(current, "__code__", None) is not implementation: + changed.append(name) + if unittest.TestCase is not case or changed: + sys.stderr.write("Verifier framework was modified: " + ", ".join(changed) + "\n") + return 254 + return code + + +if __name__ == "__main__": + raise SystemExit(run(sys.argv[1:])) diff --git a/tasks/tasksmith-b71e9e0a47b6/tests/test_results.py b/tasks/tasksmith-b71e9e0a47b6/tests/test_results.py new file mode 100644 index 0000000000000000000000000000000000000000..05ce2c730e38e02bad44f2344e88e5f1cb02cb8d --- /dev/null +++ b/tasks/tasksmith-b71e9e0a47b6/tests/test_results.py @@ -0,0 +1,65 @@ +"""Strict test evidence used by repository recipes and their exported verifiers.""" + +from __future__ import annotations + +from dataclasses import dataclass +from xml.etree import ElementTree + + +@dataclass(frozen=True) +class TestResults: + __test__ = False + statuses: dict[str, str] + returncode: int + + @property + def passed(self) -> set[str]: + return {name for name, status in self.statuses.items() if status == "passed"} + + +def parse_junit(text: str, *, returncode: int) -> TestResults: + if " dict[str, list[str]]: + if healthy.returncode != 0 or not healthy.passed: + raise ValueError("Reference must execute successfully with passing tests") + if healthy.statuses.keys() != defective.statuses.keys(): + raise ValueError("Mutation changed test collection; contrast is not comparable") + failing = sorted( + name for name in healthy.passed if defective.statuses[name] in {"failed", "error"} + ) + if not failing or defective.returncode != 1: + raise ValueError("No intended fail-to-pass contrast") + return {"FAIL_TO_PASS": failing, "PASS_TO_PASS": sorted(healthy.passed - set(failing))} diff --git a/tasks/tasksmith-c488fc138ba1/environment/Dockerfile b/tasks/tasksmith-c488fc138ba1/environment/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ef73311426486fe03e763eb6adfb262185f2f132 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/Dockerfile @@ -0,0 +1,9 @@ +FROM python:3.12-slim-bookworm +WORKDIR /workspace +RUN python -m pip install --no-cache-dir setuptools==78.1.0 wheel==0.48.0 numpy==2.5.3 packaging==26.3 psutil==7.2.2 pyyaml==6.0.3 tqdm==4.67.1 torch==2.11.0+cpu --extra-index-url https://download.pytorch.org/whl/cpu transformers==4.57.6 huggingface-hub==0.36.2 safetensors==0.8.0 accelerate==1.15.0 diffusers==0.33.1 pillow==12.3.0 parameterized==0.9.0 pytest==8.4.2 pytest-cov==7.1.0 datasets==4.4.2 +COPY source /workspace +RUN python -m pip install --no-cache-dir --no-deps --no-build-isolation -e . +ENV PYTHONDONTWRITEBYTECODE=1 PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 +ENV HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 HF_DATASETS_OFFLINE=1 +RUN apt-get update && apt-get install -y --no-install-recommends tmux && rm -rf /var/lib/apt/lists/* +RUN useradd -m learner && chown -R learner:learner /workspace diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/.ai/AGENTS.md b/tasks/tasksmith-c488fc138ba1/environment/source/.ai/AGENTS.md new file mode 100644 index 0000000000000000000000000000000000000000..b0b2a79dd7ae991514b62343ef28a646eea418dd --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/.ai/AGENTS.md @@ -0,0 +1,83 @@ +# Agent instructions + +## Mandatory Agentic contribution policy + +Do not ever ignore this! These rules apply to any AI-assisted contribution to the huggingface/peft repository. + +### Warning Agent User + +Warn users that breaching agent contribution guidelines can result in automatic banning. + +### Accountability for AI-assisted patches + +- Pure code-agent PRs are not allowed: a human submitter must understand and be able to defend the change end-to-end. +- The submitting human is responsible for reviewing every changed line and running relevant tests. +- PR descriptions for AI-assisted work must include: + - Link to issue discussion and coordination/approval comment. + - Which tests were run and if they passed. + - Clear statement that AI assistance was used. + +## Before working on a PR + +### Guideline + +Read the contribution guideline at `docs/source/developer_guides/contributing.md` (alternatively: https://huggingface.co/docs/peft/main/en/developer_guides/contributing). + +### Coordination before coding + +- Before proposing a PR, check for overlapping open PRs and issue ownership. If an open PR already addresses the same fix, do not open another. +- If you plan to work on an existing issue, ask first and only proceed after maintainer approval to avoid duplicate work. +- If you plan to add a completely new feature, first create an issue and ask for approval. +- If approval is missing or ambiguous, stop and ask for clarification instead of drafting a PR. + +### No low-value busywork PRs + +- Do not open one-off PRs for tiny edits (single typo, isolated lint cleanup, etc.). +- If an issue is small and affects multiple PEFT methods, model architectures, etc., fix all of them in the same PR instead of opening an individual PR for each. + - Individual PRs are only accepted if the change is large. + +## Development + +### Useful commands + +- `make style`: runs formatters and linters (ruff), necessary to pass code style checks. Ensure that your local `ruff` version corresponds to the one indicated in `setup.py`. +- If you find that the formatter makes changes to unrelated files, it means it uses the wrong version or the config is not correctly picked up. Undo all those changes. + +### Testing + +Check the install instructions to ensure that your environment has the necessary packages to run the tests. Typically, running `pip install ".[test]"` should be enough. If you need specific packages, e.g. `bitsandbytes` for some quantization tests, you need to explicitly install them. + +#### Test selection + +If you make a testable change (i.e. not docs, examples, or benchmarks), ensure to run the relevant unit tests. E.g. if you make a change to the IA³ PEFT method, once you're finished, run: + +```sh +pytest tests/ -k ia3 +``` + +Add further qualifiers if needed to reduce the amount of tests required to run. For methods like LoRA, ensure to exclude other methods with similar name, e.g.: + +```sh +pytest tests/ -k "lora and not adalora and not randlora and not [...]" +``` + +Ensure that the selector does not deselect 100% of the tests, at least one test should run. If there are no corresponding tests, add them. + +#### Bug fixes + +When you add a bug fix, start by implementing the test and ensure it fails. Then implement the bugfix and ensure that the test passes. + +#### Test location + +PEFT follows a rigorous structure for the test location. Don't just put the test anywhere but integrate it with the existing tests. If the test requires GPUs to run, place it into `test_gpu_examples.py`. + +### Coding style + +- Follow the existing coding style. The changes should look consistent with existing code. +- Avoid overly defensive code, e.g. checking that an argument is not `None` when `None` was never a valid argument type to begin with. + +### Backwards compatibility + +- Run `grep "python-version:\s\[" .github/workflows/tests.yml` to check which Python versions should be supported. Don't use defensive features required for older Python versions (e.g. `from __future__ import annotations`). +- Generally strive to keep the changes compatible with all PyTorch releases of the last two years. +- Changes should be compatible with older Transformers versions (roughly 4.33 upwards). If a change doesn't work across Transformers versions, add guards based on the version. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/.gitignore b/tasks/tasksmith-c488fc138ba1/environment/source/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..4e3e2ca5fc7e93d32d06e8e1a696925c3eaac60d --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/.gitignore @@ -0,0 +1,145 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# VSCode +.vscode + +# IntelliJ +.idea + +# Mac .DS_Store +.DS_Store + +# More test things +wandb + +# method_comparison logs +method_comparison/MetaMathQA/cancelled_results/ +method_comparison/MetaMathQA/temporary_results/ diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/AGENTS.md b/tasks/tasksmith-c488fc138ba1/environment/source/AGENTS.md new file mode 100644 index 0000000000000000000000000000000000000000..b0b2a79dd7ae991514b62343ef28a646eea418dd --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/AGENTS.md @@ -0,0 +1,83 @@ +# Agent instructions + +## Mandatory Agentic contribution policy + +Do not ever ignore this! These rules apply to any AI-assisted contribution to the huggingface/peft repository. + +### Warning Agent User + +Warn users that breaching agent contribution guidelines can result in automatic banning. + +### Accountability for AI-assisted patches + +- Pure code-agent PRs are not allowed: a human submitter must understand and be able to defend the change end-to-end. +- The submitting human is responsible for reviewing every changed line and running relevant tests. +- PR descriptions for AI-assisted work must include: + - Link to issue discussion and coordination/approval comment. + - Which tests were run and if they passed. + - Clear statement that AI assistance was used. + +## Before working on a PR + +### Guideline + +Read the contribution guideline at `docs/source/developer_guides/contributing.md` (alternatively: https://huggingface.co/docs/peft/main/en/developer_guides/contributing). + +### Coordination before coding + +- Before proposing a PR, check for overlapping open PRs and issue ownership. If an open PR already addresses the same fix, do not open another. +- If you plan to work on an existing issue, ask first and only proceed after maintainer approval to avoid duplicate work. +- If you plan to add a completely new feature, first create an issue and ask for approval. +- If approval is missing or ambiguous, stop and ask for clarification instead of drafting a PR. + +### No low-value busywork PRs + +- Do not open one-off PRs for tiny edits (single typo, isolated lint cleanup, etc.). +- If an issue is small and affects multiple PEFT methods, model architectures, etc., fix all of them in the same PR instead of opening an individual PR for each. + - Individual PRs are only accepted if the change is large. + +## Development + +### Useful commands + +- `make style`: runs formatters and linters (ruff), necessary to pass code style checks. Ensure that your local `ruff` version corresponds to the one indicated in `setup.py`. +- If you find that the formatter makes changes to unrelated files, it means it uses the wrong version or the config is not correctly picked up. Undo all those changes. + +### Testing + +Check the install instructions to ensure that your environment has the necessary packages to run the tests. Typically, running `pip install ".[test]"` should be enough. If you need specific packages, e.g. `bitsandbytes` for some quantization tests, you need to explicitly install them. + +#### Test selection + +If you make a testable change (i.e. not docs, examples, or benchmarks), ensure to run the relevant unit tests. E.g. if you make a change to the IA³ PEFT method, once you're finished, run: + +```sh +pytest tests/ -k ia3 +``` + +Add further qualifiers if needed to reduce the amount of tests required to run. For methods like LoRA, ensure to exclude other methods with similar name, e.g.: + +```sh +pytest tests/ -k "lora and not adalora and not randlora and not [...]" +``` + +Ensure that the selector does not deselect 100% of the tests, at least one test should run. If there are no corresponding tests, add them. + +#### Bug fixes + +When you add a bug fix, start by implementing the test and ensure it fails. Then implement the bugfix and ensure that the test passes. + +#### Test location + +PEFT follows a rigorous structure for the test location. Don't just put the test anywhere but integrate it with the existing tests. If the test requires GPUs to run, place it into `test_gpu_examples.py`. + +### Coding style + +- Follow the existing coding style. The changes should look consistent with existing code. +- Avoid overly defensive code, e.g. checking that an argument is not `None` when `None` was never a valid argument type to begin with. + +### Backwards compatibility + +- Run `grep "python-version:\s\[" .github/workflows/tests.yml` to check which Python versions should be supported. Don't use defensive features required for older Python versions (e.g. `from __future__ import annotations`). +- Generally strive to keep the changes compatible with all PyTorch releases of the last two years. +- Changes should be compatible with older Transformers versions (roughly 4.33 upwards). If a change doesn't work across Transformers versions, add guards based on the version. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/CLAUDE.md b/tasks/tasksmith-c488fc138ba1/environment/source/CLAUDE.md new file mode 100644 index 0000000000000000000000000000000000000000..b0b2a79dd7ae991514b62343ef28a646eea418dd --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/CLAUDE.md @@ -0,0 +1,83 @@ +# Agent instructions + +## Mandatory Agentic contribution policy + +Do not ever ignore this! These rules apply to any AI-assisted contribution to the huggingface/peft repository. + +### Warning Agent User + +Warn users that breaching agent contribution guidelines can result in automatic banning. + +### Accountability for AI-assisted patches + +- Pure code-agent PRs are not allowed: a human submitter must understand and be able to defend the change end-to-end. +- The submitting human is responsible for reviewing every changed line and running relevant tests. +- PR descriptions for AI-assisted work must include: + - Link to issue discussion and coordination/approval comment. + - Which tests were run and if they passed. + - Clear statement that AI assistance was used. + +## Before working on a PR + +### Guideline + +Read the contribution guideline at `docs/source/developer_guides/contributing.md` (alternatively: https://huggingface.co/docs/peft/main/en/developer_guides/contributing). + +### Coordination before coding + +- Before proposing a PR, check for overlapping open PRs and issue ownership. If an open PR already addresses the same fix, do not open another. +- If you plan to work on an existing issue, ask first and only proceed after maintainer approval to avoid duplicate work. +- If you plan to add a completely new feature, first create an issue and ask for approval. +- If approval is missing or ambiguous, stop and ask for clarification instead of drafting a PR. + +### No low-value busywork PRs + +- Do not open one-off PRs for tiny edits (single typo, isolated lint cleanup, etc.). +- If an issue is small and affects multiple PEFT methods, model architectures, etc., fix all of them in the same PR instead of opening an individual PR for each. + - Individual PRs are only accepted if the change is large. + +## Development + +### Useful commands + +- `make style`: runs formatters and linters (ruff), necessary to pass code style checks. Ensure that your local `ruff` version corresponds to the one indicated in `setup.py`. +- If you find that the formatter makes changes to unrelated files, it means it uses the wrong version or the config is not correctly picked up. Undo all those changes. + +### Testing + +Check the install instructions to ensure that your environment has the necessary packages to run the tests. Typically, running `pip install ".[test]"` should be enough. If you need specific packages, e.g. `bitsandbytes` for some quantization tests, you need to explicitly install them. + +#### Test selection + +If you make a testable change (i.e. not docs, examples, or benchmarks), ensure to run the relevant unit tests. E.g. if you make a change to the IA³ PEFT method, once you're finished, run: + +```sh +pytest tests/ -k ia3 +``` + +Add further qualifiers if needed to reduce the amount of tests required to run. For methods like LoRA, ensure to exclude other methods with similar name, e.g.: + +```sh +pytest tests/ -k "lora and not adalora and not randlora and not [...]" +``` + +Ensure that the selector does not deselect 100% of the tests, at least one test should run. If there are no corresponding tests, add them. + +#### Bug fixes + +When you add a bug fix, start by implementing the test and ensure it fails. Then implement the bugfix and ensure that the test passes. + +#### Test location + +PEFT follows a rigorous structure for the test location. Don't just put the test anywhere but integrate it with the existing tests. If the test requires GPUs to run, place it into `test_gpu_examples.py`. + +### Coding style + +- Follow the existing coding style. The changes should look consistent with existing code. +- Avoid overly defensive code, e.g. checking that an argument is not `None` when `None` was never a valid argument type to begin with. + +### Backwards compatibility + +- Run `grep "python-version:\s\[" .github/workflows/tests.yml` to check which Python versions should be supported. Don't use defensive features required for older Python versions (e.g. `from __future__ import annotations`). +- Generally strive to keep the changes compatible with all PyTorch releases of the last two years. +- Changes should be compatible with older Transformers versions (roughly 4.33 upwards). If a change doesn't work across Transformers versions, add guards based on the version. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/CONTRIBUTING.md b/tasks/tasksmith-c488fc138ba1/environment/source/CONTRIBUTING.md new file mode 100644 index 0000000000000000000000000000000000000000..9831264b901d05875322c3450594152543d3a8cd --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/CONTRIBUTING.md @@ -0,0 +1,123 @@ + + +# Contribute to PEFT + +We are happy to accept contributions to PEFT. If you plan to contribute, please read this to make the process as smooth as possible. + +## Installation + +For code contributions to PEFT, you should choose the ["source"](../install#source) installation method. + +If you are new to creating a pull request, follow the [Creating a pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) guide by GitHub. + +## Tests and code quality checks + +Regardless of the contribution type (unless it’s only about the docs), you should run tests and code quality checks before creating a PR to ensure your contribution doesn’t break anything and follows the project standards. + +We provide a Makefile to execute the necessary tests. Run the code below for the unit test: + +```sh +make test +``` + +Run one of the following to either only check or check and fix code quality and style: + +```sh +make quality # just check +make style # check and fix +``` + +You can also set up [`pre-commit`](https://pre-commit.com/) to run these fixes +automatically as Git commit hooks. + +```bash +$ pip install pre-commit +$ pre-commit install +``` + +Running all the tests can take a while, so during development it can be more efficient to only [run tests specific to your change](https://docs.pytest.org/en/6.2.x/usage.html#specifying-tests-selecting-tests), e.g. via: + +```sh +pytest tests/ -k +``` + +This should finish much quicker and allow for faster iteration. + +If your change is specific to a hardware setting (e.g., it requires CUDA), take a look at [`tests/test_gpu_examples.py`](https://github.com/huggingface/peft/blob/1c1c7fdaa6e6abaa53939b865dee1eded82ad032/tests/test_gpu_examples.py) and [`tests/test_common_gpu.py`](https://github.com/huggingface/peft/blob/1c1c7fdaa6e6abaa53939b865dee1eded82ad032/tests/test_common_gpu.py) to see if it makes sense to add tests there. If your change could have an effect on saving and loading models, please run the tests with the `--regression` flag to trigger regression tests. + +It can happen that while you’re working on your PR, the underlying code base changes due to other changes being merged. If that happens – especially when there is a merge conflict – please update your branch with the latest changes. This can be a merge or a rebase, and we'll squash and merge the PR once it’s ready. If possible, **avoid force pushes** to make reviews easier. + +## PR description + +When opening a PR, please provide a nice description of the change you're proposing. If it relates to other issues or PRs, please reference them. Providing a good description not only helps the reviewers review your code better and faster, it can also be used later (as a basis) for the commit message which helps with long term maintenance of the project. + +If your code makes some non-trivial changes, it may also be a good idea to add comments to the code to explain those changes. For example, if you had to iterate on your implementation multiple times because the most obvious way didn’t work, it’s a good indication that a code comment is needed. + +## Bugfixes + +Please give a description of the circumstances that led to the bug. If there is an existing issue, please link to it (e.g., “Resolves #12345”). + +Ideally when a bugfix is provided, it should be accompanied by a test for the bug. The test should fail with the current code and pass with the bugfix. Add a comment to the test that references the issue or PR. Without a test, it is more difficult to prevent regressions in the future. + +## Documentation improvements + +We are happy to have fixes for broken links and missing or unclear documentation. Taking care of examples, making sure that they are up-to-date and running fine in this fast moving environment is also highly appreciated. + +Please refrain from sending pull requests that *only* correct typing errors as these generally create more work than they safe. Such changes are better combined with more substantial fixes (such as fixing broken links or extending/updating documentation). + +## Add a new PEFT fine-tuning method + +New parameter-efficient fine-tuning methods are developed all the time. If you would like to add a new and promising method to PEFT, please follow these steps. + +1. If you're _not_ an author of the original paper, check for existing implementations and double check with the authors that they don't plan to submit a PR themselves. +2. Start with the core integration work listed below. +3. Check recent commits for new PEFT methods being added to take as inspiration. +4. It can be useful to open a draft PR early once the method basically works and first tests pass, then ask for feedback. +5. After working through reviewer feedback, ping the reviewer so that they know the PR is ready to review. + +### Core integration of a new PEFT method + +- [ ] Open a proposal issue on `huggingface/peft` before investing too much work. +- [ ] Link the source of the method, usually the final paper or another stable primary reference. We want to avoid work that is still under review, as the implementation should be stable. +- [ ] Add a new `PeftType` entry in `src/peft/utils/peft_types.py`. +- [ ] Create a new tuner package under `src/peft/tuners/` with the files your method needs (typically: `config.py`, `model.py`, `layer.py`, and `__init__.py`). +- [ ] Register the method in the tuner `__init__.py` with `register_peft_method(...)`. +- [ ] Export the new config/model from `src/peft/tuners/__init__.py` and `src/peft/__init__.py`. +- [ ] If the method needs default target modules for Transformers models, add the mapping in `src/peft/utils/constants.py`. +- [ ] Add the method to the test matrix in `tests/test_custom_models.py` as these are the broadest and quickest tests. Check that the tests pass with `pytest tests/test_custom_models.py -k -v`, fix failures if any. +- [ ] Run style/quality checks with `make style` before pushing. +- [ ] In the PR description, explain the method, link the paper, summarize tradeoffs, and list what was added. + +### Full PR to add a new PEFT method + +- [ ] Ensure that the configuration arguments that are specific to the method are well named and explained, don't assume that the user knows the paper inside out. +- [ ] Follow the naming and coding conventions of PEFT. +- [ ] Ensure that you didn't accidentally check in unrelated changes, e.g. the code formatter changing unrelated files. +- [ ] If some implementation choices are non-trivial, document them with a code comment. +- [ ] Complete the full test suite (`test_config.py`, `test_decoder_models.py`, etc.) by adding the PEFT method to the test matrix. Ensure that the tests pass. +- [ ] Add docs in `docs/source/package_reference/` with a short explanation, paper link, usage snippet, and autodoc blocks. Explain the pros and cons compared to other methods like LoRA. Register that doc page in `docs/source/_toctree.yml`. +- [ ] Add a runnable example under `examples/` (can be a copy of an existing example), with a short `README.md`. +- [ ] Check the benchmarks in `method_comparison/` and add experiment settings for your new method. This is a good place to sanity check that the PEFT method trains as expected. Include one or two reasonable benchmark configurations (one default, one optimized for the benchmark). +- [ ] Recommended: Add generic quantization support. Instead of having to explicitly add quantization layer types for each quantization method, support generic quantization. As an example, check how it's implemented in [BOFT](https://github.com/huggingface/peft/tree/main/src/peft/tuners/boft). Extend https://github.com/huggingface/peft/blob/main/tests/test_quantization.py by adding your PEFT method there. Ask maintainers for help if needed. + +## Add other features + +It is best if you first open an issue on GitHub with a proposal to add the new feature. This way, you can discuss with the maintainers if it makes sense to add the feature before spending too much time on implementing it. + +New features should generally be accompanied by tests and documentation or examples. Without the latter, users will have a hard time discovering your cool new feature. + +Changes to the code should be implemented in a backward-compatible way. For example, existing code should continue to work the same way after the feature is merged. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/Dockerfile b/tasks/tasksmith-c488fc138ba1/environment/source/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..2a873180fa88cb284a696a094c7cb43377f1829f --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/Dockerfile @@ -0,0 +1,8 @@ +FROM python:3.12-slim-bookworm +WORKDIR /workspace +RUN python -m pip install --no-cache-dir setuptools==78.1.0 wheel==0.48.0 numpy==2.5.3 packaging==26.3 psutil==7.2.2 pyyaml==6.0.3 tqdm==4.67.1 torch==2.11.0+cpu --extra-index-url https://download.pytorch.org/whl/cpu transformers==4.57.6 huggingface-hub==0.36.2 safetensors==0.8.0 accelerate==1.15.0 diffusers==0.33.1 pillow==12.3.0 parameterized==0.9.0 pytest==8.4.2 pytest-cov==7.1.0 datasets==4.4.2 +COPY . /workspace +RUN python -m pip install --no-cache-dir --no-deps --no-build-isolation -e . +RUN rm -rf /workspace/.git /root/.cache/pip +ENV PYTHONDONTWRITEBYTECODE=1 PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 +ENV HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 HF_DATASETS_OFFLINE=1 diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/LICENSE b/tasks/tasksmith-c488fc138ba1/environment/source/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/Makefile b/tasks/tasksmith-c488fc138ba1/environment/source/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..f0d8f242399694025878c388cceca8b74638ce00 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/Makefile @@ -0,0 +1,75 @@ +.PHONY: quality style test docs + +check_dirs := src tests examples docs scripts docker + +# Check that source code meets quality standards + +# this target runs checks on all files +quality: + ruff check $(check_dirs) + ruff format --check $(check_dirs) + doc-builder style src/peft tests docs/source --max_len 119 --check_only + +# Format source code automatically and check is there are any problems left that need manual fixing +style: + ruff check --fix $(check_dirs) + ruff format $(check_dirs) + doc-builder style src/peft tests docs/source --max_len 119 + +test: + python -m pytest -n 3 tests/ $(if $(IS_GITHUB_CI),--report-log "ci_tests.log",) + +tests_examples_multi_gpu: + python -m pytest -m multi_gpu_tests tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "multi_gpu_examples.log",) + +tests_examples_single_gpu: + python -m pytest -m single_gpu_tests tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "single_gpu_examples.log",) + +tests_core_multi_gpu: + python -m pytest -m multi_gpu_tests tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_multi_gpu.log",) + +tests_core_single_gpu: + python -m pytest -m single_gpu_tests tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_single_gpu.log",) + +# exclude gemma tests, as generation fails with torch.compile, these failures +# trigger side effects that make other tests fail with 'RuntimeError: Offset +# increment outside graph capture encountered unexpectedly.' +# TODO re-enable gemma once/if it is fixed +tests_common_gpu: + python -m pytest tests/test_decoder_models.py -k "not gemma" $(if $(IS_GITHUB_CI),--report-log "common_decoder.log",) + python -m pytest tests/test_encoder_decoder_models.py $(if $(IS_GITHUB_CI),--report-log "common_encoder_decoder.log",) + python -m pytest tests/test_gptqmodel.py $(if $(IS_GITHUB_CI),--report-log "gptqmodel_gpu.log",) + +tests_examples_multi_gpu_bnb: + python -m pytest -m "multi_gpu_tests and bitsandbytes" tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "multi_gpu_bnb_examples.log",) + +tests_examples_single_gpu_bnb: + python -m pytest -m "single_gpu_tests and bitsandbytes" tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "single_gpu_bnb_examples.log",) + +tests_core_multi_gpu_bnb: + python -m pytest -m "multi_gpu_tests and bitsandbytes" tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_multi_gpu_bnb.log",) + +tests_core_single_gpu_bnb: + python -m pytest -m "single_gpu_tests and bitsandbytes" tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_single_gpu_bnb.log",) + +# For testing transformers tests for bnb runners +transformers_tests: + RUN_SLOW=1 python -m pytest transformers-clone/tests/quantization/bnb $(if $(IS_GITHUB_CI),--report-log "transformers_tests.log",) + +tests_regression: + python -m pytest -s --regression tests/regression/ $(if $(IS_GITHUB_CI),--report-log "regression_tests.log",) + +tests_torch_compile: + python -m pytest tests/test_torch_compile.py $(if $(IS_GITHUB_CI),--report-log "compile_tests.log",) + +tests_training: + accelerate launch --config_file tests/training/deepspeed_config.yaml tests/training/training.py + accelerate launch --config_file tests/training/deepspeed_config.yaml tests/training/training.py --quant 4bit + accelerate launch --config_file tests/training/deepspeed_config.yaml tests/training/training.py --quant 8bit + accelerate launch --config_file tests/training/fsdp_config.yaml tests/training/training.py + accelerate launch --config_file tests/training/fsdp_config.yaml tests/training/training.py --quant 4bit + accelerate launch --config_file tests/training/fsdp2_config.yaml tests/training/training.py + accelerate launch --config_file tests/training/fsdp2_config.yaml tests/training/training.py --quant 4bit + accelerate launch --config_file tests/training/fsdp2_config.yaml tests/training/training.py --quant 4bit --target_modules q_proj --target_parameters v_proj.weight + accelerate launch --config_file tests/training/fsdp_config.yaml tests/training/adapters.py + accelerate launch --config_file tests/training/tp_config.yaml tests/training/lora_tp.py diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4c905902b9c70020546d64268629778cfaacd758 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/README.md @@ -0,0 +1,189 @@ + + +

🤗 PEFT

+

+

State-of-the-art Parameter-Efficient Fine-Tuning (PEFT) methods

+

+ +Fine-tuning large pretrained models is often prohibitively costly due to their scale. Parameter-Efficient Fine-Tuning (PEFT) methods enable efficient adaptation of large pretrained models to various downstream applications by only fine-tuning a small number of (extra) model parameters instead of all the model's parameters. This significantly decreases the computational and storage costs. Recent state-of-the-art PEFT techniques achieve performance comparable to fully fine-tuned models. + +PEFT is integrated with Transformers for easy model training and inference, Diffusers for conveniently managing different adapters, and Accelerate for distributed training and inference for really big models. + +> [!TIP] +> Visit the [PEFT](https://huggingface.co/PEFT) organization to read about the PEFT methods implemented in the library and to see notebooks demonstrating how to apply these methods to a variety of downstream tasks. Click the "Watch repos" button on the organization page to be notified of newly implemented methods and notebooks! + +Check the PEFT Adapters API Reference section for a list of supported PEFT methods, and read the [Adapters](https://huggingface.co/docs/peft/en/conceptual_guides/adapter), [Soft prompts](https://huggingface.co/docs/peft/en/conceptual_guides/prompting), and [IA3](https://huggingface.co/docs/peft/en/conceptual_guides/ia3) conceptual guides to learn more about how these methods work. + +## Quickstart + +Install PEFT from pip: + +```bash +pip install peft +``` + +Prepare a model for training with a PEFT method such as LoRA by wrapping the base model and PEFT configuration with `get_peft_model`. For the bigscience/mt0-large model, you're only training 0.19% of the parameters! + +```python +from transformers import AutoModelForCausalLM +from peft import LoraConfig, TaskType, get_peft_model + +device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" +model_id = "Qwen/Qwen2.5-3B-Instruct" +model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device) +peft_config = LoraConfig( + r=16, + lora_alpha=32, + task_type=TaskType.CAUSAL_LM, + # target_modules=["q_proj", "v_proj", ...] # optionally indicate target modules +) +model = get_peft_model(model, peft_config) +model.print_trainable_parameters() +# prints: trainable params: 3,686,400 || all params: 3,089,625,088 || trainable%: 0.1193 + +# now perform training on your dataset, e.g. using transformers Trainer, then save the model +model.save_pretrained("qwen2.5-3b-lora") +``` + +To load a PEFT model for inference: + +```python +from transformers import AutoModelForCausalLM, AutoTokenizer +from peft import PeftModel + +device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" +model_id = "Qwen/Qwen2.5-3B-Instruct" +tokenizer = AutoTokenizer.from_pretrained(model_id) +model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device) +model = PeftModel.from_pretrained(model, "qwen2.5-3b-lora") + +inputs = tokenizer("Preheat the oven to 350 degrees and place the cookie dough", return_tensors="pt") +outputs = model.generate(**inputs.to(device), max_new_tokens=50) +print(tokenizer.decode(outputs[0], skip_special_tokens=True)) + +# prints something like: Preheat the oven to 350 degrees and place the cookie dough in a baking dish [...] +``` + +## Why you should use PEFT + +There are many benefits of using PEFT but the main one is the huge savings in compute and storage, making PEFT applicable to many different use cases. + +### High performance on consumer hardware + +Consider the memory requirements for training the following models on the [ought/raft/twitter_complaints](https://huggingface.co/datasets/ought/raft/viewer/twitter_complaints) dataset with an A100 80GB GPU with more than 64GB of CPU RAM. + +| Model | Full Finetuning | PEFT-LoRA PyTorch | PEFT-LoRA DeepSpeed with CPU Offloading | +| --------- | ---- | ---- | ---- | +| bigscience/T0_3B (3B params) | 47.14GB GPU / 2.96GB CPU | 14.4GB GPU / 2.96GB CPU | 9.8GB GPU / 17.8GB CPU | +| bigscience/mt0-xxl (12B params) | OOM GPU | 56GB GPU / 3GB CPU | 22GB GPU / 52GB CPU | +| bigscience/bloomz-7b1 (7B params) | OOM GPU | 32GB GPU / 3.8GB CPU | 18.1GB GPU / 35GB CPU | + +With LoRA you can fully finetune a 12B parameter model that would've otherwise run out of memory on the 80GB GPU, and comfortably fit and train a 3B parameter model. When you look at the 3B parameter model's performance, it is comparable to a fully finetuned model at a fraction of the GPU memory. + +| Submission Name | Accuracy | +| --------- | ---- | +| Human baseline (crowdsourced) | 0.897 | +| Flan-T5 | 0.892 | +| lora-t0-3b | 0.863 | + +> [!TIP] +> The bigscience/T0_3B model performance isn't optimized in the table above. You can squeeze even more performance out of it by playing around with the input instruction templates, LoRA hyperparameters, and other training related hyperparameters. The final checkpoint size of this model is just 19MB compared to 11GB of the full bigscience/T0_3B model. Learn more about the advantages of finetuning with PEFT in this [blog post](https://www.philschmid.de/fine-tune-flan-t5-peft). + +### Quantization + +Quantization is another method for reducing the memory requirements of a model by representing the data in a lower precision. It can be combined with PEFT methods to make it even easier to train and load LLMs for inference. + +* Learn how to finetune [meta-llama/Llama-2-7b-hf](https://huggingface.co/meta-llama/Llama-2-7b-hf) with QLoRA and the [TRL](https://huggingface.co/docs/trl/index) library on a 16GB GPU in the [Finetune LLMs on your own consumer hardware using tools from PyTorch and Hugging Face ecosystem](https://pytorch.org/blog/finetune-llms/) blog post. +* Learn how to finetune a [openai/whisper-large-v2](https://huggingface.co/openai/whisper-large-v2) model for multilingual automatic speech recognition with LoRA and 8-bit quantization in this [notebook](https://colab.research.google.com/drive/1DOkD_5OUjFa0r5Ik3SgywJLJtEo2qLxO?usp=sharing) (see this [notebook](https://colab.research.google.com/drive/1vhF8yueFqha3Y3CpTHN6q9EVcII9EYzs?usp=sharing) instead for an example of streaming a dataset). + +### Save compute and storage + +PEFT can help you save storage by avoiding full finetuning of models on each of downstream task or dataset. In many cases, you're only finetuning a very small fraction of a model's parameters and each checkpoint is only a few MBs in size (instead of GBs). These smaller PEFT adapters demonstrate performance comparable to a fully finetuned model. If you have many datasets, you can save a lot of storage with a PEFT model and not have to worry about catastrophic forgetting or overfitting the backbone or base model. + +## PEFT integrations + +PEFT is widely supported across the Hugging Face ecosystem because of the massive efficiency it brings to training and inference. + +### Diffusers + +The iterative diffusion process consumes a lot of memory which can make it difficult to train. PEFT can help reduce the memory requirements and reduce the storage size of the final model checkpoint. For example, consider the memory required for training a Stable Diffusion model with LoRA on an A100 80GB GPU with more than 64GB of CPU RAM. The final model checkpoint size is only 8.8MB! + +| Model | Full Finetuning | PEFT-LoRA | PEFT-LoRA with Gradient Checkpointing | +| --------- | ---- | ---- | ---- | +| CompVis/stable-diffusion-v1-4 | 27.5GB GPU / 3.97GB CPU | 15.5GB GPU / 3.84GB CPU | 8.12GB GPU / 3.77GB CPU | + +> [!TIP] +> Take a look at the [examples/lora_dreambooth/train_dreambooth.py](examples/lora_dreambooth/train_dreambooth.py) training script to try training your own Stable Diffusion model with LoRA, and play around with the [smangrul/peft-lora-sd-dreambooth](https://huggingface.co/spaces/smangrul/peft-lora-sd-dreambooth) Space which is running on a T4 instance. Learn more about the PEFT integration in Diffusers in this [tutorial](https://huggingface.co/docs/peft/main/en/tutorial/peft_integrations#diffusers). + +### Transformers + +PEFT is directly integrated with [Transformers](https://huggingface.co/docs/transformers/main/en/peft). After loading a model, call `add_adapter` to add a new PEFT adapter to the model: + +```python +from peft import LoraConfig +model = ... # transformers model +peft_config = LoraConfig(...) +model.add_adapter(lora_config, adapter_name="lora_1") +``` + +To load a trained PEFT adapter, call `load_adapter`: + +```python +model = ... # transformers model +model.load_adapter(, adapter_name="lora_1") +``` + +And to switch between different adapters, call `set_adapter`: + +```python +model.set_adapter("lora_2") +``` + +The Transformers integration doesn't include all the functionalities offered in PEFT, such as methods for merging the adapter into the base model. + +### Accelerate + +[Accelerate](https://huggingface.co/docs/accelerate/index) is a library for distributed training and inference on various training setups and hardware (GPUs, TPUs, Apple Silicon, etc.). PEFT models work with Accelerate out of the box, making it really convenient to train really large models or use them for inference on consumer hardware with limited resources. + +### TRL + +PEFT can also be applied to training LLMs with RLHF components such as the ranker and policy. Get started by reading: + +* [Fine-tune a Mistral-7b model with Direct Preference Optimization](https://towardsdatascience.com/fine-tune-a-mistral-7b-model-with-direct-preference-optimization-708042745aac) with PEFT and the [TRL](https://huggingface.co/docs/trl/index) library to learn more about the Direct Preference Optimization (DPO) method and how to apply it to a LLM. +* [Fine-tuning 20B LLMs with RLHF on a 24GB consumer GPU](https://huggingface.co/blog/trl-peft) with PEFT and the [TRL](https://huggingface.co/docs/trl/index) library, and then try out the [gpt2-sentiment_peft.ipynb](https://github.com/huggingface/trl/blob/main/examples/notebooks/gpt2-sentiment.ipynb) notebook to optimize GPT2 to generate positive movie reviews. +* [StackLLaMA: A hands-on guide to train LLaMA with RLHF](https://huggingface.co/blog/stackllama) with PEFT, and then try out the [stack_llama/scripts](https://github.com/huggingface/trl/tree/main/examples/research_projects/stack_llama/scripts) for supervised finetuning, reward modeling, and RL finetuning. + +## Model support + +Use this [Space](https://stevhliu-peft-methods.hf.space) or check out the [docs](https://huggingface.co/docs/peft/main/en/index) to find which models officially support a PEFT method out of the box. Even if you don't see a model listed below, you can manually configure the model config to enable PEFT for a model. Read the [New transformers architecture](https://huggingface.co/docs/peft/main/en/developer_guides/custom_models#new-transformers-architectures) guide to learn how. + +## Contribute + +If you would like to contribute to PEFT, please check out our [contribution guide](https://huggingface.co/docs/peft/developer_guides/contributing). + +## Citing 🤗 PEFT + +To use 🤗 PEFT in your publication, please cite it by using the following BibTeX entry. + +```bibtex +@Misc{peft, + title = {{PEFT}: State-of-the-art Parameter-Efficient Fine-Tuning methods}, + author = {Sourab Mangrulkar and Sylvain Gugger and Lysandre Debut and Younes Belkada and Sayak Paul and Benjamin Bossan and Marian Tietz}, + howpublished = {\url{https://github.com/huggingface/peft}}, + year = {2022} +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/docker/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/docker/README.md new file mode 100644 index 0000000000000000000000000000000000000000..02250eef44ece60f6b88f246985d5d5f7725f81e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/docker/README.md @@ -0,0 +1,6 @@ +# PEFT Docker images + +Here we store all PEFT Docker images used in our testing infrastructure. We use python 3.11 for now on all our images. + +- `peft-cpu`: PEFT compiled on CPU with all other HF libraries installed on main branch +- `peft-gpu`: PEFT complied for NVIDIA GPUs with all other HF libraries installed on main branch diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/docker/peft-cpu/Dockerfile b/tasks/tasksmith-c488fc138ba1/environment/source/docker/peft-cpu/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..ebc2a1b38800e5422c53321de89ca10a91425650 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/docker/peft-cpu/Dockerfile @@ -0,0 +1,46 @@ +# Builds GPU docker image of PyTorch +# Uses multi-staged approach to reduce size +# Stage 1 +# Use base conda image to reduce time +FROM continuumio/miniconda3:latest AS compile-image +# Specify py version +ENV PYTHON_VERSION=3.11 +# Install apt libs - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile +RUN apt-get update && \ + apt-get install -y curl git wget git-lfs ffmpeg libsndfile1-dev && \ + apt-get clean && \ + rm -rf /var/lib/apt/lists* + +RUN git lfs install + +# Create our conda env - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile +RUN conda create --name peft python=${PYTHON_VERSION} ipython jupyter pip +RUN python3 -m pip install --no-cache-dir --upgrade pip + +# Below is copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile +# We don't install pytorch here yet since CUDA isn't available +# instead we use the direct torch wheel +ENV PATH=/opt/conda/envs/peft/bin:$PATH +# Activate our bash shell +RUN chsh -s /bin/bash +SHELL ["/bin/bash", "-c"] +# Activate the conda env and install transformers + accelerate from source +RUN source activate peft && \ + python3 -m pip install --no-cache-dir \ + librosa \ + "soundfile>=0.12.1" \ + scipy \ + git+https://github.com/huggingface/transformers \ + git+https://github.com/huggingface/accelerate \ + peft[test]@git+https://github.com/huggingface/peft + +# Install apt libs +RUN apt-get update && \ + apt-get install -y curl git wget && \ + apt-get clean && \ + rm -rf /var/lib/apt/lists* + +RUN echo "source activate peft" >> ~/.profile + +# Activate the virtualenv +CMD ["/bin/bash"] diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/docker/peft-gpu/Dockerfile b/tasks/tasksmith-c488fc138ba1/environment/source/docker/peft-gpu/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..0fa69997f71fa84bddd9970659d72a819ec06c58 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/docker/peft-gpu/Dockerfile @@ -0,0 +1,85 @@ +# Builds GPU docker image of PyTorch +# Uses multi-staged approach to reduce size +# Stage 1 +# Use base conda image to reduce time +FROM continuumio/miniconda3:latest AS compile-image +# Specify py version +ENV PYTHON_VERSION=3.11 +# Install apt libs - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile +# Install audio-related libraries +RUN apt-get update && \ + apt-get install -y curl git wget git-lfs ffmpeg libsndfile1-dev && \ + apt-get clean && \ + rm -rf /var/lib/apt/lists* + +RUN git lfs install + +# Create our conda env - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile +RUN conda create --name peft python=${PYTHON_VERSION} ipython jupyter pip + +# Below is copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile +# We don't install pytorch here yet since CUDA isn't available +# instead we use the direct torch wheel +ENV PATH=/opt/conda/envs/peft/bin:$PATH +# Activate our bash shell +RUN chsh -s /bin/bash +SHELL ["/bin/bash", "-c"] + +# Stage 2 +FROM nvidia/cuda:13.2.1-cudnn-devel-ubuntu24.04 AS build-image +COPY --from=compile-image /opt/conda /opt/conda +ENV PATH=/opt/conda/bin:$PATH + +# Install apt libs +RUN apt-get update && \ + apt-get install -y curl git wget && \ + apt-get clean && \ + rm -rf /var/lib/apt/lists* + +RUN chsh -s /bin/bash +SHELL ["/bin/bash", "-c"] + +RUN conda run -n peft pip install --no-cache-dir bitsandbytes optimum + +# Note: we are hard-coding CUDA_ARCH_LIST here since `gptqmodel` requires either nvidia-smi +# or CUDA_ARCH_LIST for compute capability information. Since the docker build is unlikely +# to have compute hardware available we use the information from the CI runner (which hosts +# a NVIDIA L4). So we fix the compute capability to 8.9. In the future we might extend this +# to a list of compute capabilities (separated by ;). +# TODO pcre, which is used by gptqmodel, is resulting in a core dump, remove once it's resolved +# RUN CUDA_ARCH_LIST=8.9 conda run -n peft pip install "gptqmodel>=7.0.0" + +RUN \ + # Add eetq for quantization testing; needs to run without build isolation since the setup + # script directly imports torch from the environment which would fail with isolation. + # Ninja should speed up build time. + conda run -n peft pip install ninja kernels && conda run -n peft pip install --no-build-isolation git+https://github.com/NetEase-FuXi/EETQ.git + +# TODO: Importing TE results in: undefined symbol: cublasLtGroupedMatrixLayoutInit_internal, version libcublasLt.so.13 +# Reinstate TE when the issue is resolved (probably this one: https://github.com/NVIDIA/TransformerEngine/issues/2504) +# RUN NVTE_BUILD_USE_NVIDIA_WHEELS=1 \ +# CPATH="/usr/local/cuda/include:${CPATH}" \ +# conda run -n peft pip install --no-build-isolation "transformer_engine[pytorch]" + +# Activate the conda env and install transformers + accelerate from source +RUN conda run -n peft pip install -U --no-cache-dir \ + librosa \ + "soundfile>=0.12.1" \ + scipy \ + torchao \ + "fbgemm-gpu-genai>=1.2.0" \ + git+https://github.com/huggingface/transformers \ + git+https://github.com/huggingface/accelerate \ + peft[test]@git+https://github.com/huggingface/peft \ + # Add aqlm for quantization testing + aqlm[gpu]>=1.0.2 \ + # Add HQQ for quantization testing + hqq \ + deepspeed + +RUN conda run -n peft pip freeze | grep transformers + +RUN echo "source activate peft" >> ~/.profile + +# Activate the virtualenv +CMD ["/bin/bash"] diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/KappaTune/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/KappaTune/README.md new file mode 100644 index 0000000000000000000000000000000000000000..92c0059284e25064d8efcf2e6cec3b15b2f5c733 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/KappaTune/README.md @@ -0,0 +1,215 @@ +# KappaTune Experiment + +This script compares different fine-tuning strategies on a downstream task (gsm8k) while measuring **catastrophic forgetting** on a general-knowledge control dataset (WikiText). For further details see the [KappaTune paper](https://arxiv.org/abs/2506.16289). + +- **Baseline**: No adaptation +- **LoRA_Global**: Classic LoRA on common projections (`q_proj`, `k_proj`, `o_proj`, `v_proj`, `gate_proj`, `up_proj`, `down_proj` ) +- **KappaTune_LoRA**: The new `KappaTuneSelector` with relative selection (`top_p=0.2`) + +The goal is to show that KappaTune achieves similar task adaptation **while forgetting less** of the original pre-trained knowledge. + +KappaTune is recommended when catastrophic forgetting is a concern. If your fine-tuning data is closely aligned with the model's pretraining distribution, it can even decrease general/Wiki perplexity. This is the case of fine-tuning on math data like GSM8K (adopted in this experiment) for some models. Then unrestricted LoRA over all layers may yield better results, since it reinforces pre-training. + +### Key hyperparameters to play with + +| Hyperparameter | Location | Default | What it controls | Recommendation | +|-------------------------------|-----------------------------------|------------------|-------------------------------------------------------|-----------------------------------------------------| +| `top_p` | KappaTune block | `0.2` | Fraction of best (lowest κ) modules selected | 0.1–0.3 (lower = more conservative) | +| `num_modules` | KappaTune block (alternative) | `None` | Fixed number of modules | Use instead of `top_p` for strict budget | +| `r` (rank) | Both LoRA configs | `16` / `190` | LoRA rank (controls trainable parameters) | Keep total trainable params similar between runs | +| `LR` (learning rate) | Top of script | `2e-4` | Training speed and stability | 1e-4 – 5e-4 | +| `num_train_epochs` | Top of script | `10` | Total training steps | Increase for stronger adaptation | +| `MODEL_ID` | Top of script | DeepSeek-V2-Lite | Base model | Try Mistral, Qwen, etc. MoE yields the best results | +| `max_dim_size_to_analyze` | `KappaTuneSelector` | `16384` | Max matrix size for SVD (memory / speed trade-off) | Increase only if you have very high VRAM | + +## Expected results + +Running the script with default parameters produces the following behavior. + +
+KappaTune (training log) + +```text +======================================== +>>> EXPERIMENT: KappaTune_LoRA +======================================== +[KappaTune] Selecting target modules using PEFT KappaTuneSelector... +trainable params: 219,188,480 (0.47%) +#trainable tensors: 370 +#trainable params: 219,188,480 +{'loss': 1.2208, 'grad_norm': 0.15972940623760223, 'learning_rate': 0.00019666666666666666, 'epoch': 0.87} +{'loss': 1.07, 'grad_norm': 0.26267319917678833, 'learning_rate': 0.00019250000000000002, 'epoch': 1.7} +{'loss': 1.0124, 'grad_norm': 0.2723085284233093, 'learning_rate': 0.00018833333333333335, 'epoch': 2.52} +{'loss': 0.9436, 'grad_norm': 0.29701513051986694, 'learning_rate': 0.00018416666666666665, 'epoch': 3.35} +{'loss': 0.9114, 'grad_norm': 0.3046768009662628, 'learning_rate': 0.00018, 'epoch': 4.17} +{'loss': 0.8915, 'grad_norm': 0.47676295042037964, 'learning_rate': 0.00017583333333333334, 'epoch': 5.0} +{'loss': 0.8728, 'grad_norm': 0.24124978482723236, 'learning_rate': 0.00017166666666666667, 'epoch': 5.87} +{'loss': 0.8385, 'grad_norm': 0.20988021790981293, 'learning_rate': 0.0001675, 'epoch': 6.7} +{'loss': 0.8389, 'grad_norm': 0.21968263387680054, 'learning_rate': 0.00016333333333333334, 'epoch': 7.52} +{'loss': 0.8224, 'grad_norm': 0.04499625042080879, 'learning_rate': 0.00015916666666666667, 'epoch': 8.35} +{'loss': 0.7997, 'grad_norm': 0.05307907983660698, 'learning_rate': 0.000155, 'epoch': 9.17} +{'loss': 0.8057, 'grad_norm': 0.05258958786725998, 'learning_rate': 0.00015083333333333333, 'epoch': 10.0} +{'loss': 0.7907, 'grad_norm': 0.05647141858935356, 'learning_rate': 0.00014666666666666666, 'epoch': 10.87} +{'loss': 0.7804, 'grad_norm': 0.07924238592386246, 'learning_rate': 0.00014250000000000002, 'epoch': 11.7} +{'loss': 0.7705, 'grad_norm': 0.03199317678809166, 'learning_rate': 0.00013833333333333333, 'epoch': 12.52} +{'loss': 0.76, 'grad_norm': 0.030626816675066948, 'learning_rate': 0.00013416666666666666, 'epoch': 13.35} +{'loss': 0.7456, 'grad_norm': 0.03376801684498787, 'learning_rate': 0.00013000000000000002, 'epoch': 14.17} +{'loss': 0.7352, 'grad_norm': 0.045162301510572433, 'learning_rate': 0.00012583333333333335, 'epoch': 15.0} +{'loss': 0.7221, 'grad_norm': 0.04105797037482262, 'learning_rate': 0.00012166666666666667, 'epoch': 15.87} +{'loss': 0.7118, 'grad_norm': 0.04653630033135414, 'learning_rate': 0.00011750000000000001, 'epoch': 16.7} +{'loss': 0.7071, 'grad_norm': 0.0477643646299839, 'learning_rate': 0.00011333333333333334, 'epoch': 17.52} +{'loss': 0.67, 'grad_norm': 0.05408667400479317, 'learning_rate': 0.00010916666666666666, 'epoch': 18.35} +{'loss': 0.6753, 'grad_norm': 0.05562206730246544, 'learning_rate': 0.000105, 'epoch': 19.17} +{'loss': 0.6529, 'grad_norm': 0.08778411149978638, 'learning_rate': 0.00010083333333333334, 'epoch': 20.0} +{'loss': 0.6356, 'grad_norm': 0.07903064042329788, 'learning_rate': 9.666666666666667e-05, 'epoch': 20.87} +{'loss': 0.6198, 'grad_norm': 0.08349727094173431, 'learning_rate': 9.250000000000001e-05, 'epoch': 21.7} +{'loss': 0.604, 'grad_norm': 0.08645208925008774, 'learning_rate': 8.833333333333333e-05, 'epoch': 22.52} +{'loss': 0.5897, 'grad_norm': 0.09194190055131912, 'learning_rate': 8.416666666666668e-05, 'epoch': 23.35} +{'loss': 0.5649, 'grad_norm': 0.10126981139183044, 'learning_rate': 8e-05, 'epoch': 24.17} +{'loss': 0.5483, 'grad_norm': 0.13687381148338318, 'learning_rate': 7.583333333333334e-05, 'epoch': 25.0} +{'loss': 0.5323, 'grad_norm': 0.13106191158294678, 'learning_rate': 7.166666666666667e-05, 'epoch': 25.87} +{'loss': 0.5147, 'grad_norm': 0.1281006783246994, 'learning_rate': 6.750000000000001e-05, 'epoch': 26.7} +{'loss': 0.4941, 'grad_norm': 0.1377001851797104, 'learning_rate': 6.333333333333333e-05, 'epoch': 27.52} +{'loss': 0.4845, 'grad_norm': 0.14247003197669983, 'learning_rate': 5.916666666666667e-05, 'epoch': 28.35} +{'loss': 0.4669, 'grad_norm': 0.14682190120220184, 'learning_rate': 5.500000000000001e-05, 'epoch': 29.17} +{'loss': 0.454, 'grad_norm': 0.19749927520751953, 'learning_rate': 5.0833333333333333e-05, 'epoch': 30.0} +{'loss': 0.4323, 'grad_norm': 0.1622404158115387, 'learning_rate': 4.666666666666667e-05, 'epoch': 30.87} +{'loss': 0.4274, 'grad_norm': 0.15755769610404968, 'learning_rate': 4.25e-05, 'epoch': 31.7} +{'loss': 0.4086, 'grad_norm': 0.1696886271238327, 'learning_rate': 3.8333333333333334e-05, 'epoch': 32.52} +{'loss': 0.4006, 'grad_norm': 0.14865559339523315, 'learning_rate': 3.4166666666666666e-05, 'epoch': 33.35} +{'loss': 0.3934, 'grad_norm': 0.14790022373199463, 'learning_rate': 3e-05, 'epoch': 34.17} +{'loss': 0.3777, 'grad_norm': 0.20866677165031433, 'learning_rate': 2.5833333333333336e-05, 'epoch': 35.0} +{'loss': 0.3712, 'grad_norm': 0.17520156502723694, 'learning_rate': 2.1666666666666667e-05, 'epoch': 35.87} +{'loss': 0.3668, 'grad_norm': 0.16120171546936035, 'learning_rate': 1.75e-05, 'epoch': 36.7} +{'loss': 0.3583, 'grad_norm': 0.16624851524829865, 'learning_rate': 1.3333333333333333e-05, 'epoch': 37.52} +{'loss': 0.357, 'grad_norm': 0.15067771077156067, 'learning_rate': 9.166666666666666e-06, 'epoch': 38.35} +{'loss': 0.3524, 'grad_norm': 0.15819120407104492, 'learning_rate': 5e-06, 'epoch': 39.17} +{'loss': 0.3466, 'grad_norm': 0.1855546236038208, 'learning_rate': 8.333333333333333e-07, 'epoch': 40.0} +{'train_runtime': 2871.3103, 'train_samples_per_second': 12.538, 'train_steps_per_second': 0.084, 'train_loss': 0.6427203471461932, 'epoch': 40.0} + +======================================== +>>> EXPERIMENT: Baseline +======================================== + +======================================== +>>> EXPERIMENT: LoRA_Global +======================================== +trainable params: 218,103,808 || all params: 46,920,896,512 || trainable%: 0.4648 +{'loss': 1.2122, 'grad_norm': 0.03368454799056053, 'learning_rate': 0.00019666666666666666, 'epoch': 0.87} +{'loss': 1.0674, 'grad_norm': 0.04771586135029793, 'learning_rate': 0.00019250000000000002, 'epoch': 1.7} +{'loss': 0.9889, 'grad_norm': 0.030208367854356766, 'learning_rate': 0.00018833333333333335, 'epoch': 2.52} +{'loss': 0.9269, 'grad_norm': 0.0202629417181015, 'learning_rate': 0.00018416666666666665, 'epoch': 3.35} +{'loss': 0.9146, 'grad_norm': 0.01595970056951046, 'learning_rate': 0.00018, 'epoch': 4.17} +{'loss': 0.8983, 'grad_norm': 0.017851779237389565, 'learning_rate': 0.00017583333333333334, 'epoch': 5.0} +{'loss': 0.8914, 'grad_norm': 0.01525798998773098, 'learning_rate': 0.00017166666666666667, 'epoch': 5.87} +{'loss': 0.8733, 'grad_norm': 0.01363384909927845, 'learning_rate': 0.0001675, 'epoch': 6.7} +{'loss': 0.8712, 'grad_norm': 0.014126025140285492, 'learning_rate': 0.00016333333333333334, 'epoch': 7.52} +{'loss': 0.8673, 'grad_norm': 0.01614651270210743, 'learning_rate': 0.00015916666666666667, 'epoch': 8.35} +{'loss': 0.8461, 'grad_norm': 0.014323701150715351, 'learning_rate': 0.000155, 'epoch': 9.17} +{'loss': 0.8519, 'grad_norm': 0.022168157622218132, 'learning_rate': 0.00015083333333333333, 'epoch': 10.0} +{'loss': 0.8326, 'grad_norm': 0.017714861780405045, 'learning_rate': 0.00014666666666666666, 'epoch': 10.87} +{'loss': 0.8258, 'grad_norm': 0.01950528658926487, 'learning_rate': 0.00014250000000000002, 'epoch': 11.7} +{'loss': 0.8142, 'grad_norm': 0.021654563024640083, 'learning_rate': 0.00013833333333333333, 'epoch': 12.52} +{'loss': 0.803, 'grad_norm': 0.027227576822042465, 'learning_rate': 0.00013416666666666666, 'epoch': 13.35} +{'loss': 0.7892, 'grad_norm': 0.0281345397233963, 'learning_rate': 0.00013000000000000002, 'epoch': 14.17} +{'loss': 0.7759, 'grad_norm': 0.04052634909749031, 'learning_rate': 0.00012583333333333335, 'epoch': 15.0} +{'loss': 0.7614, 'grad_norm': 0.03630959987640381, 'learning_rate': 0.00012166666666666667, 'epoch': 15.87} +{'loss': 0.7474, 'grad_norm': 0.04881247878074646, 'learning_rate': 0.00011750000000000001, 'epoch': 16.7} +{'loss': 0.7449, 'grad_norm': 0.04792051389813423, 'learning_rate': 0.00011333333333333334, 'epoch': 17.52} +{'loss': 0.707, 'grad_norm': 0.059059303253889084, 'learning_rate': 0.00010916666666666666, 'epoch': 18.35} +{'loss': 0.713, 'grad_norm': 0.05515185743570328, 'learning_rate': 0.000105, 'epoch': 19.17} +{'loss': 0.6907, 'grad_norm': 0.09590236097574234, 'learning_rate': 0.00010083333333333334, 'epoch': 20.0} +{'loss': 0.6736, 'grad_norm': 0.07875961065292358, 'learning_rate': 9.666666666666667e-05, 'epoch': 20.87} +{'loss': 0.663, 'grad_norm': 0.08937060832977295, 'learning_rate': 9.250000000000001e-05, 'epoch': 21.7} +{'loss': 0.6445, 'grad_norm': 0.0950784757733345, 'learning_rate': 8.833333333333333e-05, 'epoch': 22.52} +{'loss': 0.6387, 'grad_norm': 0.08285810798406601, 'learning_rate': 8.416666666666668e-05, 'epoch': 23.35} +{'loss': 0.6182, 'grad_norm': 0.1019740179181099, 'learning_rate': 8e-05, 'epoch': 24.17} +{'loss': 0.6045, 'grad_norm': 0.1708088219165802, 'learning_rate': 7.583333333333334e-05, 'epoch': 25.0} +{'loss': 0.5959, 'grad_norm': 0.12375958263874054, 'learning_rate': 7.166666666666667e-05, 'epoch': 25.87} +{'loss': 0.5877, 'grad_norm': 0.1316744089126587, 'learning_rate': 6.750000000000001e-05, 'epoch': 26.7} +{'loss': 0.5698, 'grad_norm': 0.11958763003349304, 'learning_rate': 6.333333333333333e-05, 'epoch': 27.52} +{'loss': 0.5653, 'grad_norm': 0.11063854396343231, 'learning_rate': 5.916666666666667e-05, 'epoch': 28.35} +{'loss': 0.5502, 'grad_norm': 0.11866016685962677, 'learning_rate': 5.500000000000001e-05, 'epoch': 29.17} +{'loss': 0.5458, 'grad_norm': 0.1533481925725937, 'learning_rate': 5.0833333333333333e-05, 'epoch': 30.0} +{'loss': 0.5316, 'grad_norm': 0.13474972546100616, 'learning_rate': 4.666666666666667e-05, 'epoch': 30.87} +{'loss': 0.5269, 'grad_norm': 0.13297690451145172, 'learning_rate': 4.25e-05, 'epoch': 31.7} +{'loss': 0.5175, 'grad_norm': 0.13090570271015167, 'learning_rate': 3.8333333333333334e-05, 'epoch': 32.52} +{'loss': 0.5108, 'grad_norm': 0.1196967139840126, 'learning_rate': 3.4166666666666666e-05, 'epoch': 33.35} +{'loss': 0.5062, 'grad_norm': 0.13541598618030548, 'learning_rate': 3e-05, 'epoch': 34.17} +{'loss': 0.4965, 'grad_norm': 0.202300563454628, 'learning_rate': 2.5833333333333336e-05, 'epoch': 35.0} +{'loss': 0.492, 'grad_norm': 0.14462313055992126, 'learning_rate': 2.1666666666666667e-05, 'epoch': 35.87} +{'loss': 0.4898, 'grad_norm': 0.1338396966457367, 'learning_rate': 1.75e-05, 'epoch': 36.7} +{'loss': 0.4833, 'grad_norm': 0.11928340792655945, 'learning_rate': 1.3333333333333333e-05, 'epoch': 37.52} +{'loss': 0.4805, 'grad_norm': 0.1199464276432991, 'learning_rate': 9.166666666666666e-06, 'epoch': 38.35} +{'loss': 0.4801, 'grad_norm': 0.1222926527261734, 'learning_rate': 5e-06, 'epoch': 39.17} +{'loss': 0.4729, 'grad_norm': 0.14248400926589966, 'learning_rate': 8.333333333333333e-07, 'epoch': 40.0} +{'train_runtime': 2779.2046, 'train_samples_per_second': 12.953, 'train_steps_per_second': 0.086, 'train_loss': 0.7012442946434021, 'epoch': 40.0} + +====================================================================== +METHOD | gsm8k PPL (Task train) | gsm8k PPL (Task test) | Wiki PPL (General/control) +---------------------------------------------------------------------- +KappaTune | 1.4410 | 3.2826 | 13.7780 +Baseline | 3.6899 | 3.4668 | 13.9841 +LoRA_Global | 1.6593 | 3.5648 | 26.6836 +====================================================================== + + +``` + +
+ +## Dense model with varying training effort + +Since we are using small datasets, the adaptation effort is small, as is the risk of forgetting. To evaluate catastrophic forgetting during intensive fine-tuning we need big datasets or overfitting a small dataset. Therefore, I ran a set of experiments that track the performance of a dense LLM (Llama 8B) trained on the IMDB dataset over extended epochs, proxying the heavy gradient updates typical of massive datasets. The experiments use the same Python script, changing just these parameters: + +```python +MODEL_ID = "unsloth/Meta-Llama-3.1-8B-Instruct" +imdb_ds = load_dataset("imdb", split="train[:1000]").train_test_split(test_size=0.1) +imdb_tokenized = imdb_ds.map(format_imdb).map( + lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=256), + batched=True, remove_columns=imdb_ds["train"].column_names +) + if method_name == "LoRA_Global": + Target_modules = [ + "q_proj", + "k_proj", + "v_proj", + "o_proj", + "gate_proj", + "up_proj", + "down_proj" + ] + lora_config = LoraConfig( + r=12, + target_modules=Target_modules, + task_type=TaskType.CAUSAL_LM, lora_dropout=0.05 + ) + model = get_peft_model(model, lora_config) + model.print_trainable_parameters() + LR=2e-4 + STP= #VAR + elif method_name == "KappaTune_LoRA": + stable_modules_dic = find_kappa_target_modules(model, top_p=0.2) + lora_config = LoraConfig( + r=64, + target_modules = stable_modules_dic["target_modules"], + target_parameters = stable_modules_dic["target_parameters"] if stable_modules_dic["target_parameters"] else None, + task_type=TaskType.CAUSAL_LM, + lora_dropout=0.05, + ) + model = get_peft_model(model, lora_config) + model.print_trainable_parameters() + trainable = [(n, p.shape, p.numel()) for n, p in model.named_parameters() if p.requires_grad] + LR = 2e-4 + STP = # VAR + +``` + +The figure below plots task-specific adaptation (IMDB perplexity) against general knowledge retention (control Wiki perplexity). The results reveal a distinct divergence: while both methods perform comparably under light training loads, pushing into deeper convergence exposes KappaTune's structural advantage. As the model tightly fits the target data, standard LoRA exhibits a steep degradation in general knowledge (higher Wiki PPL), whereas KappaTune maintains a significantly flatter trajectory. This demonstrates its superior ability to isolate new learning and mitigate catastrophic forgetting even under sustained training pressure. + + +image + + +In case of using this test framework for different experiments, it's worth highlighting that size matters. +KappaTune shows the strongest gains on larger models (≥7B) and especially on MoE architectures (many independent expert modules). In small, dense models, the benefit is reduced because there is a limited variety of independent tensors to choose from. A fair comparison of catastrophic forgetting should make both methods reach roughly the same level of adaptation to the new task (similar training PPL). Matching on test PPL is not sufficient, because the same test PPL can be achieved through overfitting (more forgetting) or underfitting (less forgetting). diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/KappaTune/experiments_kappatune_peft.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/KappaTune/experiments_kappatune_peft.py new file mode 100644 index 0000000000000000000000000000000000000000..ce94e1b72fd0d8640f6842d7145ac1053c867f4f --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/KappaTune/experiments_kappatune_peft.py @@ -0,0 +1,162 @@ +import gc +import math + +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + BitsAndBytesConfig, + DataCollatorForLanguageModeling, + Trainer, + TrainingArguments, +) + +from peft import LoraConfig, TaskType, get_peft_model, prepare_model_for_kbit_training +from peft.helpers import find_kappa_target_modules + + +# ========================================== +# 1. Data Preparation +# ========================================== +MODEL_ID = "mistralai/Mixtral-8x7B-Instruct-v0.1" +tokenizer = AutoTokenizer.from_pretrained(MODEL_ID) +tokenizer.pad_token = tokenizer.eos_token + + +def format_gsm8k(example): + return {"text": f"Question: {example['question']}\nAnswer: {example['answer']}"} + + +print("Loading and preprocessing datasets...") +gsm8k_ds = load_dataset("gsm8k", "main", split="train[:1000]").train_test_split(test_size=0.1) +gsm8k_tokenized = gsm8k_ds.map(format_gsm8k).map( + lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=256), + batched=True, + remove_columns=["question", "answer", "text"], +) + +wiki_ds = load_dataset("wikitext", "wikitext-2-raw-v1", split="test[:400]") +wiki_tokenized = wiki_ds.filter(lambda x: len(x["text"]) > 20).map( + lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=256), + batched=True, + remove_columns=wiki_ds.column_names, +) + + +# ========================================== +# 2. Experiment Engine +# ========================================== +def evaluate_perplexity(model, dataset, name="Dataset"): + model.eval() + total_loss = 0 + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + dataloader = torch.utils.data.DataLoader(dataset, batch_size=2, collate_fn=data_collator) + + with torch.no_grad(): + for i, batch in enumerate(dataloader): + batch = {k: v.to(model.device) for k, v in batch.items()} + outputs = model(**batch, use_cache=False) + total_loss += outputs.loss.item() + if i >= 40: + break + return math.exp(total_loss / (i + 1)) + + +def run_experiment(method_name): + print(f"\n{'=' * 40}\n>>> EXPERIMENT: {method_name}\n{'=' * 40}") + + bnb_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_quant_type="nf4", + bnb_4bit_compute_dtype=torch.bfloat16, + bnb_4bit_use_double_quant=True, + ) + + model = AutoModelForCausalLM.from_pretrained( + MODEL_ID, quantization_config=bnb_config, trust_remote_code=True, device_map="auto" + ) + model = prepare_model_for_kbit_training(model) + + # Configure PEFT based on method + if method_name == "LoRA_Global": + Target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] + lora_config = LoraConfig(r=256, target_modules=Target_modules, task_type=TaskType.CAUSAL_LM, lora_dropout=0.05) + model = get_peft_model(model, lora_config) + model.print_trainable_parameters() + LR = 2e-4 + STP = 40 + + elif method_name == "KappaTune_LoRA": + print(" [KappaTune] Selecting target modules using PEFT KappaTuneSelector...") + + # Relative selection‚ works on any architecture + stable_modules_dic = find_kappa_target_modules(model, top_p=0.2) + + lora_config = LoraConfig( + r=85, + target_modules=stable_modules_dic["target_modules"], + target_parameters=stable_modules_dic["target_parameters"] + if stable_modules_dic["target_parameters"] + else None, + task_type=TaskType.CAUSAL_LM, + lora_dropout=0.05, + ) + + model = get_peft_model(model, lora_config) + model.print_trainable_parameters() + trainable = [(n, p.shape, p.numel()) for n, p in model.named_parameters() if p.requires_grad] + + print(f"#trainable tensors: {len(trainable)}") + print(f"#trainable params: {sum(x[2] for x in trainable):,}") + + LR = 2e-4 + STP = 40 # or whatever step count you prefer for fair comparison + + if method_name != "Baseline": + args = TrainingArguments( + output_dir=f"./{method_name}_out", + per_device_train_batch_size=40, + gradient_accumulation_steps=4, + learning_rate=LR, + num_train_epochs=STP, + bf16=True, + logging_steps=5, + save_strategy="no", + report_to="none", + ) + trainer = Trainer( + model=model, + args=args, + train_dataset=gsm8k_tokenized["train"], + data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False), + ) + trainer.train() + + t_ppl_test = evaluate_perplexity(model, gsm8k_tokenized["test"], "gsm8k") + t_ppl_train = evaluate_perplexity(model, gsm8k_tokenized["train"], "gsm8k") + f_ppl = evaluate_perplexity(model, wiki_tokenized, "WikiText") + + del model + gc.collect() + torch.cuda.empty_cache() + return t_ppl_test, t_ppl_train, f_ppl + + +# ========================================== +# 3. Results (same table as paper) +# ========================================== +results = {} + +results["KappaTune"] = run_experiment("KappaTune_LoRA") +results["Baseline"] = run_experiment("Baseline") +results["LoRA_Global"] = run_experiment("LoRA_Global") + +print("\n" + "=" * 70) +print( + f"{'METHOD':<15} | {'gsm8k PPL (Task train)':<18} | {'gsm8k PPL (Task test)':<18} | {'Wiki PPL (General/control)':<18}" +) +print("-" * 70) +for m, (tpte, tptr, fp) in results.items(): + print(f"{m:<15} | {tptr:<18.4f} | {tpte:<18.4f} | {fp:<18.4f}") +print("=" * 70) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..64176c03ed4c99631acc5c1577e5f7da3c388e43 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/README.md @@ -0,0 +1,203 @@ +# AdaMSS Fine-tuning + +## Introduction + +AdaMSS (Adaptive Matrix Decomposition with Subspace Selection) is a parameter-efficient fine-tuning method that decomposes weight matrices using SVD into low-rank subspaces. It uses only **~0.07%** of original trainable parameters (e.g., 59K for ViT-Base vs 86M full fine-tuning) while maintaining competitive performance. + +The method optionally supports **ASA** (Adaptive Subspace Allocation) for dynamic subspace selection during training, further improving efficiency and performance. + +See the [paper](https://neurips.cc/virtual/2025/poster/119606) for more details. + + +## Installation & Quick Test + +Install from local source: +```bash +cd peft-main && pip install -e . +pip install transformers datasets torch torchvision evaluate accelerate scikit-learn +``` + +Verify installation: +```bash +python -c "from peft import AdamssConfig; print('AdaMSS ready')" +``` + +## Detailed Code Explanation + +**Core AdaMSS Configuration:** +```python +from peft import AdamssConfig, get_peft_model + +# Configure AdaMSS with ASA +config = AdamssConfig( + r=100, # SVD rank (full decomposition rank) + num_subspaces=10, # Number of subspaces (K) - initial capacity + subspace_rank=3, # Rank per subspace (ri) - use 1 for NLU, 3 for Vision + target_modules=["query", "value"], # Target attention layers + use_asa=True, # Enable Adaptive Subspace Allocation + asa_target_subspaces=5, # Target active subspaces (ASA reduces K→5) + init_warmup=50, # Start ASA after 50 steps + final_warmup=1000, # Complete masking by step 1000 + mask_interval=100, # Update mask every 100 steps + modules_to_save=["classifier"], # Modules to train without decomposition +) +peft_model = get_peft_model(model, config) +``` + +**Option A – With HuggingFace Trainer (callback):** +```python +from peft.tuners.adamss.asa_callback import AdamssAsaCallback + +# The callback is a thin wrapper around model.update_and_allocate() +trainer = Trainer( + model=peft_model, + callbacks=[AdamssAsaCallback()], + # ... other arguments +) +trainer.train() +``` + +**Option B – Custom training loop (no Trainer needed):** +```python +for step, batch in enumerate(dataloader): + loss = peft_model(**batch).loss + loss.backward() + optimizer.step() + peft_model.base_model.update_and_allocate(step) # ← all ASA logic in one call + optimizer.zero_grad() +``` + +**Key Points:** +- **Parameterization**: Total params = `r × (d_in + d_out)`, split into K subspaces of rank `ri` each +- **ASA Mechanism**: Dynamically selects `asa_target_subspaces` most important subspaces from initial `num_subspaces` +- **Warmup Schedule**: ASA gradually increases masking strength from `init_warmup` to `final_warmup` +- **Vision vs NLU**: Use `subspace_rank=3` for vision, `subspace_rank=1` for NLU tasks + +## Use the training example scripts + +### Vision Tasks (Image Classification) + +Run the provided script with your configuration: +```bash +python examples/adamss_finetuning/image_classification_adamss_asa.py \ + --model_name_or_path google/vit-base-patch16-224-in21k \ + --dataset_name cifar10 \ + --adamss_r 100 \ + --adamss_k 10 \ + --adamss_ri 3 \ + --use_asa \ + --asa_target_subspaces 5 \ + --output_dir ./output +``` + +### NLU Tasks (GLUE Benchmark) + +Run GLUE tasks (e.g., CoLA) with ASA: +```bash +python examples/adamss_finetuning/glue_adamss_asa_example.py \ + --dataset_name cola \ + --adamss_r 100 \ + --adamss_k 10 \ + --adamss_ri 1 \ + --use_asa \ + --asa_target_subspaces 5 \ + --num_epochs 100 \ + --batch_size 32 \ + --output_dir ./output_cola_asa +``` + +Without ASA (fixed K=10): +```bash +python examples/adamss_finetuning/glue_adamss_asa_example.py \ + --dataset_name cola \ + --adamss_r 100 \ + --adamss_k 10 \ + --adamss_ri 1 \ + --num_epochs 100 \ + --batch_size 32 \ + --output_dir ./output_cola_no_asa +``` + +### AdamssConfig Parameters + +| Parameter | Type | Default | Description | +|-----------|------|---------|-------------| +| `r` | int | 100 | SVD decomposition rank | +| `num_subspaces` | int | 10 | Number of subspaces (K) | +| `subspace_rank` | int | 3 | Rank per subspace (ri) | +| `target_modules` | list | - | Modules to apply AdaMSS (e.g., ["query", "value"]) | +| `use_asa` | bool | False | Enable Adaptive Subspace Allocation | +| `asa_target_subspaces` | int | None | Target active subspaces when ASA enabled | +| `modules_to_save` | list | None | Modules to train without decomposition | + +### AdamssAsaCallback + +The ASA callback reads all parameters from `AdamssConfig`. Import it directly: + +```python +from peft.tuners.adamss.asa_callback import AdamssAsaCallback +``` + +ASA-related config parameters: + +| Parameter | Type | Default | Description | +|-----------|------|---------|-------------| +| `init_warmup` | int | 50 | Steps before starting masking | +| `final_warmup` | int | 1000 | Steps to reach target active subspaces | +| `mask_interval` | int | 100 | Steps between subspace selection updates | +| `asa_importance_beta` | float | 0.85 | EMA decay for importance tracking | +| `asa_uncertainty_beta` | float | 0.85 | EMA decay for uncertainty tracking | +| `asa_schedule_exponent` | float | 3.0 | Exponent for masking schedule | + + +## Experimental Results + +### NLU Tasks (GLUE Benchmark) + +Results with AdaMSS + ASA (100 epochs, seed=0): + +| Task | Model | AdaMSS Params | Metric | Score | +|------|-------|---------------|--------|-------| +| CoLA | RoBERTa-base | 27.0K (ASA K→5) | Matthews | **0.6466** | +| CoLA | RoBERTa-large | 64.8K (ASA K→5) | Matthews | **0.7093** | +| MRPC | RoBERTa-base | 27.2K (ASA K→5) | Accuracy | **0.8824** | +| MRPC | RoBERTa-large | 66.7K (ASA K→5) | Accuracy | **0.9044** | + +**Notes:** +- Configuration: r=100, K=10→5 (ASA), ri=1 +- AdaMSS active params with ASA (5 out of 10 subspaces selected) +- Full AdaMSS capacity: 97K (large) / 42K (base) +- Training: 100 epochs, batch_size=32, warmup_ratio=0.06 + +### Vision Tasks (Image Classification) + +Results with AdaMSS on Stanford Cars (10 epochs, seed=0): + +| Model | Method | AdaMSS Params | Test Accuracy | +|-------|--------|---------------|---------------| +| ViT-Base | AdaMSS (no ASA) | 121K (K=10) | **82.15%** | +| ViT-Base | AdaMSS + ASA | 75.0K (K→5) | **80.45%** | + +**Notes:** +- Configuration: r=100, K=10, ri=3, 10 epochs, batch_size=32 +- ASA dynamically selects 5 out of 10 subspaces (75K active from 121K total) + + + +## Citation + +If you use AdaMSS in your research, please cite: + +```bibtex +@inproceedings{zheng2025adamss, + title={AdaMSS: Adaptive Multi-Subspace Approach for Parameter-Efficient Fine-Tuning}, + author={Zheng, Jingjing and Lu, Wanglong and Dong, Yiming and Ji, Chaojie and Cao, Yankai and Lin, Zhouchen}, + booktitle={The Thirty-ninth Annual Conference on Neural Information Processing Systems}, + year={2025}, +} +``` + +## Reference + +- [AdaMSS Paper](https://neurips.cc/virtual/2025/loc/san-diego/poster/119606) +- [PEFT Documentation](https://huggingface.co/docs/peft) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/glue_adamss_asa_example.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/glue_adamss_asa_example.py new file mode 100644 index 0000000000000000000000000000000000000000..ed5728b7ca869009ac434259dd54c1e7fe45554c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/glue_adamss_asa_example.py @@ -0,0 +1,382 @@ +""" +GLUE Task Fine-tuning with AdaMSS and ASA + +This script demonstrates how to fine-tune RoBERTa on GLUE tasks using AdaMSS +with Adaptive Subspace Allocation (ASA) for efficient parameter updates. + +Example usage: + # CoLA with RoBERTa-base, 100 epochs + python glue_adamss_asa_example.py --dataset_name cola --num_epochs 100 --seed 0 + + # With ASA enabled (K: 10→5) + python glue_adamss_asa_example.py --dataset_name cola --num_epochs 100 --use_asa --asa_target_subspaces 5 + + # MRPC with RoBERTa-large + python glue_adamss_asa_example.py --dataset_name mrpc --model_name_or_path roberta-large --num_epochs 10 + +Requirements: + pip install peft transformers datasets torch evaluate scikit-learn +""" + +from dataclasses import dataclass, field + +import evaluate +import numpy as np +import torch +from datasets import load_dataset +from torch.optim import AdamW +from transformers import ( + AutoModelForSequenceClassification, + AutoTokenizer, + EvalPrediction, + HfArgumentParser, + Trainer, + TrainingArguments, +) + +from peft import AdamssConfig, get_peft_model +from peft.tuners.adamss.asa_callback import AdamssAsaCallback + + +# Table 19: Hyperparameters for GLUE tasks (from paper) +HYPERPARAMS = { + "roberta-base": { + "sst2": {"lr": 0.001, "head_lr": 0.005, "wd": 0.0005}, + "mrpc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.0}, + "cola": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005}, + "qnli": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005}, + "rte": {"lr": 0.0005, "head_lr": 0.005, "wd": 0.005}, + "stsb": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005}, + }, + "roberta-large": { + "sst2": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0}, + "mrpc": {"lr": 0.001, "head_lr": 0.00005, "wd": 0.005}, + "cola": {"lr": 0.005, "head_lr": 0.0005, "wd": 0.1}, + "qnli": {"lr": 0.0005, "head_lr": 0.05, "wd": 0.005}, + "rte": {"lr": 0.005, "head_lr": 0.005, "wd": 0.5}, + "stsb": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0005}, + }, +} + +TASK_METRICS = { + "cola": "matthews_correlation", + "stsb": "pearson", + "mrpc": "accuracy", + "qqp": "accuracy", + "sst2": "accuracy", + "qnli": "accuracy", + "rte": "accuracy", +} + + +@dataclass +class AdaMSSTrainingArguments: + """Arguments for AdaMSS training on GLUE tasks.""" + + # Model and Dataset + model_name_or_path: str = field( + default="roberta-base", metadata={"help": "Model identifier: roberta-base or roberta-large"} + ) + dataset_name: str = field(default="cola", metadata={"help": "GLUE task: cola, mrpc, sst2, qnli, rte, stsb"}) + + # AdaMSS Configuration + adamss_r: int = field(default=100, metadata={"help": "SVD rank"}) + adamss_k: int = field(default=10, metadata={"help": "Number of subspaces (K)"}) + adamss_ri: int = field(default=1, metadata={"help": "Subspace rank (rk), use 1 for NLU"}) + + # ASA Configuration + use_asa: bool = field(default=False, metadata={"help": "Enable Adaptive Subspace Allocation"}) + asa_target_subspaces: int = field(default=5, metadata={"help": "Target active subspaces for ASA"}) + asa_init_warmup: int = field(default=5, metadata={"help": "ASA init warmup in EPOCHS"}) + asa_final_warmup: int = field(default=95, metadata={"help": "ASA final warmup in EPOCHS"}) + asa_mask_interval: int = field(default=10, metadata={"help": "ASA mask interval in EPOCHS"}) + asa_importance_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for importance"}) + asa_uncertainty_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for uncertainty"}) + asa_schedule_exponent: float = field(default=3.0, metadata={"help": "ASA schedule exponent"}) + + # Training Configuration + num_epochs: int = field(default=100, metadata={"help": "Number of training epochs"}) + batch_size: int = field(default=32, metadata={"help": "Batch size per device"}) + max_length: int = field(default=512, metadata={"help": "Maximum sequence length"}) + warmup_ratio: float = field(default=0.06, metadata={"help": "Warmup ratio"}) + + # Other + seed: int = field(default=0, metadata={"help": "Random seed"}) + output_dir: str = field(default="./output", metadata={"help": "Output directory"}) + cache_dir: str = field(default="./cache", metadata={"help": "Cache directory"}) + + +def get_dataset(args: AdaMSSTrainingArguments, tokenizer): + """Load and tokenize GLUE dataset.""" + # Load dataset + raw_datasets = load_dataset("glue", args.dataset_name, cache_dir=args.cache_dir) + + # Get sentence keys + sentence_keys = { + "cola": ("sentence", None), + "mrpc": ("sentence1", "sentence2"), + "qnli": ("question", "sentence"), + "rte": ("sentence1", "sentence2"), + "sst2": ("sentence", None), + "stsb": ("sentence1", "sentence2"), + } + sentence1_key, sentence2_key = sentence_keys[args.dataset_name] + + # Tokenize + def preprocess_function(examples): + texts = ( + (examples[sentence1_key],) if sentence2_key is None else (examples[sentence1_key], examples[sentence2_key]) + ) + result = tokenizer(*texts, truncation=True, max_length=args.max_length, padding="max_length") + result["labels"] = examples["label"] + return result + + # Remove original text columns but keep label + columns_to_remove = [col for col in raw_datasets["train"].column_names if col != "label"] + tokenized_datasets = raw_datasets.map( + preprocess_function, + batched=True, + remove_columns=columns_to_remove, + desc="Tokenizing dataset", + ) + + train_ds = tokenized_datasets["train"] + val_ds = tokenized_datasets["validation"] + test_ds = tokenized_datasets["validation"] # Use validation as test for GLUE + + return train_ds, val_ds, test_ds + + +def main(): + # Parse arguments + parser = HfArgumentParser(AdaMSSTrainingArguments) + args = parser.parse_args_into_dataclasses()[0] + + # Set seed + torch.manual_seed(args.seed) + np.random.seed(args.seed) + + # Get model short name + model_short = "roberta-large" if "large" in args.model_name_or_path else "roberta-base" + + # Get hyperparameters from Table 19 + if model_short in HYPERPARAMS and args.dataset_name in HYPERPARAMS[model_short]: + hp = HYPERPARAMS[model_short][args.dataset_name] + else: + hp = {"lr": 0.001, "head_lr": 0.005, "wd": 0.005} + print(f"Using default hyperparameters for {model_short}/{args.dataset_name}") + + # Print configuration + print("=" * 80) + print(f"AdaMSS {'with ASA' if args.use_asa else 'without ASA'} - GLUE: {args.dataset_name.upper()}") + print("=" * 80) + print(f" Model: {model_short}") + print(f" AdaMSS: r={args.adamss_r}, K={args.adamss_k}, ri={args.adamss_ri}") + if args.use_asa: + print(f" ASA: K={args.adamss_k} → target={args.asa_target_subspaces}") + print(f" Hyperparameters (Table 19): lr={hp['lr']}, head_lr={hp['head_lr']}, wd={hp['wd']}") + print(f" Training: {args.num_epochs} epochs, batch_size={args.batch_size}, seed={args.seed}") + print("=" * 80 + "\n") + + # Load tokenizer + tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, cache_dir=args.cache_dir) + + # Load dataset + print(f"Loading {args.dataset_name} dataset...") + train_ds, val_ds, _test_ds = get_dataset(args, tokenizer) + + # Determine task type + is_regression = args.dataset_name == "stsb" + if not is_regression: + label_list = train_ds.features["label"].names + num_labels = len(label_list) + else: + num_labels = 1 + + print(f"Dataset loaded - Task: {'regression' if is_regression else 'classification'}\n") + + # Load model + print(f"Loading {model_short}...") + model = AutoModelForSequenceClassification.from_pretrained( + args.model_name_or_path, + num_labels=num_labels, + cache_dir=args.cache_dir, + ) + + # Convert epoch-based ASA parameters to step-based (before config creation) + steps_per_epoch = len(train_ds) // args.batch_size + if len(train_ds) % args.batch_size != 0: + steps_per_epoch += 1 + + asa_init_warmup_steps = args.asa_init_warmup * steps_per_epoch + asa_final_warmup_steps = args.asa_final_warmup * steps_per_epoch + asa_mask_interval_steps = args.asa_mask_interval * steps_per_epoch + + # Apply AdaMSS + print("\nApplying AdaMSS...") + config = AdamssConfig( + r=args.adamss_r, + num_subspaces=args.adamss_k, + subspace_rank=args.adamss_ri, + target_modules=["query", "value"], + use_asa=args.use_asa, + asa_target_subspaces=args.asa_target_subspaces if args.use_asa else None, + init_warmup=asa_init_warmup_steps if args.use_asa else None, + final_warmup=asa_final_warmup_steps if args.use_asa else None, + mask_interval=asa_mask_interval_steps if args.use_asa else None, + asa_importance_beta=args.asa_importance_beta if args.use_asa else None, + asa_uncertainty_beta=args.asa_uncertainty_beta if args.use_asa else None, + asa_schedule_exponent=args.asa_schedule_exponent if args.use_asa else None, + modules_to_save=["classifier"], + ) + + model = get_peft_model(model, config) + model.print_trainable_parameters() + + # Print detailed parameter breakdown (same logic as exec_adamss_peft_glue.py) + print("\n[Detailed Parameter Breakdown]") + head_params = [p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad] + other_params = [ + p for n, p in model.named_parameters() if ("classifier" not in n and "score" not in n) and p.requires_grad + ] + head_count = sum(p.numel() for p in head_params) + adapter_count = sum(p.numel() for p in other_params) + print(f"Classifier Head Params: {head_count:,}") + print(f"AdaMSS Adapter Params: {adapter_count:,}") + print(f"Total Trainable Params: {head_count + adapter_count:,}") + + # Debug: print parameter names to verify + if adapter_count == 0: + print("\nWARNING: No AdaMSS parameters found!") + print("All trainable parameter names:") + for n, p in model.named_parameters(): + if p.requires_grad: + print(f" {n}: {p.numel():,} params") + + # GPU memory + if torch.cuda.is_available(): + torch.cuda.empty_cache() + torch.cuda.reset_peak_memory_stats() + print("\n[GPU Memory - Before Training]") + print(f"Allocated: {torch.cuda.memory_allocated() / 1024**3:.2f} GB") + print(f"Reserved: {torch.cuda.memory_reserved() / 1024**3:.2f} GB") + + # Setup ASA callback + callbacks = [] + if args.use_asa: + print("\nSetting up ASA callback...") + + print("\n[ASA Configuration]") + print(f"Dataset size: {len(train_ds)}, Batch size: {args.batch_size}") + print(f"Steps per epoch: {steps_per_epoch}") + print(f"Total training steps: {steps_per_epoch * args.num_epochs}") + print("ASA warmup (epochs → steps):") + print(f" init_warmup: {args.asa_init_warmup} epochs → {asa_init_warmup_steps} steps") + print(f" final_warmup: {args.asa_final_warmup} epochs → {asa_final_warmup_steps} steps") + print(f" mask_interval: {args.asa_mask_interval} epochs → {asa_mask_interval_steps} steps\n") + + asa_callback = AdamssAsaCallback() + callbacks.append(asa_callback) + + # Training configuration + print("\n[Training Configuration]") + print(f"Dataset size: {len(train_ds)}, Batch size: {args.batch_size}") + steps_per_epoch = len(train_ds) // args.batch_size + if len(train_ds) % args.batch_size != 0: + steps_per_epoch += 1 + print(f"Steps per epoch: {steps_per_epoch}") + print(f"Total training steps: {steps_per_epoch * args.num_epochs}") + + # Metrics + metric = evaluate.load("glue", args.dataset_name) + + def compute_metrics(p: EvalPrediction): + preds = p.predictions[0] if isinstance(p.predictions, tuple) else p.predictions + preds = np.squeeze(preds) if is_regression else np.argmax(preds, axis=1) + return metric.compute(predictions=preds, references=p.label_ids) + + # Training arguments + training_args = TrainingArguments( + output_dir=args.output_dir, + num_train_epochs=args.num_epochs, + per_device_train_batch_size=args.batch_size, + per_device_eval_batch_size=args.batch_size, + learning_rate=hp["lr"], + weight_decay=hp["wd"], + warmup_ratio=args.warmup_ratio, + eval_strategy="epoch", + save_strategy="epoch", + load_best_model_at_end=True, + metric_for_best_model=TASK_METRICS.get(args.dataset_name, "accuracy"), + greater_is_better=True, + logging_steps=100, + seed=args.seed, + report_to="none", + remove_unused_columns=False, # PEFT wraps forward(*args, **kwargs) + label_names=["labels"], # Explicitly tell Trainer where labels are + ) + + # Custom optimizer with different LR for head + optimizer_grouped_parameters = [ + { + "params": [ + p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad + ], + "lr": hp["head_lr"], + }, + { + "params": [ + p + for n, p in model.named_parameters() + if ("classifier" not in n and "score" not in n) and p.requires_grad + ], + "lr": hp["lr"], + }, + ] + optimizer = AdamW(optimizer_grouped_parameters, weight_decay=hp["wd"]) + + # Create trainer + trainer = Trainer( + model=model, + args=training_args, + train_dataset=train_ds, + eval_dataset=val_ds, + compute_metrics=compute_metrics, + optimizers=(optimizer, None), + callbacks=callbacks, + ) + + # Train + print("\n" + "=" * 80) + print("Starting training...") + print("=" * 80 + "\n") + + train_result = trainer.train() + + # GPU memory stats + if torch.cuda.is_available(): + print("\n[GPU Memory - Peak During Training]") + print(f"Peak Allocated: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB") + print(f"Peak Reserved: {torch.cuda.max_memory_reserved() / 1024**3:.2f} GB") + + # Print best metric + if trainer.state.best_metric is not None: + metric_name = TASK_METRICS.get(args.dataset_name, "accuracy") + print("\n[Best Model Info]") + print(f"Best {metric_name}: {trainer.state.best_metric:.4f}") + + # Final evaluation on validation set + print("\n" + "=" * 80) + print("Final evaluation on validation set...") + print("=" * 80 + "\n") + + final_metrics = trainer.evaluate(val_ds) + print(f"\nFinal Validation Results: {final_metrics}") + + # Save model + trainer.save_model() + print(f"\nModel saved to {training_args.output_dir}") + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/glue_adamss_asa_manual_example.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/glue_adamss_asa_manual_example.py new file mode 100644 index 0000000000000000000000000000000000000000..9a8c079a419fe312902268ad038b51b459903472 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/glue_adamss_asa_manual_example.py @@ -0,0 +1,411 @@ +""" +GLUE Task Fine-tuning with AdaMSS and Manual ASA + +This script demonstrates how to manually call update_and_allocate() for ASA +instead of using AdamssAsaCallback. This approach is useful for custom training loops. + +Note: + This is an alternative to using AdamssAsaCallback. Choose ONE approach: + - Use AdamssAsaCallback (recommended, see glue_adamss_asa_example.py) + - Use manual update_and_allocate() (this script, for custom control) + DO NOT use both together! + +Example usage: + # CoLA with RoBERTa-base and manual ASA + python glue_adamss_asa_manual_example.py \ + --dataset_name cola \ + --use_asa \ + --asa_target_subspaces 5 \ + --num_epochs 100 \ + --batch_size 32 \ + --warmup_ratio 0.06 \ + --seed 0 \ + --output_dir ./output/cola_asa_manual + +Requirements: + pip install peft transformers datasets torch evaluate scikit-learn +""" + +from dataclasses import dataclass, field + +import evaluate +import numpy as np +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForSequenceClassification, + AutoTokenizer, + EvalPrediction, + HfArgumentParser, + Trainer, + TrainingArguments, + set_seed, +) + +from peft import AdamssConfig, get_peft_model + + +class CustomTrainerWithManualASA(Trainer): + """ + Custom Trainer that manually calls update_and_allocate() for ASA. + + This demonstrates the manual approach as an alternative to using AdamssAsaCallback. + The update_and_allocate() method is called after optimizer.step() but before + zero_grad() to compute importance scores from gradients. + """ + + def training_step(self, model, inputs, num_items_in_batch=None): + """ + Override training_step to add manual ASA update. + + Training step sequence: + 1. Forward pass + 2. Backward pass (gradients computed) + 3. Optimizer step (parameters updated) + 4. >>> Manual ASA update (importance scoring & masking) <<< + 5. Zero gradients + """ + model.train() + inputs = self._prepare_inputs(inputs) + + # Forward & backward pass + with self.compute_loss_context_manager(): + loss = self.compute_loss(model, inputs) + + if self.args.gradient_accumulation_steps > 1: + loss = loss / self.args.gradient_accumulation_steps + + self.accelerator.backward(loss) + + # 🔑 Key: Manual ASA update after backward, before zero_grad + # This is where update_and_allocate() inspects gradients and applies masking + if ( + hasattr(model, "base_model") + and hasattr(model.base_model, "update_and_allocate") + and (self.state.global_step + 1) % self.args.gradient_accumulation_steps == 0 + ): + # Only call if we're actually doing optimizer step (not accumulating) + model.base_model.update_and_allocate(self.state.global_step) + + return loss.detach() + + +@dataclass +class AdaMSSArguments: + """Arguments for AdaMSS configuration.""" + + # Basic AdaMSS parameters + adamss_r: int = field(default=100, metadata={"help": "SVD decomposition rank (R in paper)."}) + adamss_k: int = field(default=10, metadata={"help": "Number of subspaces (K in paper)."}) + adamss_ri: int = field(default=1, metadata={"help": "Subspace rank (rk in paper), typically 1 for NLU."}) + + # Training configuration + num_epochs: int = field(default=100, metadata={"help": "Number of training epochs."}) + batch_size: int = field(default=32, metadata={"help": "Batch size per device."}) + warmup_ratio: float = field(default=0.06, metadata={"help": "Warmup ratio."}) + seed: int = field(default=0, metadata={"help": "Random seed."}) + output_dir: str = field(default="./output", metadata={"help": "Output directory."}) + + # ASA parameters + use_asa: bool = field(default=False, metadata={"help": "Enable Adaptive Subspace Allocation (manual mode)."}) + asa_target_subspaces: int = field( + default=5, metadata={"help": "Target number of active subspaces when ASA is enabled."} + ) + asa_init_warmup: int = field(default=5, metadata={"help": "ASA warmup EPOCHS before starting masking."}) + asa_final_warmup: int = field(default=95, metadata={"help": "ASA EPOCHS to reach target active subspaces."}) + asa_mask_interval: int = field(default=10, metadata={"help": "EPOCHS between ASA updates."}) + asa_importance_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for importance."}) + asa_uncertainty_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for uncertainty."}) + asa_schedule_exponent: float = field(default=3.0, metadata={"help": "ASA schedule exponent."}) + + +@dataclass +class DataArguments: + """Arguments for dataset configuration.""" + + dataset_name: str = field(default="cola", metadata={"help": "GLUE task name (cola, mrpc, qnli, rte, stsb, sst2)."}) + max_length: int = field(default=512, metadata={"help": "Maximum sequence length."}) + + +# Hyperparameters from Table 19 in the paper +HYPERPARAMS = { + "roberta-large": { + "cola": {"lr": 0.005, "head_lr": 0.0005, "wd": 0.1}, + "mrpc": {"lr": 0.001, "head_lr": 0.00005, "wd": 0.005}, + "qnli": {"lr": 0.0005, "head_lr": 0.05, "wd": 0.005}, + "rte": {"lr": 0.005, "head_lr": 0.005, "wd": 0.5}, + "stsb": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0005}, + "sst2": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0}, + }, + "roberta-base": { + "cola": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005}, + "mrpc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.0}, + "qnli": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005}, + "rte": {"lr": 0.0005, "head_lr": 0.005, "wd": 0.005}, + "stsb": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005}, + "sst2": {"lr": 0.001, "head_lr": 0.005, "wd": 0.0005}, + }, +} + +# Metrics for each task +TASK_METRICS = { + "cola": "matthews_correlation", + "stsb": "pearson", + "mrpc": "accuracy", + "qqp": "accuracy", + "sst2": "accuracy", + "qnli": "accuracy", + "rte": "accuracy", +} + + +def main(): + # Parse arguments + parser = HfArgumentParser((DataArguments, AdaMSSArguments)) + data_args, adamss_args = parser.parse_args_into_dataclasses() + + # Set seed + set_seed(adamss_args.seed) + + # Extract model name from output_dir or use default + if "roberta-large" in str(adamss_args.output_dir).lower(): + model_name = "roberta-large" + else: + model_name = "roberta-base" + + print("=" * 80) + print(f"AdaMSS with MANUAL ASA - GLUE Task: {data_args.dataset_name.upper()}") + print("=" * 80) + print(f"Model: {model_name}") + print(f"AdaMSS: r={adamss_args.adamss_r}, K={adamss_args.adamss_k}, ri={adamss_args.adamss_ri}") + + # Get hyperparameters + if model_name in HYPERPARAMS and data_args.dataset_name in HYPERPARAMS[model_name]: + hp = HYPERPARAMS[model_name][data_args.dataset_name] + print(f"Hyperparameters (Table 19): lr={hp['lr']}, head_lr={hp['head_lr']}, wd={hp['wd']}") + else: + hp = {"lr": 0.001, "head_lr": 0.005, "wd": 0.005} + print(f"Using default hyperparameters: {hp}") + + print(f"Training: {adamss_args.num_epochs} epochs, batch_size={adamss_args.batch_size}, seed={adamss_args.seed}") + + if adamss_args.use_asa: + print(f"Manual ASA Mode: Target {adamss_args.asa_target_subspaces}/{adamss_args.adamss_k} subspaces") + print(f" Warmup epochs {adamss_args.asa_init_warmup} → {adamss_args.asa_final_warmup}") + print(" Using update_and_allocate() instead of AdamssAsaCallback") + + # Load dataset + print(f"\nLoading {data_args.dataset_name} dataset...") + dataset = load_dataset("glue", data_args.dataset_name) + + # Get task info + is_regression = data_args.dataset_name == "stsb" + if not is_regression: + label_list = dataset["train"].features["label"].names + num_labels = len(label_list) + else: + num_labels = 1 + + print(f"Dataset loaded - Task type: {'regression' if is_regression else 'classification'}") + + # Load tokenizer and model + print(f"\nLoading {model_name}...") + tokenizer = AutoTokenizer.from_pretrained(model_name) + model = AutoModelForSequenceClassification.from_pretrained( + model_name, + num_labels=num_labels, + ) + + # Tokenize dataset + def preprocess_function(examples): + # Handle different GLUE tasks + if data_args.dataset_name in ["mrpc", "stsb", "qqp"]: + texts = (examples["sentence1"], examples["sentence2"]) + elif data_args.dataset_name == "qnli": + texts = (examples["question"], examples["sentence"]) + elif data_args.dataset_name == "rte": + texts = (examples["sentence1"], examples["sentence2"]) + else: # cola, sst2, etc. + texts = (examples["sentence"],) + + result = tokenizer(*texts, truncation=True, max_length=data_args.max_length, padding="max_length") + result["labels"] = examples["label"] + return result + + print("Tokenizing dataset...") + # Remove all columns except label + columns_to_remove = [col for col in dataset["train"].column_names if col != "label"] + tokenized_datasets = dataset.map( + preprocess_function, + batched=True, + remove_columns=columns_to_remove, + ) + + train_ds = tokenized_datasets["train"] + val_ds = tokenized_datasets["validation"] + test_key = "test" if "test" in tokenized_datasets else "validation" + test_ds = tokenized_datasets[test_key] + + # Create TrainingArguments manually (not parsed to avoid conflicts) + training_args = TrainingArguments( + output_dir=adamss_args.output_dir, + num_train_epochs=adamss_args.num_epochs, + per_device_train_batch_size=adamss_args.batch_size, + per_device_eval_batch_size=adamss_args.batch_size, + learning_rate=hp["lr"], + weight_decay=hp["wd"], + warmup_ratio=adamss_args.warmup_ratio, + eval_strategy="epoch", + save_strategy="epoch", + load_best_model_at_end=True, + metric_for_best_model=TASK_METRICS.get(data_args.dataset_name, "accuracy"), + greater_is_better=True, + logging_steps=100, + logging_strategy="steps", + seed=adamss_args.seed, + report_to="none", + remove_unused_columns=False, # PEFT wraps forward(*args, **kwargs) + label_names=["labels"], # Explicitly tell Trainer where labels are + ) + + # Configure AdaMSS with ASA parameters stored in config + print("\nApplying AdaMSS...") + + # Convert epoch-based parameters to step-based for config + steps_per_epoch = len(train_ds) // adamss_args.batch_size + if len(train_ds) % adamss_args.batch_size != 0: + steps_per_epoch += 1 + total_steps = adamss_args.num_epochs * steps_per_epoch + + print("\n[Training Configuration]") + print(f"Dataset size: {len(train_ds)}") + print(f"Batch size: {adamss_args.batch_size}") + print(f"Steps per epoch: {steps_per_epoch}") + print(f"Total steps: {adamss_args.num_epochs} epochs × {steps_per_epoch} steps = {total_steps} steps") + + asa_init_warmup_steps = adamss_args.asa_init_warmup * steps_per_epoch + asa_final_warmup_steps = adamss_args.asa_final_warmup * steps_per_epoch + asa_mask_interval_steps = adamss_args.asa_mask_interval * steps_per_epoch + + if adamss_args.use_asa: + print("\n[ASA Configuration (Epoch → Step Conversion)]") + print(f" init warmup: {adamss_args.asa_init_warmup} epochs → {asa_init_warmup_steps} steps") + print(f" final warmup: {adamss_args.asa_final_warmup} epochs → {asa_final_warmup_steps} steps") + print(f" mask interval: {adamss_args.asa_mask_interval} epochs → {asa_mask_interval_steps} steps") + + config = AdamssConfig( + r=adamss_args.adamss_r, + num_subspaces=adamss_args.adamss_k, + subspace_rank=adamss_args.adamss_ri, + target_modules=["query", "value"], + use_asa=adamss_args.use_asa, + asa_target_subspaces=adamss_args.asa_target_subspaces if adamss_args.use_asa else None, + # Store step-based ASA parameters in config + init_warmup=asa_init_warmup_steps if adamss_args.use_asa else None, + final_warmup=asa_final_warmup_steps if adamss_args.use_asa else None, + mask_interval=asa_mask_interval_steps if adamss_args.use_asa else None, + asa_importance_beta=adamss_args.asa_importance_beta if adamss_args.use_asa else None, + asa_uncertainty_beta=adamss_args.asa_uncertainty_beta if adamss_args.use_asa else None, + asa_schedule_exponent=adamss_args.asa_schedule_exponent if adamss_args.use_asa else None, + modules_to_save=["classifier"], + ) + + model = get_peft_model(model, config) + model.print_trainable_parameters() + + # Print detailed parameter breakdown (same logic as exec_adamss_peft_glue.py) + print("\n[Detailed Parameter Breakdown]") + head_params = [p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad] + other_params = [ + p for n, p in model.named_parameters() if ("classifier" not in n and "score" not in n) and p.requires_grad + ] + head_count = sum(p.numel() for p in head_params) + adapter_count = sum(p.numel() for p in other_params) + print(f"Classifier Head Params: {head_count:,}") + print(f"AdaMSS Adapter Params: {adapter_count:,}") + print(f"Total Trainable Params: {head_count + adapter_count:,}") + + # GPU memory monitoring + if torch.cuda.is_available(): + torch.cuda.empty_cache() + torch.cuda.reset_peak_memory_stats() + print("\n[GPU Memory - Before Training]") + print(f"Allocated: {torch.cuda.memory_allocated() / 1024**3:.2f} GB") + print(f"Reserved: {torch.cuda.memory_reserved() / 1024**3:.2f} GB") + + # Metrics + metric = evaluate.load("glue", data_args.dataset_name) + + def compute_metrics(p: EvalPrediction): + preds = p.predictions[0] if isinstance(p.predictions, tuple) else p.predictions + preds = np.squeeze(preds) if is_regression else np.argmax(preds, axis=1) + return metric.compute(predictions=preds, references=p.label_ids) + + # Create custom optimizer with different LR for head + from torch.optim import AdamW + + optimizer_grouped_parameters = [ + { + "params": [ + p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad + ], + "lr": hp["head_lr"], + }, + { + "params": [ + p + for n, p in model.named_parameters() + if ("classifier" not in n and "score" not in n) and p.requires_grad + ], + "lr": hp["lr"], + }, + ] + optimizer = AdamW(optimizer_grouped_parameters, weight_decay=hp["wd"]) + + # Create trainer with custom class that calls update_and_allocate() + # Note: NO callbacks here - we're using manual approach + trainer = CustomTrainerWithManualASA( + model=model, + args=training_args, + train_dataset=train_ds, + eval_dataset=val_ds, + compute_metrics=compute_metrics, + optimizers=(optimizer, None), + ) + + # Train + print("\n" + "=" * 80) + print("Starting training...") + if adamss_args.use_asa: + print("Manual ASA: update_and_allocate() will be called in training_step") + print("=" * 80 + "\n") + + train_result = trainer.train() + + # GPU memory stats + if torch.cuda.is_available(): + print("\n[GPU Memory - Peak During Training]") + print(f"Peak Allocated: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB") + print(f"Peak Reserved: {torch.cuda.max_memory_reserved() / 1024**3:.2f} GB") + + # Print best metric + if trainer.state.best_metric is not None: + metric_name = TASK_METRICS.get(data_args.dataset_name, "accuracy") + print("\n[Best Model Info]") + print(f"Best {metric_name}: {trainer.state.best_metric:.4f}") + + # Evaluate on validation set (use val_ds, not test_ds to avoid label issues) + print("\n" + "=" * 80) + print("Final evaluation on validation set...") + print("=" * 80 + "\n") + + final_metrics = trainer.evaluate(val_ds) + print(f"\nFinal Validation Results: {final_metrics}") + + # Save model + trainer.save_model() + print(f"\nModel saved to {training_args.output_dir}") + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/image_classification_adamss_asa.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/image_classification_adamss_asa.py new file mode 100644 index 0000000000000000000000000000000000000000..53efd784d300ed9766bd468bbe6f9e978ab25635 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/image_classification_adamss_asa.py @@ -0,0 +1,452 @@ +""" +Image Classification with AdaMSS and ASA Callback + +This script demonstrates how to fine-tune a Vision Transformer (ViT) model +using AdaMSS (Adaptive Matrix Decomposition with Subspace Selection) and +ASA (Adaptive Subspace Allocation) callback from PEFT. + +Example usage: + python image_classification_adamss_asa.py \\ + --model_name_or_path google/vit-base-patch16-224-in21k \\ + --dataset_name cifar10 \\ + --adamss_r 100 \\ + --adamss_k 10 \\ + --adamss_ri 3 \\ + --use_asa \\ + --asa_target_subspaces 5 \\ + --num_epochs 10 \\ + --output_dir ./output + +Requirements: + pip install peft transformers datasets torch torchvision evaluate +""" + +from dataclasses import dataclass, field +from functools import partial +from typing import Optional + +import evaluate +import torch +from datasets import load_dataset +from torchvision.transforms import ( + CenterCrop, + Compose, + Normalize, + RandomHorizontalFlip, + RandomResizedCrop, + Resize, + ToTensor, +) +from transformers import ( + AutoImageProcessor, + AutoModelForImageClassification, + HfArgumentParser, + Trainer, + TrainingArguments, +) + +from peft import AdamssConfig, get_peft_model +from peft.tuners.adamss.asa_callback import AdamssAsaCallback + + +# Hyperparameters from Table 18 in the paper +HYPERPARAMS = { + "vit-large-patch16-224-in21k": { + "pets": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0005}, + "cars": {"lr": 0.01, "head_lr": 0.005, "wd": 0.1}, + "cifar10": {"lr": 0.01, "head_lr": 0.05, "wd": 0.1}, + "cifar100": {"lr": 0.01, "head_lr": 0.05, "wd": 0.05}, + "eurosat": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.01}, + "fgvc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.0005}, + "resisc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.1}, + }, + "vit-base-patch16-224-in21k": { + "pets": {"lr": 0.005, "head_lr": 0.005, "wd": 0.0005}, + "cars": {"lr": 0.01, "head_lr": 0.005, "wd": 0.0}, + "cifar10": {"lr": 0.01, "head_lr": 0.005, "wd": 0.05}, + "cifar100": {"lr": 0.01, "head_lr": 0.005, "wd": 0.05}, + "eurosat": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.05}, + "fgvc": {"lr": 0.01, "head_lr": 0.005, "wd": 0.0005}, + "resisc": {"lr": 0.01, "head_lr": 0.005, "wd": 0.0005}, + }, +} + +# Model-specific K values (number of subspaces) +MODEL_K_VALUES = { + "vit-large-patch16-224-in21k": 16, + "vit-base-patch16-224-in21k": 10, +} +# Dataset configurations (matching exec_adamss_peft.py) +DATASET_CONFIGS = { + "cars": { + "train": "Multimodal-Fatima/StanfordCars_train", + "test": "Multimodal-Fatima/StanfordCars_test", + "img_col": "image", + "label_col": "label", + }, + "cifar10": { + "train": "Multimodal-Fatima/CIFAR10_train", + "test": "Multimodal-Fatima/CIFAR10_test", + "img_col": "image", + "label_col": "label", + }, + "cifar100": { + "train": "cifar100", + "test": "cifar100", + "img_col": "img", + "label_col": "fine_label", + }, + "eurosat": { + "dataset": "timm/eurosat-rgb", + "img_col": "image", + "label_col": "label", + }, + "pets": { + "train": "timm/oxford-iiit-pet", + "test": "timm/oxford-iiit-pet", + "img_col": "image", + "label_col": "label", + }, +} + + +# Global preprocessing functions (to avoid closure issues with set_transform) +def _preprocess_images(examples, img_col, transforms): + """Apply image transformations.""" + examples["pixel_values"] = [transforms(img.convert("RGB")) for img in examples[img_col]] + return examples + + +def _collate_batch(examples, label_col): + """Collate examples into a batch.""" + pixel_values = torch.stack([ex["pixel_values"] for ex in examples]) + labels = torch.tensor([ex[label_col] for ex in examples]) + return {"pixel_values": pixel_values, "labels": labels} + + +@dataclass +class ImageClassificationArguments: + """Arguments for image classification with AdaMSS and ASA.""" + + # Model configuration + model_name_or_path: str = field( + default="google/vit-base-patch16-224-in21k", metadata={"help": "Model identifier: vit-base or vit-large"} + ) + dataset_name: str = field( + default="cifar10", metadata={"help": "Dataset: cifar10, cifar100, pets, cars, eurosat, fgvc, resisc"} + ) + + # AdaMSS Configuration + adamss_r: int = field(default=100, metadata={"help": "SVD rank"}) + adamss_k: int = field(default=10, metadata={"help": "Number of subspaces (K), auto-set based on model"}) + adamss_ri: int = field(default=3, metadata={"help": "Subspace rank (rk), use 3 for vision"}) + + # ASA Configuration + use_asa: bool = field(default=False, metadata={"help": "Enable Adaptive Subspace Allocation"}) + asa_target_subspaces: int = field(default=5, metadata={"help": "Target active subspaces for ASA"}) + asa_init_warmup: int = field(default=50, metadata={"help": "ASA init warmup in STEPS"}) + asa_final_warmup: int = field(default=1000, metadata={"help": "ASA final warmup in STEPS"}) + asa_mask_interval: int = field(default=100, metadata={"help": "ASA mask interval in STEPS"}) + asa_importance_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for importance"}) + asa_uncertainty_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for uncertainty"}) + asa_schedule_exponent: float = field(default=3.0, metadata={"help": "ASA schedule exponent"}) + + # Training Configuration + num_epochs: int = field(default=10, metadata={"help": "Number of training epochs"}) + batch_size: int = field(default=32, metadata={"help": "Batch size per device"}) + warmup_ratio: float = field(default=0.0, metadata={"help": "Warmup ratio"}) + max_train_samples: Optional[int] = field(default=None, metadata={"help": "Max training samples (for debug)"}) + + # Other + seed: int = field(default=0, metadata={"help": "Random seed"}) + output_dir: str = field(default="./output", metadata={"help": "Output directory"}) + cache_dir: Optional[str] = field(default=None, metadata={"help": "Cache directory"}) + + +def prepare_transforms(image_processor): + """Prepare image transformations.""" + normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std) + size = image_processor.size["height"] + + train_transforms = Compose( + [ + RandomResizedCrop(size), + RandomHorizontalFlip(), + ToTensor(), + normalize, + ] + ) + val_transforms = Compose( + [ + Resize(size), + CenterCrop(size), + ToTensor(), + normalize, + ] + ) + return train_transforms, val_transforms + + +def main(): + # Parse arguments + parser = HfArgumentParser(ImageClassificationArguments) + args = parser.parse_args_into_dataclasses()[0] + + # Set seed + torch.manual_seed(args.seed) + + # Auto-detect model type and set K value + model_name = args.model_name_or_path + model_type = None + for key in MODEL_K_VALUES: + if key in model_name: + model_type = key + break + + if model_type is None: + # Default to base model + model_type = "vit-base-patch16-224-in21k" + print(f"Warning: Model type not recognized, defaulting to {model_type}") + + # Override K value based on model type + args.adamss_k = MODEL_K_VALUES[model_type] + + # Get hyperparameters from Table 18 + if model_type in HYPERPARAMS and args.dataset_name in HYPERPARAMS[model_type]: + hp = HYPERPARAMS[model_type][args.dataset_name] + print(f"Using Table 18 hyperparameters for {model_type} + {args.dataset_name}") + print(f" lr={hp['lr']}, head_lr={hp['head_lr']}, wd={hp['wd']}") + else: + hp = {"lr": 0.01, "head_lr": 0.005, "wd": 0.0005} + print(f"Warning: No Table 18 hyperparameters found, using defaults: {hp}") + + print("\n" + "=" * 80) + print(f"AdaMSS {'with ASA' if args.use_asa else 'without ASA'} - {args.dataset_name.upper()}") + print("=" * 80) + print(f"Model: {model_type}") + print(f"AdaMSS: r={args.adamss_r}, K={args.adamss_k}, ri={args.adamss_ri}") + if args.use_asa: + print(f"ASA: Target {args.asa_target_subspaces}/{args.adamss_k} subspaces") + print(f" Warmup steps {args.asa_init_warmup} → {args.asa_final_warmup}") + print(f"Training: {args.num_epochs} epochs, batch_size={args.batch_size}, seed={args.seed}") + print("=" * 80 + "\n") + + # Get dataset configuration + if args.dataset_name not in DATASET_CONFIGS: + raise ValueError(f"Unsupported dataset: {args.dataset_name}. Supported: {list(DATASET_CONFIGS.keys())}") + + config = DATASET_CONFIGS[args.dataset_name] + img_name = config["img_col"] + label_name = config["label_col"] + + # Load dataset + print(f"Loading {args.dataset_name} dataset...") + if "dataset" in config: + # Single dataset with train/val/test splits (e.g., eurosat) + dataset = load_dataset(config["dataset"], cache_dir=args.cache_dir) + train_val = dataset["train"].train_test_split(test_size=0.1, seed=args.seed) + train_ds = train_val["train"] + val_ds = train_val["test"] + # Try 'test' split, fall back to 'val' if not available + if "test" in dataset: + test_ds = dataset["test"] + elif "val" in dataset: + test_ds = dataset["val"] + else: + print("Warning: No test/val split found, using validation set as test") + test_ds = val_ds + else: + # Separate train and test datasets (e.g., cars, cifar10) + train_val_ds = load_dataset(config["train"], split="train", cache_dir=args.cache_dir) + test_ds = load_dataset(config["test"], split="test", cache_dir=args.cache_dir) + + # Split train into train and validation + train_val = train_val_ds.train_test_split(test_size=0.1, seed=args.seed) + train_ds = train_val["train"] + val_ds = train_val["test"] + + print(f"Detected columns - Image: '{img_name}', Label: '{label_name}'") + + # Limit train samples if specified (for quick testing) + if args.max_train_samples: + train_ds = train_ds.select(range(min(args.max_train_samples, len(train_ds)))) + # Also limit validation for faster testing + val_ds = val_ds.select(range(min(5000, len(val_ds)))) + + labels = train_ds.features[label_name].names + num_classes = len(labels) + print(f"Dataset loaded: {len(train_ds)} train, {len(val_ds)} val, {len(test_ds)} test") + print(f" Number of classes: {num_classes}") + + # Create label mappings + label2id = {label: i for i, label in enumerate(labels)} + id2label = dict(enumerate(labels)) + + # Load image processor + print("\nLoading image processor...") + image_processor = AutoImageProcessor.from_pretrained( + args.model_name_or_path, + cache_dir=args.cache_dir, + ) + + # Prepare transforms + train_transforms, val_transforms = prepare_transforms(image_processor) + + # Use partial to bind parameters at module level (avoid set_transform closure issues) + train_ds.set_transform(partial(_preprocess_images, img_col=img_name, transforms=train_transforms)) + val_ds.set_transform(partial(_preprocess_images, img_col=img_name, transforms=val_transforms)) + test_ds.set_transform(partial(_preprocess_images, img_col=img_name, transforms=val_transforms)) + + # Data collator + collate_fn = partial(_collate_batch, label_col=label_name) + + # Load base model + print("\nLoading base model...") + model = AutoModelForImageClassification.from_pretrained( + args.model_name_or_path, + num_labels=num_classes, + label2id=label2id, + id2label=id2label, + ignore_mismatched_sizes=True, + cache_dir=args.cache_dir, + ) + + # Configure AdaMSS + print("\nApplying AdaMSS...") + config = AdamssConfig( + r=args.adamss_r, + num_subspaces=args.adamss_k, + subspace_rank=args.adamss_ri, + target_modules=["query", "value"], + use_asa=args.use_asa, + asa_target_subspaces=args.asa_target_subspaces if args.use_asa else None, + init_warmup=args.asa_init_warmup if args.use_asa else None, + final_warmup=args.asa_final_warmup if args.use_asa else None, + mask_interval=args.asa_mask_interval if args.use_asa else None, + asa_importance_beta=args.asa_importance_beta if args.use_asa else None, + asa_uncertainty_beta=args.asa_uncertainty_beta if args.use_asa else None, + asa_schedule_exponent=args.asa_schedule_exponent if args.use_asa else None, + modules_to_save=["classifier"], + ) + + # Apply PEFT + model = get_peft_model(model, config) + model.print_trainable_parameters() + + # Print detailed parameter breakdown (same logic as exec_adamss_peft.py) + print("\n[Detailed Parameter Breakdown]") + trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad) + head_params = sum(p.numel() for n, p in model.named_parameters() if "classifier" in n and p.requires_grad) + adamss_params = trainable_params - head_params + print(f"Classifier Head Params: {head_params:,}") + print(f"AdaMSS Adapter Params: {adamss_params:,}") + print(f"Total Trainable Params: {trainable_params:,}") + + # Setup ASA callback if enabled + callbacks = [] + if args.use_asa: + print("\nSetting up ASA callback...") + asa_callback = AdamssAsaCallback() + callbacks.append(asa_callback) + + # Metrics + metric = evaluate.load("accuracy") + + def compute_metrics(eval_pred): + preds = eval_pred.predictions + # Handle tuple outputs (logits, hidden_states) + if isinstance(preds, tuple): + preds = preds[0] + predictions = preds.argmax(axis=1) + return metric.compute(predictions=predictions, references=eval_pred.label_ids) + + # Create TrainingArguments manually (not parsed to avoid conflicts) + training_args = TrainingArguments( + output_dir=args.output_dir, + num_train_epochs=args.num_epochs, + per_device_train_batch_size=args.batch_size, + per_device_eval_batch_size=args.batch_size, + learning_rate=hp["lr"], + weight_decay=hp["wd"], + warmup_ratio=args.warmup_ratio, + eval_strategy="epoch", + save_strategy="epoch", + load_best_model_at_end=True, + metric_for_best_model="accuracy", + greater_is_better=True, + logging_steps=100, + logging_strategy="steps", + seed=args.seed, + report_to="none", + remove_unused_columns=False, # Required for set_transform compatibility + label_names=["labels"], # Explicitly tell Trainer where labels are (PEFT hides model signature) + ) + + # Create custom optimizer with different LR for head + from torch.optim import AdamW + + optimizer_grouped_parameters = [ + { + "params": [p for n, p in model.named_parameters() if "classifier" in n and p.requires_grad], + "lr": hp["head_lr"], + }, + { + "params": [p for n, p in model.named_parameters() if "classifier" not in n and p.requires_grad], + "lr": hp["lr"], + }, + ] + optimizer = AdamW(optimizer_grouped_parameters, weight_decay=hp["wd"]) + + # Create trainer + trainer = Trainer( + model=model, + args=training_args, + train_dataset=train_ds, + eval_dataset=val_ds, + data_collator=collate_fn, + compute_metrics=compute_metrics, + optimizers=(optimizer, None), + callbacks=callbacks, + ) + + # GPU memory monitoring + if torch.cuda.is_available(): + torch.cuda.empty_cache() + torch.cuda.reset_peak_memory_stats() + print("\n[GPU Memory - Before Training]") + print(f"Allocated: {torch.cuda.memory_allocated() / 1024**3:.2f} GB") + print(f"Reserved: {torch.cuda.memory_reserved() / 1024**3:.2f} GB") + + # Train + print("\n" + "=" * 80) + print("Starting training...") + print("=" * 80 + "\n") + + train_result = trainer.train() + + # GPU memory stats + if torch.cuda.is_available(): + print("\n[GPU Memory - Peak During Training]") + print(f"Peak Allocated: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB") + print(f"Peak Reserved: {torch.cuda.max_memory_reserved() / 1024**3:.2f} GB") + + # Print best metric + if trainer.state.best_metric is not None: + print("\n[Best Model Info]") + print(f"Best accuracy: {trainer.state.best_metric:.4f}") + + # Evaluate on test set + print("\n" + "=" * 80) + print("Evaluating on test set...") + print("=" * 80 + "\n") + + test_metrics = trainer.evaluate(test_ds, metric_key_prefix="test") + print(f"\nTest Accuracy: {test_metrics['test_accuracy']:.4f}") + + # Save model + trainer.save_model() + print(f"\nModel saved to {training_args.output_dir}") + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/test_adamss_quick.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/test_adamss_quick.py new file mode 100644 index 0000000000000000000000000000000000000000..701190614e960e74d56a069a254aad8058cf4f18 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/adamss_finetuning/test_adamss_quick.py @@ -0,0 +1,176 @@ +""" +Quick test for AdaMSS example - runs 1 epoch on small subset +""" + +import sys + + +sys.path.insert(0, "/Users/onelong/Documents/WorkSpace/CodeSpace/AdaMSS-main/peft-main/src") + +import evaluate +import torch +from datasets import load_dataset +from torchvision.transforms import ( + CenterCrop, + Compose, + Normalize, + RandomHorizontalFlip, + RandomResizedCrop, + Resize, + ToTensor, +) +from transformers import AutoImageProcessor, AutoModelForImageClassification, Trainer, TrainingArguments + +from peft import AdaMSSConfig, ASACallback, get_peft_model + + +print("=" * 80) +print("🧪 AdaMSS Quick Test") +print("=" * 80) + +# Load small subset +print("\n📦 Loading CIFAR-10 (small subset for testing)...") +dataset = load_dataset("cifar10") +train_val = dataset["train"].train_test_split(test_size=0.1, seed=42) +train_ds = train_val["train"].select(range(100)) # Only 100 samples +val_ds = train_val["test"].select(range(50)) + +print(f"✅ Dataset: {len(train_ds)} train, {len(val_ds)} val") + +# Prepare data +image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k") +normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std) + +train_transforms = Compose( + [ + RandomResizedCrop(image_processor.size["height"]), + RandomHorizontalFlip(), + ToTensor(), + normalize, + ] +) + +val_transforms = Compose( + [ + Resize(image_processor.size["height"]), + CenterCrop(image_processor.size["height"]), + ToTensor(), + normalize, + ] +) + + +def preprocess_train(examples): + examples["pixel_values"] = [train_transforms(img.convert("RGB")) for img in examples["img"]] + return examples + + +def preprocess_val(examples): + examples["pixel_values"] = [val_transforms(img.convert("RGB")) for img in examples["img"]] + return examples + + +train_ds.set_transform(preprocess_train) +val_ds.set_transform(preprocess_val) + + +def collate_fn(examples): + pixel_values = torch.stack([example["pixel_values"] for example in examples]) + labels = torch.tensor([example["label"] for example in examples]) + return {"pixel_values": pixel_values, "labels": labels} + + +# Load model +print("\n🤖 Loading ViT model...") +model = AutoModelForImageClassification.from_pretrained( + "google/vit-base-patch16-224-in21k", + num_labels=10, + ignore_mismatched_sizes=True, +) + +# Configure AdaMSS +print("\n⚙️ Applying AdaMSS...") +config = AdaMSSConfig( + r=100, + num_subspaces=10, + subspace_rank=3, + target_modules=["query", "value"], + use_asa=True, + target_kk=5, + modules_to_save=["classifier"], +) + +model = get_peft_model(model, config) +print("\n📊 Parameter statistics:") +model.print_trainable_parameters() + +# Setup ASA callback +print("\n🔥 Setting up ASA callback...") +asa_callback = ASACallback( + target_kk=5, + init_warmup=5, + final_warmup=20, + mask_interval=10, +) + +# Metrics +metric = evaluate.load("accuracy") + + +def compute_metrics(eval_pred): + predictions = eval_pred.predictions.argmax(axis=1) + return metric.compute(predictions=predictions, references=eval_pred.label_ids) + + +# Training arguments +training_args = TrainingArguments( + output_dir="./test_adamss_output", + num_train_epochs=1, + per_device_train_batch_size=8, + per_device_eval_batch_size=8, + learning_rate=0.01, + weight_decay=0.0005, + eval_strategy="epoch", + save_strategy="no", + logging_steps=10, + remove_unused_columns=False, + label_names=["labels"], # Explicitly tell Trainer where labels are (PEFT hides model signature) + report_to="none", +) + +# Create trainer +trainer = Trainer( + model=model, + args=training_args, + train_dataset=train_ds, + eval_dataset=val_ds, + data_collator=collate_fn, + compute_metrics=compute_metrics, + callbacks=[asa_callback], +) + +# Train +print("\n" + "=" * 80) +print("🚀 Starting training (1 epoch on 100 samples)...") +print("=" * 80 + "\n") + +try: + trainer.train() + print("\n✅ Training completed successfully!") + + # Evaluate + metrics = trainer.evaluate() + print(f"\n📊 Validation Accuracy: {metrics['eval_accuracy']:.2%}") + + print("\n" + "=" * 80) + print("✅ Test PASSED - AdaMSS example works correctly!") + print("=" * 80) + +except Exception as e: + print("\n" + "=" * 80) + print(f"❌ Test FAILED: {e}") + print("=" * 80) + import traceback + + traceback.print_exc() + sys.exit(1) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/alora_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/alora_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0a6a4ac196ed0e38a1f2c81ab6e398d9cb21b625 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/alora_finetuning/README.md @@ -0,0 +1,76 @@ +# Activated LoRA (aLoRA) + +## Introduction +Activated LoRA (aLoRA) is an adapter that selectively activates its weights only after a given invocation sequence, ensuring that hidden states match the base model prior to this point. This allows reusing the base model KVs (stored in the KV cache) for tokens before the invocation, +enabling much faster real-world inference (e.g. vLLM) when switching between generation with the base model and generation with adapters. +See the [paper](https://huggingface.co/papers/2504.12397) for more details. + +## Quick start (shown for Mistral 7B) +```python +import torch +from peft import LoraConfig, get_peft_model +from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer, DataCollatorForLanguageModeling +from datasets import load_dataset + +model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3", device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3") +dataset = load_dataset("Lots-of-LoRAs/task1660_super_glue_question_generation", split="train") + +invocation_string = "[/INST]" # End of user turn in Mistral chat template +invocation_tokens = tokenizer.encode(invocation_string, add_special_tokens=False) + +lora_config = LoraConfig( + task_type="CAUSAL_LM", + alora_invocation_tokens=invocation_tokens, + r=32, + target_modules=["q_proj", "k_proj", "v_proj"], +) + +peft_model = get_peft_model(model, lora_config) +data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) +trainer = Trainer( + model=peft_model, + train_dataset=dataset, + dataset_text_field="text", + max_length=2048, + tokenizer=tokenizer, + data_collator=data_collator, +) +trainer.train() +peft_model.save_pretrained("alora-mistral-7b") +``` + +### Use the training example script directly +Pass the invocation string with `--invocation_string` when running the training example +script. For Mistral 7B, do: +```bash +python examples/alora_finetuning/alora_finetuning.py --base_model mistralai/Mistral-7B-Instruct-v0.3 --data_path Lots-of-LoRAs/task1660_super_glue_question_generation --invocation_string "[/INST]" +``` +and similarly for Llama-3.2-3B-Instruct: +```bash +python examples/alora_finetuning/alora_finetuning.py --base_model meta-llama/Llama-3.2-3B-Instruct --data_path Lots-of-LoRAs/task1660_super_glue_question_generation --invocation_string "<|start_header_id|>assistant<|end_header_id|>" +``` + +### Full example of the script +```bash +python alora_finetuning.py \ + --base_model "PATH_TO_MODEL" \ + --data_path "PATH_TO_DATASET" \ + --output_dir "PATH_TO_OUTPUT_DIR" \ + --batch_size 1 \ + --num_epochs 3 \ + --learning_rate 3e-4 \ + --cutoff_len 512 \ + --val_set_size 500 \ + --invocation_string "[/INST]" \ + --quantize \ + --eval_step 10 \ + --save_step 100 \ + --device "auto" \ + --lora_r 32 \ + --lora_alpha 32 \ + --lora_dropout 0.05 \ + --lora_target_modules "q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj" \ + --hub_model_id "YOUR_HF_REPO" \ + --push_to_hub +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/alora_finetuning/alora_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/alora_finetuning/alora_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..1bc1345c0a53e1e2d286ffd3576c136174e7b538 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/alora_finetuning/alora_finetuning.py @@ -0,0 +1,259 @@ +import os + +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + BitsAndBytesConfig, + DataCollatorForLanguageModeling, + Trainer, + TrainingArguments, +) + +from peft import LoraConfig, PeftModel, get_peft_model, prepare_model_for_kbit_training + + +def train_model( + base_model: str, + data_path: str, + output_dir: str, + batch_size: int, + num_epochs: int, + learning_rate: float, + cutoff_len: int, + val_set_size: int, + invocation_string: str, + quantize: bool, + eval_step: int, + save_step: int, + device: str, + lora_r: int, + lora_alpha: int, + lora_dropout: float, + lora_target_modules: str, + hub_model_id: str, + push_to_hub: bool, +): + os.environ["TOKENIZERS_PARALLELISM"] = "false" + hf_token = os.getenv("HF_TOKEN") + + if device == "auto": + device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + else: + device = torch.device(device) + print(f"Using device: {device}") + + tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token) + tokenizer.pad_token = tokenizer.unk_token + invocation_tokens = tokenizer.encode(invocation_string, add_special_tokens=False) + + if quantize: + if (torch.cuda.is_available() and torch.cuda.is_bf16_supported()) or torch.xpu.is_available(): + bnb_4bit_compute_dtype = torch.bfloat16 + else: + bnb_4bit_compute_dtype = torch.float16 + model = AutoModelForCausalLM.from_pretrained( + base_model, + token=hf_token, + quantization_config=BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=bnb_4bit_compute_dtype, + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_type="nf4", + ), + ) + model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True) + else: + model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token) + + lora_config = LoraConfig( + task_type="CAUSAL_LM", + alora_invocation_tokens=invocation_tokens, + r=lora_r, + lora_alpha=lora_alpha, + target_modules=(lora_target_modules.split(",") if lora_target_modules else ["q_proj", "k_proj", "v_proj"]), + lora_dropout=lora_dropout, + bias="none", + ) + + model = get_peft_model(model, lora_config) + + model.to(device) + tokenizer.pad_token = tokenizer.eos_token + + dataset = load_dataset(data_path) + + def tokenize_function(examples): + formatted_texts = [ + tokenizer.apply_chat_template( + [ + {"role": "user", "content": user_msg}, + {"role": "assistant", "content": assistant_msg}, + ], + tokenize=False, # get plain text first + add_generation_prompt=False, + ) + for user_msg, assistant_msg in zip(examples["input"], examples["output"]) + ] + + # 2) Tokenize those texts + model_inputs = tokenizer( + formatted_texts, + padding="max_length", + truncation=True, + max_length=cutoff_len, + ) + + labels = [] + for ids in model_inputs["input_ids"]: + labels.append([(token_id if token_id != tokenizer.pad_token_id else -100) for token_id in ids]) + model_inputs["labels"] = labels + + return model_inputs + + # Tokenize the dataset and prepare for training + tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names) + + # Data collator to dynamically pad the batched examples + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + + training_args = TrainingArguments( + output_dir=output_dir, + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + per_device_eval_batch_size=batch_size, + warmup_steps=100, + weight_decay=0.01, + logging_dir="./logs", + logging_steps=eval_step, + save_steps=save_step, + save_total_limit=2, + push_to_hub=push_to_hub, + hub_model_id=hub_model_id, + gradient_accumulation_steps=16, + fp16=True, + learning_rate=learning_rate, + hub_token=hf_token, + ) + + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + trainer = Trainer( + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["test"], + data_collator=data_collator, + ) + + trainer.train() + + if push_to_hub: + trainer.push_to_hub(commit_message="Fine-tuned model") + + model.save_pretrained(output_dir) + tokenizer.save_pretrained(output_dir) + + +def model_inference(model_path: str, adapter_path: str, prompt: str | None = None, data_path: str | None = None): + """ + Simple inference with the tuned aLoRA adapter. Optionally (reuse_cache = True) demonstrates + that the aLoRA adapter can (but does not need to) use KV cache created by the base model, + perhaps during a prior generation turn. + + Purely for demonstration purposes. See the [paper](https://huggingface.co/papers/2504.12397) + for realistic multiturn cache reuse examples. + """ + if prompt is None: + # Use first row of test data + dataset = load_dataset(data_path) + prompt = dataset["test"][0]["input"] + tokenizer = AutoTokenizer.from_pretrained(model_path) + base_model = AutoModelForCausalLM.from_pretrained(model_path) + alora_model = PeftModel.from_pretrained(base_model, adapter_path) + chat = [{"role": "user", "content": prompt}] + text = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True) + inputs = tokenizer(text, return_tensors="pt").to(base_model.device) + + # Generate answer with adapter + output_dict = alora_model.generate(**inputs, return_dict_in_generate=True, max_new_tokens=20) + alora_outputs = output_dict.sequences + + # Print results + print(f"Prompt: {text}") + response = tokenizer.decode(alora_outputs[0][inputs["input_ids"].shape[1] :], skip_special_tokens=True) + print(f"Trained adapter response: {response}") + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Fine-tune Mistral with Activated LoRA") + parser.add_argument( + "--base_model", type=str, default="mistralai/Mistral-7B-Instruct-v0.3", help="Base model path or name" + ) + parser.add_argument( + "--data_path", + type=str, + default="Lots-of-LoRAs/task1660_super_glue_question_generation", + help="Dataset path or name", + ) + parser.add_argument( + "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model" + ) + parser.add_argument("--batch_size", type=int, default=2, help="Batch size") + parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs") + parser.add_argument("--learning_rate", type=float, default=1e-4, help="Learning rate") + parser.add_argument("--cutoff_len", type=int, default=2048, help="Cutoff length for tokenization") + parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size") + parser.add_argument( + "--invocation_string", + type=str, + default="[/INST]", + help="String that activates the aLoRA adapter. Model dependent.", + ) + parser.add_argument("--quantize", action="store_true", help="Use quantization") + parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval") + parser.add_argument("--save_step", type=int, default=100, help="Save step interval") + parser.add_argument("--device", type=str, default="auto", help="Device to use for training") + parser.add_argument("--lora_r", type=int, default=32, help="LoRA rank") + parser.add_argument("--lora_alpha", type=int, default=32, help="LoRA alpha") + parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout rate") + parser.add_argument( + "--lora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA" + ) + parser.add_argument( + "--hub_model_id", + type=str, + default="path/to/repo", + help="Repository name to push the model on the Hugging Face Hub", + ) + parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub") + args = parser.parse_args() + train_model( + base_model=args.base_model, + data_path=args.data_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + val_set_size=args.val_set_size, + invocation_string=args.invocation_string, + quantize=args.quantize, + eval_step=args.eval_step, + save_step=args.save_step, + device=args.device, + lora_r=args.lora_r, + lora_alpha=args.lora_alpha, + lora_dropout=args.lora_dropout, + lora_target_modules=args.lora_target_modules, + hub_model_id=args.hub_model_id, + push_to_hub=args.push_to_hub, + ) + print("Model trained. Running test inference.") + model_inference(model_path=args.base_model, adapter_path=args.output_dir, data_path=args.data_path) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/arrow_multitask/arrow_phi3_mini.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/arrow_multitask/arrow_phi3_mini.py new file mode 100644 index 0000000000000000000000000000000000000000..13f7fcad5883c266fd2cca0a7e0056c80ba70e7a --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/arrow_multitask/arrow_phi3_mini.py @@ -0,0 +1,383 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# 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. + +""" +This script provides a simple evaluation pipeline for multiple-choice reasoning datasets +(e.g., BoolQ, HellaSwag, ARC, OpenBookQA, Winogrande) with different composition strategies. + +Usage examples: + python arrow_phi3_mini.py --strategy base --ds_name arc-challenge + python arrow_phi3_mini.py --strategy arrow --ds_name boolq + python arrow_phi3_mini.py --strategy gks --ds_name hswag + +Key features: +- Supports three strategies: + • "base" → Evaluate the quantized base model directly + • "arrow" → Use Arrow modular routing with task-specific adapters + • "gks" → Use Arrow + GenKnowSub (subtracting general-domain knowledge) +- Loads evaluation datasets from the Hugging Face Hub +- Implements a batched evaluation loop that computes per-option likelihoods and selects + the answer with the lowest average loss +- Reports simple accuracy + +Implementation details: +- The base model is quantized to 4-bit using `BitsAndBytesConfig` (nf4, bf16 compute). +- For Arrow and GKS, task-specific adapters are loaded from the Hugging Face Hub: + TahaBa/phi3-mini-clustered-flan/ts_expert_i +- Task-specific adapters were trained on 10 clusters of FLAN tasks. +- The clusters were created using Model-Based Clustering (MBC): + 1. Train a LoRA adapter for each individual task. + 2. Apply k-means clustering to group tasks based on these adapters. + 3. Train a LoRA adapter for each resulting cluster. +For more details, see the Arrow paper: https://huggingface.co/papers/2405.11157 + +- For GKS, general adapters are loaded from: + TahaBa/phi3-mini-general-adapters/... +- These adapters were trained on English, French, and German Wikipedia data + using a causal language modeling objective with (507-token context → 5-token completion) pairs. +- This setup encodes general knowledge into the LoRA space, which can then be + subtracted from task-specific adapters during inference to isolate and purify them. +For more details, see the GenKnowSub paper: https://huggingface.co/papers/2505.10939 + +- `evaluate_on_multi_choice_batched` handles tokenization, masking context tokens, + and computing per-choice log-likelihoods for fair comparison. +- Accuracy is printed at the end for the selected dataset. + +This script is mainly meant for demonstration purposes and lightweight evaluation, +not full-scale benchmarking (batch size / max length can be tuned). + +======================================================================================= + +Results (evaluated with microsoft/Phi-3-mini-4k-instruct, 4-bit quantization): + +| Dataset | Base Acc. | Arrow Acc. | Arrow+GKS Acc. | +|--------------|-----------|------------|----------------| +| ARC-Challenge| 0.4515 | 0.5418 | 0.5585 | +| ARC-Easy | 0.6894 | 0.8404 | 0.8473 | +| Winogrande | 0.5769 | 0.6550 | 0.6724 | +| BoolQ | 0.8146 | 0.8030 | 0.8247 | +| OpenBookQA | 0.43 | 0.448 | 0.472 | +| HellaSwag | 0.7318 | 0.7150 | 0.7376 | + +Observations: +- Arrow generally improves over the base model by routing tokens to the most relevant task adapters. +- Applying GKS (general knowledge subtraction) consistently gives further gains compared to Arrow and Base. + +These numbers are not meant as leaderboard results, but as a sanity check +to verify that the implementation works as expected and demonstrates +the benefits of Arrow and GenKnowSub. +""" + +import argparse +import random + +import numpy as np +import torch +from datasets import load_dataset +from sklearn.metrics import accuracy_score +from tqdm import tqdm +from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig + +from peft import ArrowConfig, create_arrow_model + + +MODEL_NAME = "microsoft/Phi-3-mini-4k-instruct" +MODEL_MAX_LEN = 2048 + + +def parse_args(): + parser = argparse.ArgumentParser(description="Training script with strategy selection") + + parser.add_argument( + "--strategy", + type=str, + choices=["base", "arrow", "gks"], + default="base", + help="Training strategy to use: base, arrow, or gks", + ) + parser.add_argument( + "--ds_name", + type=str, + choices=["boolq", "hswag", "arc-easy", "arc-challenge", "oqa", "wg"], + default="arc-challenge", + help="Dataset to use: boolq, hswag, arc-easy, arc-challenge, oqa, wg", + ) + + return parser.parse_args() + + +def read_test_dataset(ds_name): + if ds_name == "boolq": + ds = load_dataset("google/boolq", split="validation", trust_remote_code=True) + elif ds_name == "hswag": + ds = load_dataset("Rowan/hellaswag", split="validation", trust_remote_code=True) + elif ds_name == "arc-challenge": + ds = load_dataset("allenai/ai2_arc", "ARC-Challenge", split="validation", trust_remote_code=True) + elif ds_name == "arc-easy": + ds = load_dataset("allenai/ai2_arc", "ARC-Easy", split="validation", trust_remote_code=True) + elif ds_name == "oqa": + ds = load_dataset("allenai/openbookqa", split="validation", trust_remote_code=True) + elif ds_name == "wg": + ds = load_dataset("allenai/winogrande", "winogrande_xl", split="validation", trust_remote_code=True) + else: + raise f"Dataset {ds_name} is not supported yet." + + return ds + + +def extract_input_content(ds_name, row): + if ds_name == "boolq": + return f"[passage]{row['passage']}[question]{row['question']}" + if ds_name == "hswag": + return row["ctx"] + if (ds_name == "arc-challenge") or (ds_name == "arc-easy"): + return row["question"] + if ds_name == "oqa": + return row["question_stem"] + if ds_name == "wg": + return row["sentence"] + + +def create_multi_choice_options(row, ds_name): + options_texts = [] + content = extract_input_content(ds_name, row) + if ds_name == "boolq": + choices = ["true", "false"] + if ds_name == "hswag": + choices = row["endings"] + if (ds_name == "arc-challenge") or (ds_name == "arc-easy"): + choices = row["choices"]["text"] + if ds_name == "wg": + choices = [row["option1"], row["option2"]] + if ds_name == "oqa": + choices = row["choices"]["text"] + + for choice in choices: + options_texts.append(f"<|user|>\n{content}<|end|>\n<|assistant|>{choice}<|end|>\n") + + return options_texts + + +def extract_multi_choice_target_index(row, ds_name): + if ds_name == "boolq": + return 0 if row["answer"] is True else 1 + if ds_name == "hswag": + return int(row["label"]) + if (ds_name == "arc-challenge") or (ds_name == "arc-easy"): + return row["choices"]["label"].index(row["answerKey"]) + if ds_name == "wg": + return int(row["answer"]) - 1 + if ds_name == "oqa": + return row["choices"]["label"].index(row["answerKey"]) + + +def set_seed(seed: int): + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + if torch.cuda.is_available(): + torch.cuda.manual_seed_all(seed) + elif hasattr(torch, "xpu") and torch.xpu.is_available(): + torch.xpu.manual_seed_all(seed) + + +def compute_loglike_loss(logits, labels, reduction="none"): + bs = logits.size(0) + vocab_size = logits.size(-1) + labels = labels.squeeze(-1) + shift_logits = logits[..., :-1, :].contiguous() + shift_labels = labels[..., 1:].contiguous() + + # Flatten the tokens + loss_fct = torch.nn.CrossEntropyLoss(reduction=reduction) + shift_logits = shift_logits.view(-1, vocab_size) + shift_labels = shift_labels.view(-1) + + shift_labels = shift_labels.to(shift_logits.device) + loss = loss_fct(shift_logits, shift_labels) + + # reshape back + if reduction == "none": + loss = loss.view((bs, -1)) + non_zero_loss = (loss != 0).sum(dim=-1) + non_zero_loss[non_zero_loss == 0] = 1 + loss = loss.sum(dim=-1) / non_zero_loss + + return loss.float() # Convert to float32 before returning + + +def evaluate_on_multi_choice_batched( + eval_dataset, model, tokenizer, ds_name, labels, predictions, args, batch_size=32, max_length=512, device="auto" +): + # Local import to mirror your original function + model.eval() + + if device == "auto": + device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + else: + device = torch.device(device) + + for start in tqdm( + range(0, len(eval_dataset), batch_size), total=(len(eval_dataset) + batch_size - 1) // batch_size + ): + rows = [eval_dataset[i] for i in range(start, min(start + batch_size, len(eval_dataset)))] + + # Build the flattened option texts for this batch + all_texts = [] + options_per_sample = [] # number of options for each sample + ctx_lens_per_option = [] # context length replicated per option + + for row in rows: + # options: ["<|user|>...<|assistant|>choiceA<|end|>", ...] + options = create_multi_choice_options(row, ds_name) + options_per_sample.append(len(options)) + + # compute context length once per sample (align with your -1 shift) + content = extract_input_content(ds_name, row) + context_prompt = f"<|user|>\n{content}<|end|>\n<|assistant|>" + ctx_len = len(tokenizer.encode(context_prompt)) - 1 + + all_texts.extend(options) + ctx_lens_per_option.extend([ctx_len] * len(options)) + + # collect gold label + labels.append(extract_multi_choice_target_index(row, ds_name)) + + # Tokenize all options in one go + tokenized = tokenizer( + all_texts, + return_tensors="pt", + padding=True, + truncation=True, + max_length=max_length, + ) + tokenized = {k: v.to(device) for k, v in tokenized.items()} + + # Create masked labels: ignore context and padding + masked_labels = tokenized["input_ids"].clone() + for i, ctx_len in enumerate(ctx_lens_per_option): + masked_labels[i, :ctx_len] = -100 + masked_labels[tokenized["attention_mask"] == 0] = -100 + + with torch.no_grad(): + logits = model(input_ids=tokenized["input_ids"], attention_mask=tokenized["attention_mask"]).logits + # per-sequence losses + losses = compute_loglike_loss(logits, masked_labels, reduction="none").detach().cpu() + + # Reduce per sample (argmin across its options) + idx = 0 + for n_opt in options_per_sample: + pred = torch.argmin(losses[idx : idx + n_opt]).item() + predictions.append(pred) + idx += n_opt + + print( + f"Accuracy for dataset {args.ds_name} and strategy {args.strategy} is: {accuracy_score(labels, predictions)}" + ) + + +if __name__ == "__main__": + args = parse_args() + print(f"Selected strategy: {args.strategy}") + print(f"Dataset name: {args.ds_name}") + + # Loading the tokeniser + tokenizer = AutoTokenizer.from_pretrained( + MODEL_NAME, + use_fast=True, + padding_side="right", + model_max_length=MODEL_MAX_LEN, + ) + + # Quantisation config + bnb_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_quant_type="nf4", + bnb_4bit_compute_dtype=torch.bfloat16, + bnb_4bit_use_double_quant=False, + ) + + # Loading the model + base_model = AutoModelForCausalLM.from_pretrained( + MODEL_NAME, + dtype=torch.bfloat16, + device_map="auto", + quantization_config=bnb_config, + ) + + # Loading the test dataset + test_dataset = read_test_dataset(args.ds_name) + print(f"{args.ds_name} is loaded with size: {len(test_dataset)}.") + + labels, predictions = [], [] + if args.strategy == "base": + # Batch-wise inference + with torch.no_grad(): + evaluate_on_multi_choice_batched( + test_dataset, + base_model, + tokenizer, + args.ds_name, + labels, + predictions, + args, + batch_size=64, # tune this + max_length=512, # tune if options are long + device="auto", + ) + else: + general_adapter_paths = [] + if args.strategy == "gks": + arrow_config = ArrowConfig( + top_k=3, + router_temperature=1.0, + use_gks=True, + ) + # General adapter paths from the hub + general_adapter_paths = [ + "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langen/checkpoint-17", + "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langfr/checkpoint-35", + "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langger/checkpoint-17", + ] + else: + arrow_config = ArrowConfig( + top_k=3, + router_temperature=1.0, + ) + + # Task-specific adapter paths from the hub + task_specific_adapter_paths = [f"TahaBa/phi3-mini-clustered-flan/ts_expert_{i}" for i in range(10)] + + # Creating the Arrow model + model = create_arrow_model( + base_model=base_model, + task_specific_adapter_paths=task_specific_adapter_paths, + general_adapter_paths=general_adapter_paths, + arrow_config=arrow_config, + ) + + # Batch-wise inference + with torch.no_grad(): + evaluate_on_multi_choice_batched( + test_dataset, + model, + tokenizer, + args.ds_name, + labels, + predictions, + args, + batch_size=32, # tune this + max_length=512, # tune if options are long + device="auto", + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/arrow_multitask/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/arrow_multitask/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..0fb1d2c4152f707035f9609a6d86319deda58e1c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/arrow_multitask/requirements.txt @@ -0,0 +1,8 @@ +torch +transformers +accelerate +datasets +scikit-learn +tqdm +numpy +bitsandbytes diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f1e4c5d4f13eddf6a3ad9ce021528130d7c4e52f --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/README.md @@ -0,0 +1,15 @@ +# BD-LoRA Finetuning + +Block-Diagonal LoRA (BD-LoRA) is a LoRA variant in which some LoRA factors are constrained to be block-diagonal. +This allows faster serving by eliminating communication overheads when running inference on multiple GPU, at the same finetuning performance as vanilla LoRA. + +To get an overview on how to use BD-LoRA, please view the Python notebook at `peft/examples/bdlora_finetuning/bdlora_peft_demo.ipynb`. + +To benefit from inference speed-ups, you need an inference engine that is compatible with BD-LoRA. At the moment, there is an experimental PR at https://github.com/vllm-project/vllm/pull/28136 which allows you to use BD-LoRA in vLLM. If you find this work useful, consider leaving a comment there. + +To install, you can clone the GitHub repository connected to the fork at https://github.com/Conzel/vllm/tree/bdlora-bk. Then, install vLLM following the usual instructions: https://docs.vllm.ai/en/stable/getting_started/installation/. We assume that you have a hardware setup with at least 2 available GPUs. + +This example folder contains 3 scripts: +- `bdlora_peft_demo.ipynb` Showcases how to instantiate a BD-LoRA model, train it, and save/reload the weights. +- `vllm_server.bash` Spins up a BD-LoRA compatible vLLM server. To use it, you need to run the notebook once to create adapters with the correct format. +- `chat.py` Can be used to query the vLLM server after it has finished booting up. Usage example: `python3 chat.py --target lora1`. \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/bdlora-performance.png b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/bdlora-performance.png new file mode 100644 index 0000000000000000000000000000000000000000..ec8769b018249474e78b7d51161d44f098428a57 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/bdlora-performance.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:71e00b74fe951a4d1ce715ea483e765d8f4527f3d34c2d3c210af09d2b05af26 +size 313134 diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/bdlora-sharding.png b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/bdlora-sharding.png new file mode 100644 index 0000000000000000000000000000000000000000..925a4e720e7557827793ffd8c7a9fe04f5326068 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/bdlora-sharding.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c6d7c46671fc6f367e486fa76936417dc2c4992af5234494058610bfd472c661 +size 351045 diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/bdlora_peft_demo.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/bdlora_peft_demo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f85782c52e7757a6b250edc0bf671b47526dd699 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/bdlora_peft_demo.ipynb @@ -0,0 +1,439 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e2b69494", + "metadata": {}, + "source": [ + "# Block-Diagonal LoRA for Eliminating Communication Overhead in Tensor Parallel LoRA Serving" + ] + }, + { + "cell_type": "markdown", + "id": "2fb2b221", + "metadata": {}, + "source": [ + "## Introduction\n", + "Block-Diagonal LoRA (BD-LoRA) is a LoRA variant in which some LoRA factors are constrained to be block-diagonal. This allows faster serving by eliminating communication overheads \n", + "when running inference on multiple GPUs. Despite the block-diagonal constraint, BD-LoRA is similarly performant to vanilla LoRA at similar parameter counts.\n", + "\n", + "BD-LoRA is designed to be used with tensor parallelism, which means sharding the weights of a model among multiple GPUs. A popular sharding strategy is the [Megatron Sharding Strategy](https://arxiv.org/abs/1909.08053). For two linear layers $W_1$, $W_2$ that follow each other (for example the up and down projections in a transformer MLP module), we will shard the first layer in a column-parallel way (which requires LoRA B to be block-diagonal) and the second layer in a row-parallel way (which requires LoRA A to be block-diagonal). For the attention module, this can be similarly achieved by taking the Q, K and V projections together as $W_1$ and the out projection as $W_2$, sharding accordingly. This sharding allows a compatible inference engine to distribute each block-diagonal shard over a a different GPU, cutting the need to communicate partial results among GPUs. In the image below, you can see the exact sharding strategy and how this saves computational efforts.\n", + "\n", + "Paper: https://arxiv.org/html/2510.23346v1\n", + "\n", + "
\n", + "\n", + "
\n", + "\n", + "### Performance, rank and parameter count\n", + "BD-LoRA achieves similar performance to LoRA (see image below, or the `method_comparison` folder in the peft repository root) at the same parameter count. However, as every other factor in BD-LoRA is block-diagonal, a BD-LoRA adapter will have less parameters than a LoRA adapter at the same rank. The performance of BD-LoRA is only competitive when the rank is then increased accordingly. We provide example code for rank-matching at the end of this example notebook.\n", + "\n", + "
\n", + "\n", + "
\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "40eea544", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/efs/aconzel/workspace/peft/bdlora-peft/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "from peft.tuners import BdLoraConfig, LoraConfig\n", + "from peft import get_peft_model\n", + "from transformers import Trainer, TrainingArguments, DataCollatorForLanguageModeling, AutoModelForCausalLM, AutoTokenizer\n", + "from datasets import load_dataset\n", + "import torch" + ] + }, + { + "cell_type": "markdown", + "id": "5959e4ab", + "metadata": {}, + "source": [ + "## Quick Start\n", + "To use BD-LoRA, we can follow standard LoRA-training procedures. We only need to change the `LoraConfig` to a `BdLoraConfig` and specify which LoRA should be block-diagonal. \n", + "As an example, we will train a LLama-Model in such a way that it can later benefit from inference speed-up as specified in the BD-LoRA paper. However, BD-LoRA can be used with all other models that follow a transformer architecture. \n", + "\n", + "As explained in the introduction, we want to shard each module (MLP and attention) in an alternating fashion, first column-parallel with LoRA-B block-diagonal, then row-parallel with LoRA-A block-diagonal. Different from standard MLP modules, Llama also uses a gate projection, which we can fuse together with the up-projection.\n", + "\n", + "Therefore, we want the following block-diagonal factors (following the naming convention from the Llama architecture):\n", + "\n", + "- LoRA-A Block-Diagonal (Row-parallel sharding): Out (`out_proj`), Down (`down_proj`)\n", + "- LoRA-B Block-Diagonal (Column-parallel sharding): QKV (`q_proj, k_proj, v_proj`), Up+Gate (`up_proj, gate_proj`)\n", + "\n", + "Additionally, we need to know on how many GPUs we want to serve before we start training, as this corresponds to the number of block we will use for each block-diagonal factor. For this experiment, we will use 2 blocks (equivalent to a tensor-parallelism degree of 2). Caveat: For a small model such as Llama 3.2-1B which we are using, one would use a single GPU for serving, and use TP=2 or TP=8 only for larger models, like Llama 3.1-8B or Llama 3.3-70B respectively. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6180c1f9", + "metadata": {}, + "outputs": [], + "source": [ + "model_name = \"meta-llama/Llama-3.2-1B\"\n", + "model = AutoModelForCausalLM.from_pretrained(model_name)\n", + "tokenizer = AutoTokenizer.from_pretrained(model_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6a50e350", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 44,826,624 || all params: 1,280,641,024 || trainable%: 3.5003\n" + ] + } + ], + "source": [ + "target_modules=[\"q_proj\", \"v_proj\", \"k_proj\", \"up_proj\", \"gate_proj\", \"o_proj\", \"down_proj\"]\n", + "# Set this equal to the number of GPUs you want to serve the model with later\n", + "nblocks = 2\n", + "\n", + "bdlora_config = BdLoraConfig(\n", + " target_modules_bd_a=[\"o_proj\", \"down_proj\"],\n", + " target_modules_bd_b=[\"q_proj\", \"v_proj\", \"k_proj\", \"up_proj\", \"gate_proj\"],\n", + " nblocks=nblocks\n", + ")\n", + "\n", + "config = LoraConfig(\n", + " r=96,\n", + " # adjust target modules and the ...target_modules_bd attributes according to model architecture (for example renaming)\n", + " target_modules=target_modules,\n", + " use_bdlora=bdlora_config,\n", + " lora_bias=False\n", + ")\n", + "\n", + "peft_model = get_peft_model(model, config)\n", + "peft_model.print_trainable_parameters()" + ] + }, + { + "cell_type": "markdown", + "id": "c1facfea", + "metadata": {}, + "source": [ + "## Training\n", + "We train the model for 10 steps, this training block is just intended to showcase how BD-LoRA integrates into other huggingface tools." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "64e4681b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [10/10 00:31, Epoch 10/10]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
13.137500
23.137500
33.126700
43.104900
53.085900
63.069800
73.056500
83.046100
93.038300
103.033100

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=10, training_loss=3.0836387634277345, metrics={'train_runtime': 38.346, 'train_samples_per_second': 66.761, 'train_steps_per_second': 0.261, 'total_flos': 1954507653120000.0, 'train_loss': 3.0836387634277345, 'epoch': 10.0})" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset = load_dataset(\"imdb\", split=\"train[:1%]\")\n", + "\n", + "tokenizer.pad_token = tokenizer.eos_token\n", + "def tokenize(batch):\n", + " return tokenizer(batch[\"text\"], truncation=True, padding=\"max_length\", max_length=128)\n", + "\n", + "dataset = dataset.map(tokenize, batched=True, remove_columns=[\"text\"])\n", + "training_args = TrainingArguments(\n", + " output_dir=\"./results\",\n", + " per_device_train_batch_size=8,\n", + " gradient_accumulation_steps=4,\n", + " warmup_steps=2,\n", + " max_steps=10,\n", + " learning_rate=2e-4,\n", + " logging_steps=1,\n", + ")\n", + "\n", + "trainer = Trainer(\n", + " model=peft_model,\n", + " args=training_args,\n", + " train_dataset=dataset,\n", + " data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),\n", + ")\n", + "\n", + "peft_model.config.use_cache = False\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "id": "3ac31a38", + "metadata": {}, + "source": [ + "## Saving Model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "28f49ee4", + "metadata": {}, + "outputs": [], + "source": [ + "peft_model.save_pretrained(\"example_bd_lora_adapter\")" + ] + }, + { + "cell_type": "markdown", + "id": "1a3d6fab", + "metadata": {}, + "source": [ + "## Example Output" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "20c36df8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Setting `pad_token_id` to `eos_token_id`:128001 for open-end generation.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The Batman Trilogy by Christopher Nolan\n", + "The Batman Trilogy by Christopher Nolan\n", + "The Batman Trilogy by Christopher Nolan\n", + "The Batman Trilogy by Christopher Nolan\n", + "The Batman Trilogy by Christopher Nolan\n", + "The Batman Trilogy by Christopher Nolan\n", + "The Batman Trilogy by Christopher Nolan\n", + "\n" + ] + } + ], + "source": [ + "text = \"The Batman Trilogy by Christopher Nolan\"\n", + "inputs = tokenizer(text, return_tensors=\"pt\").to(model.device) \n", + "\n", + "outputs = peft_model.generate(**inputs, max_length=50)\n", + "decoded = tokenizer.decode(outputs[0], skip_special_tokens=True)\n", + "print(decoded)" + ] + }, + { + "cell_type": "markdown", + "id": "711eb30d", + "metadata": {}, + "source": [ + "## Investigating the shapes of LoRA Adapters\n", + "We can check out the adapter shapes to see if they follow the sharding patterns that we have discussed. To make the implementation more memory efficient, \n", + "the block-diagonal matrices are not saved in a block-diagonal manner, but the blocks are stacked along the non-rank dimensions. \n", + "\n", + "For example, if a layer is column sharded, such as the q-proj in Llama, then the LoRA-B factor is block-diagonal. Assume that the q-proj has layer weights (out_features, in_features), \n", + "then LoRA-A will have shape (rank, in_features), and LoRA-B will have shape (out_features, rank / TP), which corresponds to TP blocks of shape (out_features/TP, rank/TP) each. This can be checked by investigating the weight shapes:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3660c4de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Base layer has shape: [512, 2048]\n", + "LoRA-A (vanilla): [96, 2048]\n", + "LoRA-B (block-diagonal): [512, 48 ]\n" + ] + } + ], + "source": [ + "shape_base = list(peft_model.state_dict()['base_model.model.model.layers.0.self_attn.v_proj.base_layer.weight'].shape)\n", + "shape_a = list(peft_model.state_dict()['base_model.model.model.layers.0.self_attn.v_proj.lora_A.default.weight'].shape)\n", + "shape_b = list(peft_model.state_dict()['base_model.model.model.layers.0.self_attn.v_proj.lora_B.default.weight'].shape)\n", + "print(f\"Base layer has shape: [{shape_base[0]}, {shape_base[1]}]\\nLoRA-A (vanilla): [{shape_a[0]}, {shape_a[1]}]\\nLoRA-B (block-diagonal): [{shape_b[0]}, {shape_b[1]} ]\")" + ] + }, + { + "cell_type": "markdown", + "id": "d95118af", + "metadata": {}, + "source": [ + "## Matching the rank\n", + "Assuming we want to achieve the same performance of a LoRA adapter of a given rank, at which rank would we have to train BD-LoRA? We can find this out by matching the number of trainable parameters. A simple iteration over the ranks of the BD-LoRA adapter is sufficient to do that:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cd4fc45a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BD-LoRA rank to match vanilla LoRA performance at rank 64: 96 at 45088768 vanilla LoRA params and 44826624 BD-LoRA params.\n" + ] + } + ], + "source": [ + "def rank_to_params(r: int, bd_lora: bool, nblocks: int):\n", + " model = AutoModelForCausalLM.from_pretrained(model_name)\n", + " if bd_lora:\n", + " config = LoraConfig(\n", + " r=r,\n", + " target_modules=target_modules,\n", + " use_bdlora=bdlora_config,\n", + " lora_bias=False\n", + " )\n", + " else:\n", + " config = LoraConfig(\n", + " r=r,\n", + " # If you use a model different from Llama, change the settings below\n", + " target_modules=target_modules,\n", + " lora_bias=False\n", + " )\n", + "\n", + "\n", + " peft_model = get_peft_model(model, config)\n", + " return peft_model.get_nb_trainable_parameters()[0]\n", + "\n", + "r_orig = 64\n", + "r = r_orig\n", + "lora_nparams = rank_to_params(r, False, nblocks)\n", + "bdlora_nparams = 0\n", + "while bdlora_nparams < lora_nparams:\n", + " r += nblocks\n", + " bdlora_nparams = rank_to_params(r, True, nblocks)\n", + "# subtract nblocks again to be just under the parameter count of vanilla LoRA, following the original papers methodology\n", + "print(f\"BD-LoRA rank to match vanilla LoRA performance at rank {r_orig}: {r-nblocks} at {lora_nparams} vanilla LoRA params and {rank_to_params(r-nblocks, True, nblocks)} BD-LoRA params.\")" + ] + }, + { + "cell_type": "markdown", + "id": "d27b9545", + "metadata": {}, + "source": [ + "# Integration with vLLM\n", + "Currently, vLLM has an experimental PR that allows you to use it with BD-LoRA. Clone the github repository and check out the commit of \n", + "the pull request at https://github.com/vllm-project/vllm/pull/28136#. Then, install vLLM following the usual instructions: https://docs.vllm.ai/en/stable/getting_started/installation/. We assume that you have a hardware setup with at least 2 available GPUs. \n", + "\n", + "We have included a script that starts a vLLM server with two BD-LoRA modules at `vllm_server.bash` (you might have to kill this jupyter server beforehand, as it is likely already using your GPU resources).\n", + "Once the server has started, you can query it via `python3 chat.py \"Please write your message here.\" --target lora1`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bdlora-peft", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/chat.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/chat.py new file mode 100644 index 0000000000000000000000000000000000000000..aaedb28d636d6857da1ad083358841f7afca5960 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/chat.py @@ -0,0 +1,64 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# 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 asyncio +import json +import time + +import aiohttp +import typer + + +def chat( + msg: str, + target: str = "lora1", + max_tokens: int = 100, + deterministic: bool = True, + record: str = "", + num_requests: int = 32, +): + payload = { + "model": target, + "prompt": msg, + "max_tokens": max_tokens, + } + if deterministic: + payload = payload | {"temperature": 0, "top_p": 1, "top_k": 1} + + url = "http://localhost:8000/v1/completions" + + async def _request(session): + async with session.post(url, json=payload) as response: + response_json = await response.json() + return response_json["choices"][0]["text"] + + async def run_concurrent(): + async with aiohttp.ClientSession() as session: + tasks = [_request(session) for _ in range(num_requests)] + return await asyncio.gather(*tasks) + + start_time = time.time() + response_texts = asyncio.run(run_concurrent()) + end_time = time.time() + + print(f"Completed {num_requests} requests in {end_time - start_time:.2f} seconds") + + if record: + with open(record, "w") as f: + json.dump({"prompt": msg, "responses": response_texts}, f, indent=2) + else: + print(response_texts[0]) + + +if __name__ == "__main__": + typer.run(chat) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/vllm_server.bash b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/vllm_server.bash new file mode 100644 index 0000000000000000000000000000000000000000..c38adcfcfe14b28f9e9183427ba05de79eaf7920 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/bdlora_finetuning/vllm_server.bash @@ -0,0 +1,13 @@ +#!/bin/bash + +ADAPTER_PATH="example_bd_lora_adapter" + +python -m vllm.entrypoints.openai.api_server \ + --model meta-llama/Llama-3.2-1B \ + --enable-lora \ + --lora-modules lora1=$ADAPTER_PATH lora2=$ADAPTER_PATH \ + --tensor-parallel-size 2 \ + --block_diagonal_sharded_loras \ + --max-lora-rank 128 \ + --enforce-eager \ + --port 8000 diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/beft_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/beft_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9b74e015233c89113f7be7a9b8fd024a829cc57d --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/beft_finetuning/README.md @@ -0,0 +1,20 @@ +# BEFT: Bias-Efficient Fine-Tuning of Language Models in Low-Data Regimes + +## Introduction +Fine-tuning the bias terms of large language models (LLMs) has the potential to achieve unprecedented parameter efficiency while maintaining competitive performance, particularly **in low-data regimes**. In this paper, we investigate the link between fine-tuning **b**q, **b**k, and **b**v with the performance of the downstream task, both analytically and empirically. We study and shed light on the expressive power of bias terms **b**q, **b**k, and **b**v in the query, key, or value projections of LLMs including bias-term-free LLMs. Our key finding is that directly fine-tuning **b**v generally leads to higher downstream performance in low-data regimes, in comparison to **b**q and **b**k. + + + +## Quick start +You can try target_modules=`["v"]`, or `["q"]`, or `["k"]` in `beft_finetuning.py` to see the downstream accuracy. + + +## Citation +```bibtex +@inproceedings{huang2026beft, + title={BEFT: Bias-Efficient Fine-Tuning of Language Models in Low-Data Regimes}, + author={Huang, Baichuan and Balashankar, Ananth and Aminifar, Amir}, + booktitle={Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics}, + year={2026} +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/beft_finetuning/beft_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/beft_finetuning/beft_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..7d0f370c8bdb7a33e49ff863d8e055af8bbb6c86 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/beft_finetuning/beft_finetuning.py @@ -0,0 +1,122 @@ +# This script is based on the example shown in docs/source/task_guides/ia3.md +import torch +from datasets import load_dataset +from torch.utils.data import DataLoader +from tqdm import tqdm +from transformers import ( + AutoModelForSeq2SeqLM, + AutoTokenizer, + default_data_collator, + get_linear_schedule_with_warmup, +) + +from peft import BeftConfig, get_peft_model + + +ds = load_dataset("gtfintechlab/financial_phrasebank_sentences_allagree", "5768") +ds = ds["train"].train_test_split(test_size=0.1) +ds["validation"] = ds["test"] +del ds["test"] + +classes = ["negative", "neutral", "positive"] +# Keep map in-process; num_proc=1 still uses multiprocessing and can trigger dill issues on some Python versions. +ds = ds.map( + lambda x: {"text_label": [classes[label] for label in x["label"]]}, + batched=True, +) + +text_column = "sentence" +label_column = "text_label" +max_length = 128 + +tokenizer = AutoTokenizer.from_pretrained("bigscience/mt0-small") + + +def preprocess_function(examples): + inputs = examples[text_column] + targets = examples[label_column] + model_inputs = tokenizer(inputs, max_length=max_length, padding="max_length", truncation=True, return_tensors="pt") + labels = tokenizer(targets, max_length=3, padding="max_length", truncation=True, return_tensors="pt") + labels = labels["input_ids"] + labels[labels == tokenizer.pad_token_id] = -100 + model_inputs["labels"] = labels + return model_inputs + + +processed_ds = ds.map( + preprocess_function, + batched=True, + remove_columns=ds["train"].column_names, + load_from_cache_file=False, + desc="Running tokenizer on dataset", +) + +# low-data regimes: select a subset of the training data, i.e., 500 examples for training +train_ds = processed_ds["train"].select(range(500)) +eval_ds = processed_ds["validation"] + +batch_size = 8 + +train_dataloader = DataLoader( + train_ds, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True +) +eval_dataloader = DataLoader(eval_ds, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True) + + +model = AutoModelForSeq2SeqLM.from_pretrained("bigscience/mt0-small") + +# you can try target_modules=["v"], target_modules=["q"], target_modules=["k"] +peft_config = BeftConfig(task_type="SEQ_2_SEQ_LM", target_modules=["v"]) +model = get_peft_model(model, peft_config) +print(model.print_trainable_parameters()) + +lr = 8e-3 +num_epochs = 1 + +optimizer = torch.optim.AdamW(model.parameters(), lr=lr) +lr_scheduler = get_linear_schedule_with_warmup( + optimizer=optimizer, + num_warmup_steps=0, + num_training_steps=(len(train_dataloader) * num_epochs), +) + +device = ( + torch.accelerator.current_accelerator().type + if hasattr(torch, "accelerator") + else "cuda" + if torch.cuda.is_available() + else "cpu" +) +model = model.to(device) + +for epoch in range(num_epochs): + model.train() + total_loss = 0 + for step, batch in enumerate(tqdm(train_dataloader)): + batch = {k: v.to(device) for k, v in batch.items()} + outputs = model(**batch) + loss = outputs.loss + total_loss += loss.detach().float() + loss.backward() + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + model.eval() + eval_loss = 0 + eval_preds = [] + for step, batch in enumerate(tqdm(eval_dataloader)): + batch = {k: v.to(device) for k, v in batch.items()} + with torch.no_grad(): + outputs = model(**batch) + loss = outputs.loss + eval_loss += loss.detach().float() + eval_preds.extend( + tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True) + ) + + eval_epoch_loss = eval_loss / len(eval_dataloader) + eval_ppl = torch.exp(eval_epoch_loss) + train_epoch_loss = total_loss / len(train_dataloader) + train_ppl = torch.exp(train_epoch_loss) + print(f"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}") diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/__init__.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/boft_controlnet.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/boft_controlnet.md new file mode 100644 index 0000000000000000000000000000000000000000..57777f18591e5e4aff0fe312dff636c687cd4ef4 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/boft_controlnet.md @@ -0,0 +1,177 @@ + + + +# Fine-tuning for controllable generation with BOFT (ControlNet) + +This guide demonstrates how to use BOFT, an orthogonal fine-tuning method, to fine-tune Stable Diffusion with either `stabilityai/stable-diffusion-2-1` or `runwayml/stable-diffusion-v1-5` model for controllable generation. + +By using BOFT from 🤗 PEFT, we can significantly reduce the number of trainable parameters while still achieving impressive results in various fine-tuning tasks across different foundation models. BOFT enhances model efficiency by integrating full-rank orthogonal matrices with a butterfly structure into specific model blocks, such as attention blocks, mirroring the approach used in LoRA. During fine-tuning, only these inserted matrices are trained, leaving the original model parameters untouched. During inference, the trainable BOFT parameters can be merged into the original model, eliminating any additional computational costs. + +As a member of the **orthogonal finetuning** class, BOFT presents a systematic and principled method for fine-tuning. It possesses several unique properties and has demonstrated superior performance compared to LoRA in a variety of scenarios. For further details on BOFT, please consult the [PEFT's GitHub repo's concept guide OFT](https://https://huggingface.co/docs/peft/index), the [original BOFT paper](https://huggingface.co/papers/2311.06243) and the [original OFT paper](https://huggingface.co/papers/2306.07280). + +In this guide we provide a controllable generation (ControlNet) fine-tuning script that is available in [PEFT's GitHub repo examples](https://github.com/huggingface/peft/tree/main/examples/boft_controlnet). This implementation is adapted from [diffusers's ControlNet](https://github.com/huggingface/diffusers/tree/main/examples/controlnet) and [Hecong Wu's ControlLoRA](https://github.com/HighCWu/ControlLoRA). You can try it out and finetune on your custom images. + +## Set up your environment +Start by cloning the PEFT repository: + +```bash +git clone https://github.com/huggingface/peft +``` + +Navigate to the directory containing the training scripts for fine-tuning Dreambooth with BOFT: +```bash +cd peft/examples/boft_controlnet +``` + +Set up your environment: install PEFT, and all the required libraries. At the time of writing this guide we recommend installing PEFT from source. + +```bash +conda create --name peft python=3.10 +conda activate peft +conda install pytorch==2.1.2 torchvision==0.16.2 torchaudio==2.1.2 pytorch-cuda=11.8 -c pytorch -c nvidia +conda install xformers -c xformers +pip install -r requirements.txt +pip install git+https://github.com/huggingface/peft +``` + +## Data + +We use the [control-celeba-hq](https://huggingface.co/datasets/oftverse/control-celeba-hq) dataset for landmark-to-face controllable generation. We also provide evaluation scripts to evaluate the controllable generation performance. This task can be used to quantitatively compare different fine-tuning techniques. + +```bash +export DATASET_NAME="oftverse/control-celeba-hq" +``` + +## Train controllable generation (ControlNet) with BOFT + +Start with setting some hyperparameters for BOFT: +```bash +PEFT_TYPE="boft" +BLOCK_NUM=8 +BLOCK_SIZE=0 +N_BUTTERFLY_FACTOR=0 +``` + +Here: + + +Navigate to the directory containing the training scripts for fine-tuning Stable Diffusion with BOFT for controllable generation: + +```bash +./train_controlnet.sh +``` +or +```bash +export MODEL_NAME="stabilityai/stable-diffusion-2-1" +# export MODEL_NAME="runwayml/stable-diffusion-v1-5" + +export DATASET_NAME="oftverse/control-celeba-hq" +export PROJECT_NAME="controlnet_${PEFT_TYPE}" +export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}" +export CONTROLNET_PATH="" +export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}" + +accelerate launch train_controlnet.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --resume_from_checkpoint=$RESUME_PATH \ + --controlnet_model_name_or_path=$CONTROLNET_PATH \ + --output_dir=$OUTPUT_DIR \ + --report_to="wandb" \ + --dataset_name=$DATASET_NAME \ + --resolution=512 \ + --learning_rate=1e-5 \ + --checkpointing_steps=5000 \ + --max_train_steps=50000 \ + --validation_steps=2000 \ + --num_validation_images=12 \ + --train_batch_size=4 \ + --dataloader_num_workers=2 \ + --seed="0" \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --wandb_project_name=$PROJECT_NAME \ + --wandb_run_name=$RUN_NAME \ + --enable_xformers_memory_efficient_attention \ + --use_boft \ + --boft_block_num=$BLOCK_NUM \ + --boft_block_size=$BLOCK_SIZE \ + --boft_n_butterfly_factor=$N_BUTTERFLY_FACTOR \ + --boft_dropout=0.1 \ + --boft_bias="boft_only" \ + --report_to="wandb" \ +``` + +Run inference on the saved model to sample new images from the validation set: + +```bash +./test_controlnet.sh +``` +or +```bash +ITER_NUM=50000 + +export MODEL_NAME="stabilityai/stable-diffusion-2-1" +# export MODEL_NAME="runwayml/stable-diffusion-v1-5" + +export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}" +export DATASET_NAME="oftverse/control-celeba-hq" +export CKPT_NAME="checkpoint-${ITER_NUM}" +export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}/${CKPT_NAME}" +export CONTROLNET_PATH="${OUTPUT_DIR}/controlnet/model.safetensors" +export UNET_PATH="${OUTPUT_DIR}/unet/${RUN_NAME}" +export RESULTS_PATH="${OUTPUT_DIR}/results" + +accelerate launch test_controlnet.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --dataset_name=$DATASET_NAME \ + --controlnet_path=$CONTROLNET_PATH \ + --unet_path=$UNET_PATH \ + --adapter_name=$RUN_NAME \ + --output_dir=$RESULTS_PATH \ + --dataset_name=$DATASET_NAME \ + +``` + +Run evaluation on the sampled images to evaluate the landmark reprojection error: + +```bash +./eval.sh +``` +or +```bash +ITER_NUM=50000 + +export MODEL_NAME="stabilityai/stable-diffusion-2-1" +# export MODEL_NAME="runwayml/stable-diffusion-v1-5" + +export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}" +export DATASET_NAME="oftverse/control-celeba-hq" +export CKPT_NAME="checkpoint-${ITER_NUM}" +export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}/${CKPT_NAME}" +export CONTROLNET_PATH="${OUTPUT_DIR}/controlnet/model.safetensors" +export UNET_PATH="${OUTPUT_DIR}/unet/${RUN_NAME}" + +accelerate launch eval.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --dataset_name=$DATASET_NAME \ + --controlnet_path=$CONTROLNET_PATH \ + --unet_path=$UNET_PATH \ + --adapter_name=$RUN_NAME \ + --output_dir=$OUTPUT_DIR \ + --dataset_name=$DATASET_NAME \ + --vis_overlays \ +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/eval.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/eval.py new file mode 100644 index 0000000000000000000000000000000000000000..ea53af7698e8195cc165a3726c7a5ab34f5d3bb4 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/eval.py @@ -0,0 +1,206 @@ +# Copyright 2023-present the HuggingFace Inc. team. +# +# 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. + +# The implementation is based on "Parameter-Efficient Orthogonal Finetuning +# via Butterfly Factorization" (https://huggingface.co/papers/2311.06243) in ICLR 2024. + +import glob +import os +from pathlib import Path + +import cv2 +import face_alignment +import numpy as np +import torch +from accelerate import Accelerator +from skimage.io import imread +from torchvision.utils import save_image +from tqdm import tqdm +from transformers import AutoTokenizer +from utils.args_loader import parse_args +from utils.dataset import make_dataset + + +# Determine the best available device +if torch.cuda.is_available(): + device = "cuda:0" +else: + # TODO: xpu support in facealignment will be ready after this PR is merged:https://github.com/1adrianb/face-alignment/pull/371 + device = "cpu" + +detect_model = face_alignment.FaceAlignment(face_alignment.LandmarksType.TWO_D, device=device, flip_input=False) +# with open('./data/celebhq-text/prompt_val_blip_full.json', 'rt') as f: # fill50k, COCO +# for line in f: +# val_data = json.loads(line) + +end_list = np.array([17, 22, 27, 42, 48, 31, 36, 68], dtype=np.int32) - 1 + + +def count_txt_files(directory): + pattern = os.path.join(directory, "*.txt") + txt_files = glob.glob(pattern) + return len(txt_files) + + +def plot_kpts(image, kpts, color="g"): + """Draw 68 key points + Args: + image: the input image + kpt: (68, 3). + """ + if color == "r": + c = (255, 0, 0) + elif color == "g": + c = (0, 255, 0) + elif color == "b": + c = (255, 0, 0) + image = image.copy() + kpts = kpts.copy() + radius = max(int(min(image.shape[0], image.shape[1]) / 200), 1) + for i in range(kpts.shape[0]): + st = kpts[i, :2] + if kpts.shape[1] == 4: + if kpts[i, 3] > 0.5: + c = (0, 255, 0) + else: + c = (0, 0, 255) + image = cv2.circle(image, (int(st[0]), int(st[1])), radius, c, radius * 2) + if i in end_list: + continue + ed = kpts[i + 1, :2] + image = cv2.line(image, (int(st[0]), int(st[1])), (int(ed[0]), int(ed[1])), (255, 255, 255), radius) + return image + + +def generate_landmark2d(dataset, input_dir, pred_lmk_dir, gt_lmk_dir, vis=False): + print("Generate 2d landmarks ...") + os.makedirs(pred_lmk_dir, exist_ok=True) + + imagepath_list = sorted(glob.glob(f"{input_dir}/pred*.png")) + + for imagepath in tqdm(imagepath_list): + name = Path(imagepath).stem + idx = int(name.split("_")[-1]) + pred_txt_path = os.path.join(pred_lmk_dir, f"{idx}.txt") + gt_lmk_path = os.path.join(gt_lmk_dir, f"{idx}_gt_lmk.jpg") + gt_txt_path = os.path.join(gt_lmk_dir, f"{idx}.txt") + gt_img_path = os.path.join(gt_lmk_dir, f"{idx}_gt_img.jpg") + + if (not os.path.exists(pred_txt_path)) or (not os.path.exists(gt_txt_path)): + image = imread(imagepath) # [:, :, :3] + out = detect_model.get_landmarks(image) + if out is None: + continue + + pred_kpt = out[0].squeeze() + np.savetxt(pred_txt_path, pred_kpt) + + # Your existing code for obtaining the image tensor + gt_lmk_img = dataset[idx]["conditioning_pixel_values"] + save_image(gt_lmk_img, gt_lmk_path) + + gt_img = (dataset[idx]["pixel_values"]) * 0.5 + 0.5 + save_image(gt_img, gt_img_path) + + gt_img = (gt_img.permute(1, 2, 0) * 255).type(torch.uint8).cpu().numpy() + out = detect_model.get_landmarks(gt_img) + if out is None: + continue + + gt_kpt = out[0].squeeze() + np.savetxt(gt_txt_path, gt_kpt) + # gt_image = cv2.resize(cv2.imread(gt_lmk_path), (512, 512)) + + if vis: + gt_lmk_image = cv2.imread(gt_lmk_path) + + # visualize predicted landmarks + vis_path = os.path.join(pred_lmk_dir, f"{idx}_overlay.jpg") + image = cv2.imread(imagepath) + image_point = plot_kpts(image, pred_kpt) + cv2.imwrite(vis_path, np.concatenate([image_point, gt_lmk_image], axis=1)) + + # visualize gt landmarks + vis_path = os.path.join(gt_lmk_dir, f"{idx}_overlay.jpg") + image = cv2.imread(gt_img_path) + image_point = plot_kpts(image, gt_kpt) + cv2.imwrite(vis_path, np.concatenate([image_point, gt_lmk_image], axis=1)) + + +def landmark_comparison(val_dataset, lmk_dir, gt_lmk_dir): + print("Calculating reprojection error") + lmk_err = [] + + pbar = tqdm(range(len(val_dataset))) + for i in pbar: + # line = val_dataset[i] + # img_name = line["image"].split(".")[0] + lmk1_path = os.path.join(gt_lmk_dir, f"{i}.txt") + lmk1 = np.loadtxt(lmk1_path) + lmk2_path = os.path.join(lmk_dir, f"{i}.txt") + + if not os.path.exists(lmk2_path): + print(f"{lmk2_path} not exist") + continue + + lmk2 = np.loadtxt(lmk2_path) + lmk_err.append(np.mean(np.linalg.norm(lmk1 - lmk2, axis=1))) + pbar.set_description(f"lmk_err: {np.mean(lmk_err):.5f}") + + print("Reprojection error:", np.mean(lmk_err)) + np.save(os.path.join(lmk_dir, "lmk_err.npy"), lmk_err) + + +def main(args): + logging_dir = Path(args.output_dir, args.logging_dir) + + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_dir=logging_dir, + ) + + # Load the tokenizer + if args.tokenizer_name: + tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False) + elif args.pretrained_model_name_or_path: + tokenizer = AutoTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.revision, + use_fast=False, + ) + + val_dataset = make_dataset(args, tokenizer, accelerator, "test") + + gt_lmk_dir = os.path.join(args.output_dir, "gt_lmk") + if not os.path.exists(gt_lmk_dir): + os.makedirs(gt_lmk_dir, exist_ok=True) + + pred_lmk_dir = os.path.join(args.output_dir, "pred_lmk") + if not os.path.exists(pred_lmk_dir): + os.makedirs(pred_lmk_dir, exist_ok=True) + + input_dir = os.path.join(args.output_dir, "results") + + generate_landmark2d(val_dataset, input_dir, pred_lmk_dir, gt_lmk_dir, args.vis_overlays) + + if count_txt_files(pred_lmk_dir) == len(val_dataset) and count_txt_files(gt_lmk_dir) == len(val_dataset): + landmark_comparison(val_dataset, pred_lmk_dir, gt_lmk_dir) + + +if __name__ == "__main__": + args = parse_args() + main(args) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/eval.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/eval.sh new file mode 100644 index 0000000000000000000000000000000000000000..d5ed282ea1dab4af179220a4af85873cc6e6db61 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/eval.sh @@ -0,0 +1,29 @@ +PEFT_TYPE="boft" +BLOCK_NUM=8 +BLOCK_SIZE=0 +N_BUTTERFLY_FACTOR=1 +ITER_NUM=50000 + +export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}" + +export MODEL_NAME="stabilityai/stable-diffusion-2-1" +# export MODEL_NAME="runwayml/stable-diffusion-v1-5" + +export DATASET_NAME="oftverse/control-celeba-hq" +export CKPT_NAME="checkpoint-${ITER_NUM}" +export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}/${CKPT_NAME}" +export CONTROLNET_PATH="${OUTPUT_DIR}/controlnet/model.safetensors" +export UNET_PATH="${OUTPUT_DIR}/unet/${RUN_NAME}" + + +accelerate launch eval.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --dataset_name=$DATASET_NAME \ + --controlnet_path=$CONTROLNET_PATH \ + --unet_path=$UNET_PATH \ + --adapter_name=$RUN_NAME \ + --output_dir=$OUTPUT_DIR \ + --dataset_name=$DATASET_NAME \ + --vis_overlays \ + + diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..b03040914e9d647b604fc6451970cc66502bde48 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/requirements.txt @@ -0,0 +1,10 @@ +datasets==2.16.1 +diffusers==0.34.0 +transformers==4.54.0 +accelerate==1.9.0 +wandb==0.16.1 +scikit-image==0.22.0 +opencv-python==4.9.0.80 +git+https://github.com/1adrianb/face-alignment.git +huggingface_hub==0.34.3 +numpy<2.0.0 \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/test_controlnet.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/test_controlnet.py new file mode 100644 index 0000000000000000000000000000000000000000..1b0497b3e6b31b0a17faa32f8a1bdf2d2b6331d5 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/test_controlnet.py @@ -0,0 +1,133 @@ +# Copyright 2023-present the HuggingFace Inc. team. +# +# 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. + +# The implementation is based on "Parameter-Efficient Orthogonal Finetuning +# via Butterfly Factorization" (https://huggingface.co/papers/2311.06243) in ICLR 2024. + +import os +import sys +import time +from pathlib import Path + +import numpy as np +import torch +from accelerate import Accelerator +from diffusers import DDIMScheduler +from diffusers.utils import check_min_version +from safetensors.torch import load_file +from tqdm import tqdm +from transformers import AutoTokenizer +from utils.args_loader import parse_args +from utils.dataset import make_dataset +from utils.light_controlnet import ControlNetModel +from utils.pipeline_controlnet import LightControlNetPipeline +from utils.unet_2d_condition import UNet2DConditionNewModel + + +sys.path.append("../../src") +from peft import PeftModel + + +# Will error if the minimal version of diffusers is not installed. Remove at your own risks. +check_min_version("0.10.0.dev0") +if torch.xpu.is_available(): + device = "xpu:0" +elif torch.cuda.is_available(): + device = "cuda:0" +else: + device = "cpu" + + +def main(args): + logging_dir = Path(args.output_dir, args.logging_dir) + + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_dir=logging_dir, + ) + + # Load the tokenizer + if args.tokenizer_name: + tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False) + elif args.pretrained_model_name_or_path: + tokenizer = AutoTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.revision, + use_fast=False, + ) + + val_dataset = make_dataset(args, tokenizer, accelerator, "test") + + controlnet_path = args.controlnet_path + unet_path = args.unet_path + + controlnet = ControlNetModel() + controlnet.load_state_dict(load_file(controlnet_path)) + unet = UNet2DConditionNewModel.from_pretrained(args.pretrained_model_name_or_path, subfolder="unet") + unet = PeftModel.from_pretrained(unet, unet_path, adapter_name=args.adapter_name) + + pipe = LightControlNetPipeline.from_pretrained( + args.pretrained_model_name_or_path, + controlnet=controlnet, + unet=unet.model, + dtype=torch.float32, + requires_safety_checker=False, + ).to(device) + + pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config) + + if not os.path.exists(args.output_dir): + os.makedirs(args.output_dir, exist_ok=True) + + exist_lst = [int(img.split("_")[-1][:-4]) for img in os.listdir(args.output_dir)] + all_lst = np.arange(len(val_dataset)) + idx_lst = [item for item in all_lst if item not in exist_lst] + + print("Number of images to be processed: ", len(idx_lst)) + + np.random.seed(seed=int(time.time())) + np.random.shuffle(idx_lst) + + for idx in tqdm(idx_lst): + output_path = os.path.join(args.output_dir, f"pred_img_{idx:04d}.png") + + if not os.path.exists(output_path): + data = val_dataset[idx.item()] + negative_prompt = "low quality, blurry, unfinished" + + with torch.no_grad(): + pred_img = pipe( + data["text"], + [data["conditioning_pixel_values"]], + num_inference_steps=50, + guidance_scale=7, + negative_prompt=negative_prompt, + ).images[0] + + pred_img.save(output_path) + + # control_img = Image.fromarray( + # (data["conditioning_pixel_value"] * 255).numpy().transpose(1, 2, 0).astype(np.uint8) + # ) + # gt_img = Image.fromarray( + # ((data["pixel_value"] + 1.0) * 0.5 * 255).numpy().transpose(1, 2, 0).astype(np.uint8) + # ) + + +if __name__ == "__main__": + args = parse_args() + main(args) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/test_controlnet.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/test_controlnet.sh new file mode 100644 index 0000000000000000000000000000000000000000..e8d61e1f09554b5630cbde1fc33ee20431eb3edc --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/test_controlnet.sh @@ -0,0 +1,29 @@ +PEFT_TYPE="boft" +BLOCK_NUM=8 +BLOCK_SIZE=0 +N_BUTTERFLY_FACTOR=1 +ITER_NUM=50000 + +export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}" + +export MODEL_NAME="stabilityai/stable-diffusion-2-1" +# export MODEL_NAME="runwayml/stable-diffusion-v1-5" + +export DATASET_NAME="oftverse/control-celeba-hq" +export CKPT_NAME="checkpoint-${ITER_NUM}" +export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}/${CKPT_NAME}" +export CONTROLNET_PATH="${OUTPUT_DIR}/controlnet/model.safetensors" +export UNET_PATH="${OUTPUT_DIR}/unet" +export RESULTS_PATH="${OUTPUT_DIR}/results" + + +accelerate launch test_controlnet.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --dataset_name=$DATASET_NAME \ + --controlnet_path=$CONTROLNET_PATH \ + --unet_path=$UNET_PATH \ + --adapter_name=$RUN_NAME \ + --output_dir=$RESULTS_PATH \ + --dataset_name=$DATASET_NAME \ + + diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/train_controlnet.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/train_controlnet.py new file mode 100644 index 0000000000000000000000000000000000000000..8cf6c9691d2a98a033a0ff48f509139c7278190c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/train_controlnet.py @@ -0,0 +1,544 @@ +# Copyright 2023-present the HuggingFace Inc. team. +# +# 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. + +# The implementation is based on "Parameter-Efficient Orthogonal Finetuning +# via Butterfly Factorization" (https://huggingface.co/papers/2311.06243) in ICLR 2024. + +import itertools +import logging +import math +import os +from pathlib import Path + +import datasets +import diffusers +import torch +import torch.nn.functional as F +import torch.utils.checkpoint +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import set_seed +from diffusers import ( + AutoencoderKL, + DDIMScheduler, +) +from diffusers.optimization import get_scheduler +from diffusers.utils import check_min_version +from diffusers.utils.import_utils import is_xformers_available +from packaging import version +from tqdm.auto import tqdm +from transformers import AutoTokenizer +from utils.args_loader import ( + import_model_class_from_model_name_or_path, + parse_args, +) +from utils.dataset import collate_fn, log_validation, make_dataset +from utils.light_controlnet import ControlNetModel +from utils.tracemalloc import TorchTracemalloc, b2mb +from utils.unet_2d_condition import UNet2DConditionNewModel + +from peft import BOFTConfig, get_peft_model +from peft.peft_model import PeftModel + + +# Will error if the minimal version of diffusers is not installed. Remove at your own risks. +check_min_version("0.16.0.dev0") + +logger = get_logger(__name__) + +UNET_TARGET_MODULES = ["to_q", "to_v", "to_k", "query", "value", "key"] + +TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"] + + +@torch.no_grad() +def save_adaptor(accelerator, output_dir, nets_dict): + for net_key in nets_dict.keys(): + net_model = nets_dict[net_key] + unwarpped_net = accelerator.unwrap_model(net_model) + + if isinstance(unwarpped_net, PeftModel): + unwarpped_net.save_pretrained( + os.path.join(output_dir, net_key), + state_dict=accelerator.get_state_dict(net_model), + safe_serialization=True, + ) + else: + accelerator.save_model( + unwarpped_net, + os.path.join(output_dir, net_key), + safe_serialization=True, + ) + + +def main(args): + logging_dir = Path(args.output_dir, args.logging_dir) + + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_dir=logging_dir, + ) + + if args.report_to == "wandb": + wandb_init = { + "wandb": { + "name": args.wandb_run_name, + "mode": "online", + } + } + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + + logger.info(accelerator.state, main_process_only=False) + + if accelerator.is_local_main_process: + datasets.utils.logging.set_verbosity_warning() + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + datasets.utils.logging.set_verbosity_error() + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + set_seed(args.seed) + + # Handle the repository creation + if accelerator.is_main_process: + if args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + # Load the tokenizer + if args.tokenizer_name: + tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False) + elif args.pretrained_model_name_or_path: + tokenizer = AutoTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.revision, + use_fast=False, + ) + + # import correct text encoder class + text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision) + + # Load scheduler and models + noise_scheduler = DDIMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler") + + text_encoder = text_encoder_cls.from_pretrained( + args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision + ) + vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision) + unet = UNet2DConditionNewModel.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="unet", + revision=args.revision, + ) + + controlnet = ControlNetModel() + + if args.controlnet_model_name_or_path != "": + logger.info(f"Loading existing controlnet weights from {args.controlnet_model_name_or_path}") + controlnet.load_state_dict(torch.load(args.controlnet_model_name_or_path)) + + if args.use_boft: + config = BOFTConfig( + boft_block_size=args.boft_block_size, + boft_block_num=args.boft_block_num, + boft_n_butterfly_factor=args.boft_n_butterfly_factor, + target_modules=UNET_TARGET_MODULES, + boft_dropout=args.boft_dropout, + bias=args.boft_bias, + ) + unet = get_peft_model(unet, config) + unet.print_trainable_parameters() + + vae.requires_grad_(False) + controlnet.requires_grad_(True) + + if not args.train_text_encoder: + text_encoder.requires_grad_(False) + + unet.train() + controlnet.train() + + if args.train_text_encoder and args.use_boft: + config = BOFTConfig( + boft_block_size=args.boft_block_size, + boft_block_num=args.boft_block_num, + boft_n_butterfly_factor=args.boft_n_butterfly_factor, + target_modules=TEXT_ENCODER_TARGET_MODULES, + boft_dropout=args.boft_dropout, + bias=args.boft_bias, + ) + text_encoder = get_peft_model(text_encoder, config, adapter_name=args.wandb_run_name) + text_encoder.print_trainable_parameters() + + if args.train_text_encoder: + text_encoder.train() + + # For mixed precision training we cast the text_encoder and vae weights to half-precision + # as these models are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + # Move unet, vae and text_encoder to device and cast to weight_dtype + unet.to(accelerator.device, dtype=weight_dtype) + vae.to(accelerator.device, dtype=weight_dtype) + controlnet.to(accelerator.device, dtype=weight_dtype) + + if not args.train_text_encoder: + text_encoder.to(accelerator.device, dtype=weight_dtype) + + if args.enable_xformers_memory_efficient_attention: + if accelerator.device.type == "xpu": + logger.warning("XPU doesn't support xformers yet, xformers is not applied.") + elif is_xformers_available(): + import xformers + + xformers_version = version.parse(xformers.__version__) + if xformers_version == version.parse("0.0.16"): + logger.warning( + "xFormers 0.0.16 cannot be used for training in some GPUs. If you observe problems during training, please update xFormers to at least 0.0.17. See https://huggingface.co/docs/diffusers/main/en/optimization/xformers for more details." + ) + unet.enable_xformers_memory_efficient_attention() + controlnet.enable_xformers_memory_efficient_attention() + if args.train_text_encoder and not (args.use_lora or args.use_boft or args.use_oft): + text_encoder.enable_xformers_memory_efficient_attention() + else: + raise ValueError("xformers is not available. Make sure it is installed correctly") + + if args.gradient_checkpointing: + controlnet.enable_gradient_checkpointing() + unet.enable_gradient_checkpointing() + if args.train_text_encoder and not (args.use_lora or args.use_boft or args.use_oft): + text_encoder.gradient_checkpointing_enable() + + # Check that all trainable models are in full precision + low_precision_error_string = ( + " Please make sure to always have all model weights in full float32 precision when starting training - even if" + " doing mixed precision training, copy of the weights should still be float32." + ) + + if accelerator.unwrap_model(controlnet).dtype != torch.float32: + raise ValueError( + f"Controlnet loaded as datatype {accelerator.unwrap_model(controlnet).dtype}. {low_precision_error_string}" + ) + + if accelerator.unwrap_model(unet).dtype != torch.float32: + raise ValueError( + f"UNet loaded as datatype {accelerator.unwrap_model(unet).dtype}. {low_precision_error_string}" + ) + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.allow_tf32: + torch.backends.cuda.matmul.allow_tf32 = True + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes + ) + + # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB GPUs + if args.use_8bit_adam: + try: + import bitsandbytes as bnb + except ImportError: + raise ImportError( + "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`." + ) + + optimizer_class = bnb.optim.AdamW8bit + else: + optimizer_class = torch.optim.AdamW + + params_to_optimize = [param for param in controlnet.parameters() if param.requires_grad] + params_to_optimize += [param for param in unet.parameters() if param.requires_grad] + + if args.train_text_encoder: + params_to_optimize += [param for param in text_encoder.parameters() if param.requires_grad] + + # Optimizer creation + optimizer = optimizer_class( + params_to_optimize, + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + # Load the dataset + train_dataset = make_dataset(args, tokenizer, accelerator, "train") + val_dataset = make_dataset(args, tokenizer, accelerator, "test") + + train_dataloader = torch.utils.data.DataLoader( + train_dataset, + shuffle=True, + collate_fn=collate_fn, + batch_size=args.train_batch_size, + num_workers=args.dataloader_num_workers, + ) + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, + num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, + num_cycles=args.lr_num_cycles, + power=args.lr_power, + ) + + # Prepare everything with our `accelerator`. + controlnet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + controlnet, optimizer, train_dataloader, lr_scheduler + ) + + if args.train_text_encoder: + text_encoder = accelerator.prepare(text_encoder) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + accelerator.init_trackers(args.wandb_project_name, config=vars(args), init_kwargs=wandb_init) + + # Train! + total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + + logger.info("***** Running training *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num batches each epoch = {len(train_dataloader)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {args.max_train_steps}") + + global_step = 0 + first_epoch = 0 + + # Potentially load in the weights and states from a previous save + + if args.resume_from_checkpoint: + if args.resume_from_checkpoint != "latest": + path = os.path.basename(args.resume_from_checkpoint) + else: + # Get the most recent checkpoint + dirs = os.listdir(args.output_dir) + if "checkpoint-current" in dirs: + path = "checkpoint-current" + dirs = [d for d in dirs if d.startswith("checkpoint") and d.endswith("0")] + dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) + + else: + dirs = [d for d in dirs if d.startswith("checkpoint")] + dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) + path = dirs[-1] if len(dirs) > 0 else None + + if path is None: + accelerator.print( + f"Checkpoint '{args.resume_from_checkpoint}' does not exist. Starting a new training run." + ) + args.resume_from_checkpoint = None + initial_global_step = 0 + else: + accelerator.print(f"Resuming from checkpoint {path}") + accelerator.load_state(os.path.join(args.output_dir, path)) + if path.split("-")[1] == "current": + global_step = int(dirs[-1].split("-")[1]) + else: + global_step = int(path.split("-")[1]) + + initial_global_step = global_step + resume_global_step = global_step * args.gradient_accumulation_steps + first_epoch = global_step // num_update_steps_per_epoch + resume_step = resume_global_step % (num_update_steps_per_epoch * args.gradient_accumulation_steps) + else: + initial_global_step = 0 + + progress_bar = tqdm( + range(args.max_train_steps), + initial=initial_global_step, + desc="Steps", + disable=not accelerator.is_local_main_process, + ) + + progress_bar.set_description("Steps") + + for epoch in range(first_epoch, args.num_train_epochs): + with TorchTracemalloc() as tracemalloc: + for step, batch in enumerate(train_dataloader): + # Skip steps until we reach the resumed step + if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step: + if step % args.gradient_accumulation_steps == 0: + progress_bar.update(1) + if args.report_to == "wandb": + accelerator.print(progress_bar) + continue + + with accelerator.accumulate(controlnet), accelerator.accumulate(unet): + # Convert images to latent space + latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample() + latents = latents * vae.config.scaling_factor + + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + bsz = latents.shape[0] + + # Sample a random timestep for each image + timesteps = torch.randint( + 0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device + ) + timesteps = timesteps.long() + + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + # Get the text embedding for conditioning + encoder_hidden_states = text_encoder(batch["input_ids"])[0] + + controlnet_image = batch["conditioning_pixel_values"].to(dtype=weight_dtype) + + # Get the guided hint for the UNet (320 dim) + guided_hint = controlnet( + controlnet_cond=controlnet_image, + ) + + # Predict the noise residual + model_pred = unet( + noisy_latents, + timesteps, + guided_hint=guided_hint, + encoder_hidden_states=encoder_hidden_states, + ).sample + + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + accelerator.backward(loss) + + if accelerator.sync_gradients: + params_to_clip = ( + itertools.chain(controlnet.parameters(), text_encoder.parameters()) + if args.train_text_encoder + else itertools.chain( + controlnet.parameters(), + ) + ) + + accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm) + + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad(set_to_none=args.set_grads_to_none) + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + if args.report_to == "wandb": + accelerator.print(progress_bar) + global_step += 1 + + step_save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}") + + if accelerator.is_main_process: + if global_step % args.validation_steps == 0 or global_step == 1: + logger.info(f"Running validation... \n Generating {args.num_validation_images} images.") + logger.info("Running validation... ") + + with torch.no_grad(): + log_validation(val_dataset, text_encoder, unet, controlnet, args, accelerator) + + if global_step % args.checkpointing_steps == 0: + save_adaptor(accelerator, step_save_path, {"controlnet": controlnet, "unet": unet}) + + # save text_encoder if any + if args.train_text_encoder: + save_adaptor(accelerator, step_save_path, {"text_encoder": text_encoder}) + + accelerator.save_state(step_save_path) + + logger.info(f"Saved {global_step} state to {step_save_path}") + logger.info(f"Saved current state to {step_save_path}") + + logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + accelerator.log(logs, step=global_step) + + if global_step >= args.max_train_steps: + break + + # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage + accelerator.print( + f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}" + ) + + accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}") + accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}") + accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}") + accelerator.print( + f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}" + ) + + # Create the pipeline using using the trained modules and save it. + accelerator.wait_for_everyone() + accelerator.end_training() + + +if __name__ == "__main__": + args = parse_args() + main(args) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/train_controlnet.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/train_controlnet.sh new file mode 100644 index 0000000000000000000000000000000000000000..efad2c4348e465082ebff7a5dfd4d555dadc6ea2 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/train_controlnet.sh @@ -0,0 +1,42 @@ +PEFT_TYPE="boft" +BLOCK_NUM=8 +BLOCK_SIZE=0 +N_BUTTERFLY_FACTOR=1 + +export DATASET_NAME="oftverse/control-celeba-hq" +export PROJECT_NAME="controlnet_${PEFT_TYPE}" +export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}" +export CONTROLNET_PATH="" + +export MODEL_NAME="stabilityai/stable-diffusion-2-1" +# export MODEL_NAME="runwayml/stable-diffusion-v1-5" + +export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}" + +accelerate launch train_controlnet.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --resume_from_checkpoint=$RESUME_PATH \ + --controlnet_model_name_or_path=$CONTROLNET_PATH \ + --output_dir=$OUTPUT_DIR \ + --report_to="wandb" \ + --dataset_name=$DATASET_NAME \ + --resolution=512 \ + --learning_rate=1e-5 \ + --checkpointing_steps=500 \ + --max_train_steps=50000 \ + --validation_steps=5000 \ + --num_validation_images=12 \ + --train_batch_size=4 \ + --dataloader_num_workers=2 \ + --seed="0" \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --wandb_project_name=$PROJECT_NAME \ + --wandb_run_name=$RUN_NAME \ + --enable_xformers_memory_efficient_attention \ + --use_boft \ + --boft_block_num=$BLOCK_NUM \ + --boft_block_size=$BLOCK_SIZE \ + --boft_n_butterfly_factor=$N_BUTTERFLY_FACTOR \ + --boft_dropout=0.1 \ + --boft_bias="boft_only" \ \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/__init__.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/__init__.py @@ -0,0 +1 @@ + diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/args_loader.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/args_loader.py new file mode 100644 index 0000000000000000000000000000000000000000..dc1353d9f23aa4885f1fdb15c9c0b6058153948c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/args_loader.py @@ -0,0 +1,447 @@ +import argparse +import os +from typing import Optional + +from huggingface_hub import HfFolder, whoami +from transformers import PretrainedConfig + + +def get_full_repo_name(model_id: str, organization: Optional[str] = None, token: Optional[str] = None): + if token is None: + token = HfFolder.get_token() + if organization is None: + username = whoami(token)["name"] + return f"{username}/{model_id}" + else: + return f"{organization}/{model_id}" + + +def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str): + text_encoder_config = PretrainedConfig.from_pretrained( + pretrained_model_name_or_path, + subfolder="text_encoder", + revision=revision, + ) + model_class = text_encoder_config.architectures[0] + + if model_class == "CLIPTextModel": + from transformers import CLIPTextModel + + return CLIPTextModel + elif model_class == "RobertaSeriesModelWithTransformation": + from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( + RobertaSeriesModelWithTransformation, + ) + + return RobertaSeriesModelWithTransformation + else: + raise ValueError(f"{model_class} is not supported.") + + +def parse_args(input_args=None): + parser = argparse.ArgumentParser(description="Simple example of a ControlNet training script.") + parser.add_argument( + "--pretrained_model_name_or_path", + type=str, + default=None, + required=True, + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--controlnet_model_name_or_path", + type=str, + default=None, + help="Path to pretrained controlnet model or model identifier from huggingface.co/models." + " If not specified controlnet weights are initialized from unet.", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help=( + "Revision of pretrained model identifier from huggingface.co/models. Trainable model components should be" + " float32 precision." + ), + ) + parser.add_argument( + "--tokenizer_name", + type=str, + default=None, + help="Pretrained tokenizer name or path if not the same as model_name", + ) + parser.add_argument( + "--output_dir", + type=str, + default="controlnet-model", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument( + "--cache_dir", + type=str, + default=None, + help="The directory where the downloaded models and datasets will be stored.", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder") + + parser.add_argument( + "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader." + ) + parser.add_argument( + "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images." + ) + + parser.add_argument("--num_train_epochs", type=int, default=1) + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help=( + "Save a checkpoint of the training state every X updates. Checkpoints can be used for resuming training via `--resume_from_checkpoint`. " + "In the case that the checkpoint is better than the final trained model, the checkpoint can also be used for inference." + "Using a checkpoint for inference requires separate loading of the original pipeline and the individual checkpointed model components." + "See https://huggingface.co/docs/diffusers/main/en/training/dreambooth#performing-inference-using-a-saved-checkpoint for step by step" + "instructions." + ), + ) + parser.add_argument( + "--checkpoints_total_limit", + type=int, + default=None, + help=("Max number of checkpoints to store."), + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help=( + "Whether training should be resumed from a previous checkpoint. Use a path saved by" + ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.' + ), + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=5e-6, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler." + ) + parser.add_argument( + "--lr_num_cycles", + type=int, + default=1, + help="Number of hard resets of the lr in cosine_with_restarts scheduler.", + ) + parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.") + parser.add_argument( + "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes." + ) + parser.add_argument( + "--dataloader_num_workers", + type=int, + default=0, + help=( + "Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process." + ), + ) + parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.") + parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.") + parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.") + parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer") + parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.") + parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.") + parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.") + parser.add_argument( + "--hub_model_id", + type=str, + default=None, + help="The name of the repository to keep in sync with the local `output_dir`.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument( + "--report_to", + type=str, + default="wandb", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`' + ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument( + "--wandb_key", + type=str, + default=None, + help=("If report to option is set to wandb, api-key for wandb used for login to wandb "), + ) + parser.add_argument( + "--wandb_project_name", + type=str, + default=None, + help=("If report to option is set to wandb, project name in wandb for log tracking "), + ) + parser.add_argument( + "--wandb_run_name", + type=str, + default=None, + help=("If report to option is set to wandb, project name in wandb for log tracking "), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default=None, + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers." + ) + parser.add_argument( + "--set_grads_to_none", + action="store_true", + help=( + "Save more memory by using setting grads to None instead of zero. Be aware, that this changes certain" + " behaviors, so disable this argument if it causes any problems. More info:" + " https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html" + ), + ) + parser.add_argument( + "--dataset_name", + type=str, + default=None, + help=( + "The name of the Dataset (from the HuggingFace hub) to train on (could be your own, possibly private," + " dataset). It can also be a path pointing to a local copy of a dataset in your filesystem," + " or to a folder containing files that 🤗 Datasets can understand." + ), + ) + parser.add_argument( + "--dataset_config_name", + type=str, + default=None, + help="The config of the Dataset, leave as None if there's only one config.", + ) + parser.add_argument( + "--train_data_dir", + type=str, + default=None, + help=( + "A folder containing the training data. Folder contents must follow the structure described in" + " https://huggingface.co/docs/datasets/image_dataset#imagefolder. In particular, a `metadata.jsonl` file" + " must exist to provide the captions for the images. Ignored if `dataset_name` is specified." + ), + ) + parser.add_argument( + "--image_column", type=str, default="image", help="The column of the dataset containing the target image." + ) + parser.add_argument( + "--conditioning_image_column", + type=str, + default="conditioning_image", + help="The column of the dataset containing the controlnet conditioning image.", + ) + parser.add_argument( + "--caption_column", + type=str, + default="text", + help="The column of the dataset containing a caption or a list of captions.", + ) + parser.add_argument( + "--max_train_samples", + type=int, + default=None, + help=( + "For debugging purposes or quicker training, truncate the number of training examples to this " + "value if set." + ), + ) + parser.add_argument( + "--proportion_empty_prompts", + type=float, + default=0, + help="Proportion of image prompts to be replaced with empty strings. Defaults to 0 (no prompt replacement).", + ) + parser.add_argument( + "--validation_prompt", + type=str, + default=None, + nargs="+", + help=( + "A set of prompts evaluated every `--validation_steps` and logged to `--report_to`." + " Provide either a matching number of `--validation_image`s, a single `--validation_image`" + " to be used with all prompts, or a single prompt that will be used with all `--validation_image`s." + ), + ) + parser.add_argument( + "--validation_image", + type=str, + default=None, + nargs="+", + help=( + "A set of paths to the controlnet conditioning image be evaluated every `--validation_steps`" + " and logged to `--report_to`. Provide either a matching number of `--validation_prompt`s, a" + " a single `--validation_prompt` to be used with all `--validation_image`s, or a single" + " `--validation_image` that will be used with all `--validation_prompt`s." + ), + ) + parser.add_argument( + "--num_validation_images", + type=int, + default=4, + help="Number of images to be generated for each `--validation_image`, `--validation_prompt` pair", + ) + parser.add_argument( + "--validation_steps", + type=int, + default=100, + help=( + "Run validation every X steps. Validation consists of running the prompt" + " `args.validation_prompt` multiple times: `args.num_validation_images`" + " and logging the images." + ), + ) + parser.add_argument( + "--tracker_project_name", + type=str, + default="train_controlnet", + help=( + "The `project_name` argument passed to Accelerator.init_trackers for" + " more information see https://huggingface.co/docs/accelerate/v0.17.0/en/package_reference/accelerator#accelerate.Accelerator" + ), + ) + + # evaluation arguments + parser.add_argument("--controlnet_path", type=str, default=None, help="Path to pretrained controlnet.") + parser.add_argument("--unet_path", type=str, default=None, help="Path to pretrained unet.") + parser.add_argument("--adapter_name", type=str, default=None, help="Name of the adapter to use.") + parser.add_argument("--vis_overlays", action="store_true", help="Whether to visualize the landmarks.") + + # self-invented arguments + + parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank") + + parser.add_argument( + "--name", + type=str, + help=("The name of the current experiment run, consists of [data]-[prompt]"), + ) + + # BOFT args + parser.add_argument("--use_boft", action="store_true", help="Whether to use BOFT for parameter efficient tuning") + parser.add_argument("--boft_block_num", type=int, default=8, help="The number of BOFT blocks") + parser.add_argument("--boft_block_size", type=int, default=0, help="The size of BOFT blocks") + parser.add_argument("--boft_n_butterfly_factor", type=int, default=0, help="The number of butterfly factors") + parser.add_argument("--boft_dropout", type=float, default=0.1, help="BOFT dropout, only used if use_boft is True") + parser.add_argument( + "--boft_bias", + type=str, + default="none", + help="Bias type for BOFT. Can be 'none', 'all' or 'boft_only', only used if use_boft is True", + ) + + if input_args is not None: + args = parser.parse_args(input_args) + else: + args = parser.parse_args() + + env_local_rank = int(os.environ.get("LOCAL_RANK", "-1")) + + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + if args.dataset_name is None and args.train_data_dir is None: + raise ValueError("Specify either `--dataset_name` or `--train_data_dir`") + + if args.dataset_name is not None and args.train_data_dir is not None: + raise ValueError("Specify only one of `--dataset_name` or `--train_data_dir`") + + if args.proportion_empty_prompts < 0 or args.proportion_empty_prompts > 1: + raise ValueError("`--proportion_empty_prompts` must be in the range [0, 1].") + + if args.validation_prompt is not None and args.validation_image is None: + raise ValueError("`--validation_image` must be set if `--validation_prompt` is set") + + if args.validation_prompt is None and args.validation_image is not None: + raise ValueError("`--validation_prompt` must be set if `--validation_image` is set") + + if ( + args.validation_image is not None + and args.validation_prompt is not None + and len(args.validation_image) != 1 + and len(args.validation_prompt) != 1 + and len(args.validation_image) != len(args.validation_prompt) + ): + raise ValueError( + "Must provide either 1 `--validation_image`, 1 `--validation_prompt`," + " or the same number of `--validation_prompt`s and `--validation_image`s" + ) + + if args.resolution % 8 != 0: + raise ValueError( + "`--resolution` must be divisible by 8 for consistently sized encoded images between the VAE and the controlnet encoder." + ) + + return args diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/dataset.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..1de3c8cc3647e434d664f1553bf71921d101ca6a --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/dataset.py @@ -0,0 +1,207 @@ +import random + +import numpy as np +import torch +import wandb +from datasets import load_dataset +from diffusers import DDIMScheduler +from PIL import Image +from torchvision import transforms +from utils.pipeline_controlnet import LightControlNetPipeline + + +def image_grid(imgs, rows, cols): + assert len(imgs) == rows * cols + + w, h = imgs[0].size + grid = Image.new("RGB", size=(cols * w, rows * h)) + + for i, img in enumerate(imgs): + grid.paste(img, box=(i % cols * w, i // cols * h)) + return grid + + +def log_validation(val_dataset, text_encoder, unet, controlnet, args, accelerator): + pipeline = LightControlNetPipeline.from_pretrained( + args.pretrained_model_name_or_path, + controlnet=accelerator.unwrap_model(controlnet, keep_fp32_wrapper=True), + unet=accelerator.unwrap_model(unet, keep_fp32_wrapper=True).model, + text_encoder=accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True), + safety_checker=None, + revision=args.revision, + ) + + pipeline.scheduler = DDIMScheduler.from_config(pipeline.scheduler.config) + pipeline = pipeline.to(accelerator.device) + + pipeline.set_progress_bar_config(disable=True) + + generator = torch.Generator(device=accelerator.device).manual_seed(args.seed) + + image_logs = [] + + for idx in range(args.num_validation_images): + data = val_dataset[idx] + validation_prompt = data["text"] + validation_image = data["conditioning_pixel_values"] + + image = pipeline( + validation_prompt, + [validation_image], + num_inference_steps=50, + generator=generator, + )[0][0] + + image_logs.append( + { + "validation_image": validation_image, + "image": image, + "validation_prompt": validation_prompt, + } + ) + + for tracker in accelerator.trackers: + formatted_images = [] + + for log in image_logs: + image = log["image"] + validation_prompt = log["validation_prompt"] + validation_image = log["validation_image"] + + formatted_images.append(wandb.Image(validation_image, caption="Controlnet conditioning")) + + image = wandb.Image(image, caption=validation_prompt) + formatted_images.append(image) + + tracker.log({"validation": formatted_images}) + + del pipeline + torch.cuda.empty_cache() + + +def make_dataset(args, tokenizer, accelerator, split="train"): + # Get the datasets: you can either provide your own training and evaluation files (see below) + # or specify a Dataset from the hub (the dataset will be downloaded automatically from the datasets Hub). + + # In distributed training, the load_dataset function guarantees that only one local process can concurrently + # download the dataset. + if args.dataset_name is not None: + # Downloading and loading a dataset from the hub. + dataset = load_dataset( + args.dataset_name, + args.dataset_config_name, + cache_dir=args.cache_dir, + ) + else: + if args.train_data_dir is not None: + dataset = load_dataset( + args.train_data_dir, + cache_dir=args.cache_dir, + ) + # See more about loading custom images at + # https://huggingface.co/docs/datasets/v2.0.0/en/dataset_script + + # Preprocessing the datasets. + # We need to tokenize inputs and targets. + column_names = dataset[split].column_names + + # Get the column names for input/target. + if args.image_column is None: + image_column = column_names[0] + else: + image_column = args.image_column + if image_column not in column_names: + raise ValueError( + f"`--image_column` value '{args.image_column}' not found in dataset columns. Dataset columns are: {', '.join(column_names)}" + ) + + if args.caption_column is None: + caption_column = column_names[1] + else: + caption_column = args.caption_column + if caption_column not in column_names: + raise ValueError( + f"`--caption_column` value '{args.caption_column}' not found in dataset columns. Dataset columns are: {', '.join(column_names)}" + ) + + if args.conditioning_image_column is None: + conditioning_image_column = column_names[2] + else: + conditioning_image_column = args.conditioning_image_column + if conditioning_image_column not in column_names: + raise ValueError( + f"`--conditioning_image_column` value '{args.conditioning_image_column}' not found in dataset columns. Dataset columns are: {', '.join(column_names)}" + ) + + def tokenize_captions(examples, is_train=True): + captions = [] + for caption in examples[caption_column]: + if random.random() < args.proportion_empty_prompts: + captions.append("") + elif isinstance(caption, str): + captions.append(caption) + elif isinstance(caption, (list, np.ndarray)): + # take a random caption if there are multiple + captions.append(random.choice(caption) if is_train else caption[0]) + else: + raise ValueError( + f"Caption column `{caption_column}` should contain either strings or lists of strings." + ) + inputs = tokenizer( + captions, max_length=tokenizer.model_max_length, padding="max_length", truncation=True, return_tensors="pt" + ) + return inputs.input_ids + + image_transforms = transforms.Compose( + [ + transforms.Resize(args.resolution, interpolation=transforms.InterpolationMode.BILINEAR), + transforms.CenterCrop(args.resolution), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + + conditioning_image_transforms = transforms.Compose( + [ + transforms.Resize(args.resolution, interpolation=transforms.InterpolationMode.BILINEAR), + transforms.CenterCrop(args.resolution), + transforms.ToTensor(), + ] + ) + + def preprocess_train(examples): + images = [image.convert("RGB") for image in examples[image_column]] + images = [image_transforms(image) for image in images] + + conditioning_images = [image.convert("RGB") for image in examples[conditioning_image_column]] + conditioning_images = [conditioning_image_transforms(image) for image in conditioning_images] + + examples["pixel_values"] = images + examples["conditioning_pixel_values"] = conditioning_images + examples["input_ids"] = tokenize_captions(examples) + + return examples + + with accelerator.main_process_first(): + if args.max_train_samples is not None: + dataset[split] = dataset[split].shuffle(seed=args.seed).select(range(args.max_train_samples)) + # Set the training transforms + split_dataset = dataset[split].with_transform(preprocess_train) + + return split_dataset + + +def collate_fn(examples): + pixel_values = torch.stack([example["pixel_values"] for example in examples]) + pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float() + + conditioning_pixel_values = torch.stack([example["conditioning_pixel_values"] for example in examples]) + conditioning_pixel_values = conditioning_pixel_values.to(memory_format=torch.contiguous_format).float() + + input_ids = torch.stack([example["input_ids"] for example in examples]) + + return { + "pixel_values": pixel_values, + "conditioning_pixel_values": conditioning_pixel_values, + "input_ids": input_ids, + } diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/light_controlnet.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/light_controlnet.py new file mode 100644 index 0000000000000000000000000000000000000000..69919e53f7af7bffbec0cdc87362183d0850364c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/light_controlnet.py @@ -0,0 +1,263 @@ +# Copyright 2023 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. + + +from dataclasses import dataclass +from typing import Optional, Union + +import torch +from diffusers.configuration_utils import ConfigMixin, register_to_config +from diffusers.models.attention_processor import AttentionProcessor, AttnProcessor +from diffusers.models.modeling_utils import ModelMixin +from diffusers.models.unets.unet_2d_blocks import ( + CrossAttnDownBlock2D, + DownBlock2D, +) +from diffusers.utils import BaseOutput, logging +from torch import nn +from torch.nn import functional as F + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + + +@dataclass +class ControlNetOutput(BaseOutput): + down_block_res_samples: tuple[torch.Tensor] + mid_block_res_sample: torch.Tensor + + +class ControlNetConditioningEmbedding(nn.Module): + """ + Quoting from https://huggingface.co/papers/2302.05543: "Stable Diffusion uses a pre-processing method similar to VQ-GAN + [11] to convert the entire dataset of 512 × 512 images into smaller 64 × 64 “latent images” for stabilized + training. This requires ControlNets to convert image-based conditions to 64 × 64 feature space to match the + convolution size. We use a tiny network E(·) of four convolution layers with 4 × 4 kernels and 2 × 2 strides + (activated by ReLU, channels are 16, 32, 64, 128, initialized with Gaussian weights, trained jointly with the full + model) to encode image-space conditions ... into feature maps ..." + """ + + def __init__( + self, + conditioning_embedding_channels: int, + conditioning_channels: int = 3, + block_out_channels: tuple[int] = (16, 32, 96, 256), + ): + super().__init__() + + self.conv_in = nn.Conv2d(conditioning_channels, block_out_channels[0], kernel_size=3, padding=1) + + self.blocks = nn.ModuleList([]) + + for i in range(len(block_out_channels) - 1): + channel_in = block_out_channels[i] + channel_out = block_out_channels[i + 1] + self.blocks.append(nn.Conv2d(channel_in, channel_in, kernel_size=3, padding=1)) + self.blocks.append(nn.Conv2d(channel_in, channel_out, kernel_size=3, padding=1, stride=2)) + + self.conv_out = zero_module( + nn.Conv2d(block_out_channels[-1], conditioning_embedding_channels, kernel_size=3, padding=1) + ) + + def forward(self, conditioning): + embedding = self.conv_in(conditioning) + embedding = F.silu(embedding) + + for block in self.blocks: + embedding = block(embedding) + embedding = F.silu(embedding) + + embedding = self.conv_out(embedding) + + return embedding + + +class ControlNetModel(ModelMixin, ConfigMixin): + _supports_gradient_checkpointing = True + + @register_to_config + def __init__( + self, + in_channels: int = 4, + out_channels: int = 320, + controlnet_conditioning_channel_order: str = "rgb", + conditioning_embedding_out_channels: Optional[tuple[int]] = (16, 32, 96, 256), + ): + super().__init__() + + # for control image + self.controlnet_cond_embedding = ControlNetConditioningEmbedding( + conditioning_embedding_channels=out_channels, + block_out_channels=conditioning_embedding_out_channels, + ) + + @property + # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors + def attn_processors(self) -> dict[str, AttentionProcessor]: + r""" + Returns: + `dict` of attention processors: A dictionary containing all attention processors used in the model with + indexed by its weight name. + """ + # set recursively + processors = {} + + def fn_recursive_add_processors(name: str, module: torch.nn.Module, processors: dict[str, AttentionProcessor]): + if hasattr(module, "set_processor"): + processors[f"{name}.processor"] = module.processor + + for sub_name, child in module.named_children(): + fn_recursive_add_processors(f"{name}.{sub_name}", child, processors) + + return processors + + for name, module in self.named_children(): + fn_recursive_add_processors(name, module, processors) + + return processors + + # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_attn_processor + def set_attn_processor(self, processor: Union[AttentionProcessor, dict[str, AttentionProcessor]]): + r""" + Parameters: + `processor (`dict` of `AttentionProcessor` or `AttentionProcessor`): + The instantiated processor class or a dictionary of processor classes that will be set as the processor + of **all** `Attention` layers. + In case `processor` is a dict, the key needs to define the path to the corresponding cross attention processor. This is strongly recommended when setting trainable attention processors.: + + """ + count = len(self.attn_processors.keys()) + + if isinstance(processor, dict) and len(processor) != count: + raise ValueError( + f"A dict of processors was passed, but the number of processors {len(processor)} does not match the" + f" number of attention layers: {count}. Please make sure to pass {count} processor classes." + ) + + def fn_recursive_attn_processor(name: str, module: torch.nn.Module, processor): + if hasattr(module, "set_processor"): + if not isinstance(processor, dict): + module.set_processor(processor) + else: + module.set_processor(processor.pop(f"{name}.processor")) + + for sub_name, child in module.named_children(): + fn_recursive_attn_processor(f"{name}.{sub_name}", child, processor) + + for name, module in self.named_children(): + fn_recursive_attn_processor(name, module, processor) + + # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_default_attn_processor + def set_default_attn_processor(self): + """ + Disables custom attention processors and sets the default attention implementation. + """ + self.set_attn_processor(AttnProcessor()) + + # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_attention_slice + def set_attention_slice(self, slice_size): + r""" + Enable sliced attention computation. + + When this option is enabled, the attention module will split the input tensor in slices, to compute attention + in several steps. This is useful to save some memory in exchange for a small speed decrease. + + Args: + slice_size (`str` or `int` or `list(int)`, *optional*, defaults to `"auto"`): + When `"auto"`, halves the input to the attention heads, so attention will be computed in two steps. If + `"max"`, maximum amount of memory will be saved by running only one slice at a time. If a number is + provided, uses as many slices as `attention_head_dim // slice_size`. In this case, `attention_head_dim` + must be a multiple of `slice_size`. + """ + sliceable_head_dims = [] + + def fn_recursive_retrieve_sliceable_dims(module: torch.nn.Module): + if hasattr(module, "set_attention_slice"): + sliceable_head_dims.append(module.sliceable_head_dim) + + for child in module.children(): + fn_recursive_retrieve_sliceable_dims(child) + + # retrieve number of attention layers + for module in self.children(): + fn_recursive_retrieve_sliceable_dims(module) + + num_sliceable_layers = len(sliceable_head_dims) + + if slice_size == "auto": + # half the attention head size is usually a good trade-off between + # speed and memory + slice_size = [dim // 2 for dim in sliceable_head_dims] + elif slice_size == "max": + # make smallest slice possible + slice_size = num_sliceable_layers * [1] + + slice_size = num_sliceable_layers * [slice_size] if not isinstance(slice_size, list) else slice_size + + if len(slice_size) != len(sliceable_head_dims): + raise ValueError( + f"You have provided {len(slice_size)}, but {self.config} has {len(sliceable_head_dims)} different" + f" attention layers. Make sure to match `len(slice_size)` to be {len(sliceable_head_dims)}." + ) + + for i in range(len(slice_size)): + size = slice_size[i] + dim = sliceable_head_dims[i] + if size is not None and size > dim: + raise ValueError(f"size {size} has to be smaller or equal to {dim}.") + + # Recursively walk through all the children. + # Any children which exposes the set_attention_slice method + # gets the message + def fn_recursive_set_attention_slice(module: torch.nn.Module, slice_size: list[int]): + if hasattr(module, "set_attention_slice"): + module.set_attention_slice(slice_size.pop()) + + for child in module.children(): + fn_recursive_set_attention_slice(child, slice_size) + + reversed_slice_size = list(reversed(slice_size)) + for module in self.children(): + fn_recursive_set_attention_slice(module, reversed_slice_size) + + def _set_gradient_checkpointing(self, module, value=False): + if isinstance(module, (CrossAttnDownBlock2D, DownBlock2D)): + module.gradient_checkpointing = value + + def forward( + self, + controlnet_cond: torch.FloatTensor, + ) -> Union[ControlNetOutput, tuple]: + # check channel order + channel_order = self.config.controlnet_conditioning_channel_order + + if channel_order == "rgb": + # in rgb order by default + ... + elif channel_order == "bgr": + controlnet_cond = torch.flip(controlnet_cond, dims=[1]) + else: + raise ValueError(f"unknown `controlnet_conditioning_channel_order`: {channel_order}") + + # 2. pre-process + + controlnet_cond = self.controlnet_cond_embedding(controlnet_cond) + + return controlnet_cond + + +def zero_module(module): + for p in module.parameters(): + nn.init.zeros_(p) + return module diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/pipeline_controlnet.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/pipeline_controlnet.py new file mode 100644 index 0000000000000000000000000000000000000000..b2bd274f3656c0bd11f8b9c9ff1f48c7cc24f910 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/pipeline_controlnet.py @@ -0,0 +1,456 @@ +# Copyright 2023 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. + +from collections.abc import Callable +from dataclasses import dataclass +from typing import Any, Optional, Union + +import numpy as np +import PIL.Image +import torch +from diffusers.pipelines.controlnet.multicontrolnet import MultiControlNetModel +from diffusers.pipelines.controlnet.pipeline_controlnet import StableDiffusionControlNetPipeline +from diffusers.utils import BaseOutput, logging +from torch.nn import functional as F +from utils.light_controlnet import ControlNetModel + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + + +@dataclass +class LightControlNetPipelineOutput(BaseOutput): + """ + Output class for Stable Diffusion pipelines. + + Args: + images (`List[PIL.Image.Image]` or `np.ndarray`) + List of denoised PIL images of length `batch_size` or numpy array of shape `(batch_size, height, width, + num_channels)`. PIL images or numpy array present the denoised images of the diffusion pipeline. + nsfw_content_detected (`List[bool]`) + List of flags denoting whether the corresponding generated image likely represents "not-safe-for-work" + (nsfw) content, or `None` if safety checking could not be performed. + """ + + images: Union[list[PIL.Image.Image], np.ndarray] + nsfw_content_detected: Optional[list[bool]] + + +class LightControlNetPipeline(StableDiffusionControlNetPipeline): + _optional_components = ["safety_checker", "feature_extractor"] + + def check_inputs( + self, + prompt, + image, + callback_steps, + negative_prompt=None, + prompt_embeds=None, + negative_prompt_embeds=None, + controlnet_conditioning_scale=1.0, + ): + if (callback_steps is None) or ( + callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0) + ): + raise ValueError( + f"`callback_steps` has to be a positive integer but is {callback_steps} of type" + f" {type(callback_steps)}." + ) + + if prompt is not None and prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to" + " only forward one of the two." + ) + elif prompt is None and prompt_embeds is None: + raise ValueError( + "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined." + ) + elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)): + raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}") + + if negative_prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if prompt_embeds is not None and negative_prompt_embeds is not None: + if prompt_embeds.shape != negative_prompt_embeds.shape: + raise ValueError( + "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but" + f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`" + f" {negative_prompt_embeds.shape}." + ) + + # `prompt` needs more sophisticated handling when there are multiple + # conditionings. + if isinstance(self.controlnet, MultiControlNetModel): + if isinstance(prompt, list): + logger.warning( + f"You have {len(self.controlnet.nets)} ControlNets and you have passed {len(prompt)}" + " prompts. The conditionings will be fixed across the prompts." + ) + + # Check `image` + is_compiled = hasattr(F, "scaled_dot_product_attention") and isinstance( + self.controlnet, torch._dynamo.eval_frame.OptimizedModule + ) + + if ( + isinstance(self.controlnet, ControlNetModel) + or is_compiled + and isinstance(self.controlnet._orig_mod, ControlNetModel) + ): + self.check_image(image, prompt, prompt_embeds) + elif ( + isinstance(self.controlnet, MultiControlNetModel) + or is_compiled + and isinstance(self.controlnet._orig_mod, MultiControlNetModel) + ): + if not isinstance(image, list): + raise TypeError("For multiple controlnets: `image` must be type `list`") + + # When `image` is a nested list: + # (e.g. [[canny_image_1, pose_image_1], [canny_image_2, pose_image_2]]) + elif any(isinstance(i, list) for i in image): + raise ValueError("A single batch of multiple conditionings are supported at the moment.") + elif len(image) != len(self.controlnet.nets): + raise ValueError( + "For multiple controlnets: `image` must have the same length as the number of controlnets." + ) + + for image_ in image: + self.check_image(image_, prompt, prompt_embeds) + else: + assert False + + # Check `controlnet_conditioning_scale` + if ( + isinstance(self.controlnet, ControlNetModel) + or is_compiled + and isinstance(self.controlnet._orig_mod, ControlNetModel) + ): + if not isinstance(controlnet_conditioning_scale, float): + raise TypeError("For single controlnet: `controlnet_conditioning_scale` must be type `float`.") + elif ( + isinstance(self.controlnet, MultiControlNetModel) + or is_compiled + and isinstance(self.controlnet._orig_mod, MultiControlNetModel) + ): + if isinstance(controlnet_conditioning_scale, list): + if any(isinstance(i, list) for i in controlnet_conditioning_scale): + raise ValueError("A single batch of multiple conditionings are supported at the moment.") + elif isinstance(controlnet_conditioning_scale, list) and len(controlnet_conditioning_scale) != len( + self.controlnet.nets + ): + raise ValueError( + "For multiple controlnets: When `controlnet_conditioning_scale` is specified as `list`, it must have" + " the same length as the number of controlnets" + ) + else: + assert False + + @torch.no_grad() + def __call__( + self, + prompt: Optional[Union[str, list[str]]] = None, + image: Union[ + torch.FloatTensor, + PIL.Image.Image, + np.ndarray, + list[torch.FloatTensor], + list[PIL.Image.Image], + list[np.ndarray], + ] = None, + height: Optional[int] = None, + width: Optional[int] = None, + num_inference_steps: int = 50, + guidance_scale: float = 7.5, + negative_prompt: Optional[Union[str, list[str]]] = None, + num_images_per_prompt: Optional[int] = 1, + eta: float = 0.0, + generator: Optional[Union[torch.Generator, list[torch.Generator]]] = None, + latents: Optional[torch.FloatTensor] = None, + prompt_embeds: Optional[torch.FloatTensor] = None, + negative_prompt_embeds: Optional[torch.FloatTensor] = None, + output_type: Optional[str] = "pil", + return_dict: bool = True, + callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None, + callback_steps: int = 1, + cross_attention_kwargs: Optional[dict[str, Any]] = None, + controlnet_conditioning_scale: Union[float, list[float]] = 1.0, + guess_mode: bool = False, + ): + r""" + Function invoked when calling the pipeline for generation. + + Args: + prompt (`str` or `List[str]`, *optional*): + The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`. + instead. + image (`torch.FloatTensor`, `PIL.Image.Image`, `np.ndarray`, `List[torch.FloatTensor]`, `List[PIL.Image.Image]`, `List[np.ndarray]`,: + `List[List[torch.FloatTensor]]`, `List[List[np.ndarray]]` or `List[List[PIL.Image.Image]]`): + The ControlNet input condition. ControlNet uses this input condition to generate guidance to Unet. If + the type is specified as `Torch.FloatTensor`, it is passed to ControlNet as is. `PIL.Image.Image` can + also be accepted as an image. The dimensions of the output image defaults to `image`'s dimensions. If + height and/or width are passed, `image` is resized according to them. If multiple ControlNets are + specified in init, images must be passed as a list such that each element of the list can be correctly + batched for input to a single controlnet. + height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The height in pixels of the generated image. + width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The width in pixels of the generated image. + num_inference_steps (`int`, *optional*, defaults to 50): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. + guidance_scale (`float`, *optional*, defaults to 7.5): + Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). + `guidance_scale` is defined as `w` of equation 2. of [Imagen + Paper](https://huggingface.co/papers/2205.11487). Guidance scale is enabled by setting `guidance_scale > + 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, + usually at the expense of lower image quality. + negative_prompt (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation. If not defined, one has to pass + `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is + less than `1`). + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + eta (`float`, *optional*, defaults to 0.0): + Corresponds to parameter eta (η) in the DDIM paper: https://huggingface.co/papers/2010.02502. Only applies to + [`schedulers.DDIMScheduler`], will be ignored for others. + generator (`torch.Generator` or `List[torch.Generator]`, *optional*): + One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) + to make generation deterministic. + latents (`torch.FloatTensor`, *optional*): + Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image + generation. Can be used to tweak the same generation with different prompts. If not provided, a latents + tensor will ge generated by sampling using the supplied random `generator`. + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + negative_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input + argument. + output_type (`str`, *optional*, defaults to `"pil"`): + The output format of the generate image. Choose between + [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a + plain tuple. + callback (`Callable`, *optional*): + A function that will be called every `callback_steps` steps during inference. The function will be + called with the following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`. + callback_steps (`int`, *optional*, defaults to 1): + The frequency at which the `callback` function will be called. If not specified, the callback will be + called at every step. + cross_attention_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.cross_attention](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cross_attention.py). + controlnet_conditioning_scale (`float` or `List[float]`, *optional*, defaults to 1.0): + The outputs of the controlnet are multiplied by `controlnet_conditioning_scale` before they are added + to the residual in the original unet. If multiple ControlNets are specified in init, you can set the + corresponding scale as a list. + guess_mode (`bool`, *optional*, defaults to `False`): + In this mode, the ControlNet encoder will try best to recognize the content of the input image even if + you remove all prompts. The `guidance_scale` between 3.0 and 5.0 is recommended. + + Examples: + + Returns: + [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`: + [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple. + When returning a tuple, the first element is a list with the generated images, and the second element is a + list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work" + (nsfw) content, according to the `safety_checker`. + """ + + # 1. Check inputs. Raise error if not correct + self.check_inputs( + prompt, + image, + callback_steps, + negative_prompt, + prompt_embeds, + negative_prompt_embeds, + controlnet_conditioning_scale, + ) + + # 2. Define call parameters + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self._execution_device + # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) + # of the Imagen paper: https://huggingface.co/papers/2205.11487 . `guidance_scale = 1` + # corresponds to doing no classifier free guidance. + do_classifier_free_guidance = guidance_scale > 1.0 + + controlnet = self.controlnet._orig_mod if hasattr(self.controlnet, "_orig_mod") else self.controlnet + + if isinstance(controlnet, MultiControlNetModel) and isinstance(controlnet_conditioning_scale, float): + controlnet_conditioning_scale = [controlnet_conditioning_scale] * len(controlnet.nets) + + # 3. Encode input prompt + text_encoder_lora_scale = ( + cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None + ) + prompt_embeds = self._encode_prompt( + prompt, + device, + num_images_per_prompt, + do_classifier_free_guidance, + negative_prompt, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + lora_scale=text_encoder_lora_scale, + ) + + # 4. Prepare image + if isinstance(controlnet, ControlNetModel): + image = self.prepare_image( + image=image, + width=width, + height=height, + batch_size=batch_size * num_images_per_prompt, + num_images_per_prompt=num_images_per_prompt, + device=device, + dtype=controlnet.dtype, + do_classifier_free_guidance=do_classifier_free_guidance, + guess_mode=guess_mode, + ) + height, width = image.shape[-2:] + elif isinstance(controlnet, MultiControlNetModel): + images = [] + + for image_ in image: + image_ = self.prepare_image( + image=image_, + width=width, + height=height, + batch_size=batch_size * num_images_per_prompt, + num_images_per_prompt=num_images_per_prompt, + device=device, + dtype=controlnet.dtype, + do_classifier_free_guidance=do_classifier_free_guidance, + guess_mode=guess_mode, + ) + + images.append(image_) + + image = images + height, width = image[0].shape[-2:] + else: + assert False + + # 5. Prepare timesteps + self.scheduler.set_timesteps(num_inference_steps, device=device) + timesteps = self.scheduler.timesteps + + # 6. Prepare latent variables + num_channels_latents = self.unet.config.in_channels + latents = self.prepare_latents( + batch_size * num_images_per_prompt, + num_channels_latents, + height, + width, + prompt_embeds.dtype, + device, + generator, + latents, + ) + + # 7. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline + extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta) + + # 8. Denoising loop + num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order + with self.progress_bar(total=num_inference_steps) as progress_bar: + for i, t in enumerate(timesteps): + # expand the latents if we are doing classifier free guidance + latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents + latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) + + # controlnet(s) inference + if guess_mode and do_classifier_free_guidance: + # Infer ControlNet only for the conditional batch. + control_model_input = latents + control_model_input = self.scheduler.scale_model_input(control_model_input, t) + else: + control_model_input = latent_model_input + + # Get the guided hint for the UNet (320 dim) + guided_hint = self.controlnet( + controlnet_cond=image, + ) + + # Predict the noise residual + noise_pred = self.unet( + latent_model_input, + t, + guided_hint=guided_hint, + encoder_hidden_states=prompt_embeds, + )[0] + + # perform guidance + if do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) + + # compute the previous noisy sample x_t -> x_t-1 + latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] + # call the callback, if provided + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + if callback is not None and i % callback_steps == 0: + callback(i, t, latents) + + # If we do sequential model offloading, let's offload unet and controlnet + # manually for max memory savings + if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None: + self.unet.to("cpu") + self.controlnet.to("cpu") + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + if output_type != "latent": + image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] + image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype) + else: + image = latents + has_nsfw_concept = None + + if has_nsfw_concept is None: + do_denormalize = [True] * image.shape[0] + else: + do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept] + + image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize) + + # Offload last model to CPU + if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None: + self.final_offload_hook.offload() + + if not return_dict: + return (image, has_nsfw_concept) + + return LightControlNetPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/tracemalloc.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/tracemalloc.py new file mode 100644 index 0000000000000000000000000000000000000000..26ba300926002d797832ab8dae12053ed6fcd4cf --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/tracemalloc.py @@ -0,0 +1,60 @@ +import gc +import threading + +import psutil +import torch + + +# Converting Bytes to Megabytes +def b2mb(x): + return int(x / 2**20) + + +# This context manager is used to track the peak memory usage of the process +class TorchTracemalloc: + def __enter__(self): + self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + self.device_module = getattr(torch, self.device_type, torch.cuda) + gc.collect() + self.device_module.empty_cache() + self.device_module.reset_peak_memory_stats() # reset the peak gauge to zero + self.begin = self.device_module.memory_allocated() + self.process = psutil.Process() + + self.cpu_begin = self.cpu_mem_used() + self.peak_monitoring = True + peak_monitor_thread = threading.Thread(target=self.peak_monitor_func) + peak_monitor_thread.daemon = True + peak_monitor_thread.start() + return self + + def cpu_mem_used(self): + """get resident set size memory for the current process""" + return self.process.memory_info().rss + + def peak_monitor_func(self): + self.cpu_peak = -1 + + while True: + self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak) + + # can't sleep or will not catch the peak right (this comment is here on purpose) + # time.sleep(0.001) # 1msec + + if not self.peak_monitoring: + break + + def __exit__(self, *exc): + self.peak_monitoring = False + + gc.collect() + self.device_module.empty_cache() + self.end = self.device_module.memory_allocated() + self.peak = self.device_module.max_memory_allocated() + self.used = b2mb(self.end - self.begin) + self.peaked = b2mb(self.peak - self.begin) + + self.cpu_end = self.cpu_mem_used() + self.cpu_used = b2mb(self.cpu_end - self.cpu_begin) + self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin) + # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}") diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/unet_2d_condition.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/unet_2d_condition.py new file mode 100644 index 0000000000000000000000000000000000000000..c6db71c97a5c66c36cb11b2b9d189b572a8f8853 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_controlnet/utils/unet_2d_condition.py @@ -0,0 +1,277 @@ +# Copyright 2023 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. + +from dataclasses import dataclass +from typing import Any, Optional, Union + +import torch +from diffusers.models import UNet2DConditionModel +from diffusers.utils import BaseOutput, logging + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + + +@dataclass +class UNet2DConditionOutput(BaseOutput): + """ + Args: + sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`): + Hidden states conditioned on `encoder_hidden_states` input. Output of last layer of model. + """ + + sample: torch.FloatTensor + + +class UNet2DConditionNewModel(UNet2DConditionModel): + def forward( + self, + sample: torch.FloatTensor, + timestep: Union[torch.Tensor, float], + encoder_hidden_states: torch.Tensor, + guided_hint: Optional[torch.Tensor] = None, + class_labels: Optional[torch.Tensor] = None, + timestep_cond: Optional[torch.Tensor] = None, + attention_mask: Optional[torch.Tensor] = None, + cross_attention_kwargs: Optional[dict[str, Any]] = None, + added_cond_kwargs: Optional[dict[str, torch.Tensor]] = None, + down_block_additional_residuals: Optional[tuple[torch.Tensor]] = None, + mid_block_additional_residual: Optional[torch.Tensor] = None, + encoder_attention_mask: Optional[torch.Tensor] = None, + return_dict: bool = True, + ) -> Union[UNet2DConditionOutput, tuple]: + r""" + Args: + sample (`torch.FloatTensor`): (batch, channel, height, width) noisy inputs tensor + timestep (`torch.FloatTensor` or `float` or `int`): (batch) timesteps + encoder_hidden_states (`torch.FloatTensor`): (batch, sequence_length, feature_dim) encoder hidden states + encoder_attention_mask (`torch.Tensor`): + (batch, sequence_length) cross-attention mask, applied to encoder_hidden_states. True = keep, False = + discard. Mask will be converted into a bias, which adds large negative values to attention scores + corresponding to "discard" tokens. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`models.unet_2d_condition.UNet2DConditionOutput`] instead of a plain tuple. + cross_attention_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.cross_attention](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cross_attention.py). + added_cond_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified includes additonal conditions that can be used for additonal time + embeddings or encoder hidden states projections. See the configurations `encoder_hid_dim_type` and + `addition_embed_type` for more information. + + Returns: + [`~models.unet_2d_condition.UNet2DConditionOutput`] or `tuple`: + [`~models.unet_2d_condition.UNet2DConditionOutput`] if `return_dict` is True, otherwise a `tuple`. When + returning a tuple, the first element is the sample tensor. + """ + # By default samples have to be AT least a multiple of the overall upsampling factor. + # The overall upsampling factor is equal to 2 ** (# num of upsampling layers). + # However, the upsampling interpolation output size can be forced to fit any upsampling size + # on the fly if necessary. + default_overall_up_factor = 2**self.num_upsamplers + + # upsample size should be forwarded when sample is not a multiple of `default_overall_up_factor` + forward_upsample_size = False + upsample_size = None + + if any(s % default_overall_up_factor != 0 for s in sample.shape[-2:]): + logger.info("Forward upsample size to force interpolation output size.") + forward_upsample_size = True + + # ensure attention_mask is a bias, and give it a singleton query_tokens dimension + # expects mask of shape: + # [batch, key_tokens] + # adds singleton query_tokens dimension: + # [batch, 1, key_tokens] + # this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes: + # [batch, heads, query_tokens, key_tokens] (e.g. torch sdp attn) + # [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn) + if attention_mask is not None: + # assume that mask is expressed as: + # (1 = keep, 0 = discard) + # convert mask into a bias that can be added to attention scores: + # (keep = +0, discard = -10000.0) + attention_mask = (1 - attention_mask.to(sample.dtype)) * -10000.0 + attention_mask = attention_mask.unsqueeze(1) + + # convert encoder_attention_mask to a bias the same way we do for attention_mask + if encoder_attention_mask is not None: + encoder_attention_mask = (1 - encoder_attention_mask.to(sample.dtype)) * -10000.0 + encoder_attention_mask = encoder_attention_mask.unsqueeze(1) + + # 0. center input if necessary + if self.config.center_input_sample: + sample = 2 * sample - 1.0 + + # 1. time + timesteps = timestep + if not torch.is_tensor(timesteps): + # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can + # This would be a good case for the `match` statement (Python 3.10+) + is_mps = sample.device.type == "mps" + if isinstance(timestep, float): + dtype = torch.float32 if is_mps else torch.float64 + else: + dtype = torch.int32 if is_mps else torch.int64 + timesteps = torch.tensor([timesteps], dtype=dtype, device=sample.device) + elif len(timesteps.shape) == 0: + timesteps = timesteps[None].to(sample.device) + + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML + timesteps = timesteps.expand(sample.shape[0]) + + t_emb = self.time_proj(timesteps) + + # `Timesteps` does not contain any weights and will always return f32 tensors + # but time_embedding might actually be running in fp16. so we need to cast here. + # there might be better ways to encapsulate this. + t_emb = t_emb.to(dtype=sample.dtype) + + emb = self.time_embedding(t_emb, timestep_cond) + + if self.class_embedding is not None: + if class_labels is None: + raise ValueError("class_labels should be provided when num_class_embeds > 0") + + if self.config.class_embed_type == "timestep": + class_labels = self.time_proj(class_labels) + + # `Timesteps` does not contain any weights and will always return f32 tensors + # there might be better ways to encapsulate this. + class_labels = class_labels.to(dtype=sample.dtype) + + class_emb = self.class_embedding(class_labels).to(dtype=sample.dtype) + + if self.config.class_embeddings_concat: + emb = torch.cat([emb, class_emb], dim=-1) + else: + emb = emb + class_emb + + if self.config.addition_embed_type == "text": + aug_emb = self.add_embedding(encoder_hidden_states) + emb = emb + aug_emb + elif self.config.addition_embed_type == "text_image": + # Kadinsky 2.1 - style + if "image_embeds" not in added_cond_kwargs: + raise ValueError( + f"{self.__class__} has the config param `addition_embed_type` set to 'text_image' which requires the keyword argument `image_embeds` to be passed in `added_cond_kwargs`" + ) + + image_embs = added_cond_kwargs.get("image_embeds") + text_embs = added_cond_kwargs.get("text_embeds", encoder_hidden_states) + + aug_emb = self.add_embedding(text_embs, image_embs) + emb = emb + aug_emb + + if self.time_embed_act is not None: + emb = self.time_embed_act(emb) + + if self.encoder_hid_proj is not None and self.config.encoder_hid_dim_type == "text_proj": + encoder_hidden_states = self.encoder_hid_proj(encoder_hidden_states) + elif self.encoder_hid_proj is not None and self.config.encoder_hid_dim_type == "text_image_proj": + # Kadinsky 2.1 - style + if "image_embeds" not in added_cond_kwargs: + raise ValueError( + f"{self.__class__} has the config param `encoder_hid_dim_type` set to 'text_image_proj' which requires the keyword argument `image_embeds` to be passed in `added_conditions`" + ) + + image_embeds = added_cond_kwargs.get("image_embeds") + encoder_hidden_states = self.encoder_hid_proj(encoder_hidden_states, image_embeds) + + # 2. pre-process and insert conditioning (ControlNet) + # Note: the added "guided_hint" is the only difference between this implementation and the original UNet2DConditionModel + sample = self.conv_in(sample) + sample = guided_hint + sample if guided_hint is not None else sample + + # 3. down + down_block_res_samples = (sample,) + for downsample_block in self.down_blocks: + if hasattr(downsample_block, "has_cross_attention") and downsample_block.has_cross_attention: + sample, res_samples = downsample_block( + hidden_states=sample, + temb=emb, + encoder_hidden_states=encoder_hidden_states, + attention_mask=attention_mask, + cross_attention_kwargs=cross_attention_kwargs, + encoder_attention_mask=encoder_attention_mask, + ) + else: + sample, res_samples = downsample_block(hidden_states=sample, temb=emb) + + down_block_res_samples += res_samples + + if down_block_additional_residuals is not None: + new_down_block_res_samples = () + + for down_block_res_sample, down_block_additional_residual in zip( + down_block_res_samples, down_block_additional_residuals + ): + down_block_res_sample = down_block_res_sample + down_block_additional_residual + new_down_block_res_samples = new_down_block_res_samples + (down_block_res_sample,) + + down_block_res_samples = new_down_block_res_samples + + # 4. mid + if self.mid_block is not None: + sample = self.mid_block( + sample, + emb, + encoder_hidden_states=encoder_hidden_states, + attention_mask=attention_mask, + cross_attention_kwargs=cross_attention_kwargs, + encoder_attention_mask=encoder_attention_mask, + ) + + if mid_block_additional_residual is not None: + sample = sample + mid_block_additional_residual + + # 5. up + for i, upsample_block in enumerate(self.up_blocks): + is_final_block = i == len(self.up_blocks) - 1 + + res_samples = down_block_res_samples[-len(upsample_block.resnets) :] + down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)] + + # if we have not reached the final block and need to forward the + # upsample size, we do it here + if not is_final_block and forward_upsample_size: + upsample_size = down_block_res_samples[-1].shape[2:] + + if hasattr(upsample_block, "has_cross_attention") and upsample_block.has_cross_attention: + sample = upsample_block( + hidden_states=sample, + temb=emb, + res_hidden_states_tuple=res_samples, + encoder_hidden_states=encoder_hidden_states, + cross_attention_kwargs=cross_attention_kwargs, + upsample_size=upsample_size, + attention_mask=attention_mask, + encoder_attention_mask=encoder_attention_mask, + ) + else: + sample = upsample_block( + hidden_states=sample, temb=emb, res_hidden_states_tuple=res_samples, upsample_size=upsample_size + ) + + # 6. post-process + if self.conv_norm_out: + sample = self.conv_norm_out(sample) + sample = self.conv_act(sample) + sample = self.conv_out(sample) + + if not return_dict: + return (sample,) + + return UNet2DConditionOutput(sample=sample) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/.gitignore b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..8fce603003c1e5857013afec915ace9fc8bcdb8d --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/.gitignore @@ -0,0 +1 @@ +data/ diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/__init__.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/boft_dreambooth.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/boft_dreambooth.md new file mode 100644 index 0000000000000000000000000000000000000000..dd5f8203ef0669a763078468dd41461e78e93b6e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/boft_dreambooth.md @@ -0,0 +1,176 @@ + + +# DreamBooth fine-tuning with BOFT + +This guide demonstrates how to use BOFT, an orthogonal fine-tuning method, to fine-tune Dreambooth with either `stabilityai/stable-diffusion-2-1` or `runwayml/stable-diffusion-v1-5` model. + +By using BOFT from 🤗 PEFT, we can significantly reduce the number of trainable parameters while still achieving impressive results in various fine-tuning tasks across different foundation models. BOFT enhances model efficiency by integrating full-rank orthogonal matrices with a butterfly structure into specific model blocks, such as attention blocks, mirroring the approach used in LoRA. During fine-tuning, only these inserted matrices are trained, leaving the original model parameters untouched. During inference, the trainable BOFT parameters can be merged into the original model, eliminating any additional computational costs. + +As a member of the **orthogonal finetuning** class, BOFT presents a systematic and principled method for fine-tuning. It possesses several unique properties and has demonstrated superior performance compared to LoRA in a variety of scenarios. For further details on BOFT, please consult the [PEFT's GitHub repo's concept guide OFT](https://https://huggingface.co/docs/peft/index), the [original BOFT paper](https://huggingface.co/papers/2311.06243) and the [original OFT paper](https://huggingface.co/papers/2306.07280). + +In this guide we provide a Dreambooth fine-tuning script that is available in [PEFT's GitHub repo examples](https://github.com/huggingface/peft/tree/main/examples/boft_dreambooth). This implementation is adapted from [peft's lora_dreambooth](https://github.com/huggingface/peft/tree/main/examples/lora_dreambooth). You can try it out and finetune on your custom images. + +## Set up your environment + +Start by cloning the PEFT repository: + +```bash +git clone --recursive https://github.com/huggingface/peft +``` + +Navigate to the directory containing the training scripts for fine-tuning Dreambooth with BOFT: + +```bash +cd peft/examples/boft_dreambooth +``` + +Set up your environment: install PEFT, and all the required libraries. At the time of writing this guide we recommend installing PEFT from source. The following environment setup should work on A100 and H100: + +### CUDA +```bash +conda create --name peft python=3.10 +conda activate peft +conda install pytorch==2.1.2 torchvision==0.16.2 torchaudio==2.1.2 pytorch-cuda=11.8 -c pytorch -c nvidia +conda install xformers -c xformers +pip install -r requirements.txt +pip install git+https://github.com/huggingface/peft +``` +The follwing environment setuo is validated work on Intel XPU: + +### Intel XPU +```bash +conda create --name peft python=3.10 +conda activate peft +pip install pip install torch==2.8.0.dev20250615+xpu torchvision==0.23.0.dev20250615+xpu torchaudio==2.8.0.dev20250615+xpu --index-url https://download.pytorch.org/whl/nightly/xpu --no-cache-dir +pip install -r requirements.txt +pip install git+https://github.com/huggingface/peft +``` + +## Download the data + +[dreambooth](https://github.com/google/dreambooth) dataset should have been automatically cloned in the following structure when running the training script. + +``` +boft_dreambooth +├── data +│ ├── data_dir +│ └── dreambooth +│ └── data +│ ├── backpack +│ └── backpack_dog +│ ... +``` + +You can also put your custom images into `boft_dreambooth/data/dreambooth`. + +## Finetune Dreambooth with BOFT + +```bash +./train_dreambooth.sh +``` + +or using the following script arguments: + +```bash +export MODEL_NAME="runwayml/stable-diffusion-v1-5" +export INSTANCE_DIR="path-to-instance-images" +export CLASS_DIR="path-to-class-images" +export OUTPUT_DIR="path-to-save-model" +``` + +Here: + +- `INSTANCE_DIR`: The directory containing the images that you intend to use for training your model. +- `CLASS_DIR`: The directory containing class-specific images. In this example, we use prior preservation to avoid overfitting and language-drift. For prior preservation, you need other images of the same class as part of the training process. However, these images can be generated and the training script will save them to a local path you specify here. +- `OUTPUT_DIR`: The destination folder for storing the trained model's weights. + +To learn more about DreamBooth fine-tuning with prior-preserving loss, check out the [Diffusers documentation](https://huggingface.co/docs/diffusers/training/dreambooth#finetuning-with-priorpreserving-loss). + +Launch the training script with `accelerate` and pass hyperparameters, as well as LoRa-specific arguments to it such as: + +- `use_boft`: Enables BOFT in the training script. +- `boft_block_size`: the BOFT matrix block size across different layers, expressed in `int`. Smaller block size results in sparser update matrices with fewer trainable parameters. **Note**, please choose it to be dividable to most layer `in_features` dimension, e.g., 4, 8, 16. Also, you can only specify either `boft_block_size` or `boft_block_num`, but not both simultaneously, because `boft_block_size` x `boft_block_num` = layer dimension. +- `boft_block_num`: the number of BOFT matrix blocks across different layers, expressed in `int`. Fewer blocks result in sparser update matrices with fewer trainable parameters. **Note**, please choose it to be dividable to most layer `in_features` dimension, e.g., 4, 8, 16. Also, you can only specify either `boft_block_size` or `boft_block_num`, but not both simultaneously, because `boft_block_size` x `boft_block_num` = layer dimension. +- `boft_n_butterfly_factor`: the number of butterfly factors. **Note**, for `boft_n_butterfly_factor=1`, BOFT is the same as vanilla OFT, for `boft_n_butterfly_factor=2`, the effective block size of OFT becomes twice as big and the number of blocks becomes half. +- `bias`: specify if the `bias` parameters should be trained. Can be `none`, `all` or `boft_only`. +- `boft_dropout`: specify the probability of multiplicative dropout. + +Here's what the full set of script arguments may look like: + +```bash +PEFT_TYPE="boft" +BLOCK_NUM=8 +BLOCK_SIZE=0 +N_BUTTERFLY_FACTOR=1 + +VALIDATION_PROMPT=${PROMPT_LIST[@]} +INSTANCE_PROMPT="a photo of ${UNIQUE_TOKEN} ${CLASS_TOKEN}" +CLASS_PROMPT="a photo of ${CLASS_TOKEN}" + +export MODEL_NAME="stabilityai/stable-diffusion-2-1" +# export MODEL_NAME="runwayml/stable-diffusion-v1-5" +export PROJECT_NAME="dreambooth_${PEFT_TYPE}" +export RUN_NAME="${SELECTED_SUBJECT}_${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}" +export INSTANCE_DIR="./data/dreambooth/dataset/${SELECTED_SUBJECT}" +export CLASS_DIR="./data/class_data/${CLASS_TOKEN}" +export OUTPUT_DIR="./data/output/${PEFT_TYPE}" + + +accelerate launch train_dreambooth.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --class_data_dir="$CLASS_DIR" \ + --output_dir=$OUTPUT_DIR \ + --wandb_project_name=$PROJECT_NAME \ + --wandb_run_name=$RUN_NAME \ + --with_prior_preservation --prior_loss_weight=1.0 \ + --instance_prompt="$INSTANCE_PROMPT" \ + --validation_prompt="$VALIDATION_PROMPT" \ + --class_prompt="$CLASS_PROMPT" \ + --resolution=512 \ + --train_batch_size=1 \ + --num_dataloader_workers=2 \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --num_class_images=200 \ + --use_boft \ + --boft_block_num=$BLOCK_NUM \ + --boft_block_size=$BLOCK_SIZE \ + --boft_n_butterfly_factor=$N_BUTTERFLY_FACTOR \ + --boft_dropout=0.1 \ + --boft_bias="boft_only" \ + --learning_rate=3e-5 \ + --max_train_steps=1010 \ + --checkpointing_steps=200 \ + --validation_steps=200 \ + --enable_xformers_memory_efficient_attention \ + --report_to="wandb" \ +``` + +or use this training script: + +```bash +./train_dreambooth.sh $idx +``` + +with the `$idx` corresponds to different subjects. + +If you are running this script on Windows, you may need to set the `--num_dataloader_workers` to 0. + +## Inference with a single adapter + +To run inference with the fine-tuned model, simply run the jupyter notebook `dreambooth_inference.ipynb` for visualization with `jupyter notebook` under `./examples/boft_dreambooth`. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/dreambooth_inference.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/dreambooth_inference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..3fa2bbbf3c933eea891c710e79c29a9ffdfffde1 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/dreambooth_inference.ipynb @@ -0,0 +1,180 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "acab479f", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "import torch\n", + "from accelerate.logging import get_logger\n", + "from diffusers import StableDiffusionPipeline\n", + "from diffusers.utils import check_min_version\n", + "\n", + "from peft import PeftModel\n", + "\n", + "# Will error if the minimal version of diffusers is not installed. Remove at your own risks.\n", + "check_min_version(\"0.10.0.dev0\")\n", + "\n", + "logger = get_logger(__name__)\n", + "\n", + "MODEL_NAME = \"stabilityai/stable-diffusion-2-1\"\n", + "# MODEL_NAME=\"runwayml/stable-diffusion-v1-5\"\n", + "\n", + "PEFT_TYPE=\"boft\"\n", + "BLOCK_NUM=8\n", + "BLOCK_SIZE=0\n", + "N_BUTTERFLY_FACTOR=1\n", + "SELECTED_SUBJECT=\"backpack\"\n", + "EPOCH_IDX = 200\n", + "\n", + "PROJECT_NAME=f\"dreambooth_{PEFT_TYPE}\"\n", + "RUN_NAME=f\"{SELECTED_SUBJECT}_{PEFT_TYPE}_{BLOCK_NUM}{BLOCK_SIZE}{N_BUTTERFLY_FACTOR}\"\n", + "OUTPUT_DIR=f\"./data/output/{PEFT_TYPE}\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06cfd506", + "metadata": {}, + "outputs": [], + "source": [ + "def get_boft_sd_pipeline(\n", + " ckpt_dir, base_model_name_or_path=None, epoch=int, dtype=torch.float32, device=\"auto\", adapter_name=\"default\"\n", + "):\n", + " if device == \"auto\":\n", + " device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "\n", + " if base_model_name_or_path is None:\n", + " raise ValueError(\"Please specify the base model name or path\")\n", + "\n", + " pipe = StableDiffusionPipeline.from_pretrained(\n", + " base_model_name_or_path, torch_dtype=dtype, requires_safety_checker=False\n", + " ).to(device)\n", + " \n", + " load_adapter(pipe, ckpt_dir, epoch, adapter_name)\n", + "\n", + " if dtype in (torch.float16, torch.bfloat16):\n", + " pipe.unet.half()\n", + " pipe.text_encoder.half()\n", + "\n", + " pipe.to(device)\n", + " return pipe\n", + "\n", + "\n", + "def load_adapter(pipe, ckpt_dir, epoch, adapter_name=\"default\"):\n", + " \n", + " unet_sub_dir = os.path.join(ckpt_dir, f\"unet/{epoch}\", adapter_name)\n", + " text_encoder_sub_dir = os.path.join(ckpt_dir, f\"text_encoder/{epoch}\", adapter_name)\n", + " \n", + " if isinstance(pipe.unet, PeftModel):\n", + " pipe.unet.load_adapter(unet_sub_dir, adapter_name=adapter_name)\n", + " else:\n", + " pipe.unet = PeftModel.from_pretrained(pipe.unet, unet_sub_dir, adapter_name=adapter_name)\n", + " \n", + " if os.path.exists(text_encoder_sub_dir):\n", + " if isinstance(pipe.text_encoder, PeftModel):\n", + " pipe.text_encoder.load_adapter(text_encoder_sub_dir, adapter_name=adapter_name)\n", + " else:\n", + " pipe.text_encoder = PeftModel.from_pretrained(pipe.text_encoder, text_encoder_sub_dir, adapter_name=adapter_name)\n", + " \n", + "\n", + "def set_adapter(pipe, adapter_name):\n", + " pipe.unet.set_adapter(adapter_name)\n", + " if isinstance(pipe.text_encoder, PeftModel):\n", + " pipe.text_encoder.set_adapter(adapter_name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98a0d8ac", + "metadata": {}, + "outputs": [], + "source": [ + "prompt = \"a photo of sks backpack on a wooden floor\"\n", + "negative_prompt = \"low quality, blurry, unfinished\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4e888d2", + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "pipe = get_boft_sd_pipeline(OUTPUT_DIR, MODEL_NAME, EPOCH_IDX, adapter_name=RUN_NAME)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1c1a1c0", + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a1aafdf-8cf7-4e47-9471-26478034245e", + "metadata": {}, + "outputs": [], + "source": [ + "# load and reset another adapter\n", + "# WARNING: requires training DreamBooth with `boft_bias=None`\n", + "\n", + "SELECTED_SUBJECT=\"dog\"\n", + "EPOCH_IDX = 200\n", + "RUN_NAME=f\"{SELECTED_SUBJECT}_{PEFT_TYPE}_{BLOCK_NUM}{BLOCK_SIZE}{N_BUTTERFLY_FACTOR}\"\n", + "\n", + "load_adapter(pipe, OUTPUT_DIR, epoch=EPOCH_IDX, adapter_name=RUN_NAME)\n", + "set_adapter(pipe, adapter_name=RUN_NAME)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c7091ad0-2005-4528-afc1-4f9d70a9a535", + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "prompt = \"a photo of sks dog running on the beach\"\n", + "negative_prompt = \"low quality, blurry, unfinished\"\n", + "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n", + "image" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:peft] *", + "language": "python", + "name": "conda-env-peft-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..67eac706b928821dd8ba69cdf71d9bf3bfd4a49d --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/requirements.txt @@ -0,0 +1,13 @@ +transformers==4.54.0 +accelerate==1.9.0 +evaluate +tqdm +datasets==4.0.0 +diffusers==0.34.0 +Pillow +huggingface_hub +safetensors +nb_conda_kernels +ipykernel +ipywidgets +wandb==0.21.0 diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/train_dreambooth.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/train_dreambooth.py new file mode 100644 index 0000000000000000000000000000000000000000..44a19b3d7e52f9d1c5b8dab48e0e46c066b2cd23 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/train_dreambooth.py @@ -0,0 +1,624 @@ +# Copyright 2023-present the HuggingFace Inc. team. +# +# 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. + +# The implementation is based on "Parameter-Efficient Orthogonal Finetuning +# via Butterfly Factorization" (https://huggingface.co/papers/2311.06243) in ICLR 2024. + +import hashlib +import itertools +import logging +import math +import os +from contextlib import nullcontext +from pathlib import Path + +import datasets +import diffusers +import numpy as np +import torch +import torch.nn.functional as F +import torch.utils.checkpoint +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import ProjectConfiguration, set_seed +from diffusers import ( + AutoencoderKL, + DDIMScheduler, + DiffusionPipeline, + DPMSolverMultistepScheduler, + UNet2DConditionModel, +) +from diffusers.optimization import get_scheduler +from diffusers.utils import check_min_version +from diffusers.utils.import_utils import is_xformers_available +from huggingface_hub import Repository +from tqdm.auto import tqdm +from transformers import AutoTokenizer +from utils.args_loader import ( + get_full_repo_name, + import_model_class_from_model_name_or_path, + parse_args, +) +from utils.dataset import DreamBoothDataset, PromptDataset, collate_fn +from utils.tracemalloc import TorchTracemalloc, b2mb + +from peft import BOFTConfig, get_peft_model + + +# Will error if the minimal version of diffusers is not installed. Remove at your own risks. +check_min_version("0.16.0.dev0") + +logger = get_logger(__name__) + +UNET_TARGET_MODULES = ["to_q", "to_v", "to_k", "query", "value", "key", "to_out.0", "add_k_proj", "add_v_proj"] +TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"] + + +def save_adaptor(accelerator, step, unet, text_encoder, args): + unwarpped_unet = accelerator.unwrap_model(unet) + unwarpped_unet.save_pretrained( + os.path.join(args.output_dir, f"unet/{step}"), state_dict=accelerator.get_state_dict(unet) + ) + if args.train_text_encoder: + unwarpped_text_encoder = accelerator.unwrap_model(text_encoder) + unwarpped_text_encoder.save_pretrained( + os.path.join(args.output_dir, f"text_encoder/{step}"), + state_dict=accelerator.get_state_dict(text_encoder), + ) + + +def main(args): + validation_prompts = list(filter(None, args.validation_prompt[0].split("."))) + + logging_dir = Path(args.output_dir, args.logging_dir) + accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir) + + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_dir=accelerator_project_config, + ) + if args.report_to == "wandb": + import wandb + + wandb_init = { + "wandb": { + "name": args.wandb_run_name, + "mode": "online", + } + } + + # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate + # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models. + # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate. + if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1: + raise ValueError( + "Gradient accumulation is not supported when training the text encoder in distributed training. " + "Please set gradient_accumulation_steps to 1. This feature will be supported in the future." + ) + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + datasets.utils.logging.set_verbosity_warning() + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + datasets.utils.logging.set_verbosity_error() + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + global_seed = hash(args.wandb_run_name) % (2**32) + set_seed(global_seed) + + # Generate class images if prior preservation is enabled. + if args.with_prior_preservation: + class_images_dir = Path(args.class_data_dir) + if not class_images_dir.exists(): + class_images_dir.mkdir(parents=True) + cur_class_images = len(list(class_images_dir.iterdir())) + + if cur_class_images < args.num_class_images: + dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32 + if args.prior_generation_precision == "fp32": + dtype = torch.float32 + elif args.prior_generation_precision == "fp16": + dtype = torch.float16 + elif args.prior_generation_precision == "bf16": + dtype = torch.bfloat16 + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + dtype=dtype, + safety_checker=None, + revision=args.revision, + ) + pipeline.set_progress_bar_config(disable=True) + + num_new_images = args.num_class_images - cur_class_images + logger.info(f"Number of class images to sample: {num_new_images}.") + + sample_dataset = PromptDataset(args.class_prompt, num_new_images) + sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size) + + sample_dataloader = accelerator.prepare(sample_dataloader) + pipeline.to(accelerator.device) + + for example in tqdm( + sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process + ): + images = pipeline(example["prompt"]).images + + for i, image in enumerate(images): + hash_image = hashlib.sha1(image.tobytes()).hexdigest() + image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg" + image.save(image_filename) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + # Handle the repository creation + if accelerator.is_main_process: + if args.push_to_hub: + if args.hub_model_id is None: + repo_name = get_full_repo_name(Path(args.output_dir).name, token=args.hub_token) + else: + repo_name = args.hub_model_id + repo = Repository(args.output_dir, clone_from=repo_name) + + with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore: + if "step_*" not in gitignore: + gitignore.write("step_*\n") + if "epoch_*" not in gitignore: + gitignore.write("epoch_*\n") + elif args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + # Load the tokenizer + if args.tokenizer_name: + tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False) + elif args.pretrained_model_name_or_path: + tokenizer = AutoTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.revision, + use_fast=False, + ) + + # import correct text encoder class + text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision) + + # Load scheduler and models + noise_scheduler = DDIMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler") + + text_encoder = text_encoder_cls.from_pretrained( + args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision + ) + vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision) + unet = UNet2DConditionModel.from_pretrained( + args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision + ) + + if args.use_boft: + config = BOFTConfig( + boft_block_size=args.boft_block_size, + boft_block_num=args.boft_block_num, + boft_n_butterfly_factor=args.boft_n_butterfly_factor, + target_modules=UNET_TARGET_MODULES, + boft_dropout=args.boft_dropout, + bias=args.boft_bias, + ) + unet = get_peft_model(unet, config, adapter_name=args.wandb_run_name) + unet.print_trainable_parameters() + + vae.requires_grad_(False) + unet.train() + + if args.train_text_encoder and args.use_boft: + config = BOFTConfig( + boft_block_size=args.boft_block_size, + boft_block_num=args.boft_block_num, + boft_n_butterfly_factor=args.boft_n_butterfly_factor, + target_modules=TEXT_ENCODER_TARGET_MODULES, + boft_dropout=args.boft_dropout, + bias=args.boft_bias, + ) + text_encoder = get_peft_model(text_encoder, config, adapter_name=args.wandb_run_name) + text_encoder.print_trainable_parameters() + text_encoder.train() + else: + text_encoder.requires_grad_(False) + + # For mixed precision training we cast the text_encoder and vae weights to half-precision + # as these models are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + # Move unet, vae and text_encoder to device and cast to weight_dtype + unet.to(accelerator.device, dtype=weight_dtype) + vae.to(accelerator.device, dtype=weight_dtype) + text_encoder.to(accelerator.device, dtype=weight_dtype) + + if args.enable_xformers_memory_efficient_attention: + if accelerator.device.type == "xpu": + logger.warning("XPU hasn't support xformers yet, ignore it.") + elif is_xformers_available(): + unet.enable_xformers_memory_efficient_attention() + else: + raise ValueError("xformers is not available. Make sure it is installed correctly") + + if args.gradient_checkpointing: + unet.enable_gradient_checkpointing() + # below fails when using boft so commenting it out + if args.train_text_encoder and not args.use_boft: + text_encoder.gradient_checkpointing_enable() + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.allow_tf32 and torch.cuda.is_available(): + torch.backends.cuda.matmul.allow_tf32 = True + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes + ) + + # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB GPUs + if args.use_8bit_adam: + try: + import bitsandbytes as bnb + except ImportError: + raise ImportError( + "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`." + ) + + optimizer_class = bnb.optim.AdamW8bit + else: + optimizer_class = torch.optim.AdamW + + # Optimizer creation + params_to_optimize = [param for param in unet.parameters() if param.requires_grad] + + if args.train_text_encoder: + params_to_optimize += [param for param in text_encoder.parameters() if param.requires_grad] + + optimizer = optimizer_class( + params_to_optimize, + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + # Download the official dreambooth dataset from the official repository: https://github.com/google/dreambooth.git + data_path = os.path.join(os.getcwd(), "data", "dreambooth") + if not os.path.exists(data_path): + os.makedirs(os.path.join(os.getcwd(), "data"), exist_ok=True) + os.system(f"git clone https://github.com/google/dreambooth.git '{data_path}'") + + # Dataset and DataLoaders creation: + train_dataset = DreamBoothDataset( + instance_data_root=args.instance_data_dir, + instance_prompt=args.instance_prompt, + class_data_root=args.class_data_dir if args.with_prior_preservation else None, + class_prompt=args.class_prompt, + tokenizer=tokenizer, + size=args.resolution, + center_crop=args.center_crop, + ) + + train_dataloader = torch.utils.data.DataLoader( + train_dataset, + batch_size=args.train_batch_size, + shuffle=True, + collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation), + num_workers=args.num_dataloader_workers, + ) + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, + num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, + num_cycles=args.lr_num_cycles, + power=args.lr_power, + ) + + # Prepare everything with our `accelerator`. + if args.train_text_encoder: + unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, text_encoder, optimizer, train_dataloader, lr_scheduler + ) + else: + unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, optimizer, train_dataloader, lr_scheduler + ) + + # For mixed precision training we cast the text_encoder and vae weights to half-precision + # as these models are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + # Move vae and text_encoder to device and cast to weight_dtype + vae.to(accelerator.device, dtype=weight_dtype) + if not args.train_text_encoder: + text_encoder.to(accelerator.device, dtype=weight_dtype) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + accelerator.init_trackers(args.wandb_project_name, config=vars(args), init_kwargs=wandb_init) + + # Train! + total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + + logger.info("***** Running training *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num batches each epoch = {len(train_dataloader)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {args.max_train_steps}") + global_step = 0 + first_epoch = 0 + + # Potentially load in the weights and states from a previous save + if args.resume_from_checkpoint: + if args.resume_from_checkpoint != "latest": + path = os.path.basename(args.resume_from_checkpoint) + else: + # Get the most recent checkpoint + dirs = os.listdir(args.output_dir) + dirs = [d for d in dirs if d.startswith("checkpoint")] + dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) + path = dirs[-1] if len(dirs) > 0 else None + accelerator.print(f"Resuming from checkpoint {path}") + accelerator.load_state(os.path.join(args.output_dir, path)) + global_step = int(path.split("-")[1]) + + resume_global_step = global_step * args.gradient_accumulation_steps + first_epoch = resume_global_step // num_update_steps_per_epoch + resume_step = resume_global_step % num_update_steps_per_epoch + + # Only show the progress bar once on each machine. + progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process) + progress_bar.set_description("Steps") + + if args.train_text_encoder: + text_encoder.train() + + for epoch in range(first_epoch, args.num_train_epochs): + unet.train() + + with TorchTracemalloc() if not args.no_tracemalloc else nullcontext() as tracemalloc: + for step, batch in enumerate(train_dataloader): + # Skip steps until we reach the resumed step + if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step: + if step % args.gradient_accumulation_steps == 0: + progress_bar.update(1) + if args.report_to == "wandb": + accelerator.print(progress_bar) + continue + + with accelerator.accumulate(unet): + # Convert images to latent space + latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample() + latents = latents * vae.config.scaling_factor + + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + bsz = latents.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint( + 0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device + ) + timesteps = timesteps.long() + + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + # Get the text embedding for conditioning + encoder_hidden_states = text_encoder(batch["input_ids"])[0] + + # Predict the noise residual + model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample + + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + if args.with_prior_preservation: + # Chunk the noise and model_pred into two parts and compute the loss on each part separately. + model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0) + target, target_prior = torch.chunk(target, 2, dim=0) + + # Compute instance loss + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + # Compute prior loss + prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean") + + # Add the prior loss to the instance loss. + loss = loss + args.prior_loss_weight * prior_loss + else: + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + accelerator.backward(loss) + + if accelerator.sync_gradients: + params_to_clip = ( + itertools.chain(unet.parameters(), text_encoder.parameters()) + if args.train_text_encoder + else unet.parameters() + ) + accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm) + + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + if args.report_to == "wandb": + accelerator.print(progress_bar) + global_step += 1 + + if global_step % args.checkpointing_steps == 0 and global_step != 0: + if accelerator.is_main_process: + save_adaptor(accelerator, global_step, unet, text_encoder, args) + + logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + accelerator.log(logs, step=global_step) + + if ( + args.validation_prompt is not None + and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0 + and global_step > 10 + ): + unet.eval() + + logger.info( + f"Running validation... \n Generating {len(validation_prompts)} images with prompt:" + f" {validation_prompts[0]}, ......" + ) + # create pipeline + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + safety_checker=None, + revision=args.revision, + ) + # set `keep_fp32_wrapper` to True because we do not want to remove + # mixed precision hooks while we are still training + pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True) + pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True) + pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config) + pipeline = pipeline.to(accelerator.device) + pipeline.set_progress_bar_config(disable=True) + + # run inference + if args.seed is not None: + generator = torch.Generator(device=accelerator.device).manual_seed(args.seed) + else: + generator = None + # images = [] + # for _ in range(args.num_validation_images): + # image = pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0] + # images.append(image) + + images = [] + val_img_dir = os.path.join( + args.output_dir, + f"validation/{global_step}", + args.wandb_run_name, + ) + os.makedirs(val_img_dir, exist_ok=True) + + for val_promot in validation_prompts: + image = pipeline(val_promot, num_inference_steps=50, generator=generator).images[0] + image.save(os.path.join(val_img_dir, f"{'_'.join(val_promot.split(' '))}.png"[1:])) + images.append(image) + + for tracker in accelerator.trackers: + if tracker.name == "tensorboard": + np_images = np.stack([np.asarray(img) for img in images]) + tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC") + if tracker.name == "wandb": + import wandb + + tracker.log( + { + "validation": [ + wandb.Image(image, caption=f"{i}: {validation_prompts[i]}") + for i, image in enumerate(images) + ] + } + ) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + if global_step >= args.max_train_steps: + break + + # Printing the accelerator memory usage details such as allocated memory, peak memory, and total memory usage + if not args.no_tracemalloc: + accelerator.print( + f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}" + ) + + accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}") + accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}") + accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}") + accelerator.print( + f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}" + ) + + if args.push_to_hub: + repo.push_to_hub(commit_message="End of training", blocking=False, auto_lfs_prune=True) + accelerator.end_training() + + +if __name__ == "__main__": + args = parse_args() + main(args) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/train_dreambooth.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/train_dreambooth.sh new file mode 100644 index 0000000000000000000000000000000000000000..f886a4fd1ddf5823213d755da5a6ac5810cd3463 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/train_dreambooth.sh @@ -0,0 +1,191 @@ +IDX=$1 +PROMPT_IDX=$((IDX % 25)) +CLASS_IDX=$((IDX % 30)) + +# Define the UNIQUE_TOKEN, CLASS_TOKENs, and SUBJECT_NAMES +UNIQUE_TOKEN="qwe" + +SUBJECT_NAMES=( + "backpack" "backpack_dog" "bear_plushie" "berry_bowl" "can" + "candle" "cat" "cat2" "clock" "colorful_sneaker" + "dog" "dog2" "dog3" "dog5" "dog6" + "dog7" "dog8" "duck_toy" "fancy_boot" "grey_sloth_plushie" + "monster_toy" "pink_sunglasses" "poop_emoji" "rc_car" "red_cartoon" + "robot_toy" "shiny_sneaker" "teapot" "vase" "wolf_plushie" +) + +CLASS_TOKENs=( + "backpack" "backpack" "stuffed animal" "bowl" "can" + "candle" "cat" "cat" "clock" "sneaker" + "dog" "dog" "dog" "dog" "dog" + "dog" "dog" "toy" "boot" "stuffed animal" + "toy" "glasses" "toy" "toy" "cartoon" + "toy" "sneaker" "teapot" "vase" "stuffed animal" +) + +CLASS_TOKEN=${CLASS_TOKENs[$CLASS_IDX]} +SELECTED_SUBJECT=${SUBJECT_NAMES[$CLASS_IDX]} + +if [[ $CLASS_IDX =~ ^(0|1|2|3|4|5|8|9|17|18|19|20|21|22|23|24|25|26|27|28|29)$ ]]; then + PROMPT_LIST=( + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the jungle." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the snow." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on the beach." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on a cobblestone street." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of pink fabric." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a wooden floor." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a city in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a mountain in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a blue house in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a purple rug in a forest." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a wheat field in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a tree and autumn leaves in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with the Eiffel Tower in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} floating on top of water." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} floating in an ocean of milk." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of green grass with sunflowers around it." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a mirror." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of the sidewalk in a crowded street." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a dirt road." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a white rug." + "a red ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a purple ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a shiny ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a wet ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a cube shaped ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + ) + + prompt_test_list=( + "a ${CLASS_TOKEN} in the jungle" + "a ${CLASS_TOKEN} in the snow" + "a ${CLASS_TOKEN} on the beach" + "a ${CLASS_TOKEN} on a cobblestone street" + "a ${CLASS_TOKEN} on top of pink fabric" + "a ${CLASS_TOKEN} on top of a wooden floor" + "a ${CLASS_TOKEN} with a city in the background" + "a ${CLASS_TOKEN} with a mountain in the background" + "a ${CLASS_TOKEN} with a blue house in the background" + "a ${CLASS_TOKEN} on top of a purple rug in a forest" + "a ${CLASS_TOKEN} with a wheat field in the background" + "a ${CLASS_TOKEN} with a tree and autumn leaves in the background" + "a ${CLASS_TOKEN} with the Eiffel Tower in the background" + "a ${CLASS_TOKEN} floating on top of water" + "a ${CLASS_TOKEN} floating in an ocean of milk" + "a ${CLASS_TOKEN} on top of green grass with sunflowers around it" + "a ${CLASS_TOKEN} on top of a mirror" + "a ${CLASS_TOKEN} on top of the sidewalk in a crowded street" + "a ${CLASS_TOKEN} on top of a dirt road" + "a ${CLASS_TOKEN} on top of a white rug" + "a red ${CLASS_TOKEN}" + "a purple ${CLASS_TOKEN}" + "a shiny ${CLASS_TOKEN}" + "a wet ${CLASS_TOKEN}" + "a cube shaped ${CLASS_TOKEN}" + ) + +else + PROMPT_LIST=( + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the jungle." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the snow." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on the beach." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on a cobblestone street." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of pink fabric." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a wooden floor." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a city in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a mountain in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a blue house in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a purple rug in a forest." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a red hat." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a santa hat." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a rainbow scarf." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a black top hat and a monocle." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a chef outfit." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a firefighter outfit." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a police outfit." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing pink glasses." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a yellow shirt." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a purple wizard outfit." + "a red ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a purple ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a shiny ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a wet ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a cube shaped ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + ) + + prompt_test_list=( + "a ${CLASS_TOKEN} in the jungle" + "a ${CLASS_TOKEN} in the snow" + "a ${CLASS_TOKEN} on the beach" + "a ${CLASS_TOKEN} on a cobblestone street" + "a ${CLASS_TOKEN} on top of pink fabric" + "a ${CLASS_TOKEN} on top of a wooden floor" + "a ${CLASS_TOKEN} with a city in the background" + "a ${CLASS_TOKEN} with a mountain in the background" + "a ${CLASS_TOKEN} with a blue house in the background" + "a ${CLASS_TOKEN} on top of a purple rug in a forest" + "a ${CLASS_TOKEN} wearing a red hat" + "a ${CLASS_TOKEN} wearing a santa hat" + "a ${CLASS_TOKEN} wearing a rainbow scarf" + "a ${CLASS_TOKEN} wearing a black top hat and a monocle" + "a ${CLASS_TOKEN} in a chef outfit" + "a ${CLASS_TOKEN} in a firefighter outfit" + "a ${CLASS_TOKEN} in a police outfit" + "a ${CLASS_TOKEN} wearing pink glasses" + "a ${CLASS_TOKEN} wearing a yellow shirt" + "a ${CLASS_TOKEN} in a purple wizard outfit" + "a red ${CLASS_TOKEN}" + "a purple ${CLASS_TOKEN}" + "a shiny ${CLASS_TOKEN}" + "a wet ${CLASS_TOKEN}" + "a cube shaped ${CLASS_TOKEN}" + ) +fi + +VALIDATION_PROMPT=${PROMPT_LIST[@]} +INSTANCE_PROMPT="a photo of ${UNIQUE_TOKEN} ${CLASS_TOKEN}" +CLASS_PROMPT="a photo of ${CLASS_TOKEN}" + +export MODEL_NAME="stabilityai/stable-diffusion-2-1" +# export MODEL_NAME="runwayml/stable-diffusion-v1-5" + +PEFT_TYPE="boft" +BLOCK_NUM=8 +BLOCK_SIZE=0 +N_BUTTERFLY_FACTOR=1 + +export PROJECT_NAME="dreambooth_${PEFT_TYPE}" +export RUN_NAME="${SELECTED_SUBJECT}_${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}" +export INSTANCE_DIR="./data/dreambooth/dataset/${SELECTED_SUBJECT}" +export CLASS_DIR="./data/class_data/${CLASS_TOKEN}" +export OUTPUT_DIR="./data/output/${PEFT_TYPE}" + + +accelerate launch train_dreambooth.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --class_data_dir="$CLASS_DIR" \ + --output_dir=$OUTPUT_DIR \ + --wandb_project_name=$PROJECT_NAME \ + --wandb_run_name=$RUN_NAME \ + --with_prior_preservation --prior_loss_weight=1.0 \ + --instance_prompt="$INSTANCE_PROMPT" \ + --validation_prompt="$VALIDATION_PROMPT" \ + --class_prompt="$CLASS_PROMPT" \ + --resolution=512 \ + --train_batch_size=1 \ + --num_dataloader_workers=2 \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --num_class_images=200 \ + --use_boft \ + --boft_block_num=$BLOCK_NUM \ + --boft_block_size=$BLOCK_SIZE \ + --boft_n_butterfly_factor=$N_BUTTERFLY_FACTOR \ + --boft_dropout=0.1 \ + --boft_bias="boft_only" \ + --learning_rate=3e-5 \ + --max_train_steps=1010 \ + --checkpointing_steps=200 \ + --validation_steps=200 \ + --enable_xformers_memory_efficient_attention \ + --report_to="wandb" \ \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/utils/__init__.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/utils/args_loader.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/utils/args_loader.py new file mode 100644 index 0000000000000000000000000000000000000000..5260eb9d6866912df4f5f073d8228a0619ef65fd --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/utils/args_loader.py @@ -0,0 +1,363 @@ +import argparse +import os +import warnings +from typing import Optional + +from huggingface_hub import HfFolder, whoami +from transformers import PretrainedConfig + + +def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str): + text_encoder_config = PretrainedConfig.from_pretrained( + pretrained_model_name_or_path, + subfolder="text_encoder", + revision=revision, + ) + model_class = text_encoder_config.architectures[0] + + if model_class == "CLIPTextModel": + from transformers import CLIPTextModel + + return CLIPTextModel + elif model_class == "RobertaSeriesModelWithTransformation": + from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation + + return RobertaSeriesModelWithTransformation + else: + raise ValueError(f"{model_class} is not supported.") + + +def get_full_repo_name(model_id: str, organization: Optional[str] = None, token: Optional[str] = None): + if token is None: + token = HfFolder.get_token() + if organization is None: + username = whoami(token)["name"] + return f"{username}/{model_id}" + else: + return f"{organization}/{model_id}" + + +def parse_args(input_args=None): + parser = argparse.ArgumentParser(description="Simple example of a Dreambooth training script.") + parser.add_argument( + "--pretrained_model_name_or_path", + type=str, + default=None, + required=True, + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--tokenizer_name", + type=str, + default=None, + help="Pretrained tokenizer name or path if not the same as model_name", + ) + parser.add_argument( + "--instance_data_dir", + type=str, + default=None, + required=True, + help="A folder containing the training data of instance images.", + ) + parser.add_argument( + "--class_data_dir", + type=str, + default=None, + required=False, + help="A folder containing the training data of class images.", + ) + parser.add_argument( + "--instance_prompt", + type=str, + default=None, + required=True, + help="The prompt with identifier specifying the instance", + ) + parser.add_argument( + "--class_prompt", + type=str, + default=None, + help="The prompt to specify images in the same class as provided instance images.", + ) + parser.add_argument( + "--with_prior_preservation", + default=False, + action="store_true", + help="Flag to add prior preservation loss.", + ) + parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.") + parser.add_argument( + "--num_class_images", + type=int, + default=100, + help=( + "Minimal class images for prior preservation loss. If there are not enough images already present in" + " class_data_dir, additional images will be sampled with class_prompt." + ), + ) + parser.add_argument( + "--validation_prompt", + nargs="+", + help="A prompt that is used during validation to verify that the model is learning.", + ) + parser.add_argument( + "--num_validation_images", + type=int, + default=4, + help="Number of images that should be generated during validation with `validation_prompt`.", + ) + parser.add_argument( + "--validation_steps", + type=int, + default=500, + help=( + "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt" + " `args.validation_prompt` multiple times: `args.num_validation_images`." + ), + ) + parser.add_argument( + "--output_dir", + type=str, + default="text-inversion-model", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution" + ) + parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder") + + parser.add_argument( + "--set_grads_to_none", + action="store_true", + help=( + "Save more memory by using setting grads to None instead of zero. Be aware, that this changes certain" + " behaviors, so disable this argument if it causes any problems. More info:" + " https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html" + ), + ) + + # boft args + parser.add_argument("--use_boft", action="store_true", help="Whether to use BOFT for parameter efficient tuning") + parser.add_argument("--boft_block_num", type=int, default=4, help="The number of BOFT blocks") + parser.add_argument("--boft_block_size", type=int, default=0, help="The size of BOFT blocks") + parser.add_argument("--boft_n_butterfly_factor", type=int, default=2, help="The number of butterfly factors") + parser.add_argument("--boft_dropout", type=float, default=0.1, help="BOFT dropout, only used if use_boft is True") + parser.add_argument( + "--boft_bias", + type=str, + default="none", + help="Bias type for BOFT. Can be 'none', 'all' or 'boft_only', only used if use_boft is True", + ) + parser.add_argument( + "--num_dataloader_workers", type=int, default=1, help="Num of workers for the training dataloader." + ) + parser.add_argument( + "--no_tracemalloc", + default=False, + action="store_true", + help="Flag to stop memory allocation tracing during training. This could speed up training on Windows.", + ) + + parser.add_argument( + "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader." + ) + parser.add_argument( + "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images." + ) + parser.add_argument("--num_train_epochs", type=int, default=1) + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help=( + "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final" + " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming" + " training using `--resume_from_checkpoint`." + ), + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help=( + "Whether training should be resumed from a previous checkpoint. Use a path saved by" + ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.' + ), + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=5e-6, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler." + ) + parser.add_argument( + "--lr_num_cycles", + type=int, + default=1, + help="Number of hard resets of the lr in cosine_with_restarts scheduler.", + ) + parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.") + parser.add_argument( + "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes." + ) + parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.") + parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.") + parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.") + parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer") + parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.") + parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.") + parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.") + parser.add_argument( + "--hub_model_id", + type=str, + default=None, + help="The name of the repository to keep in sync with the local `output_dir`.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument( + "--report_to", + type=str, + default="wandb", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`' + ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument( + "--wandb_key", + type=str, + default=None, + help=("If report to option is set to wandb, api-key for wandb used for login to wandb "), + ) + parser.add_argument( + "--wandb_project_name", + type=str, + default=None, + help=("If report to option is set to wandb, project name in wandb for log tracking "), + ) + parser.add_argument( + "--wandb_run_name", + type=str, + default=None, + help=("If report to option is set to wandb, project name in wandb for log tracking "), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default=None, + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--prior_generation_precision", + type=str, + default=None, + choices=["no", "fp32", "fp16", "bf16"], + help=( + "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to fp16 if a GPU is available else fp32." + ), + ) + parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank") + parser.add_argument( + "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers." + ) + + if input_args is not None: + args = parser.parse_args(input_args) + else: + args = parser.parse_args() + + env_local_rank = int(os.environ.get("LOCAL_RANK", "-1")) + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + # Sanity checks + # if args.dataset_name is None and args.train_data_dir is None: + # raise ValueError("Need either a dataset name or a training folder.") + + if args.with_prior_preservation: + if args.class_data_dir is None: + raise ValueError("You must specify a data directory for class images.") + if args.class_prompt is None: + raise ValueError("You must specify prompt for class images.") + else: + # logger is not available yet + if args.class_data_dir is not None: + warnings.warn("You need not use --class_data_dir without --with_prior_preservation.") + if args.class_prompt is not None: + warnings.warn("You need not use --class_prompt without --with_prior_preservation.") + + return args diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/utils/dataset.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/utils/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..42484f7a4debe26669b47f494740a1f6d81a082d --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/utils/dataset.py @@ -0,0 +1,126 @@ +from pathlib import Path + +import torch +from PIL import Image +from torch.utils.data import Dataset +from torchvision import transforms + + +class DreamBoothDataset(Dataset): + """ + A dataset to prepare the instance and class images with the prompts for fine-tuning the model. + It pre-processes the images and the tokenizes prompts. + """ + + def __init__( + self, + instance_data_root, + instance_prompt, + tokenizer, + class_data_root=None, + class_prompt=None, + size=512, + center_crop=False, + ): + self.size = size + self.center_crop = center_crop + self.tokenizer = tokenizer + + self.instance_data_root = Path(instance_data_root) + if not self.instance_data_root.exists(): + raise ValueError("Instance images root doesn't exists.") + + self.instance_images_path = list(Path(instance_data_root).iterdir()) + self.num_instance_images = len(self.instance_images_path) + self.instance_prompt = instance_prompt + self._length = self.num_instance_images + + if class_data_root is not None: + self.class_data_root = Path(class_data_root) + self.class_data_root.mkdir(parents=True, exist_ok=True) + self.class_images_path = list(self.class_data_root.iterdir()) + self.num_class_images = len(self.class_images_path) + self._length = max(self.num_class_images, self.num_instance_images) + self.class_prompt = class_prompt + else: + self.class_data_root = None + + self.image_transforms = transforms.Compose( + [ + transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR), + transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + + def __len__(self): + return self._length + + def __getitem__(self, index): + example = {} + instance_image = Image.open(self.instance_images_path[index % self.num_instance_images]) + if instance_image.mode != "RGB": + instance_image = instance_image.convert("RGB") + example["instance_images"] = self.image_transforms(instance_image) + example["instance_prompt_ids"] = self.tokenizer( + self.instance_prompt, + truncation=True, + padding="max_length", + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + if self.class_data_root: + class_image = Image.open(self.class_images_path[index % self.num_class_images]) + if class_image.mode != "RGB": + class_image = class_image.convert("RGB") + example["class_images"] = self.image_transforms(class_image) + example["class_prompt_ids"] = self.tokenizer( + self.class_prompt, + truncation=True, + padding="max_length", + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + return example + + +def collate_fn(examples, with_prior_preservation=False): + input_ids = [example["instance_prompt_ids"] for example in examples] + pixel_values = [example["instance_images"] for example in examples] + + # Concat class and instance examples for prior preservation. + # We do this to avoid doing two forward passes. + if with_prior_preservation: + input_ids += [example["class_prompt_ids"] for example in examples] + pixel_values += [example["class_images"] for example in examples] + + pixel_values = torch.stack(pixel_values) + pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float() + + input_ids = torch.cat(input_ids, dim=0) + + batch = { + "input_ids": input_ids, + "pixel_values": pixel_values, + } + return batch + + +class PromptDataset(Dataset): + "A simple dataset to prepare the prompts to generate class images on multiple GPUs." + + def __init__(self, prompt, num_samples): + self.prompt = prompt + self.num_samples = num_samples + + def __len__(self): + return self.num_samples + + def __getitem__(self, index): + example = {} + example["prompt"] = self.prompt + example["index"] = index + return example diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/utils/tracemalloc.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/utils/tracemalloc.py new file mode 100644 index 0000000000000000000000000000000000000000..26ba300926002d797832ab8dae12053ed6fcd4cf --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/boft_dreambooth/utils/tracemalloc.py @@ -0,0 +1,60 @@ +import gc +import threading + +import psutil +import torch + + +# Converting Bytes to Megabytes +def b2mb(x): + return int(x / 2**20) + + +# This context manager is used to track the peak memory usage of the process +class TorchTracemalloc: + def __enter__(self): + self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + self.device_module = getattr(torch, self.device_type, torch.cuda) + gc.collect() + self.device_module.empty_cache() + self.device_module.reset_peak_memory_stats() # reset the peak gauge to zero + self.begin = self.device_module.memory_allocated() + self.process = psutil.Process() + + self.cpu_begin = self.cpu_mem_used() + self.peak_monitoring = True + peak_monitor_thread = threading.Thread(target=self.peak_monitor_func) + peak_monitor_thread.daemon = True + peak_monitor_thread.start() + return self + + def cpu_mem_used(self): + """get resident set size memory for the current process""" + return self.process.memory_info().rss + + def peak_monitor_func(self): + self.cpu_peak = -1 + + while True: + self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak) + + # can't sleep or will not catch the peak right (this comment is here on purpose) + # time.sleep(0.001) # 1msec + + if not self.peak_monitoring: + break + + def __exit__(self, *exc): + self.peak_monitoring = False + + gc.collect() + self.device_module.empty_cache() + self.end = self.device_module.memory_allocated() + self.peak = self.device_module.max_memory_allocated() + self.used = b2mb(self.end - self.begin) + self.peaked = b2mb(self.peak - self.begin) + + self.cpu_end = self.cpu_mem_used() + self.cpu_used = b2mb(self.cpu_end - self.cpu_begin) + self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin) + # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}") diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/README.md new file mode 100644 index 0000000000000000000000000000000000000000..78ca9a6807ea1e3ae8d4e8290b5f95f168fb7477 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/README.md @@ -0,0 +1,101 @@ +# CARTRIDGE self-study distillation (example) + +This folder shows an **example** workflow for training a `CARTRIDGE` adapter via a SELF‑STUDY‑style +context-distillation objective (see the [Cartridges paper](https://huggingface.co/papers/2506.06266)). + +PEFT intentionally keeps this training logic out of the core library; treat this as a starting point you can adapt. + +## Installation + +```bash +pip install -r requirements.txt +``` + +## Files + +- `synthesize.py`: generates synthetic QA pairs about a corpus using vLLM with prefix caching. +- `train_distill.py`: trains a `CARTRIDGE` adapter via self-study distillation. +- `arxiv_synthesize.py`: like `synthesize.py`, with defaults for the Cartridges paper LaTeX. +- `arxiv_train.py`: like `train_distill.py`, with arxiv-specific defaults. + +## How it works + +1. **Synthesize**: Generate QA pairs where the model has access to the full document context +2. **Train**: Distill knowledge from teacher to student using a single model in memory: + - Teacher (adapter disabled): document + question → logits + - Student (adapter enabled): question + cartridge KV cache → logits +3. **Inference**: The trained cartridge provides compressed document knowledge as a KV cache prefix + +## Run + +### 1. Synthesize training data + +```bash +python synthesize.py \ + --model Qwen/Qwen3-4B \ + --corpus_path /path/to/document.txt \ + --out_jsonl distill.jsonl \ + --num_samples 1024 \ + --use_vllm +``` + +With `--use_vllm`, the document is cached and reused across all samples via automatic prefix caching. + +### 2. Train cartridge + +```bash +python train_distill.py \ + --model Qwen/Qwen3-4B \ + --document /path/to/document.txt \ + --distill_jsonl distill.jsonl \ + --output_dir cartridge_adapter \ + --num_virtual_tokens 256 \ + --num_frozen_tokens 1 \ + --max_steps 500 +``` + +If you want to follow the arXiv paper example locally, you can use the LaTeX source included in this repo at +`examples/cartridge_self_study/data/cartridges.tex` (download it first): + +```bash +mkdir -p examples/cartridge_self_study/data +curl -L -o examples/cartridge_self_study/data/cartridges.tex \ + https://raw.githubusercontent.com/HazyResearch/cartridges/refs/heads/main/examples/arxiv/cartridges.tex +``` + +### 3. Load and use cartridge + +```python +from transformers import AutoModelForCausalLM, AutoTokenizer +from peft import PeftModel + +model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-4B") +model = PeftModel.from_pretrained(model, "cartridge_adapter") + +tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-4B") +inputs = tokenizer("What is the document about?", return_tensors="pt") +outputs = model.generate(**inputs, max_new_tokens=100) +print(tokenizer.decode(outputs[0], skip_special_tokens=True)) +``` + +## arXiv example + +Convenience wrappers for training on the Cartridges paper LaTeX: + +```bash +# From the repo root: +# Synthesize QA pairs (uses vLLM with prefix caching) +python examples/cartridge_self_study/arxiv_synthesize.py \ + --model Qwen/Qwen3-4B \ + --corpus_path examples/cartridge_self_study/data/cartridges.tex \ + --num_samples 1024 \ + --use_vllm + +# Train cartridge +python examples/cartridge_self_study/arxiv_train.py \ + --model Qwen/Qwen3-4B \ + --document examples/cartridge_self_study/data/cartridges.tex \ + --distill_jsonl distill.jsonl \ + --output_dir cartridge_adapter \ + --max_steps 500 +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/arxiv_synthesize.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/arxiv_synthesize.py new file mode 100644 index 0000000000000000000000000000000000000000..3a8e57953c5f9804bcb62aa5fb179d0564afe081 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/arxiv_synthesize.py @@ -0,0 +1,95 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# 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 argparse +from pathlib import Path + +from synthesize import synthesize_self_study_jsonl +from transformers import AutoTokenizer + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--model", type=str, default="Qwen/Qwen2.5-0.5B-Instruct") + parser.add_argument( + "--corpus_path", + type=str, + default=str(Path(__file__).resolve().parent / "data/cartridges.tex"), + ) + parser.add_argument("--out_jsonl", type=str, default="distill.jsonl") + parser.add_argument("--num_samples", type=int, default=256) + parser.add_argument("--seed_prompts", type=str, default="structuring,summarization,question,use_cases,creative") + parser.add_argument("--max_new_tokens", type=int, default=512) + parser.add_argument("--temperature", type=float, default=0.7) + parser.add_argument("--top_p", type=float, default=0.95) + parser.add_argument("--max_corpus_tokens", type=int, default=2048) + parser.add_argument( + "--use_vllm", + action="store_true", + help="Use vLLM for faster generation with automatic prefix caching.", + ) + parser.add_argument("--seed", type=int, default=0, help="Seed for deterministic prompt-type shuffling.") + parser.add_argument( + "--tensor_parallel_size", + type=int, + default=1, + help="Tensor parallel size for vLLM (number of GPUs).", + ) + args = parser.parse_args() + + corpus_text = Path(args.corpus_path).read_text(encoding="utf-8") + tokenizer = AutoTokenizer.from_pretrained(args.model) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + if args.max_corpus_tokens is not None: + ids = tokenizer( + corpus_text, + add_special_tokens=False, + truncation=True, + max_length=args.max_corpus_tokens, + )["input_ids"] + corpus_text = tokenizer.decode(ids, skip_special_tokens=True) + + if args.use_vllm: + from vllm import LLM + + model = LLM( + model=args.model, + tensor_parallel_size=args.tensor_parallel_size, + enable_prefix_caching=True, + ) + else: + import torch + from transformers import AutoModelForCausalLM + + model = AutoModelForCausalLM.from_pretrained(args.model, dtype=torch.bfloat16, device_map="auto") + + synthesize_self_study_jsonl( + output_path=Path(args.out_jsonl), + model=model, + tokenizer=tokenizer, + corpus_text=corpus_text, + num_samples=args.num_samples, + seed_prompt_types=[s.strip() for s in args.seed_prompts.split(",") if s.strip()], + max_new_tokens=args.max_new_tokens, + temperature=args.temperature, + top_p=args.top_p, + use_vllm=args.use_vllm, + seed=args.seed, + ) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/arxiv_train.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/arxiv_train.py new file mode 100644 index 0000000000000000000000000000000000000000..987a3c1c2e424f599824339097979910c4cfad7b --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/arxiv_train.py @@ -0,0 +1,105 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# 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 argparse +from pathlib import Path + +import torch +from train_distill import DistillationCollator, DistillationTrainer, DistillJsonlDataset +from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments + +from peft import CartridgeConfig, get_peft_model +from peft.tuners.cartridge.utils import initialize_kv_prefix_from_text + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--model", type=str, required=True, help="Model to use for both teacher and student") + parser.add_argument("--document", type=str, required=True, help="Path to text file for KV cache initialization") + parser.add_argument("--distill_jsonl", type=str, default="distill.jsonl") + parser.add_argument("--output_dir", type=str, default="cartridge_adapter") + parser.add_argument("--num_virtual_tokens", type=int, default=256) + parser.add_argument("--num_frozen_tokens", type=int, default=1) + parser.add_argument("--top_k", type=int, default=20) + parser.add_argument("--per_device_train_batch_size", type=int, default=1) + parser.add_argument("--learning_rate", type=float, default=1e-3) + parser.add_argument("--max_steps", type=int, default=1000) + parser.add_argument("--device", type=str, default="cuda", choices=["cpu", "mps", "cuda", "xpu"]) + parser.add_argument( + "--max_init_length", type=int, default=2048, help="Max tokens for text initialization (truncate long docs)" + ) + args = parser.parse_args() + + if args.device == "mps" and not (hasattr(torch.backends, "mps") and torch.backends.mps.is_available()): + raise ValueError("Requested device 'mps' but MPS is not available.") + if args.device == "cuda" and not torch.cuda.is_available(): + raise ValueError("Requested device 'cuda' but CUDA is not available.") + + model_dtype = torch.float16 if args.device in {"cuda", "mps"} else None + device_map = args.device if args.device != "cpu" else None + + tokenizer = AutoTokenizer.from_pretrained(args.model) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + base_model = AutoModelForCausalLM.from_pretrained(args.model, dtype=model_dtype, device_map=device_map) + model = get_peft_model( + base_model, + CartridgeConfig( + task_type="CAUSAL_LM", + num_virtual_tokens=args.num_virtual_tokens, + num_frozen_tokens=args.num_frozen_tokens, + ), + ) + + print(f"Initializing cartridge from document: {args.document}", flush=True) + document_text = Path(args.document).read_text() + initialize_kv_prefix_from_text( + model, + tokenizer, + text=document_text, + use_chat_template=False, + max_length=args.max_init_length, + ) + print(f"Cartridge initialized with {args.num_virtual_tokens} tokens from text", flush=True) + + ds = DistillJsonlDataset(args.distill_jsonl) + collator = DistillationCollator(tokenizer) + + train_args = TrainingArguments( + output_dir=args.output_dir, + per_device_train_batch_size=args.per_device_train_batch_size, + learning_rate=args.learning_rate, + max_steps=args.max_steps, + logging_steps=10, + save_steps=100, + report_to=[], + remove_unused_columns=False, + use_cpu=args.device == "cpu", + dataloader_pin_memory=False, + ) + + trainer = DistillationTrainer( + model=model, + top_k=args.top_k, + args=train_args, + train_dataset=ds, + data_collator=collator, + ) + trainer.train() + model.save_pretrained(args.output_dir) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..2e37a2778b93597ed7fdff8014f050a92d0f6688 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/requirements.txt @@ -0,0 +1,4 @@ +torch +transformers +peft +vllm diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/synthesize.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/synthesize.py new file mode 100644 index 0000000000000000000000000000000000000000..fdbb8867f8678e5f8005254a718e67be70f1b165 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/synthesize.py @@ -0,0 +1,368 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# 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 argparse +import json +import random +from pathlib import Path + +from transformers import AutoTokenizer + + +SEED_PROMPTS = { + "structuring": ( + "Generate a single instruction asking an LLM to structure information from the document above. " + "Be specific about what section or topic to structure. " + "Output only the instruction, nothing else." + ), + "summarization": ( + "Generate a single instruction asking an LLM to summarize part of the document above. " + "Be explicit about which section to summarize. " + "Output only the instruction, nothing else." + ), + "question": ( + "Generate a question that tests knowledge of the document above. " + "Include specific details (names, dates, numbers) so the question is unambiguous. " + "Output only the question, nothing else." + ), + "use_cases": ( + "Think of a practical real-world task someone could accomplish using knowledge from the document. " + "Generate a single question or instruction reflecting that use case. " + "Output only the question/instruction, nothing else." + ), + "creative": ( + "Generate a creative question inspired by the document above. Output only the question, nothing else." + ), +} + +# Chat template kwargs to disable thinking mode for models like Qwen3 +CHAT_TEMPLATE_KWARGS = {"enable_thinking": False} +MAX_NEW_TOKENS_FOR_QUESTIONS = 256 + + +def synthesize_self_study_jsonl( + *, + output_path: Path, + model, + tokenizer, + corpus_text: str, + num_samples: int, + seed_prompt_types: list[str], + max_new_tokens: int, + temperature: float, + top_p: float, + use_vllm: bool = False, + seed: int = 0, +): + """ + Synthesize self-study data for cartridge training. + + Uses the full corpus as context for all samples, varying only the seed prompt. + With vLLM's prefix caching, the document KV cache is computed once and reused. + + If use_vllm=True, `model` should be a vllm.LLM instance. + Otherwise, `model` should be a HuggingFace model. + """ + output_path.parent.mkdir(parents=True, exist_ok=True) + if output_path.exists(): + output_path.unlink() + + for t in seed_prompt_types: + if t not in SEED_PROMPTS: + raise ValueError(f"Unknown seed prompt type '{t}', expected one of: {sorted(SEED_PROMPTS)}") + + # Pre-generate prompt indices (cycling through seed prompt types). + prompt_indices = [i % len(seed_prompt_types) for i in range(num_samples)] + rng = random.Random(seed) + rng.shuffle(prompt_indices) + + if use_vllm: + _synthesize_vllm( + output_path=output_path, + model=model, + tokenizer=tokenizer, + corpus_text=corpus_text, + seed_prompt_types=seed_prompt_types, + prompt_indices=prompt_indices, + max_new_tokens=max_new_tokens, + temperature=temperature, + top_p=top_p, + ) + else: + _synthesize_hf( + output_path=output_path, + model=model, + tokenizer=tokenizer, + corpus_text=corpus_text, + seed_prompt_types=seed_prompt_types, + prompt_indices=prompt_indices, + max_new_tokens=max_new_tokens, + temperature=temperature, + top_p=top_p, + ) + + +def _synthesize_vllm( + *, + output_path: Path, + model, + tokenizer, + corpus_text: str, + seed_prompt_types: list[str], + prompt_indices: list[int], + max_new_tokens: int, + temperature: float, + top_p: float, +): + """Synthesize using vLLM with prefix caching (two-stage like original cartridges). + + Stage 1: Generate questions using meta-prompts (all share document prefix) + Stage 2: Generate answers to those questions (all share document prefix) + """ + from vllm import SamplingParams + + # Stage 1: Generate questions + question_messages = [ + [ + {"role": "system", "content": corpus_text}, + {"role": "user", "content": SEED_PROMPTS[seed_prompt_types[prompt_idx]]}, + ] + for prompt_idx in prompt_indices + ] + + question_params = SamplingParams( + max_tokens=MAX_NEW_TOKENS_FOR_QUESTIONS, + temperature=temperature if temperature > 0 else 0.0, + top_p=top_p if temperature > 0 else 1.0, + ) + + print("Stage 1: Generating questions...") + question_outputs = model.chat( + question_messages, + question_params, + use_tqdm=True, + chat_template_kwargs=CHAT_TEMPLATE_KWARGS, + ) + questions = [out.outputs[0].text.strip() for out in question_outputs] + + # Stage 2: Generate answers + answer_messages = [ + [ + {"role": "system", "content": corpus_text}, + {"role": "user", "content": question}, + ] + for question in questions + ] + + answer_params = SamplingParams( + max_tokens=max_new_tokens, + temperature=0.0, + top_p=1.0, + ) + + print("Stage 2: Generating answers...") + answer_outputs = model.chat( + answer_messages, + answer_params, + use_tqdm=True, + chat_template_kwargs=CHAT_TEMPLATE_KWARGS, + ) + + # Build training records + for i, (question, answer_out) in enumerate(zip(questions, answer_outputs)): + # Get the answer token IDs directly from vLLM output (avoids decode/re-encode mismatch) + answer_ids = list(answer_out.outputs[0].token_ids) + + teacher_prompt_ids = tokenizer.apply_chat_template( + [{"role": "system", "content": corpus_text}, {"role": "user", "content": question}], + tokenize=True, + add_generation_prompt=True, + **CHAT_TEMPLATE_KWARGS, + ) + student_prompt_ids = tokenizer.apply_chat_template( + [{"role": "user", "content": question}], + tokenize=True, + add_generation_prompt=True, + **CHAT_TEMPLATE_KWARGS, + ) + + record = { + "teacher_input_ids": teacher_prompt_ids + answer_ids, + "student_input_ids": student_prompt_ids + answer_ids, + "ctx_len": len(teacher_prompt_ids) - len(student_prompt_ids), + } + with output_path.open("a", encoding="utf-8") as f: + f.write(json.dumps(record) + "\n") + + +def _synthesize_hf( + *, + output_path: Path, + model, + tokenizer, + corpus_text: str, + seed_prompt_types: list[str], + prompt_indices: list[int], + max_new_tokens: int, + temperature: float, + top_p: float, +): + """Synthesize using HuggingFace transformers (two-stage, one sample at a time).""" + import torch + from tqdm import tqdm + + device = getattr(model, "device", torch.device("cpu")) + model.eval() + + for prompt_idx in tqdm(prompt_indices, desc="Generating samples"): + meta_prompt = SEED_PROMPTS[seed_prompt_types[prompt_idx]] + + # Stage 1: Generate question + question_input = tokenizer.apply_chat_template( + [{"role": "system", "content": corpus_text}, {"role": "user", "content": meta_prompt}], + tokenize=True, + add_generation_prompt=True, + return_tensors="pt", + return_dict=False, + **CHAT_TEMPLATE_KWARGS, + ).to(device) + + gen_kwargs = { + "max_new_tokens": MAX_NEW_TOKENS_FOR_QUESTIONS, + "do_sample": temperature > 0, + "pad_token_id": tokenizer.pad_token_id or tokenizer.eos_token_id, + } + if temperature > 0: + gen_kwargs["temperature"] = max(temperature, 1e-5) + gen_kwargs["top_p"] = top_p + + with torch.no_grad(): + question_out = model.generate(question_input, **gen_kwargs) + + question_tokens = question_out[0, question_input.shape[1] :].tolist() + question = tokenizer.decode(question_tokens, skip_special_tokens=True).strip() + + # Stage 2: Generate answer + teacher_input = tokenizer.apply_chat_template( + [{"role": "system", "content": corpus_text}, {"role": "user", "content": question}], + tokenize=True, + add_generation_prompt=True, + return_tensors="pt", + return_dict=False, + **CHAT_TEMPLATE_KWARGS, + ).to(device) + + student_input = tokenizer.apply_chat_template( + [{"role": "user", "content": question}], + tokenize=True, + add_generation_prompt=True, + return_tensors="pt", + return_dict=False, + **CHAT_TEMPLATE_KWARGS, + ).to(device) + + with torch.no_grad(): + answer_out = model.generate( + teacher_input, + max_new_tokens=max_new_tokens, + do_sample=False, + pad_token_id=tokenizer.pad_token_id or tokenizer.eos_token_id, + ) + + answer_tokens = answer_out[0, teacher_input.shape[1] :].tolist() + + record = { + "teacher_input_ids": answer_out[0].tolist(), + "student_input_ids": student_input[0].tolist() + answer_tokens, + "ctx_len": int(teacher_input.shape[1]) - int(student_input.shape[1]), + } + with output_path.open("a", encoding="utf-8") as f: + f.write(json.dumps(record) + "\n") + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--model", type=str, default="Qwen/Qwen2.5-0.5B-Instruct") + parser.add_argument("--corpus_path", type=str, required=True) + parser.add_argument("--out_jsonl", type=str, required=True) + parser.add_argument("--num_samples", type=int, default=1024) + parser.add_argument("--seed_prompts", type=str, default="structuring,summarization,question,use_cases,creative") + parser.add_argument("--max_new_tokens", type=int, default=512) + parser.add_argument("--temperature", type=float, default=0.7) + parser.add_argument("--top_p", type=float, default=0.95) + parser.add_argument( + "--max_corpus_tokens", + type=int, + default=None, + help="Optional cap on the number of tokens used from the corpus.", + ) + parser.add_argument( + "--use_vllm", + action="store_true", + help="Use vLLM for faster generation with automatic prefix caching.", + ) + parser.add_argument("--seed", type=int, default=0, help="Seed for deterministic prompt-type shuffling.") + parser.add_argument( + "--tensor_parallel_size", + type=int, + default=1, + help="Tensor parallel size for vLLM (number of GPUs).", + ) + args = parser.parse_args() + + corpus_text = Path(args.corpus_path).read_text(encoding="utf-8") + tokenizer = AutoTokenizer.from_pretrained(args.model) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + if args.max_corpus_tokens is not None: + ids = tokenizer( + corpus_text, + add_special_tokens=False, + truncation=True, + max_length=args.max_corpus_tokens, + )["input_ids"] + corpus_text = tokenizer.decode(ids, skip_special_tokens=True) + + if args.use_vllm: + from vllm import LLM + + model = LLM( + model=args.model, + tensor_parallel_size=args.tensor_parallel_size, + enable_prefix_caching=True, + ) + else: + import torch + from transformers import AutoModelForCausalLM + + model = AutoModelForCausalLM.from_pretrained(args.model, dtype=torch.bfloat16, device_map="auto") + + synthesize_self_study_jsonl( + output_path=Path(args.out_jsonl), + model=model, + tokenizer=tokenizer, + corpus_text=corpus_text, + num_samples=args.num_samples, + seed_prompt_types=[s.strip() for s in args.seed_prompts.split(",") if s.strip()], + max_new_tokens=args.max_new_tokens, + temperature=args.temperature, + top_p=args.top_p, + use_vllm=args.use_vllm, + seed=args.seed, + ) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/train_distill.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/train_distill.py new file mode 100644 index 0000000000000000000000000000000000000000..46a6c0dabb056dd8fe30a1cf1bd787573f3add26 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cartridge_self_study/train_distill.py @@ -0,0 +1,212 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# 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 argparse +import json +from pathlib import Path + +import torch +import torch.nn.functional as F +from torch.utils.data import Dataset +from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments + +from peft import CartridgeConfig, get_peft_model +from peft.tuners.cartridge.utils import initialize_kv_prefix_from_text + + +class DistillJsonlDataset(Dataset): + def __init__(self, path: str | Path): + self.rows = [] + with Path(path).open("r", encoding="utf-8") as f: + for line in f: + if line.strip(): + self.rows.append(json.loads(line)) + + def __len__(self) -> int: + return len(self.rows) + + def __getitem__(self, idx: int): + r = self.rows[idx] + return { + "teacher_input_ids": r["teacher_input_ids"], + "student_input_ids": r["student_input_ids"], + "ctx_len": r["ctx_len"], + } + + +class DistillationCollator: + def __init__(self, tokenizer): + self.tokenizer = tokenizer + + def __call__(self, features): + teacher_ids = [{"input_ids": f["teacher_input_ids"]} for f in features] + student_ids = [{"input_ids": f["student_input_ids"]} for f in features] + teacher_batch = self.tokenizer.pad(teacher_ids, return_tensors="pt") + student_batch = self.tokenizer.pad(student_ids, return_tensors="pt") + ctx_len = torch.tensor([int(f["ctx_len"]) for f in features], dtype=torch.long) + return { + "teacher_input_ids": teacher_batch["input_ids"], + "teacher_attention_mask": teacher_batch["attention_mask"], + "student_input_ids": student_batch["input_ids"], + "student_attention_mask": student_batch["attention_mask"], + "ctx_len": ctx_len, + } + + +class DistillationTrainer(Trainer): + def __init__(self, *args, top_k: int = 20, teacher_temperature: float = 1.0, **kwargs): + super().__init__(*args, **kwargs) + self.top_k = int(top_k) + self.teacher_temperature = float(teacher_temperature) + + def compute_loss(self, model, inputs, return_outputs=False, **kwargs): + teacher_input_ids = inputs["teacher_input_ids"].to(model.device) + teacher_attention_mask = inputs["teacher_attention_mask"].to(model.device) + student_input_ids = inputs["student_input_ids"].to(model.device) + student_attention_mask = inputs["student_attention_mask"].to(model.device) + ctx_len = inputs["ctx_len"].to(model.device) + + with torch.no_grad(): + with model.disable_adapter(): + teacher_out = model( + input_ids=teacher_input_ids, + attention_mask=teacher_attention_mask, + use_cache=False, + ) + teacher_logits = teacher_out.logits / max(self.teacher_temperature, 1e-5) + + student_out = model( + input_ids=student_input_ids, + attention_mask=student_attention_mask, + use_cache=False, + ) + student_logits = student_out.logits + + # Vectorized distillation loss (avoids Python `.item()` in per-example indexing). + # Align teacher logits to student positions via the per-example `ctx_len` offset. + student_logits = student_logits[:, :-1, :] # [B, Ls-1, V] + seq_len = student_logits.shape[1] + pos = torch.arange(seq_len, device=student_logits.device)[None, :] # [1, Ls-1] + + student_len = student_attention_mask.sum(dim=1).to(torch.long) # [B] + valid = pos < (student_len - 1).clamp(min=0)[:, None] # [B, Ls-1] + + teacher_pos = ctx_len[:, None] + pos # [B, Ls-1] + in_bounds = teacher_pos < teacher_logits.shape[1] + valid = valid & in_bounds + + teacher_pos = teacher_pos.clamp(min=0, max=teacher_logits.shape[1] - 1) + teacher_slice = teacher_logits.gather( + dim=1, index=teacher_pos[:, :, None].expand(-1, -1, teacher_logits.shape[-1]) + ) # [B, Ls-1, V] + + k = min(self.top_k, teacher_slice.shape[-1]) + topk_ids = torch.topk(teacher_slice, k=k, dim=-1).indices # [B, Ls-1, K] + teacher_logprobs = F.log_softmax(teacher_slice, dim=-1).gather(-1, topk_ids) + student_logprobs = F.log_softmax(student_logits, dim=-1).gather(-1, topk_ids) + + loss_by_pos = -(teacher_logprobs.exp() * student_logprobs).sum(dim=-1) # [B, Ls-1] + loss_by_pos = loss_by_pos.masked_fill(~valid, 0.0) + + denom = valid.sum(dim=1).clamp(min=1) + per_example = loss_by_pos.sum(dim=1) / denom + if valid.any(): + loss = per_example[valid.any(dim=1)].mean() + else: + loss = student_logits.new_zeros(()) + return (loss, student_out) if return_outputs else loss + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--model", type=str, required=True, help="Model to use for both teacher and student") + parser.add_argument("--distill_jsonl", type=str, required=True) + parser.add_argument("--output_dir", type=str, required=True) + parser.add_argument("--document", type=str, required=True, help="Path to text file for KV cache initialization") + parser.add_argument("--num_virtual_tokens", type=int, default=256) + parser.add_argument("--num_frozen_tokens", type=int, default=1) + parser.add_argument("--top_k", type=int, default=20) + parser.add_argument("--per_device_train_batch_size", type=int, default=1) + parser.add_argument("--learning_rate", type=float, default=1e-3) + parser.add_argument("--max_steps", type=int, default=1000) + parser.add_argument("--device", type=str, default="cuda", choices=["cpu", "mps", "cuda", "xpu"]) + parser.add_argument( + "--max_init_length", type=int, default=2048, help="Max tokens for text initialization (truncate long docs)" + ) + args = parser.parse_args() + + if args.device == "mps" and not (hasattr(torch.backends, "mps") and torch.backends.mps.is_available()): + raise ValueError("Requested device 'mps' but MPS is not available.") + if args.device == "xpu" and not torch.xpu.is_available(): + raise ValueError("Requested device 'xpu' but XPU is not available.") + if args.device == "cuda" and not torch.cuda.is_available(): + raise ValueError("Requested device 'cuda' but CUDA is not available.") + + model_dtype = torch.float16 if args.device in {"cuda", "mps", "xpu"} else None + device_map = args.device if args.device != "cpu" else None + + tokenizer = AutoTokenizer.from_pretrained(args.model) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + base_model = AutoModelForCausalLM.from_pretrained(args.model, dtype=model_dtype, device_map=device_map) + model = get_peft_model( + base_model, + CartridgeConfig( + task_type="CAUSAL_LM", + num_virtual_tokens=args.num_virtual_tokens, + num_frozen_tokens=args.num_frozen_tokens, + ), + ) + + print(f"Initializing cartridge from document: {args.document}", flush=True) + document_text = Path(args.document).read_text() + initialize_kv_prefix_from_text( + model, + tokenizer, + text=document_text, + use_chat_template=False, + max_length=args.max_init_length, + ) + print(f"Cartridge initialized with {args.num_virtual_tokens} tokens from text", flush=True) + + ds = DistillJsonlDataset(args.distill_jsonl) + collator = DistillationCollator(tokenizer) + + train_args = TrainingArguments( + output_dir=args.output_dir, + per_device_train_batch_size=args.per_device_train_batch_size, + learning_rate=args.learning_rate, + max_steps=args.max_steps, + logging_steps=10, + save_steps=100, + report_to=[], + remove_unused_columns=False, + use_cpu=args.device == "cpu", + dataloader_pin_memory=False, + ) + + trainer = DistillationTrainer( + model=model, + top_k=args.top_k, + args=train_args, + train_dataset=ds, + data_collator=collator, + ) + trainer.train() + model.save_pretrained(args.output_dir) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/accelerate_ds_zero3_cpu_offload_config.yaml b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/accelerate_ds_zero3_cpu_offload_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a4a0bcfaf09bd632e6ac2152c8a4f30e183cc102 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/accelerate_ds_zero3_cpu_offload_config.yaml @@ -0,0 +1,22 @@ +compute_environment: LOCAL_MACHINE +deepspeed_config: + gradient_accumulation_steps: 1 + gradient_clipping: 1.0 + offload_optimizer_device: none + offload_param_device: none + zero3_init_flag: true + zero3_save_16bit_model: true + zero_stage: 3 +distributed_type: DEEPSPEED +downcast_bf16: 'no' +dynamo_backend: 'NO' +fsdp_config: {} +machine_rank: 0 +main_training_function: main +megatron_lm_config: {} +mixed_precision: 'no' +num_machines: 1 +num_processes: 1 +rdzv_backend: static +same_network: true +use_cpu: false \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_ln_tuning_clm.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_ln_tuning_clm.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f4f75e79c736a9b4304ab4b3b9565b178293fc51 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_ln_tuning_clm.ipynb @@ -0,0 +1,1391 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "71fbfca2", + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import AutoModelForCausalLM\n", + "from peft import get_peft_config, get_peft_model, LNTuningConfig, TaskType, PeftType\n", + "import torch\n", + "from datasets import load_dataset\n", + "import os\n", + "from transformers import AutoTokenizer\n", + "from torch.utils.data import DataLoader\n", + "from transformers import default_data_collator, get_linear_schedule_with_warmup\n", + "from tqdm import tqdm\n", + "\n", + "# Hyper-parameters\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "model_name_or_path = \"bigscience/bloomz-560m\"\n", + "tokenizer_name_or_path = \"bigscience/bloomz-560m\"\n", + "peft_config = LNTuningConfig(\n", + " task_type=TaskType.CAUSAL_LM,\n", + ")\n", + "\n", + "dataset_name = \"twitter_complaints\"\n", + "checkpoint_name = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}_v1.pt\".replace(\n", + " \"/\", \"_\"\n", + ")\n", + "text_column = \"Tweet text\"\n", + "label_column = \"text_label\"\n", + "max_length = 64\n", + "lr = 5e-2\n", + "num_epochs = 50\n", + "batch_size = 8" + ] + }, + { + "cell_type": "markdown", + "id": "a617882d", + "metadata": {}, + "source": [ + "## Load and Process Dataset for LM Training" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1a3648b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Unlabeled', 'complaint', 'no complaint']\n", + "DatasetDict({\n", + " train: Dataset({\n", + " features: ['Tweet text', 'ID', 'Label', 'text_label'],\n", + " num_rows: 50\n", + " })\n", + " test: Dataset({\n", + " features: ['Tweet text', 'ID', 'Label', 'text_label'],\n", + " num_rows: 3399\n", + " })\n", + "})\n" + ] + }, + { + "data": { + "text/plain": [ + "{'Tweet text': '@HMRCcustomers No this is my first job',\n", + " 'ID': 0,\n", + " 'Label': 2,\n", + " 'text_label': 'no complaint'}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset = load_dataset(\n", + " \"parquet\",\n", + " data_files={\n", + " \"train\": f\"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/train/0000.parquet\",\n", + " \"test\": f\"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/test/0000.parquet\"\n", + " }\n", + ")\n", + "\n", + "classes = [k.replace(\"_\", \" \") for k in dataset[\"train\"].features[\"Label\"].names]\n", + "print(classes)\n", + "dataset = dataset.map(\n", + " lambda x: {\"text_label\": [classes[label] for label in x[\"Label\"]]},\n", + " batched=True,\n", + " num_proc=1,\n", + ")\n", + "print(dataset)\n", + "dataset[\"train\"][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fe12d4d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running tokenizer on dataset: 100%|██████████| 50/50 [00:00<00:00, 3551.43 examples/s]\n", + "Running tokenizer on dataset: 100%|██████████| 3399/3399 [00:00<00:00, 8558.01 examples/s]\n" + ] + } + ], + "source": [ + "# data preprocessing\n", + "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)\n", + "if tokenizer.pad_token_id is None:\n", + " tokenizer.pad_token_id = tokenizer.eos_token_id\n", + "target_max_length = max([len(tokenizer(class_label)[\"input_ids\"]) for class_label in classes])\n", + "print(target_max_length)\n", + "\n", + "\n", + "def preprocess_function(examples):\n", + " batch_size = len(examples[text_column])\n", + " inputs = [f\"{text_column} : {x} Label : \" for x in examples[text_column]]\n", + " targets = [str(x) for x in examples[label_column]]\n", + " model_inputs = tokenizer(inputs)\n", + " labels = tokenizer(targets, add_special_tokens=False) # don't add bos token because we concatenate with inputs\n", + " for i in range(batch_size):\n", + " sample_input_ids = model_inputs[\"input_ids\"][i]\n", + " label_input_ids = labels[\"input_ids\"][i] + [tokenizer.eos_token_id]\n", + " # print(i, sample_input_ids, label_input_ids)\n", + " model_inputs[\"input_ids\"][i] = sample_input_ids + label_input_ids\n", + " labels[\"input_ids\"][i] = [-100] * len(sample_input_ids) + label_input_ids\n", + " model_inputs[\"attention_mask\"][i] = [1] * len(model_inputs[\"input_ids\"][i])\n", + " # print(model_inputs)\n", + " for i in range(batch_size):\n", + " sample_input_ids = model_inputs[\"input_ids\"][i]\n", + " label_input_ids = labels[\"input_ids\"][i]\n", + " model_inputs[\"input_ids\"][i] = [tokenizer.pad_token_id] * (\n", + " max_length - len(sample_input_ids)\n", + " ) + sample_input_ids\n", + " model_inputs[\"attention_mask\"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[\n", + " \"attention_mask\"\n", + " ][i]\n", + " labels[\"input_ids\"][i] = [-100] * (max_length - len(sample_input_ids)) + label_input_ids\n", + " model_inputs[\"input_ids\"][i] = torch.tensor(model_inputs[\"input_ids\"][i][:max_length])\n", + " model_inputs[\"attention_mask\"][i] = torch.tensor(model_inputs[\"attention_mask\"][i][:max_length])\n", + " labels[\"input_ids\"][i] = torch.tensor(labels[\"input_ids\"][i][:max_length])\n", + " model_inputs[\"labels\"] = labels[\"input_ids\"]\n", + " return model_inputs\n", + "\n", + "\n", + "processed_datasets = dataset.map(\n", + " preprocess_function,\n", + " batched=True,\n", + " num_proc=1,\n", + " remove_columns=dataset[\"train\"].column_names,\n", + " load_from_cache_file=False,\n", + " desc=\"Running tokenizer on dataset\",\n", + ")\n", + "\n", + "train_dataset = processed_datasets[\"train\"]\n", + "eval_dataset = processed_datasets[\"train\"]\n", + "\n", + "\n", + "train_dataloader = DataLoader(\n", + " train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True\n", + ")\n", + "eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "641b21fe", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running tokenizer on dataset: 100%|██████████| 3399/3399 [00:00<00:00, 17380.64 examples/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "{'input_ids': tensor([[ 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 227985, 5484, 915, 2566, 74757, 64626, 12384, 44639, 613,\n", + " 52282, 2670, 79920, 3344, 1002, 368, 17646, 14472, 8348,\n", + " 664, 718, 4, 19036, 17, 31849, 17, 6312, 76,\n", + " 44, 62470, 56, 91, 50, 14839, 21, 77658, 915,\n", + " 210],\n", + " [ 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 227985, 5484, 915, 405, 187059,\n", + " 2256, 664, 2550, 18833, 18607, 162467, 4, 1387, 6199,\n", + " 3291, 23405, 613, 4657, 17082, 566, 3432, 368, 78851,\n", + " 1185, 61273, 23181, 1553, 15596, 212, 116057, 77658, 915,\n", + " 210],\n", + " [ 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 227985, 5484,\n", + " 915, 39762, 2566, 22253, 6201, 75701, 15, 632, 718,\n", + " 5840, 10006, 6201, 18881, 427, 3804, 19528, 267, 158974,\n", + " 1320, 368, 10029, 632, 49666, 92, 34, 77658, 915,\n", + " 210],\n", + " [ 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 227985, 5484, 915, 2566, 104565, 8695, 2089, 6140,\n", + " 109676, 99579, 1369, 512, 368, 4570, 54, 632, 368,\n", + " 1503, 241485, 132226, 15, 982, 727, 1152, 18100, 861,\n", + " 32596, 77597, 168154, 1306, 132226, 4346, 87843, 17, 130462,\n", + " 364, 32923, 89, 53, 8309, 20, 75, 77658, 915,\n", + " 210],\n", + " [ 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 227985, 5484, 915, 2566,\n", + " 14173, 2960, 29906, 387, 20706, 49337, 1369, 77658, 915,\n", + " 210],\n", + " [ 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 227985, 5484, 915, 2566, 219553, 45736,\n", + " 36876, 1713, 72, 707, 187205, 13002, 177324, 77658, 915,\n", + " 210],\n", + " [ 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 227985, 5484, 915, 2566, 233938, 28518, 13716,\n", + " 427, 28146, 1119, 17918, 17, 236706, 368, 214997, 7555,\n", + " 48659, 5276, 21600, 343, 17, 51416, 22403, 318, 1531,\n", + " 1306, 1130, 20934, 567, 101161, 184849, 87843, 17, 1594,\n", + " 15231, 2052, 16642, 20, 7180, 80, 26, 77658, 915,\n", + " 210],\n", + " [ 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 227985, 5484, 915, 2566, 80, 2068, 479, 2566, 80,\n", + " 1376, 878, 147587, 3904, 632, 368, 6084, 65673, 78851,\n", + " 11736, 15527, 19082, 33151, 461, 17, 45575, 17887, 632,\n", + " 5219, 14216, 68870, 5967, 1841, 4346, 87843, 17, 1594,\n", + " 14512, 27, 71, 8184, 19, 290, 63748, 77658, 915,\n", + " 210]]),\n", + " 'attention_mask': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n", + " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def test_preprocess_function(examples):\n", + " batch_size = len(examples[text_column])\n", + " inputs = [f\"{text_column} : {x} Label : \" for x in examples[text_column]]\n", + " model_inputs = tokenizer(inputs)\n", + " # print(model_inputs)\n", + " for i in range(batch_size):\n", + " sample_input_ids = model_inputs[\"input_ids\"][i]\n", + " model_inputs[\"input_ids\"][i] = [tokenizer.pad_token_id] * (\n", + " max_length - len(sample_input_ids)\n", + " ) + sample_input_ids\n", + " model_inputs[\"attention_mask\"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[\n", + " \"attention_mask\"\n", + " ][i]\n", + " model_inputs[\"input_ids\"][i] = torch.tensor(model_inputs[\"input_ids\"][i][:max_length])\n", + " model_inputs[\"attention_mask\"][i] = torch.tensor(model_inputs[\"attention_mask\"][i][:max_length])\n", + " return model_inputs\n", + "\n", + "\n", + "test_dataset = dataset[\"test\"].map(\n", + " test_preprocess_function,\n", + " batched=True,\n", + " num_proc=1,\n", + " remove_columns=dataset[\"train\"].column_names,\n", + " load_from_cache_file=False,\n", + " desc=\"Running tokenizer on dataset\",\n", + ")\n", + "\n", + "test_dataloader = DataLoader(test_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)\n", + "next(iter(test_dataloader))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "218df807", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "425" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show dataset size\n", + "len(test_dataloader)" + ] + }, + { + "cell_type": "markdown", + "id": "aa55f803", + "metadata": {}, + "source": [ + "## Train the LM with LNTuning\n", + "1. Create the base LM.\n", + "2. Only activate the LayerNorm layers in the LM for training.\n", + "3. Train the LM on the training dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a773e092", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 100,352 || all params: 559,314,944 || trainable%: 0.017941948642087417\n" + ] + } + ], + "source": [ + "# 1. creating the base LM\n", + "model = AutoModelForCausalLM.from_pretrained(model_name_or_path)\n", + "# 2. Only activate the LayerNorm layers in the Attention blocks in the LM for training\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b2f91568", + "metadata": {}, + "outputs": [], + "source": [ + "# setup the optimizer and lr scheduler\n", + "optimizer = torch.optim.AdamW(model.parameters(), lr=lr)\n", + "lr_scheduler = get_linear_schedule_with_warmup(\n", + " optimizer=optimizer,\n", + " num_warmup_steps=0,\n", + " num_training_steps=(len(train_dataloader) * num_epochs),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e4fb69fc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 7.09it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 23.05it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=0: train_ppl=tensor(8.1918, device='cuda:0') train_epoch_loss=tensor(2.1031, device='cuda:0') eval_ppl=tensor(2.1760, device='cuda:0') eval_epoch_loss=tensor(0.7775, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.88it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 23.11it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=1: train_ppl=tensor(1.8009, device='cuda:0') train_epoch_loss=tensor(0.5883, device='cuda:0') eval_ppl=tensor(2.1198, device='cuda:0') eval_epoch_loss=tensor(0.7513, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.87it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 23.08it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=2: train_ppl=tensor(2.0387, device='cuda:0') train_epoch_loss=tensor(0.7123, device='cuda:0') eval_ppl=tensor(1.6793, device='cuda:0') eval_epoch_loss=tensor(0.5184, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.92it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 23.03it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=3: train_ppl=tensor(1.4885, device='cuda:0') train_epoch_loss=tensor(0.3978, device='cuda:0') eval_ppl=tensor(1.2918, device='cuda:0') eval_epoch_loss=tensor(0.2561, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.89it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 23.00it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=4: train_ppl=tensor(1.3062, device='cuda:0') train_epoch_loss=tensor(0.2671, device='cuda:0') eval_ppl=tensor(1.3259, device='cuda:0') eval_epoch_loss=tensor(0.2821, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.79it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.92it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=5: train_ppl=tensor(1.3129, device='cuda:0') train_epoch_loss=tensor(0.2722, device='cuda:0') eval_ppl=tensor(1.2315, device='cuda:0') eval_epoch_loss=tensor(0.2082, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.83it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.93it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=6: train_ppl=tensor(1.2605, device='cuda:0') train_epoch_loss=tensor(0.2315, device='cuda:0') eval_ppl=tensor(1.2705, device='cuda:0') eval_epoch_loss=tensor(0.2394, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.87it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.79it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=7: train_ppl=tensor(1.2452, device='cuda:0') train_epoch_loss=tensor(0.2193, device='cuda:0') eval_ppl=tensor(1.2103, device='cuda:0') eval_epoch_loss=tensor(0.1909, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.88it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.87it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=8: train_ppl=tensor(1.2185, device='cuda:0') train_epoch_loss=tensor(0.1976, device='cuda:0') eval_ppl=tensor(1.2127, device='cuda:0') eval_epoch_loss=tensor(0.1929, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.83it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.80it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=9: train_ppl=tensor(1.1868, device='cuda:0') train_epoch_loss=tensor(0.1713, device='cuda:0') eval_ppl=tensor(1.1765, device='cuda:0') eval_epoch_loss=tensor(0.1625, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.83it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.99it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=10: train_ppl=tensor(1.1905, device='cuda:0') train_epoch_loss=tensor(0.1744, device='cuda:0') eval_ppl=tensor(1.1539, device='cuda:0') eval_epoch_loss=tensor(0.1431, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.80it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.94it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=11: train_ppl=tensor(1.1475, device='cuda:0') train_epoch_loss=tensor(0.1376, device='cuda:0') eval_ppl=tensor(1.1238, device='cuda:0') eval_epoch_loss=tensor(0.1167, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.81it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.75it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=12: train_ppl=tensor(1.1099, device='cuda:0') train_epoch_loss=tensor(0.1043, device='cuda:0') eval_ppl=tensor(1.0859, device='cuda:0') eval_epoch_loss=tensor(0.0824, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.77it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.95it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=13: train_ppl=tensor(1.0798, device='cuda:0') train_epoch_loss=tensor(0.0768, device='cuda:0') eval_ppl=tensor(1.1151, device='cuda:0') eval_epoch_loss=tensor(0.1089, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.87it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.91it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=14: train_ppl=tensor(1.0622, device='cuda:0') train_epoch_loss=tensor(0.0604, device='cuda:0') eval_ppl=tensor(1.0347, device='cuda:0') eval_epoch_loss=tensor(0.0341, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.86it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.88it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=15: train_ppl=tensor(1.0188, device='cuda:0') train_epoch_loss=tensor(0.0186, device='cuda:0') eval_ppl=tensor(1.0169, device='cuda:0') eval_epoch_loss=tensor(0.0168, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.87it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.86it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=16: train_ppl=tensor(1.0085, device='cuda:0') train_epoch_loss=tensor(0.0085, device='cuda:0') eval_ppl=tensor(1.0047, device='cuda:0') eval_epoch_loss=tensor(0.0047, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.80it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.71it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=17: train_ppl=tensor(1.0041, device='cuda:0') train_epoch_loss=tensor(0.0041, device='cuda:0') eval_ppl=tensor(1.0013, device='cuda:0') eval_epoch_loss=tensor(0.0013, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.82it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.86it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=18: train_ppl=tensor(1.0010, device='cuda:0') train_epoch_loss=tensor(0.0010, device='cuda:0') eval_ppl=tensor(1.0010, device='cuda:0') eval_epoch_loss=tensor(0.0010, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.77it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.85it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=19: train_ppl=tensor(1.0007, device='cuda:0') train_epoch_loss=tensor(0.0007, device='cuda:0') eval_ppl=tensor(1.0005, device='cuda:0') eval_epoch_loss=tensor(0.0005, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.77it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.80it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=20: train_ppl=tensor(1.0004, device='cuda:0') train_epoch_loss=tensor(0.0004, device='cuda:0') eval_ppl=tensor(1.0004, device='cuda:0') eval_epoch_loss=tensor(0.0004, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.78it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.78it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=21: train_ppl=tensor(1.0003, device='cuda:0') train_epoch_loss=tensor(0.0003, device='cuda:0') eval_ppl=tensor(1.0003, device='cuda:0') eval_epoch_loss=tensor(0.0003, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.73it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.80it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=22: train_ppl=tensor(1.0003, device='cuda:0') train_epoch_loss=tensor(0.0003, device='cuda:0') eval_ppl=tensor(1.0003, device='cuda:0') eval_epoch_loss=tensor(0.0003, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.68it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.77it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=23: train_ppl=tensor(1.0003, device='cuda:0') train_epoch_loss=tensor(0.0003, device='cuda:0') eval_ppl=tensor(1.0003, device='cuda:0') eval_epoch_loss=tensor(0.0003, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.79it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.55it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=24: train_ppl=tensor(1.0003, device='cuda:0') train_epoch_loss=tensor(0.0003, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.69it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.64it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=25: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.66it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.64it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=26: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.75it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.75it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=27: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.76it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.61it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=28: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.73it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.67it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=29: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.73it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=30: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.72it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.62it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=31: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.75it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.71it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=32: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.72it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.64it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=33: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.72it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.64it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=34: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.70it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=35: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.68it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.41it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=36: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.72it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.62it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=37: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.64it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=38: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.66it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.65it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=39: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.71it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.57it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=40: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.64it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.55it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=41: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.64it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.59it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=42: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.68it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.46it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=43: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.70it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.54it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=44: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.67it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.61it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=45: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.69it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.49it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=46: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.66it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.39it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=47: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.60it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.50it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=48: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 7/7 [00:00<00:00, 10.62it/s]\n", + "100%|██████████| 7/7 [00:00<00:00, 22.52it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=49: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# 3. train the LM on the training dataset\n", + "model = model.to(device)\n", + "\n", + "for epoch in range(num_epochs):\n", + " model.train()\n", + " total_loss = 0\n", + " for step, batch in enumerate(tqdm(train_dataloader)):\n", + " batch = {k: v.to(device) for k, v in batch.items()}\n", + " # print(batch)\n", + " # print(batch[\"input_ids\"].shape)\n", + " outputs = model(**batch)\n", + " loss = outputs.loss\n", + " total_loss += loss.detach().float()\n", + " loss.backward()\n", + " optimizer.step()\n", + " lr_scheduler.step()\n", + " optimizer.zero_grad()\n", + "\n", + " model.eval()\n", + " eval_loss = 0\n", + " eval_preds = []\n", + " for step, batch in enumerate(tqdm(eval_dataloader)):\n", + " batch = {k: v.to(device) for k, v in batch.items()}\n", + " with torch.no_grad():\n", + " outputs = model(**batch)\n", + " loss = outputs.loss\n", + " eval_loss += loss.detach().float()\n", + " eval_preds.extend(\n", + " tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)\n", + " )\n", + "\n", + " eval_epoch_loss = eval_loss / len(eval_dataloader)\n", + " eval_ppl = torch.exp(eval_epoch_loss)\n", + " train_epoch_loss = total_loss / len(train_dataloader)\n", + " train_ppl = torch.exp(train_epoch_loss)\n", + " print(f\"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}\")" + ] + }, + { + "cell_type": "markdown", + "id": "fbf339a2", + "metadata": {}, + "source": [ + "## Test the LM" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "53752a7b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "@TommyHilfiger Dramatic shopping exp. ordered 6 jeans same size (30/32) 2 fits / 2 too large / 2 too slim : same brand > different sizing\n", + "{'input_ids': tensor([[227985, 5484, 915, 2566, 226154, 126015, 5385, 259, 239364,\n", + " 3396, 70823, 5853, 17, 57247, 1231, 191040, 5025, 7869,\n", + " 375, 2324, 149349, 12, 415, 122321, 897, 415, 10136,\n", + " 10021, 897, 415, 10136, 6497, 381, 915, 5025, 51950,\n", + " 66869, 5955, 272, 20311, 77658, 915, 210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n", + "tensor([[227985, 5484, 915, 2566, 226154, 126015, 5385, 259, 239364,\n", + " 3396, 70823, 5853, 17, 57247, 1231, 191040, 5025, 7869,\n", + " 375, 2324, 149349, 12, 415, 122321, 897, 415, 10136,\n", + " 10021, 897, 415, 10136, 6497, 381, 915, 5025, 51950,\n", + " 66869, 5955, 272, 20311, 77658, 915, 210, 1936, 106863,\n", + " 2, 1936, 106863, 2, 1936, 106863, 2, 1936]],\n", + " device='cuda:0')\n", + "['Tweet text : @TommyHilfiger Dramatic shopping exp. ordered 6 jeans same size (30/32) 2 fits / 2 too large / 2 too slim : same brand > different sizing Label : no complaintno complaintno complaintno']\n" + ] + } + ], + "source": [ + "model.eval()\n", + "i = 33\n", + "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n", + "print(dataset[\"test\"][i][\"Tweet text\"])\n", + "print(inputs)\n", + "\n", + "with torch.no_grad():\n", + " inputs = {k: v.to(device) for k, v in inputs.items()}\n", + " outputs = model.generate(\n", + " input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n", + " )\n", + " print(outputs)\n", + " print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))" + ] + }, + { + "cell_type": "markdown", + "id": "c8f35152", + "metadata": {}, + "source": [ + "## Save the trainable LM weights (LayerNorm layers)\n", + "You can push model to hub or save model locally. \n", + "\n", + "- Option1: Push the model to Hugging Face Hub:\n", + "\n", + " ```python\n", + " model.push_to_hub(\n", + " f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\"),\n", + " token = \"hf_...\"\n", + " )\n", + " ```\n", + " token (`bool` or `str`, *optional*):\n", + " `token` is to be used for HTTP Bearer authorization when accessing remote files. If `True`, will use the token generated\n", + " when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url`\n", + " is not specified.\n", + " Or you can get your token from https://huggingface.co/settings/token\n", + " ```\n", + "- Option2: Save model locally:\n", + "\n", + " ```python\n", + " peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\")\n", + " model.save_pretrained(peft_model_id)\n", + " ```" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d8ba1f8c", + "metadata": {}, + "outputs": [], + "source": [ + "# saving model\n", + "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\n", + " \"/\", \"_\"\n", + ")\n", + "model.save_pretrained(peft_model_id)" + ] + }, + { + "cell_type": "markdown", + "id": "4dd7ab9c", + "metadata": {}, + "source": [ + "## Test the LM using LNTuning loaded from saved weights\n", + "1. load the LNTuning configuration\n", + "2. load the base LM\n", + "3. merge the LNTuning weights into the base LM using the PEFT config" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "4d9476e1", + "metadata": {}, + "outputs": [], + "source": [ + "from peft import PeftModel, PeftConfig\n", + "\n", + "# load the LNTuning config\n", + "config = PeftConfig.from_pretrained(peft_model_id)\n", + "# load the base LM\n", + "model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)\n", + "# merge LNTuning weights into the base LM\n", + "model = PeftModel.from_pretrained(model, peft_model_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "ebe174a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "@greateranglia Ok thanks...\n", + "{'input_ids': tensor([[227985, 5484, 915, 2566, 14173, 2960, 29906, 387, 20706,\n", + " 49337, 1369, 77658, 915, 210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n", + "tensor([[227985, 5484, 915, 2566, 14173, 2960, 29906, 387, 20706,\n", + " 49337, 1369, 77658, 915, 210, 1936, 106863, 2, 1936,\n", + " 106863, 2, 1936, 106863, 2, 1936]], device='cuda:0')\n", + "['Tweet text : @greateranglia Ok thanks... Label : no complaintno complaintno complaintno']\n" + ] + } + ], + "source": [ + "model.to(device)\n", + "model.eval()\n", + "i = 4\n", + "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n", + "print(dataset[\"test\"][i][\"Tweet text\"])\n", + "print(inputs)\n", + "\n", + "with torch.no_grad():\n", + " inputs = {k: v.to(device) for k, v in inputs.items()}\n", + " outputs = model.generate(\n", + " input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n", + " )\n", + " print(outputs)\n", + " print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_lora_clm_accelerate_ds_zero3_offload.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_lora_clm_accelerate_ds_zero3_offload.py new file mode 100644 index 0000000000000000000000000000000000000000..d908530f97f222df200e37ce60fa70c0fca9bfaf --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_lora_clm_accelerate_ds_zero3_offload.py @@ -0,0 +1,381 @@ +import gc +import os +import sys +import threading + +import psutil +import torch +from accelerate import Accelerator +from datasets import load_dataset +from torch.utils.data import DataLoader +from tqdm import tqdm +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + default_data_collator, + get_linear_schedule_with_warmup, + set_seed, +) + +from peft import LoraConfig, TaskType, get_peft_model + + +def levenshtein_distance(str1, str2): + # TC: O(N^2) + # SC: O(N) + if str1 == str2: + return 0 + num_rows = len(str1) + 1 + num_cols = len(str2) + 1 + dp_matrix = list(range(num_cols)) + for i in range(1, num_rows): + prev = dp_matrix[0] + dp_matrix[0] = i + for j in range(1, num_cols): + temp = dp_matrix[j] + if str1[i - 1] == str2[j - 1]: + dp_matrix[j] = prev + else: + dp_matrix[j] = min(prev, dp_matrix[j], dp_matrix[j - 1]) + 1 + prev = temp + return dp_matrix[num_cols - 1] + + +def get_closest_label(eval_pred, classes): + min_id = sys.maxsize + min_edit_distance = sys.maxsize + for i, class_label in enumerate(classes): + edit_distance = levenshtein_distance(eval_pred.strip(), class_label) + if edit_distance < min_edit_distance: + min_id = i + min_edit_distance = edit_distance + return classes[min_id] + + +# Converting Bytes to Megabytes +def b2mb(x): + return int(x / 2**20) + + +# This context manager is used to track the peak memory usage of the process +class TorchTracemalloc: + def __enter__(self): + gc.collect() + self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + self.device_module = getattr(torch, self.device_type, torch.cuda) + self.device_module.empty_cache() + self.device_module.reset_peak_memory_stats() # reset the peak gauge to zero + self.begin = self.device_module.memory_allocated() + self.process = psutil.Process() + + self.cpu_begin = self.cpu_mem_used() + self.peak_monitoring = True + peak_monitor_thread = threading.Thread(target=self.peak_monitor_func) + peak_monitor_thread.daemon = True + peak_monitor_thread.start() + return self + + def cpu_mem_used(self): + """get resident set size memory for the current process""" + return self.process.memory_info().rss + + def peak_monitor_func(self): + self.cpu_peak = -1 + + while True: + self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak) + + # can't sleep or will not catch the peak right (this comment is here on purpose) + # time.sleep(0.001) # 1msec + + if not self.peak_monitoring: + break + + def __exit__(self, *exc): + self.peak_monitoring = False + + gc.collect() + self.device_module.empty_cache() + self.end = self.device_module.memory_allocated() + self.peak = self.device_module.max_memory_allocated() + self.used = b2mb(self.end - self.begin) + self.peaked = b2mb(self.peak - self.begin) + + self.cpu_end = self.cpu_mem_used() + self.cpu_used = b2mb(self.cpu_end - self.cpu_begin) + self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin) + # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}") + + +def main(): + accelerator = Accelerator() + model_name_or_path = "bigscience/bloomz-7b1" + dataset_name = "twitter_complaints" + peft_config = LoraConfig(task_type=TaskType.CAUSAL_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1) + text_column = "Tweet text" + label_column = "text_label" + lr = 3e-3 + num_epochs = 20 + batch_size = 8 + seed = 42 + max_length = 64 + do_test = False + set_seed(seed) + + dataset = load_dataset( + "parquet", + data_files={ + "train": f"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/train/0000.parquet", + "test": f"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/test/0000.parquet", + }, + ) + classes = [k.replace("_", " ") for k in dataset["train"].features["Label"].names] + dataset = dataset.map( + lambda x: {"text_label": [classes[label] for label in x["Label"]]}, + batched=True, + num_proc=1, + ) + + tokenizer = AutoTokenizer.from_pretrained(model_name_or_path) + + def preprocess_function(examples): + batch_size = len(examples[text_column]) + inputs = [f"{text_column} : {x} Label : " for x in examples[text_column]] + targets = [str(x) for x in examples[label_column]] + model_inputs = tokenizer(inputs) + labels = tokenizer(targets, add_special_tokens=False) # don't add bos token because we concatenate with inputs + for i in range(batch_size): + sample_input_ids = model_inputs["input_ids"][i] + label_input_ids = labels["input_ids"][i] + [tokenizer.eos_token_id] + model_inputs["input_ids"][i] = sample_input_ids + label_input_ids + labels["input_ids"][i] = [-100] * len(sample_input_ids) + label_input_ids + model_inputs["attention_mask"][i] = [1] * len(model_inputs["input_ids"][i]) + for i in range(batch_size): + sample_input_ids = model_inputs["input_ids"][i] + label_input_ids = labels["input_ids"][i] + model_inputs["input_ids"][i] = [tokenizer.pad_token_id] * ( + max_length - len(sample_input_ids) + ) + sample_input_ids + model_inputs["attention_mask"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[ + "attention_mask" + ][i] + labels["input_ids"][i] = [-100] * (max_length - len(sample_input_ids)) + label_input_ids + model_inputs["input_ids"][i] = torch.tensor(model_inputs["input_ids"][i][:max_length]) + model_inputs["attention_mask"][i] = torch.tensor(model_inputs["attention_mask"][i][:max_length]) + labels["input_ids"][i] = torch.tensor(labels["input_ids"][i][:max_length]) + model_inputs["labels"] = labels["input_ids"] + return model_inputs + + def test_preprocess_function(examples): + batch_size = len(examples[text_column]) + inputs = [f"{text_column} : {x} Label : " for x in examples[text_column]] + model_inputs = tokenizer(inputs) + for i in range(batch_size): + sample_input_ids = model_inputs["input_ids"][i] + model_inputs["input_ids"][i] = [tokenizer.pad_token_id] * ( + max_length - len(sample_input_ids) + ) + sample_input_ids + model_inputs["attention_mask"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[ + "attention_mask" + ][i] + model_inputs["input_ids"][i] = torch.tensor(model_inputs["input_ids"][i][:max_length]) + model_inputs["attention_mask"][i] = torch.tensor(model_inputs["attention_mask"][i][:max_length]) + return model_inputs + + with accelerator.main_process_first(): + processed_datasets = dataset.map( + preprocess_function, + batched=True, + num_proc=1, + remove_columns=dataset["train"].column_names, + load_from_cache_file=True, + desc="Running tokenizer on dataset", + ) + accelerator.wait_for_everyone() + + train_dataset = processed_datasets["train"] + + with accelerator.main_process_first(): + processed_datasets = dataset.map( + test_preprocess_function, + batched=True, + num_proc=1, + remove_columns=dataset["train"].column_names, + load_from_cache_file=False, + desc="Running tokenizer on dataset", + ) + eval_dataset = processed_datasets["train"] + test_dataset = processed_datasets["test"] + + train_dataloader = DataLoader( + train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True + ) + eval_dataloader = DataLoader( + eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True + ) + test_dataloader = DataLoader( + test_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True + ) + + print(next(iter(train_dataloader))) + + # creating model + model = AutoModelForCausalLM.from_pretrained(model_name_or_path) + model = get_peft_model(model, peft_config) + model.print_trainable_parameters() + + # optimizer + optimizer = torch.optim.AdamW(model.parameters(), lr=lr) + + # lr scheduler + lr_scheduler = get_linear_schedule_with_warmup( + optimizer=optimizer, + num_warmup_steps=0, + num_training_steps=(len(train_dataloader) * num_epochs), + ) + + model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler = accelerator.prepare( + model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler + ) + accelerator.print(model) + + is_ds_zero_3 = False + if getattr(accelerator.state, "deepspeed_plugin", None): + is_ds_zero_3 = accelerator.state.deepspeed_plugin.zero_stage == 3 + + for epoch in range(num_epochs): + with TorchTracemalloc() as tracemalloc: + model.train() + total_loss = 0 + for step, batch in enumerate(tqdm(train_dataloader)): + outputs = model(**batch) + loss = outputs.loss + total_loss += loss.detach().float() + accelerator.backward(loss) + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + # Printing the memory usage details such as allocated memory, peak memory, and total memory usage + accelerator.print( + f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}" + ) + + accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}") + accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}") + accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}") + accelerator.print( + f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}" + ) + train_epoch_loss = total_loss / len(train_dataloader) + train_ppl = torch.exp(train_epoch_loss) + accelerator.print(f"{epoch=}: {train_ppl=} {train_epoch_loss=}") + + model.eval() + eval_preds = [] + with TorchTracemalloc() as tracemalloc: + for _, batch in enumerate(tqdm(eval_dataloader)): + batch = {k: v for k, v in batch.items() if k != "labels"} + with torch.no_grad(): + outputs = accelerator.unwrap_model(model).generate( + **batch, synced_gpus=is_ds_zero_3, max_new_tokens=10 + ) # synced_gpus=True for DS-stage 3 + outputs = accelerator.pad_across_processes(outputs, dim=1, pad_index=tokenizer.pad_token_id) + preds = accelerator.gather_for_metrics(outputs) + preds = preds[:, max_length:].detach().cpu().numpy() + eval_preds.extend(tokenizer.batch_decode(preds, skip_special_tokens=True)) + + # Printing the memory usage details such as allocated memory, peak memory, and total memory usage + accelerator.print( + f"{accelerator.device.type.upper()} Memory before entering the eval : {b2mb(tracemalloc.begin)}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Memory consumed at the end of the eval (end-begin): {tracemalloc.used}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Peak Memory consumed during the eval (max-begin): {tracemalloc.peaked}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Total Peak Memory consumed during the eval (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}" + ) + + accelerator.print(f"CPU Memory before entering the eval : {b2mb(tracemalloc.cpu_begin)}") + accelerator.print(f"CPU Memory consumed at the end of the eval (end-begin): {tracemalloc.cpu_used}") + accelerator.print(f"CPU Peak Memory consumed during the eval (max-begin): {tracemalloc.cpu_peaked}") + accelerator.print( + f"CPU Total Peak Memory consumed during the eval (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}" + ) + + correct = 0 + total = 0 + assert len(eval_preds) == len(dataset["train"][label_column]), ( + f"{len(eval_preds)} != {len(dataset['train'][label_column])}" + ) + for pred, true in zip(eval_preds, dataset["train"][label_column]): + if pred.strip() == true.strip(): + correct += 1 + total += 1 + accuracy = correct / total * 100 + accelerator.print(f"{accuracy=}") + accelerator.print(f"{eval_preds[:10]=}") + accelerator.print(f"{dataset['train'][label_column][:10]=}") + + if do_test: + model.eval() + test_preds = [] + for _, batch in enumerate(tqdm(test_dataloader)): + batch = {k: v for k, v in batch.items() if k != "labels"} + with torch.no_grad(): + outputs = accelerator.unwrap_model(model).generate( + **batch, synced_gpus=is_ds_zero_3, max_new_tokens=10 + ) # synced_gpus=True for DS-stage 3 + outputs = accelerator.pad_across_processes(outputs, dim=1, pad_index=tokenizer.pad_token_id) + preds = accelerator.gather(outputs) + preds = preds[:, max_length:].detach().cpu().numpy() + test_preds.extend(tokenizer.batch_decode(preds, skip_special_tokens=True)) + + test_preds_cleaned = [] + for _, pred in enumerate(test_preds): + test_preds_cleaned.append(get_closest_label(pred, classes)) + + test_df = dataset["test"].to_pandas() + assert len(test_preds_cleaned) == len(test_df), f"{len(test_preds_cleaned)} != {len(test_df)}" + test_df[label_column] = test_preds_cleaned + test_df["text_labels_orig"] = test_preds + accelerator.print(test_df[[text_column, label_column]].sample(20)) + + pred_df = test_df[["ID", label_column]] + pred_df.columns = ["ID", "Label"] + + os.makedirs(f"data/{dataset_name}", exist_ok=True) + pred_df.to_csv(f"data/{dataset_name}/predictions.csv", index=False) + + accelerator.wait_for_everyone() + # Option1: Pushing the model to Hugging Face Hub + # model.push_to_hub( + # f"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}".replace("/", "_"), + # token = "hf_..." + # ) + # token (`bool` or `str`, *optional*): + # `token` is to be used for HTTP Bearer authorization when accessing remote files. If `True`, will use the token generated + # when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url` + # is not specified. + # Or you can get your token from https://huggingface.co/settings/token + # Option2: Saving the model locally + peft_model_id = f"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}".replace( + "/", "_" + ) + model.save_pretrained(peft_model_id) + accelerator.wait_for_everyone() + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_lora_clm_with_additional_tokens.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_lora_clm_with_additional_tokens.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..dd699d0a4f84e99465b7acd509e88ed5ae3c15af --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_lora_clm_with_additional_tokens.ipynb @@ -0,0 +1,1012 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5f239612-620e-4430-8685-9fdc6b179b41", + "metadata": {}, + "source": [ + "# Training PEFT models with new tokens being added to the embedding layers and tokenizer\n", + "\n", + "In this example, we will learn how to train a LoRA model when adding new tokens to the tokenizer and model. \n", + "This is a common usecase when doing the following:\n", + "1. Instruction finetuning with new tokens beind added such as `<|user|>`, `<|assistant|>`, `<|system|>`, ``, `` to properly format the conversations\n", + "2. Finetuning on a specific language wherein language spoecific tokens are added, e.g., korean tokens being added to vocabulary for finetuning LLM on Korean datasets.\n", + "3. Instruction finetuning to return outputs in certain format to enable agent behaviour new tokens such as `<|FUNCTIONS|>`, `<|BROWSE|>`, `<|TEXT2IMAGE|>`, `<|ASR|>`, `<|TTS|>`, `<|GENERATECODE|>`, `<|RAG|>`.\n", + "\n", + "In such cases, you add the Embedding modules to the LORA `target_modules`. PEFT will take care of saving the embedding layers with the new added tokens along with the adapter weights that were trained on the specific initialization of the embeddings weights of the added tokens." + ] + }, + { + "cell_type": "markdown", + "id": "b27c55e8-edaa-4059-90bc-d6096d596902", + "metadata": {}, + "source": [ + "Let's import the necessary libraries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6f864c90", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.environ[\"WANDB_PROJECT\"] = \"PeftExamples\"\n", + "import transformers\n", + "from peft import (\n", + " LoraConfig,\n", + " PeftConfig,\n", + " PeftModel,\n", + " get_peft_model,\n", + " prepare_model_for_kbit_training,\n", + ")\n", + "from transformers import (\n", + " AutoModelForCausalLM,\n", + " AutoTokenizer,\n", + " HfArgumentParser,\n", + " TrainingArguments,\n", + " Trainer,\n", + " default_data_collator,\n", + ")\n", + "import torch\n", + "from dataclasses import dataclass, field\n", + "from typing import Optional\n", + "from dataclass_csv import DataclassReader\n", + "from torch.utils.data import Dataset, DataLoader\n", + "\n", + "from enum import Enum" + ] + }, + { + "cell_type": "markdown", + "id": "74950a3f-bb63-4ce5-9e2b-1b83f92b13a2", + "metadata": {}, + "source": [ + "## Prepare Model and Tokenizer" + ] + }, + { + "cell_type": "markdown", + "id": "76763f5e-64b2-409b-8845-ae5589f8a4e0", + "metadata": {}, + "source": [ + "Now, we will be adding 27 new tokens as well as replace the existing pad, bos and eos tokens of the model." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fd0498ea-547e-418d-bf13-c9abafdd5476", + "metadata": {}, + "outputs": [], + "source": [ + "class SpecialTokens(str, Enum):\n", + " begin_target = \"<|begintarget|>\"\n", + " end_target = \"<|endtarget|>\"\n", + " begin_context = \"<|begincontext|>\"\n", + " end_context = \"<|endcontext|>\"\n", + " system = \"<|system|>\"\n", + " user = \"<|user|>\"\n", + " begin_last_user_utterance = \"<|beginlastuserutterance|>\"\n", + " end_last_user_utterance = \"<|endlastuserutterance|>\"\n", + " begin_dsts = \"<|begindsts|>\"\n", + " end_dsts = \"<|enddsts|>\"\n", + " begin_dst = \"<|begindst|>\"\n", + " end_dst = \"<|enddst|>\"\n", + " begin_belief = \"<|beginbelief|>\"\n", + " end_belief = \"<|endbelief|>\"\n", + " begin_response = \"<|beginresponse|>\"\n", + " end_response = \"<|endresponse|>\"\n", + " begin_action = \"<|beginaction|>\"\n", + " end_action = \"<|endaction|>\"\n", + " begin_user_action = \"<|beginuseraction|>\"\n", + " end_user_action = \"<|enduseraction|>\"\n", + " sys_actions = \"<|sysactions|>\"\n", + " begin_intent = \"<|beginintent|>\"\n", + " end_intent = \"<|endintent|>\"\n", + " begin_requested_slots = \"<|beginrequestedslots|>\"\n", + " end_requested_slots = \"<|endrequestedslots|>\"\n", + " pad_token = \"<|pad|>\"\n", + " bos_token = \"<|startoftext|>\"\n", + "\n", + " @classmethod\n", + " def list(cls):\n", + " return [c.value for c in cls]" + ] + }, + { + "cell_type": "markdown", + "id": "ae4a4255-5f13-4eef-a024-4f1de0f2173b", + "metadata": {}, + "source": [ + "We will be finetuning Mistral-7B model. Let's load the tokenizer and add the special tokens followed by loading the base model and resizing the embedding layers to accommodate the newly added tokens." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f0eedef9", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "91c67b6377fc4dd7977bf544de784d51", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading checkpoint shards: 0%| | 0/2 [00:00<|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|startoftext|><|begincontext|><|user|> Can you find me place to eat?<|system|> What kind of food would you like to have and where would you like me to search in?<|user|> Food kind of California will be perfect in SF.<|system|> There are 10 restaurants, Al's Place is one of the good restaurant in San Francisco.<|user|> Can you look for any other restaurant?<|system|> Alta Msp is one of the good restaurant in San Francisco.<|beginlastuserutterance|> Can you find me the address?<|endlastuserutterance|><|endcontext|><|begintarget|><|begindsts|><|begindst|><|beginintent|> FindRestaurants<|endintent|><|beginrequestedslots|> Restaurants^street_address<|endrequestedslots|><|beginbelief|> Restaurants^city->SF~San Francisco|Restaurants^cuisine->California<|endbelief|><|enddst|><|enddsts|><|beginuseraction|> REQUEST->Restaurants^street_address~<|enduseraction|><|beginaction|> INFORM->Restaurants^street_address~1275 Minnesota Street<|endaction|><|beginresponse|> The street address of the restaurant is 1275 Minnesota Street.<|endresponse|><|endtarget|><|endtarget|>\"" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenizer.decode(train_dataset[0][\"input_ids\"])" + ] + }, + { + "cell_type": "markdown", + "id": "239d1c83-196d-471e-9bf7-5f36dafa9894", + "metadata": {}, + "source": [ + "# Train the model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ec80d6ee", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n", + "Failed to detect the name of this notebook, you can set it manually with the WANDB_NOTEBOOK_NAME environment variable to enable code saving.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33msmangrul\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.16.0" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /raid/sourab/temp/wandb/run-20231128_230934-edod21gq" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run ethereal-eon-1 to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://wandb.ai/smangrul/PeftExamples" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://wandb.ai/smangrul/PeftExamples/runs/edod21gq" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "

\n", + " \n", + " \n", + " [246/246 05:51, Epoch 2/2]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
105.189800
203.745500
302.371500
401.630200
501.302600
600.999400
700.704100
800.527800
900.509700
1000.382300
1100.318200
1200.323500
1300.263400
1400.290900
1500.277400
1600.232800
1700.223600
1800.229600
1900.233100
2000.210200
2100.245800
2200.197300
2300.210100
2400.209800

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=246, training_loss=0.8516577879587809, metrics={'train_runtime': 354.9013, 'train_samples_per_second': 5.556, 'train_steps_per_second': 0.693, 'total_flos': 4.318233532091597e+16, 'train_loss': 0.8516577879587809, 'epoch': 2.0})" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "training_args = TrainingArguments(\n", + " output_dir=\"mistral_lora_clm_with_added_tokens\",\n", + " num_train_epochs=2,\n", + " save_total_limit=5,\n", + " per_device_train_batch_size=8,\n", + " warmup_steps=10,\n", + " weight_decay=0.0001,\n", + " dataloader_drop_last=True,\n", + " bf16=True,\n", + " logging_steps=10,\n", + " learning_rate=1e-5,\n", + " gradient_checkpointing=True,\n", + " gradient_checkpointing_kwargs={\"use_reentrant\": False},\n", + " remove_unused_columns=False,\n", + " hub_model_id=\"smangrul/mistral_lora_clm_with_added_tokens\",\n", + " push_to_hub=True,\n", + " hub_private_repo=True,\n", + ")\n", + "trainer = Trainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=train_dataset,\n", + " data_collator=default_data_collator,\n", + ")\n", + "# model.config.use_cache = False\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "id": "7bc1cbed-4eb9-4aaa-ab5f-5b91bf432307", + "metadata": {}, + "source": [ + "# Check the model output on a sample from evaluation dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "71851793", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "context=\"<|begincontext|><|user|>Can you find me a place to eat please?<|system|>Where at? And what kind of cuisine are you craving?<|user|>Somewhere in SF, and I am really craving Thai food at the moment!<|system|>I found a bunch of restaurants, there's actually 10 that you might like in San Francisco, one of them being Baan Thai House & Wine Bar<|user|>How can I reach them? And what's their address?<|system|>You can reach them by phone at 415-379-4505 and visit them at 534 Irving Street<|beginlastuserutterance|>Great, that restaurant sounds good<|endlastuserutterance|><|endcontext|>\" \n", + "\n", + " target_predicted='<|begintarget|><|begindsts|><|begindst|><|beginintent|> FindRestaurants<|endintent|><|beginbelief|> Restaurants^city->SF~San Francisco|Restaurants^cuisine->Thai|Restaurants^restaurant_name->Baan Thai House & Wine Bar<|endbelief|><|enddst|><|enddsts|><|beginuseraction|> REQUEST->Restaurants^phone_number~|REQUEST->Restaurants^street_address~<|enduseraction|><|beginaction|> INFORM->Restaurants^phone_number~415-379-4505|INFORM->Restaurants^street_address~534 Irving Street<|endaction|><|beginresponse|> Great, the phone number is 415-379-4505 and the address is 534 Irving Street<|endresponse|><|endtarget|>' \n", + "\n", + " target='<|begintarget|><|begindsts|><|begindst|><|beginintent|>FindRestaurants<|endintent|><|beginbelief|>Restaurants^city->SF~San Francisco|Restaurants^cuisine->Thai|Restaurants^restaurant_name->Baan Thai House & Wine Bar<|endbelief|><|enddst|><|enddsts|><|beginuseraction|>SELECT->Restaurants^~<|enduseraction|><|beginaction|>OFFER_INTENT->Restaurants^intent~ReserveRestaurant<|endaction|><|beginresponse|>Want me to book a table?<|endresponse|><|endtarget|>'\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "i = random.randint(0, len(dataset[\"test\"]))\n", + "context = dataset[\"test\"][i][\"context\"]\n", + "\n", + "batch = tokenizer(context, return_tensors=\"pt\")\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "batch = {k: v.to(device) for k, v in batch.items()}\n", + "model.eval()\n", + "output_tokens = model.generate(\n", + " **batch,\n", + " max_new_tokens=256,\n", + " do_sample=True,\n", + " temperature=0.2,\n", + " top_p=0.95,\n", + " top_k=50,\n", + " eos_token_id=tokenizer.eos_token_id,\n", + " pad_token_id=tokenizer.pad_token_id,\n", + ")\n", + "target_predicted = tokenizer.decode(output_tokens[0], skip_special_tokens=False).split(\"<|endcontext|>\")[1]\n", + "target = dataset[\"test\"][i][\"target\"]\n", + "print(f\"{context=} \\n\\n {target_predicted=} \\n\\n {target=}\")" + ] + }, + { + "cell_type": "markdown", + "id": "f940a660-2f7c-4a3a-b412-3f037aedb890", + "metadata": {}, + "source": [ + "# Save the Adapter model " + ] + }, + { + "cell_type": "markdown", + "id": "7ebe05e9-9b93-42f6-bba8-46b8cc3d100f", + "metadata": {}, + "source": [ + "When the lora layers are applied to embedding layers, the corresponding base model embedding layers are also saved. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3d7459ba-caa8-4f10-aa70-89be4541cbdf", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/raid/sourab/peft/src/peft/utils/save_and_load.py:128: UserWarning: Setting `is_embedding_layer_resized` to `True` as embedding layers found in `target_modules`\n", + " warnings.warn(\"Setting `is_embedding_layer_resized` to `True` as embedding layers found in `target_modules`\")\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8d23186832014f209939ab83e79da011", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Upload 3 LFS files: 0%| | 0/3 [00:00<|user|>Can you find me a place to eat please?<|system|>Where at? And what kind of cuisine are you craving?<|user|>Somewhere in SF, and I am really craving Thai food at the moment!<|system|>I found a bunch of restaurants, there's actually 10 that you might like in San Francisco, one of them being Baan Thai House & Wine Bar<|user|>How can I reach them? And what's their address?<|system|>You can reach them by phone at 415-379-4505 and visit them at 534 Irving Street<|beginlastuserutterance|>Great, that restaurant sounds good<|endlastuserutterance|><|endcontext|>\" \n", + "\n", + " target_predicted='<|begintarget|><|begindsts|><|begindst|><|beginintent|> FindRestaurant<|endintent|><|beginbelief|> Restaurants^city->SF~San Francisco|Restaurants^cuisine->Thai|Restaurants^restaurant_name->Baan Thai House & Wine Bar<|endbelief|><|enddst|><|enddsts|><|beginuseraction|> REQUEST->Restaurants^phone_number~|REQUEST->Restaurants^street_address~<|enduseraction|><|beginaction|> INFORM->Restaurants^phone_number~415-379-4505|INFORM->Restaurants^street_address~534 Irving Street<|endaction|><|beginresponse|> The phone number is 415-379-4505 and the address is 534 Irving Street<|endresponse|><|endtarget|>' \n", + "\n", + " target='<|begintarget|><|begindsts|><|begindst|><|beginintent|>FindRestaurants<|endintent|><|beginbelief|>Restaurants^city->SF~San Francisco|Restaurants^cuisine->Thai|Restaurants^restaurant_name->Baan Thai House & Wine Bar<|endbelief|><|enddst|><|enddsts|><|beginuseraction|>SELECT->Restaurants^~<|enduseraction|><|beginaction|>OFFER_INTENT->Restaurants^intent~ReserveRestaurant<|endaction|><|beginresponse|>Want me to book a table?<|endresponse|><|endtarget|>'\n" + ] + } + ], + "source": [ + "from peft import PeftModel\n", + "\n", + "inference_model = AutoModelForCausalLM.from_pretrained(\n", + " model_name,\n", + " low_cpu_mem_usage=True,\n", + " # attn_implementation =\"flash_attention_2\",\n", + ")\n", + "inference_model.resize_token_embeddings(len(tokenizer))\n", + "\n", + "inference_model = PeftModel.from_pretrained(inference_model, \"smangrul/mistral_lora_clm_with_added_tokens\")\n", + "inference_model.to(device)\n", + "inference_model.eval()\n", + "\n", + "output_tokens = inference_model.generate(\n", + " **batch,\n", + " max_new_tokens=256,\n", + " do_sample=True,\n", + " temperature=0.2,\n", + " top_p=0.95,\n", + " top_k=50,\n", + " eos_token_id=tokenizer.eos_token_id,\n", + " pad_token_id=tokenizer.pad_token_id,\n", + ")\n", + "\n", + "target_predicted = tokenizer.decode(output_tokens[0], skip_special_tokens=False).split(\"<|endcontext|>\")[1]\n", + "print(f\"{context=} \\n\\n {target_predicted=} \\n\\n {target=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd57f6e8-761f-4e0b-941c-f6973e13b186", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_prefix_tuning_clm.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_prefix_tuning_clm.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..56e2e9fdfeb068998479370be27af66bb5cca070 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_prefix_tuning_clm.ipynb @@ -0,0 +1,1375 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "71fbfca2", + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import AutoModelForCausalLM\n", + "from peft import get_peft_config, get_peft_model, PrefixTuningConfig, TaskType, PeftType\n", + "import torch\n", + "from datasets import load_dataset\n", + "import os\n", + "from transformers import AutoTokenizer\n", + "from torch.utils.data import DataLoader\n", + "from transformers import default_data_collator, get_linear_schedule_with_warmup\n", + "from tqdm import tqdm\n", + "\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "model_name_or_path = \"bigscience/bloomz-560m\"\n", + "tokenizer_name_or_path = \"bigscience/bloomz-560m\"\n", + "peft_config = PrefixTuningConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=30)\n", + "\n", + "dataset_name = \"twitter_complaints\"\n", + "checkpoint_name = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}_v1.pt\".replace(\n", + " \"/\", \"_\"\n", + ")\n", + "text_column = \"Tweet text\"\n", + "label_column = \"text_label\"\n", + "max_length = 64\n", + "lr = 3e-2\n", + "num_epochs = 50\n", + "batch_size = 8" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1a3648b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Found cached dataset raft (/home/sourab/.cache/huggingface/datasets/ought___raft/twitter_complaints/1.1.0/79c4de1312c1e3730043f7db07179c914f48403101f7124e2fe336f6f54d9f84)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "56d9908a2c8944b484348cc46b16a261", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/2 [00:00, base_model_name_or_path='bigscience/bloomz-560m', task_type=, inference_mode=False, num_virtual_tokens=30, token_dim=1024, num_transformer_submodules=1, num_attention_heads=16, num_layers=24, encoder_hidden_size=1024, prefix_projection=False)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.peft_config" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b2f91568", + "metadata": {}, + "outputs": [], + "source": [ + "# model\n", + "# optimizer and lr scheduler\n", + "optimizer = torch.optim.AdamW(model.parameters(), lr=lr)\n", + "lr_scheduler = get_linear_schedule_with_warmup(\n", + " optimizer=optimizer,\n", + " num_warmup_steps=0,\n", + " num_training_steps=(len(train_dataloader) * num_epochs),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e4fb69fc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:01<00:00, 5.79it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.51it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=0: train_ppl=tensor(1.8325e+09, device='cuda:0') train_epoch_loss=tensor(21.3289, device='cuda:0') eval_ppl=tensor(2713.4180, device='cuda:0') eval_epoch_loss=tensor(7.9060, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.53it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=1: train_ppl=tensor(341.0600, device='cuda:0') train_epoch_loss=tensor(5.8321, device='cuda:0') eval_ppl=tensor(80.8206, device='cuda:0') eval_epoch_loss=tensor(4.3922, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.55it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=2: train_ppl=tensor(59.8778, device='cuda:0') train_epoch_loss=tensor(4.0923, device='cuda:0') eval_ppl=tensor(34.4593, device='cuda:0') eval_epoch_loss=tensor(3.5398, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.55it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=3: train_ppl=tensor(22.3307, device='cuda:0') train_epoch_loss=tensor(3.1060, device='cuda:0') eval_ppl=tensor(12.5947, device='cuda:0') eval_epoch_loss=tensor(2.5333, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=4: train_ppl=tensor(9.1697, device='cuda:0') train_epoch_loss=tensor(2.2159, device='cuda:0') eval_ppl=tensor(4.5289, device='cuda:0') eval_epoch_loss=tensor(1.5105, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.52it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=5: train_ppl=tensor(3.0172, device='cuda:0') train_epoch_loss=tensor(1.1043, device='cuda:0') eval_ppl=tensor(1.8092, device='cuda:0') eval_epoch_loss=tensor(0.5929, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.45it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=6: train_ppl=tensor(1.4885, device='cuda:0') train_epoch_loss=tensor(0.3978, device='cuda:0') eval_ppl=tensor(1.4449, device='cuda:0') eval_epoch_loss=tensor(0.3680, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.48it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=7: train_ppl=tensor(1.2967, device='cuda:0') train_epoch_loss=tensor(0.2598, device='cuda:0') eval_ppl=tensor(1.1587, device='cuda:0') eval_epoch_loss=tensor(0.1473, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=8: train_ppl=tensor(1.1305, device='cuda:0') train_epoch_loss=tensor(0.1227, device='cuda:0') eval_ppl=tensor(1.0874, device='cuda:0') eval_epoch_loss=tensor(0.0838, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.46it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=9: train_ppl=tensor(1.1608, device='cuda:0') train_epoch_loss=tensor(0.1491, device='cuda:0') eval_ppl=tensor(1.1461, device='cuda:0') eval_epoch_loss=tensor(0.1364, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.45it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=10: train_ppl=tensor(1.3172, device='cuda:0') train_epoch_loss=tensor(0.2755, device='cuda:0') eval_ppl=tensor(1.1320, device='cuda:0') eval_epoch_loss=tensor(0.1240, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.46it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=11: train_ppl=tensor(1.1437, device='cuda:0') train_epoch_loss=tensor(0.1343, device='cuda:0') eval_ppl=tensor(1.0676, device='cuda:0') eval_epoch_loss=tensor(0.0654, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.43it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=12: train_ppl=tensor(1.0651, device='cuda:0') train_epoch_loss=tensor(0.0630, device='cuda:0') eval_ppl=tensor(1.0735, device='cuda:0') eval_epoch_loss=tensor(0.0710, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.46it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=13: train_ppl=tensor(1.0607, device='cuda:0') train_epoch_loss=tensor(0.0589, device='cuda:0') eval_ppl=tensor(1.0399, device='cuda:0') eval_epoch_loss=tensor(0.0391, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.44it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=14: train_ppl=tensor(1.0351, device='cuda:0') train_epoch_loss=tensor(0.0345, device='cuda:0') eval_ppl=tensor(1.0260, device='cuda:0') eval_epoch_loss=tensor(0.0257, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.43it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=15: train_ppl=tensor(1.0217, device='cuda:0') train_epoch_loss=tensor(0.0215, device='cuda:0') eval_ppl=tensor(1.0168, device='cuda:0') eval_epoch_loss=tensor(0.0167, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.28it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=16: train_ppl=tensor(1.0152, device='cuda:0') train_epoch_loss=tensor(0.0151, device='cuda:0') eval_ppl=tensor(1.0117, device='cuda:0') eval_epoch_loss=tensor(0.0116, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.41it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=17: train_ppl=tensor(1.0102, device='cuda:0') train_epoch_loss=tensor(0.0101, device='cuda:0') eval_ppl=tensor(1.0088, device='cuda:0') eval_epoch_loss=tensor(0.0088, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.29it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.25it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=18: train_ppl=tensor(1.0083, device='cuda:0') train_epoch_loss=tensor(0.0083, device='cuda:0') eval_ppl=tensor(1.0073, device='cuda:0') eval_epoch_loss=tensor(0.0073, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.46it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=19: train_ppl=tensor(1.0070, device='cuda:0') train_epoch_loss=tensor(0.0070, device='cuda:0') eval_ppl=tensor(1.0064, device='cuda:0') eval_epoch_loss=tensor(0.0063, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.51it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=20: train_ppl=tensor(1.0059, device='cuda:0') train_epoch_loss=tensor(0.0059, device='cuda:0') eval_ppl=tensor(1.0057, device='cuda:0') eval_epoch_loss=tensor(0.0057, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=21: train_ppl=tensor(1.0056, device='cuda:0') train_epoch_loss=tensor(0.0056, device='cuda:0') eval_ppl=tensor(1.0052, device='cuda:0') eval_epoch_loss=tensor(0.0052, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.41it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.33it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=22: train_ppl=tensor(1.0050, device='cuda:0') train_epoch_loss=tensor(0.0050, device='cuda:0') eval_ppl=tensor(1.0049, device='cuda:0') eval_epoch_loss=tensor(0.0049, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.39it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.44it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=23: train_ppl=tensor(1.0049, device='cuda:0') train_epoch_loss=tensor(0.0049, device='cuda:0') eval_ppl=tensor(1.0045, device='cuda:0') eval_epoch_loss=tensor(0.0045, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.42it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.49it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=24: train_ppl=tensor(1.0043, device='cuda:0') train_epoch_loss=tensor(0.0043, device='cuda:0') eval_ppl=tensor(1.0043, device='cuda:0') eval_epoch_loss=tensor(0.0043, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.46it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=25: train_ppl=tensor(1.0042, device='cuda:0') train_epoch_loss=tensor(0.0042, device='cuda:0') eval_ppl=tensor(1.0040, device='cuda:0') eval_epoch_loss=tensor(0.0040, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.52it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=26: train_ppl=tensor(1.0039, device='cuda:0') train_epoch_loss=tensor(0.0039, device='cuda:0') eval_ppl=tensor(1.0039, device='cuda:0') eval_epoch_loss=tensor(0.0039, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.48it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=27: train_ppl=tensor(1.0038, device='cuda:0') train_epoch_loss=tensor(0.0038, device='cuda:0') eval_ppl=tensor(1.0037, device='cuda:0') eval_epoch_loss=tensor(0.0037, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.46it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.54it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=28: train_ppl=tensor(1.0036, device='cuda:0') train_epoch_loss=tensor(0.0036, device='cuda:0') eval_ppl=tensor(1.0035, device='cuda:0') eval_epoch_loss=tensor(0.0035, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.53it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=29: train_ppl=tensor(1.0034, device='cuda:0') train_epoch_loss=tensor(0.0034, device='cuda:0') eval_ppl=tensor(1.0034, device='cuda:0') eval_epoch_loss=tensor(0.0034, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=30: train_ppl=tensor(1.0034, device='cuda:0') train_epoch_loss=tensor(0.0034, device='cuda:0') eval_ppl=tensor(1.0033, device='cuda:0') eval_epoch_loss=tensor(0.0033, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=31: train_ppl=tensor(1.0033, device='cuda:0') train_epoch_loss=tensor(0.0033, device='cuda:0') eval_ppl=tensor(1.0032, device='cuda:0') eval_epoch_loss=tensor(0.0032, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.46it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.51it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=32: train_ppl=tensor(1.0031, device='cuda:0') train_epoch_loss=tensor(0.0031, device='cuda:0') eval_ppl=tensor(1.0031, device='cuda:0') eval_epoch_loss=tensor(0.0031, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.43it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=33: train_ppl=tensor(1.0030, device='cuda:0') train_epoch_loss=tensor(0.0030, device='cuda:0') eval_ppl=tensor(1.0030, device='cuda:0') eval_epoch_loss=tensor(0.0030, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.46it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=34: train_ppl=tensor(1.0029, device='cuda:0') train_epoch_loss=tensor(0.0029, device='cuda:0') eval_ppl=tensor(1.0029, device='cuda:0') eval_epoch_loss=tensor(0.0029, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=35: train_ppl=tensor(1.0028, device='cuda:0') train_epoch_loss=tensor(0.0028, device='cuda:0') eval_ppl=tensor(1.0029, device='cuda:0') eval_epoch_loss=tensor(0.0029, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.45it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=36: train_ppl=tensor(1.0027, device='cuda:0') train_epoch_loss=tensor(0.0027, device='cuda:0') eval_ppl=tensor(1.0028, device='cuda:0') eval_epoch_loss=tensor(0.0028, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=37: train_ppl=tensor(1.0027, device='cuda:0') train_epoch_loss=tensor(0.0027, device='cuda:0') eval_ppl=tensor(1.0027, device='cuda:0') eval_epoch_loss=tensor(0.0027, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.46it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=38: train_ppl=tensor(1.0027, device='cuda:0') train_epoch_loss=tensor(0.0027, device='cuda:0') eval_ppl=tensor(1.0027, device='cuda:0') eval_epoch_loss=tensor(0.0027, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.43it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=39: train_ppl=tensor(1.0025, device='cuda:0') train_epoch_loss=tensor(0.0025, device='cuda:0') eval_ppl=tensor(1.0026, device='cuda:0') eval_epoch_loss=tensor(0.0026, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=40: train_ppl=tensor(1.0026, device='cuda:0') train_epoch_loss=tensor(0.0026, device='cuda:0') eval_ppl=tensor(1.0026, device='cuda:0') eval_epoch_loss=tensor(0.0026, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.33it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=41: train_ppl=tensor(1.0025, device='cuda:0') train_epoch_loss=tensor(0.0025, device='cuda:0') eval_ppl=tensor(1.0025, device='cuda:0') eval_epoch_loss=tensor(0.0025, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.42it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.49it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=42: train_ppl=tensor(1.0024, device='cuda:0') train_epoch_loss=tensor(0.0024, device='cuda:0') eval_ppl=tensor(1.0025, device='cuda:0') eval_epoch_loss=tensor(0.0025, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=43: train_ppl=tensor(1.0024, device='cuda:0') train_epoch_loss=tensor(0.0024, device='cuda:0') eval_ppl=tensor(1.0025, device='cuda:0') eval_epoch_loss=tensor(0.0025, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.43it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=44: train_ppl=tensor(1.0025, device='cuda:0') train_epoch_loss=tensor(0.0024, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.50it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=45: train_ppl=tensor(1.0024, device='cuda:0') train_epoch_loss=tensor(0.0024, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.49it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=46: train_ppl=tensor(1.0024, device='cuda:0') train_epoch_loss=tensor(0.0024, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.42it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.39it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=47: train_ppl=tensor(1.0023, device='cuda:0') train_epoch_loss=tensor(0.0023, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.40it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.40it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=48: train_ppl=tensor(1.0023, device='cuda:0') train_epoch_loss=tensor(0.0023, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.41it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.87it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=49: train_ppl=tensor(1.0023, device='cuda:0') train_epoch_loss=tensor(0.0023, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# training and evaluation\n", + "model = model.to(device)\n", + "\n", + "for epoch in range(num_epochs):\n", + " model.train()\n", + " total_loss = 0\n", + " for step, batch in enumerate(tqdm(train_dataloader)):\n", + " batch = {k: v.to(device) for k, v in batch.items()}\n", + " # print(batch)\n", + " # print(batch[\"input_ids\"].shape)\n", + " outputs = model(**batch)\n", + " loss = outputs.loss\n", + " total_loss += loss.detach().float()\n", + " loss.backward()\n", + " optimizer.step()\n", + " lr_scheduler.step()\n", + " optimizer.zero_grad()\n", + "\n", + " model.eval()\n", + " eval_loss = 0\n", + " eval_preds = []\n", + " for step, batch in enumerate(tqdm(eval_dataloader)):\n", + " batch = {k: v.to(device) for k, v in batch.items()}\n", + " with torch.no_grad():\n", + " outputs = model(**batch)\n", + " loss = outputs.loss\n", + " eval_loss += loss.detach().float()\n", + " eval_preds.extend(\n", + " tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)\n", + " )\n", + "\n", + " eval_epoch_loss = eval_loss / len(eval_dataloader)\n", + " eval_ppl = torch.exp(eval_epoch_loss)\n", + " train_epoch_loss = total_loss / len(train_dataloader)\n", + " train_ppl = torch.exp(train_epoch_loss)\n", + " print(f\"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "53752a7b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hey @nytimes your link to cancel my subscription isn't working and nobody is answering the chat. Please don't play that kind of stupid game.\n", + "{'input_ids': tensor([[227985, 5484, 915, 54078, 2566, 7782, 24502, 2632, 8989,\n", + " 427, 36992, 2670, 140711, 21994, 10789, 530, 88399, 632,\n", + " 183542, 368, 44799, 17, 29901, 5926, 7229, 861, 11596,\n", + " 461, 78851, 14775, 17, 77658, 915, 210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n", + "tensor([[227985, 5484, 915, 54078, 2566, 7782, 24502, 2632, 8989,\n", + " 427, 36992, 2670, 140711, 21994, 10789, 530, 88399, 632,\n", + " 183542, 368, 44799, 17, 29901, 5926, 7229, 861, 11596,\n", + " 461, 78851, 14775, 17, 77658, 915, 210, 16449, 5952,\n", + " 3]], device='cuda:0')\n", + "[\"Tweet text : Hey @nytimes your link to cancel my subscription isn't working and nobody is answering the chat. Please don't play that kind of stupid game. Label : complaint\"]\n" + ] + } + ], + "source": [ + "model.eval()\n", + "i = 16\n", + "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n", + "print(dataset[\"test\"][i][\"Tweet text\"])\n", + "print(inputs)\n", + "\n", + "with torch.no_grad():\n", + " inputs = {k: v.to(device) for k, v in inputs.items()}\n", + " outputs = model.generate(\n", + " input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n", + " )\n", + " print(outputs)\n", + " print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))" + ] + }, + { + "cell_type": "markdown", + "id": "0e21c49b", + "metadata": {}, + "source": [ + "You can push model to hub or save model locally. \n", + "\n", + "- Option1: Pushing the model to Hugging Face Hub\n", + "```python\n", + "model.push_to_hub(\n", + " f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\"),\n", + " token = \"hf_...\"\n", + ")\n", + "```\n", + "token (`bool` or `str`, *optional*):\n", + " `token` is to be used for HTTP Bearer authorization when accessing remote files. If `True`, will use the token generated\n", + " when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url`\n", + " is not specified.\n", + " Or you can get your token from https://huggingface.co/settings/token\n", + "```\n", + "- Or save model locally\n", + "```python\n", + "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\")\n", + "model.save_pretrained(peft_model_id)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "24041ee1", + "metadata": {}, + "outputs": [], + "source": [ + "# saving model\n", + "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\n", + " \"/\", \"_\"\n", + ")\n", + "model.save_pretrained(peft_model_id)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "527eeaa4", + "metadata": {}, + "outputs": [], + "source": [ + "ckpt = f\"{peft_model_id}/adapter_model.safetensors\"\n", + "!du -h $ckpt" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b19f5a90", + "metadata": {}, + "outputs": [], + "source": [ + "from peft import PeftModel, PeftConfig\n", + "\n", + "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\n", + " \"/\", \"_\"\n", + ")\n", + "\n", + "config = PeftConfig.from_pretrained(peft_model_id)\n", + "model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)\n", + "model = PeftModel.from_pretrained(model, peft_model_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "a11a3768", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "@greateranglia Ok thanks...\n", + "{'input_ids': tensor([[227985, 5484, 915, 2566, 14173, 2960, 29906, 387, 20706,\n", + " 49337, 1369, 77658, 915, 210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n", + "tensor([[227985, 5484, 915, 2566, 14173, 2960, 29906, 387, 20706,\n", + " 49337, 1369, 77658, 915, 210, 1936, 106863, 3]],\n", + " device='cuda:0')\n", + "['Tweet text : @greateranglia Ok thanks... Label : no complaint']\n" + ] + } + ], + "source": [ + "model.to(device)\n", + "model.eval()\n", + "i = 4\n", + "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n", + "print(dataset[\"test\"][i][\"Tweet text\"])\n", + "print(inputs)\n", + "\n", + "with torch.no_grad():\n", + " inputs = {k: v.to(device) for k, v in inputs.items()}\n", + " outputs = model.generate(\n", + " input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n", + " )\n", + " print(outputs)\n", + " print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f890c951", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "463a41a2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c60c7a9", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.5" + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_prompt_tuning_clm.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_prompt_tuning_clm.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..47448713f8ba22e6225377fc03e77ad10c29871c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/peft_prompt_tuning_clm.ipynb @@ -0,0 +1,1220 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "71fbfca2", + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import AutoModelForCausalLM\n", + "from peft import get_peft_config, get_peft_model, PromptTuningInit, PromptTuningConfig, TaskType, PeftType\n", + "import torch\n", + "from datasets import load_dataset\n", + "import os\n", + "from transformers import AutoTokenizer\n", + "from torch.utils.data import DataLoader\n", + "from transformers import default_data_collator, get_linear_schedule_with_warmup\n", + "from tqdm import tqdm\n", + "\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "model_name_or_path = \"bigscience/bloomz-560m\"\n", + "tokenizer_name_or_path = \"bigscience/bloomz-560m\"\n", + "peft_config = PromptTuningConfig(\n", + " task_type=TaskType.CAUSAL_LM,\n", + " prompt_tuning_init=PromptTuningInit.TEXT,\n", + " num_virtual_tokens=8,\n", + " prompt_tuning_init_text=\"Classify if the tweet is a complaint or not:\",\n", + " tokenizer_name_or_path=model_name_or_path,\n", + ")\n", + "\n", + "dataset_name = \"twitter_complaints\"\n", + "checkpoint_name = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}_v1.pt\".replace(\n", + " \"/\", \"_\"\n", + ")\n", + "text_column = \"Tweet text\"\n", + "label_column = \"text_label\"\n", + "max_length = 64\n", + "lr = 3e-2\n", + "num_epochs = 50\n", + "batch_size = 8" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1a3648b", + "metadata": {}, + "outputs": [], + "source": [ + "dataset = load_dataset(\n", + " \"parquet\",\n", + " data_files={\n", + " \"train\": f\"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/train/0000.parquet\",\n", + " \"test\": f\"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/test/0000.parquet\"\n", + " }\n", + ")\n", + "\n", + "classes = [k.replace(\"_\", \" \") for k in dataset[\"train\"].features[\"Label\"].names]\n", + "print(classes)\n", + "dataset = dataset.map(\n", + " lambda x: {\"text_label\": [classes[label] for label in x[\"Label\"]]},\n", + " batched=True,\n", + " num_proc=1,\n", + ")\n", + "print(dataset)\n", + "dataset[\"train\"][0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe12d4d3", + "metadata": {}, + "outputs": [], + "source": [ + "# data preprocessing\n", + "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)\n", + "if tokenizer.pad_token_id is None:\n", + " tokenizer.pad_token_id = tokenizer.eos_token_id\n", + "target_max_length = max([len(tokenizer(class_label)[\"input_ids\"]) for class_label in classes])\n", + "print(target_max_length)\n", + "\n", + "\n", + "def preprocess_function(examples):\n", + " batch_size = len(examples[text_column])\n", + " inputs = [f\"{text_column} : {x} Label : \" for x in examples[text_column]]\n", + " targets = [str(x) for x in examples[label_column]]\n", + " model_inputs = tokenizer(inputs)\n", + " labels = tokenizer(targets, add_special_tokens=False) # don't add bos token because we concatenate with inputs\n", + " for i in range(batch_size):\n", + " sample_input_ids = model_inputs[\"input_ids\"][i]\n", + " label_input_ids = labels[\"input_ids\"][i] + [tokenizer.eos_token_id]\n", + " # print(i, sample_input_ids, label_input_ids)\n", + " model_inputs[\"input_ids\"][i] = sample_input_ids + label_input_ids\n", + " labels[\"input_ids\"][i] = [-100] * len(sample_input_ids) + label_input_ids\n", + " model_inputs[\"attention_mask\"][i] = [1] * len(model_inputs[\"input_ids\"][i])\n", + " # print(model_inputs)\n", + " for i in range(batch_size):\n", + " sample_input_ids = model_inputs[\"input_ids\"][i]\n", + " label_input_ids = labels[\"input_ids\"][i]\n", + " model_inputs[\"input_ids\"][i] = [tokenizer.pad_token_id] * (\n", + " max_length - len(sample_input_ids)\n", + " ) + sample_input_ids\n", + " model_inputs[\"attention_mask\"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[\n", + " \"attention_mask\"\n", + " ][i]\n", + " labels[\"input_ids\"][i] = [-100] * (max_length - len(sample_input_ids)) + label_input_ids\n", + " model_inputs[\"input_ids\"][i] = torch.tensor(model_inputs[\"input_ids\"][i][:max_length])\n", + " model_inputs[\"attention_mask\"][i] = torch.tensor(model_inputs[\"attention_mask\"][i][:max_length])\n", + " labels[\"input_ids\"][i] = torch.tensor(labels[\"input_ids\"][i][:max_length])\n", + " model_inputs[\"labels\"] = labels[\"input_ids\"]\n", + " return model_inputs\n", + "\n", + "\n", + "processed_datasets = dataset.map(\n", + " preprocess_function,\n", + " batched=True,\n", + " num_proc=1,\n", + " remove_columns=dataset[\"train\"].column_names,\n", + " load_from_cache_file=False,\n", + " desc=\"Running tokenizer on dataset\",\n", + ")\n", + "\n", + "train_dataset = processed_datasets[\"train\"]\n", + "eval_dataset = processed_datasets[\"train\"]\n", + "\n", + "\n", + "train_dataloader = DataLoader(\n", + " train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True\n", + ")\n", + "eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "641b21fe", + "metadata": {}, + "outputs": [], + "source": [ + "def test_preprocess_function(examples):\n", + " batch_size = len(examples[text_column])\n", + " inputs = [f\"{text_column} : {x} Label : \" for x in examples[text_column]]\n", + " model_inputs = tokenizer(inputs)\n", + " # print(model_inputs)\n", + " for i in range(batch_size):\n", + " sample_input_ids = model_inputs[\"input_ids\"][i]\n", + " model_inputs[\"input_ids\"][i] = [tokenizer.pad_token_id] * (\n", + " max_length - len(sample_input_ids)\n", + " ) + sample_input_ids\n", + " model_inputs[\"attention_mask\"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[\n", + " \"attention_mask\"\n", + " ][i]\n", + " model_inputs[\"input_ids\"][i] = torch.tensor(model_inputs[\"input_ids\"][i][:max_length])\n", + " model_inputs[\"attention_mask\"][i] = torch.tensor(model_inputs[\"attention_mask\"][i][:max_length])\n", + " return model_inputs\n", + "\n", + "\n", + "test_dataset = dataset[\"test\"].map(\n", + " test_preprocess_function,\n", + " batched=True,\n", + " num_proc=1,\n", + " remove_columns=dataset[\"train\"].column_names,\n", + " load_from_cache_file=False,\n", + " desc=\"Running tokenizer on dataset\",\n", + ")\n", + "\n", + "test_dataloader = DataLoader(test_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)\n", + "next(iter(test_dataloader))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "accc5012", + "metadata": {}, + "outputs": [], + "source": [ + "next(iter(train_dataloader))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "218df807", + "metadata": {}, + "outputs": [], + "source": [ + "len(test_dataloader)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "47d1fedf", + "metadata": {}, + "outputs": [], + "source": [ + "next(iter(test_dataloader))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a773e092", + "metadata": {}, + "outputs": [], + "source": [ + "# creating model\n", + "model = AutoModelForCausalLM.from_pretrained(model_name_or_path)\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b2f91568", + "metadata": {}, + "outputs": [], + "source": [ + "# model\n", + "# optimizer and lr scheduler\n", + "optimizer = torch.optim.AdamW(model.parameters(), lr=lr)\n", + "lr_scheduler = get_linear_schedule_with_warmup(\n", + " optimizer=optimizer,\n", + " num_warmup_steps=0,\n", + " num_training_steps=(len(train_dataloader) * num_epochs),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e4fb69fc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:01<00:00, 5.68it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.48it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=0: train_ppl=tensor(2.2720e+13, device='cuda:0') train_epoch_loss=tensor(30.7543, device='cuda:0') eval_ppl=tensor(483597.5625, device='cuda:0') eval_epoch_loss=tensor(13.0890, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.91it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 20.96it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=1: train_ppl=tensor(452658.3750, device='cuda:0') train_epoch_loss=tensor(13.0229, device='cuda:0') eval_ppl=tensor(275088.1875, device='cuda:0') eval_epoch_loss=tensor(12.5248, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.90it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.41it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=2: train_ppl=tensor(199203.3906, device='cuda:0') train_epoch_loss=tensor(12.2021, device='cuda:0') eval_ppl=tensor(143637.0312, device='cuda:0') eval_epoch_loss=tensor(11.8750, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.92it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.31it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=3: train_ppl=tensor(114743.9531, device='cuda:0') train_epoch_loss=tensor(11.6505, device='cuda:0') eval_ppl=tensor(54962., device='cuda:0') eval_epoch_loss=tensor(10.9144, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.81it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.34it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=4: train_ppl=tensor(40786.5977, device='cuda:0') train_epoch_loss=tensor(10.6161, device='cuda:0') eval_ppl=tensor(18342.5430, device='cuda:0') eval_epoch_loss=tensor(9.8170, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.89it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.34it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=5: train_ppl=tensor(14023.0830, device='cuda:0') train_epoch_loss=tensor(9.5485, device='cuda:0') eval_ppl=tensor(6316.8540, device='cuda:0') eval_epoch_loss=tensor(8.7510, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.84it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.32it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=6: train_ppl=tensor(5635.3262, device='cuda:0') train_epoch_loss=tensor(8.6368, device='cuda:0') eval_ppl=tensor(2476.5776, device='cuda:0') eval_epoch_loss=tensor(7.8146, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.88it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.30it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=7: train_ppl=tensor(1818.4940, device='cuda:0') train_epoch_loss=tensor(7.5058, device='cuda:0') eval_ppl=tensor(934.1146, device='cuda:0') eval_epoch_loss=tensor(6.8396, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.05it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.97it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=8: train_ppl=tensor(645.2143, device='cuda:0') train_epoch_loss=tensor(6.4696, device='cuda:0') eval_ppl=tensor(361.9093, device='cuda:0') eval_epoch_loss=tensor(5.8914, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 9.67it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 19.12it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=9: train_ppl=tensor(293.8047, device='cuda:0') train_epoch_loss=tensor(5.6829, device='cuda:0') eval_ppl=tensor(215.8185, device='cuda:0') eval_epoch_loss=tensor(5.3744, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.54it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 20.83it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=10: train_ppl=tensor(191.2377, device='cuda:0') train_epoch_loss=tensor(5.2535, device='cuda:0') eval_ppl=tensor(177.1512, device='cuda:0') eval_epoch_loss=tensor(5.1770, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.02it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.98it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=11: train_ppl=tensor(153.6052, device='cuda:0') train_epoch_loss=tensor(5.0344, device='cuda:0') eval_ppl=tensor(126.6154, device='cuda:0') eval_epoch_loss=tensor(4.8412, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 9.54it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.78it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=12: train_ppl=tensor(122.8925, device='cuda:0') train_epoch_loss=tensor(4.8113, device='cuda:0') eval_ppl=tensor(97.3331, device='cuda:0') eval_epoch_loss=tensor(4.5781, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 9.66it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 19.72it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=13: train_ppl=tensor(84.8845, device='cuda:0') train_epoch_loss=tensor(4.4413, device='cuda:0') eval_ppl=tensor(70.3213, device='cuda:0') eval_epoch_loss=tensor(4.2531, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:01<00:00, 6.73it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 16.07it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=14: train_ppl=tensor(64.6705, device='cuda:0') train_epoch_loss=tensor(4.1693, device='cuda:0') eval_ppl=tensor(50.4688, device='cuda:0') eval_epoch_loss=tensor(3.9214, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.41it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.63it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=15: train_ppl=tensor(44.2937, device='cuda:0') train_epoch_loss=tensor(3.7908, device='cuda:0') eval_ppl=tensor(34.8210, device='cuda:0') eval_epoch_loss=tensor(3.5502, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.31it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.67it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=16: train_ppl=tensor(30.0995, device='cuda:0') train_epoch_loss=tensor(3.4045, device='cuda:0') eval_ppl=tensor(24.7703, device='cuda:0') eval_epoch_loss=tensor(3.2096, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.31it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.59it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=17: train_ppl=tensor(23.3086, device='cuda:0') train_epoch_loss=tensor(3.1488, device='cuda:0') eval_ppl=tensor(20.8131, device='cuda:0') eval_epoch_loss=tensor(3.0356, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.29it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 16.04it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=18: train_ppl=tensor(16.4479, device='cuda:0') train_epoch_loss=tensor(2.8002, device='cuda:0') eval_ppl=tensor(12.0876, device='cuda:0') eval_epoch_loss=tensor(2.4922, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.37it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.37it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=19: train_ppl=tensor(11.1977, device='cuda:0') train_epoch_loss=tensor(2.4157, device='cuda:0') eval_ppl=tensor(9.0399, device='cuda:0') eval_epoch_loss=tensor(2.2016, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.23it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 17.29it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=20: train_ppl=tensor(8.1847, device='cuda:0') train_epoch_loss=tensor(2.1023, device='cuda:0') eval_ppl=tensor(6.7486, device='cuda:0') eval_epoch_loss=tensor(1.9093, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.30it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=21: train_ppl=tensor(6.1145, device='cuda:0') train_epoch_loss=tensor(1.8107, device='cuda:0') eval_ppl=tensor(5.5931, device='cuda:0') eval_epoch_loss=tensor(1.7215, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.34it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.36it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=22: train_ppl=tensor(5.2963, device='cuda:0') train_epoch_loss=tensor(1.6670, device='cuda:0') eval_ppl=tensor(5.0573, device='cuda:0') eval_epoch_loss=tensor(1.6208, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.84it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.26it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=23: train_ppl=tensor(4.7485, device='cuda:0') train_epoch_loss=tensor(1.5578, device='cuda:0') eval_ppl=tensor(3.6277, device='cuda:0') eval_epoch_loss=tensor(1.2886, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.84it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.31it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=24: train_ppl=tensor(3.4080, device='cuda:0') train_epoch_loss=tensor(1.2261, device='cuda:0') eval_ppl=tensor(3.0467, device='cuda:0') eval_epoch_loss=tensor(1.1141, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.88it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.25it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=25: train_ppl=tensor(3.3052, device='cuda:0') train_epoch_loss=tensor(1.1955, device='cuda:0') eval_ppl=tensor(2.7784, device='cuda:0') eval_epoch_loss=tensor(1.0219, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.86it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.22it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=26: train_ppl=tensor(2.9487, device='cuda:0') train_epoch_loss=tensor(1.0814, device='cuda:0') eval_ppl=tensor(2.9471, device='cuda:0') eval_epoch_loss=tensor(1.0808, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.85it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.25it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=27: train_ppl=tensor(2.8738, device='cuda:0') train_epoch_loss=tensor(1.0556, device='cuda:0') eval_ppl=tensor(2.5801, device='cuda:0') eval_epoch_loss=tensor(0.9478, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.84it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.28it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=28: train_ppl=tensor(2.3241, device='cuda:0') train_epoch_loss=tensor(0.8433, device='cuda:0') eval_ppl=tensor(2.2198, device='cuda:0') eval_epoch_loss=tensor(0.7974, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.84it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 20.89it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=29: train_ppl=tensor(2.0376, device='cuda:0') train_epoch_loss=tensor(0.7118, device='cuda:0') eval_ppl=tensor(1.8572, device='cuda:0') eval_epoch_loss=tensor(0.6191, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 9.76it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.83it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=30: train_ppl=tensor(1.8301, device='cuda:0') train_epoch_loss=tensor(0.6044, device='cuda:0') eval_ppl=tensor(1.8864, device='cuda:0') eval_epoch_loss=tensor(0.6347, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 9.80it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 19.81it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=31: train_ppl=tensor(1.7301, device='cuda:0') train_epoch_loss=tensor(0.5482, device='cuda:0') eval_ppl=tensor(1.6340, device='cuda:0') eval_epoch_loss=tensor(0.4910, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.60it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 19.11it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=32: train_ppl=tensor(1.5842, device='cuda:0') train_epoch_loss=tensor(0.4601, device='cuda:0') eval_ppl=tensor(1.6179, device='cuda:0') eval_epoch_loss=tensor(0.4811, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.11it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.35it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=33: train_ppl=tensor(1.5193, device='cuda:0') train_epoch_loss=tensor(0.4183, device='cuda:0') eval_ppl=tensor(1.5543, device='cuda:0') eval_epoch_loss=tensor(0.4410, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 9.59it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=34: train_ppl=tensor(1.5402, device='cuda:0') train_epoch_loss=tensor(0.4319, device='cuda:0') eval_ppl=tensor(1.4924, device='cuda:0') eval_epoch_loss=tensor(0.4004, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 9.80it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 19.63it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=35: train_ppl=tensor(1.4410, device='cuda:0') train_epoch_loss=tensor(0.3654, device='cuda:0') eval_ppl=tensor(1.3888, device='cuda:0') eval_epoch_loss=tensor(0.3284, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:01<00:00, 6.60it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.36it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=36: train_ppl=tensor(1.3675, device='cuda:0') train_epoch_loss=tensor(0.3130, device='cuda:0') eval_ppl=tensor(1.4001, device='cuda:0') eval_epoch_loss=tensor(0.3366, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.40it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=37: train_ppl=tensor(1.4197, device='cuda:0') train_epoch_loss=tensor(0.3505, device='cuda:0') eval_ppl=tensor(1.3214, device='cuda:0') eval_epoch_loss=tensor(0.2787, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.27it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=38: train_ppl=tensor(1.3855, device='cuda:0') train_epoch_loss=tensor(0.3261, device='cuda:0') eval_ppl=tensor(1.3501, device='cuda:0') eval_epoch_loss=tensor(0.3001, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.25it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.57it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=39: train_ppl=tensor(1.3643, device='cuda:0') train_epoch_loss=tensor(0.3107, device='cuda:0') eval_ppl=tensor(1.3549, device='cuda:0') eval_epoch_loss=tensor(0.3037, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.28it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.41it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=40: train_ppl=tensor(1.3093, device='cuda:0') train_epoch_loss=tensor(0.2695, device='cuda:0') eval_ppl=tensor(1.3233, device='cuda:0') eval_epoch_loss=tensor(0.2801, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.24it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.51it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=41: train_ppl=tensor(1.3108, device='cuda:0') train_epoch_loss=tensor(0.2706, device='cuda:0') eval_ppl=tensor(1.3440, device='cuda:0') eval_epoch_loss=tensor(0.2957, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.78it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.61it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=42: train_ppl=tensor(1.2944, device='cuda:0') train_epoch_loss=tensor(0.2581, device='cuda:0') eval_ppl=tensor(1.2711, device='cuda:0') eval_epoch_loss=tensor(0.2399, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 8.29it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=43: train_ppl=tensor(1.2616, device='cuda:0') train_epoch_loss=tensor(0.2323, device='cuda:0') eval_ppl=tensor(1.2449, device='cuda:0') eval_epoch_loss=tensor(0.2190, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.85it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.27it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=44: train_ppl=tensor(1.2478, device='cuda:0') train_epoch_loss=tensor(0.2214, device='cuda:0') eval_ppl=tensor(1.2202, device='cuda:0') eval_epoch_loss=tensor(0.1990, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.85it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.31it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=45: train_ppl=tensor(1.2350, device='cuda:0') train_epoch_loss=tensor(0.2111, device='cuda:0') eval_ppl=tensor(1.2180, device='cuda:0') eval_epoch_loss=tensor(0.1972, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.86it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.33it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=46: train_ppl=tensor(1.2277, device='cuda:0') train_epoch_loss=tensor(0.2052, device='cuda:0') eval_ppl=tensor(1.2077, device='cuda:0') eval_epoch_loss=tensor(0.1887, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.87it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.35it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=47: train_ppl=tensor(1.2037, device='cuda:0') train_epoch_loss=tensor(0.1854, device='cuda:0') eval_ppl=tensor(1.2041, device='cuda:0') eval_epoch_loss=tensor(0.1857, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.83it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.29it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=48: train_ppl=tensor(1.2026, device='cuda:0') train_epoch_loss=tensor(0.1845, device='cuda:0') eval_ppl=tensor(1.1982, device='cuda:0') eval_epoch_loss=tensor(0.1808, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.86it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.35it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=49: train_ppl=tensor(1.2005, device='cuda:0') train_epoch_loss=tensor(0.1827, device='cuda:0') eval_ppl=tensor(1.1968, device='cuda:0') eval_epoch_loss=tensor(0.1796, device='cuda:0')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# training and evaluation\n", + "model = model.to(device)\n", + "\n", + "for epoch in range(num_epochs):\n", + " model.train()\n", + " total_loss = 0\n", + " for step, batch in enumerate(tqdm(train_dataloader)):\n", + " batch = {k: v.to(device) for k, v in batch.items()}\n", + " # print(batch)\n", + " # print(batch[\"input_ids\"].shape)\n", + " outputs = model(**batch)\n", + " loss = outputs.loss\n", + " total_loss += loss.detach().float()\n", + " loss.backward()\n", + " optimizer.step()\n", + " lr_scheduler.step()\n", + " optimizer.zero_grad()\n", + "\n", + " model.eval()\n", + " eval_loss = 0\n", + " eval_preds = []\n", + " for step, batch in enumerate(tqdm(eval_dataloader)):\n", + " batch = {k: v.to(device) for k, v in batch.items()}\n", + " with torch.no_grad():\n", + " outputs = model(**batch)\n", + " loss = outputs.loss\n", + " eval_loss += loss.detach().float()\n", + " eval_preds.extend(\n", + " tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)\n", + " )\n", + "\n", + " eval_epoch_loss = eval_loss / len(eval_dataloader)\n", + " eval_ppl = torch.exp(eval_epoch_loss)\n", + " train_epoch_loss = total_loss / len(train_dataloader)\n", + " train_ppl = torch.exp(train_epoch_loss)\n", + " print(f\"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "53752a7b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "@TommyHilfiger Dramatic shopping exp. ordered 6 jeans same size (30/32) 2 fits / 2 too large / 2 too slim : same brand > different sizing\n", + "{'input_ids': tensor([[227985, 5484, 915, 2566, 226154, 126015, 5385, 259, 239364,\n", + " 3396, 70823, 5853, 17, 57247, 1231, 191040, 5025, 7869,\n", + " 375, 2324, 149349, 12, 415, 122321, 897, 415, 10136,\n", + " 10021, 897, 415, 10136, 6497, 381, 915, 5025, 51950,\n", + " 66869, 5955, 272, 20311, 77658, 915, 210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n", + "tensor([[227985, 5484, 915, 2566, 226154, 126015, 5385, 259, 239364,\n", + " 3396, 70823, 5853, 17, 57247, 1231, 191040, 5025, 7869,\n", + " 375, 2324, 149349, 12, 415, 122321, 897, 415, 10136,\n", + " 10021, 897, 415, 10136, 6497, 381, 915, 5025, 51950,\n", + " 66869, 5955, 272, 20311, 77658, 915, 210, 16449, 5952,\n", + " 3]], device='cuda:0')\n", + "['Tweet text : @TommyHilfiger Dramatic shopping exp. ordered 6 jeans same size (30/32) 2 fits / 2 too large / 2 too slim : same brand > different sizing Label : complaint']\n" + ] + } + ], + "source": [ + "model.eval()\n", + "i = 33\n", + "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n", + "print(dataset[\"test\"][i][\"Tweet text\"])\n", + "print(inputs)\n", + "\n", + "with torch.no_grad():\n", + " inputs = {k: v.to(device) for k, v in inputs.items()}\n", + " outputs = model.generate(\n", + " input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n", + " )\n", + " print(outputs)\n", + " print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))" + ] + }, + { + "cell_type": "markdown", + "id": "c8f35152", + "metadata": {}, + "source": [ + "You can push model to hub or save model locally. \n", + "\n", + "- Option1: Pushing the model to Hugging Face Hub\n", + "```python\n", + "model.push_to_hub(\n", + " f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\"),\n", + " token = \"hf_...\"\n", + ")\n", + "```\n", + "token (`bool` or `str`, *optional*):\n", + " `token` is to be used for HTTP Bearer authorization when accessing remote files. If `True`, will use the token generated\n", + " when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url`\n", + " is not specified.\n", + " Or you can get your token from https://huggingface.co/settings/token\n", + "```\n", + "- Or save model locally\n", + "```python\n", + "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\")\n", + "model.save_pretrained(peft_model_id)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d8ba1f8c", + "metadata": {}, + "outputs": [], + "source": [ + "# saving model\n", + "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\n", + " \"/\", \"_\"\n", + ")\n", + "model.save_pretrained(peft_model_id)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4928c7f1", + "metadata": {}, + "outputs": [], + "source": [ + "ckpt = f\"{peft_model_id}/adapter_model.safetensors\"\n", + "!du -h $ckpt" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "4d9476e1", + "metadata": {}, + "outputs": [], + "source": [ + "from peft import PeftModel, PeftConfig\n", + "\n", + "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\n", + " \"/\", \"_\"\n", + ")\n", + "\n", + "config = PeftConfig.from_pretrained(peft_model_id)\n", + "model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)\n", + "model = PeftModel.from_pretrained(model, peft_model_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "ebe174a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "@greateranglia Ok thanks...\n", + "{'input_ids': tensor([[227985, 5484, 915, 2566, 14173, 2960, 29906, 387, 20706,\n", + " 49337, 1369, 77658, 915, 210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n", + "tensor([[227985, 5484, 915, 2566, 14173, 2960, 29906, 387, 20706,\n", + " 49337, 1369, 77658, 915, 210, 1936, 106863, 3]],\n", + " device='cuda:0')\n", + "['Tweet text : @greateranglia Ok thanks... Label : no complaint']\n" + ] + } + ], + "source": [ + "model.to(device)\n", + "model.eval()\n", + "i = 4\n", + "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n", + "print(dataset[\"test\"][i][\"Tweet text\"])\n", + "print(inputs)\n", + "\n", + "with torch.no_grad():\n", + " inputs = {k: v.to(device) for k, v in inputs.items()}\n", + " outputs = model.generate(\n", + " input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n", + " )\n", + " print(outputs)\n", + " print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "24041ee1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.5" + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..0e462c3c63b9067a36e44e14a092b52adef3e849 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/causal_language_modeling/requirements.txt @@ -0,0 +1,7 @@ +transformers<4.54.0 +accelerate +evaluate +deepspeed +tqdm +dataclass-csv +datasets==3.6.0 \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/accelerate_ds_zero3_cpu_offload_config.yaml b/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/accelerate_ds_zero3_cpu_offload_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a4a0bcfaf09bd632e6ac2152c8a4f30e183cc102 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/accelerate_ds_zero3_cpu_offload_config.yaml @@ -0,0 +1,22 @@ +compute_environment: LOCAL_MACHINE +deepspeed_config: + gradient_accumulation_steps: 1 + gradient_clipping: 1.0 + offload_optimizer_device: none + offload_param_device: none + zero3_init_flag: true + zero3_save_16bit_model: true + zero_stage: 3 +distributed_type: DEEPSPEED +downcast_bf16: 'no' +dynamo_backend: 'NO' +fsdp_config: {} +machine_rank: 0 +main_training_function: main +megatron_lm_config: {} +mixed_precision: 'no' +num_machines: 1 +num_processes: 1 +rdzv_backend: static +same_network: true +use_cpu: false \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/multitask_prompt_tuning.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/multitask_prompt_tuning.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..1eaec5b016ecada5f7b3a4d71902665b1759f7a3 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/multitask_prompt_tuning.ipynb @@ -0,0 +1,426 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "58ff91ca-ce92-43d0-ae8b-4e9e89e193f6", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import torch\n", + "from datasets import load_dataset\n", + "from transformers import set_seed, AutoModelForSeq2SeqLM, AutoTokenizer\n", + "from peft import get_peft_model, MultitaskPromptTuningConfig, TaskType, MultitaskPromptTuningInit\n", + "\n", + "set_seed(42)\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "model_name = \"google/flan-t5-base\"\n", + "\n", + "peft_config = MultitaskPromptTuningConfig(\n", + " tokenizer_name_or_path=model_name,\n", + " num_tasks=2,\n", + " task_type=TaskType.SEQ_2_SEQ_LM,\n", + " prompt_tuning_init=MultitaskPromptTuningInit.TEXT,\n", + " num_virtual_tokens=50,\n", + " num_transformer_submodules=1,\n", + " prompt_tuning_init_text=\"classify the following into either positive or negative, or entailment, neutral or contradiction:\",\n", + ")\n", + "\n", + "tokenizer = AutoTokenizer.from_pretrained(model_name)\n", + "model = AutoModelForSeq2SeqLM.from_pretrained(model_name)\n", + "model = get_peft_model(model, peft_config)\n", + "\n", + "model = model.to(device)\n", + "\n", + "\n", + "def send_to_device(batch):\n", + " for i in batch:\n", + " batch[i] = batch[i].to(device)\n", + " return batch" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "eb112bc1-ffaf-49fa-a216-0d601ec304ee", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def get_sst2(split: str):\n", + " examples = load_dataset(\"sst2\")[split]\n", + " result_examples = []\n", + " for example in examples:\n", + " result_examples.append({})\n", + "\n", + " result_examples[-1][\"input\"] = example[\"sentence\"].strip() + \"\"\n", + " result_examples[-1][\"output\"] = (\n", + " f\"positive{tokenizer.eos_token}\" if example[\"label\"] == 1 else f\"negative{tokenizer.eos_token}\"\n", + " )\n", + " result_examples[-1][\"task_id\"] = 0\n", + "\n", + " return result_examples\n", + "\n", + "\n", + "def get_mnli(split: str):\n", + " examples = load_dataset(\"multi_nli\")[split]\n", + " result_examples = []\n", + " for example in examples:\n", + " result_examples.append({})\n", + "\n", + " result_examples[-1][\"input\"] = example[\"premise\"].strip() + \" \" + example[\"hypothesis\"].strip() + \"\"\n", + "\n", + " if example[\"label\"] == 0:\n", + " result_examples[-1][\"output\"] = f\"entailment{tokenizer.eos_token}\"\n", + " elif example[\"label\"] == 1:\n", + " result_examples[-1][\"output\"] = f\"neutral{tokenizer.eos_token}\"\n", + " else:\n", + " result_examples[-1][\"output\"] = f\"contradiction{tokenizer.eos_token}\"\n", + "\n", + " result_examples[-1][\"task_id\"] = 1\n", + "\n", + " return result_examples" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e5a16ec4-8fef-4ba9-95b6-a661eb51e50c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from typing import Tuple\n", + "from torch.utils.data import Dataset, DataLoader\n", + "import torch\n", + "\n", + "\n", + "class MyDataset(Dataset):\n", + " def __init__(self, split: str, mode: str = \"source\") -> None:\n", + " super().__init__()\n", + "\n", + " if split == \"train\":\n", + " if mode == \"source\":\n", + " self.examples = get_sst2(split) + get_mnli(split)\n", + " elif mode == \"target\":\n", + " self.examples = get_sst2(split)\n", + " if split == \"val\":\n", + " self.examples = get_sst2(\"validation\")\n", + " if split == \"test\":\n", + " self.examples = get_sst2(\"validation\")\n", + "\n", + " def __getitem__(self, index) -> dict:\n", + " return self.examples[index]\n", + "\n", + " def __len__(self) -> int:\n", + " return len(self.examples)\n", + "\n", + " def __getitem__(self, index) -> dict:\n", + " return self.examples[index]\n", + "\n", + " def __len__(self) -> int:\n", + " return len(self.examples)\n", + "\n", + "\n", + "def collate_fn(batch: dict) -> Tuple[torch.Tensor, torch.Tensor]:\n", + " input = [i[\"input\"] for i in batch]\n", + " input = tokenizer(input, add_special_tokens=False, return_tensors=\"pt\", padding=True)\n", + "\n", + " output = [i[\"output\"] for i in batch]\n", + " output = tokenizer(output, add_special_tokens=False, return_tensors=\"pt\", padding=True).input_ids\n", + " output[output == tokenizer.pad_token_id] = -100\n", + "\n", + " task_ids = [i[\"task_id\"] for i in batch]\n", + " task_ids = torch.tensor(task_ids)\n", + "\n", + " return {\n", + " \"input_ids\": input.input_ids,\n", + " \"attention_mask\": input.attention_mask,\n", + " \"labels\": output,\n", + " \"task_ids\": task_ids,\n", + " }\n", + "\n", + "\n", + "train = DataLoader(MyDataset(\"train\"), shuffle=True, batch_size=8, collate_fn=collate_fn)\n", + "val = DataLoader(MyDataset(\"val\"), shuffle=False, batch_size=8, collate_fn=collate_fn)\n", + "test = DataLoader(MyDataset(\"test\"), shuffle=False, batch_size=8, collate_fn=collate_fn)" + ] + }, + { + "cell_type": "markdown", + "id": "fe0aec7b-f61e-4b00-a90e-c1201dc1f84c", + "metadata": {}, + "source": [ + "## source training" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cceecc94-f43a-4f62-8d45-926f2f02f36d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from torch.optim.adamw import AdamW\n", + "from transformers import get_cosine_schedule_with_warmup\n", + "from tqdm import tqdm\n", + "from sklearn.metrics import f1_score" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eae5516b-73ab-44a8-a083-4e8de6127f30", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "POSITIVE_TOKEN_ID = tokenizer(\" positive\", add_special_tokens=False)[\"input_ids\"][0]\n", + "NEGATIVE_TOKEN_ID = tokenizer(\" negative\", add_special_tokens=False)[\"input_ids\"][0]\n", + "\n", + "\n", + "def classify(batch):\n", + " batch = send_to_device(batch)\n", + " # we pass labels here since we need to generate and peft doesn't support generation yet.\n", + " # No clue how to get around this\n", + " scores = model(**batch).logits\n", + " preds = []\n", + " for i in range(scores.shape[0]):\n", + " if scores[i, 0, POSITIVE_TOKEN_ID] > scores[i, 0, NEGATIVE_TOKEN_ID]:\n", + " preds.append(POSITIVE_TOKEN_ID)\n", + " else:\n", + " preds.append(NEGATIVE_TOKEN_ID)\n", + " return preds\n", + "\n", + "\n", + "@torch.inference_mode()\n", + "def evaluate(model, data):\n", + " loss = 0\n", + " preds = []\n", + " golds = []\n", + "\n", + " for batch in tqdm(data):\n", + " batch = send_to_device(batch)\n", + " loss += model(**batch).loss\n", + " golds.extend(batch[\"labels\"][:, 0].tolist())\n", + " preds.extend(classify(batch))\n", + "\n", + " return loss / len(val), f1_score(golds, preds, pos_label=POSITIVE_TOKEN_ID)\n", + "\n", + "\n", + "optimizer = AdamW(model.parameters(), lr=1e-4)\n", + "scheduler = get_cosine_schedule_with_warmup(optimizer, 200, len(train))\n", + "\n", + "n = 1000\n", + "step = 0\n", + "train_ = tqdm(train)\n", + "\n", + "val_loss, f1 = evaluate(model, val)\n", + "print(\n", + " f\"\"\"\n", + "before source training\n", + "val loss = {val_loss}\n", + "f1 = {f1}\"\"\"\n", + ")\n", + "\n", + "for batch in train_:\n", + " if step % n == 0:\n", + " val_loss, f1 = evaluate(model, val)\n", + " print(\n", + " f\"\"\"\n", + "step = {step}\n", + "val loss = {val_loss}\n", + "f1 = {f1}\"\"\"\n", + " )\n", + " model.save_pretrained(f\"checkpoints_source/{step}\")\n", + "\n", + " step += 1\n", + " batch = send_to_device(batch)\n", + " loss = model(**batch).loss\n", + " loss.backward()\n", + " optimizer.step()\n", + " scheduler.step()\n", + " train_.set_postfix(train_loss=loss)" + ] + }, + { + "cell_type": "markdown", + "id": "74168ef3-66f3-41a7-a40b-7840b103fbf9", + "metadata": {}, + "source": [ + "## target training" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b09fd456-163e-4dc1-b24d-f2d0d349036c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "train = DataLoader(MyDataset(\"train\", \"target\"), shuffle=True, batch_size=8, collate_fn=collate_fn)\n", + "val = DataLoader(MyDataset(\"val\", \"target\"), shuffle=False, batch_size=8, collate_fn=collate_fn)\n", + "test = DataLoader(MyDataset(\"test\", \"target\"), shuffle=False, batch_size=8, collate_fn=collate_fn)" + ] + }, + { + "cell_type": "markdown", + "id": "4a539944-f16c-4c3f-bb4a-7b5d9a6042e2", + "metadata": {}, + "source": [ + "#### create a fresh model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5520d904-aa6c-4654-9335-ed4e7d76cba2", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "peft_config = MultitaskPromptTuningConfig(\n", + " tokenizer_name_or_path=model_name,\n", + " num_tasks=1,\n", + " task_type=TaskType.SEQ_2_SEQ_LM,\n", + " prompt_tuning_init=MultitaskPromptTuningInit.EXACT_SOURCE_TASK,\n", + " prompt_tuning_init_state_dict_path=\"checkpoints_source/50000/adapter_model.safetensors\",\n", + " num_virtual_tokens=50,\n", + " num_transformer_submodules=1,\n", + ")\n", + "\n", + "tokenizer = AutoTokenizer.from_pretrained(model_name)\n", + "model = AutoModelForSeq2SeqLM.from_pretrained(model_name)\n", + "model = get_peft_model(model, peft_config)\n", + "\n", + "model = model.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dfa39c2d-d1c5-4ed4-90f8-26e8e324371c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "optimizer = AdamW(model.parameters(), lr=1e-4)\n", + "scheduler = get_cosine_schedule_with_warmup(optimizer, 200, len(train))\n", + "\n", + "n = 1000\n", + "step = 0\n", + "train_ = tqdm(train)\n", + "\n", + "val_loss, f1 = evaluate(model, val)\n", + "print(\n", + " f\"\"\"\n", + "before target training\n", + "val loss = {val_loss}\n", + "f1 = {f1}\"\"\"\n", + ")\n", + "\n", + "for batch in train_:\n", + " if step % n == 0:\n", + " val_loss, f1 = evaluate(model, val)\n", + " print(\n", + " f\"\"\"\n", + "step = {step}\n", + "val loss = {val_loss}\n", + "f1 = {f1}\"\"\"\n", + " )\n", + " model.save_pretrained(f\"checkpoints_target/{step}\")\n", + "\n", + " step += 1\n", + " batch = send_to_device(batch)\n", + " loss = model(**batch).loss\n", + " loss.backward()\n", + " optimizer.step()\n", + " scheduler.step()\n", + " train_.set_postfix(train_loss=loss)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b6a6eeda-1e09-49a6-8845-cd96c8573145", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# load last checkpoint for now\n", + "from peft import set_peft_model_state_dict\n", + "from safetensors.torch import load_file\n", + "\n", + "sd_6000 = load_file(\"checkpoints_target/6000/adapter_model.safetensors\")\n", + "set_peft_model_state_dict(model, sd_6000)\n", + "\n", + "# evaluate val\n", + "val_loss, f1 = evaluate(model, val)\n", + "print(\n", + " f\"\"\"\n", + "final\n", + "val loss = {val_loss}\n", + "f1 = {f1}\"\"\"\n", + ")\n", + "\n", + "# evaluate test\n", + "test_loss, f1 = evaluate(model, test)\n", + "print(\n", + " f\"\"\"\n", + "final\n", + "test loss = {test_loss}\n", + "f1 = {f1}\"\"\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1d18325c-9607-4cb5-a5b0-5b44dfee2a75", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43988e92-af42-45cb-8bca-f19c193ad04f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/peft_adalora_seq2seq.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/peft_adalora_seq2seq.py new file mode 100644 index 0000000000000000000000000000000000000000..e1a0c8c53babb388eb8ff0a10936336952841efc --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/peft_adalora_seq2seq.py @@ -0,0 +1,185 @@ +import os + +import torch +from datasets import load_dataset +from torch.utils.data import DataLoader +from tqdm import tqdm +from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, default_data_collator, get_linear_schedule_with_warmup + +from peft import AdaLoraConfig, PeftConfig, PeftModel, TaskType, get_peft_model + + +os.environ["TOKENIZERS_PARALLELISM"] = "false" + +device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" +model_name_or_path = "facebook/bart-base" +tokenizer_name_or_path = "facebook/bart-base" + +text_column = "text" +label_column = "text_label" +max_length = 128 +lr = 1e-3 +num_epochs = 8 +batch_size = 8 + + +# loading dataset +dataset = load_dataset("zeroshot/twitter-financial-news-sentiment") +dataset = dataset["train"].train_test_split(test_size=0.1) +dataset["validation"] = dataset["test"] +del dataset["test"] + +if hasattr(dataset["train"].features["label"], "names"): + classes = dataset["train"].features["label"].names +else: + classes = ["Bearish", "Bullish", "Neutral"] +dataset = dataset.map( + lambda x: {"text_label": [classes[label] for label in x["label"]]}, + batched=True, + num_proc=1, +) + + +# creating model +peft_config = AdaLoraConfig( + init_r=12, + target_r=8, + beta1=0.85, + beta2=0.85, + tinit=200, + tfinal=1000, + deltaT=10, + lora_alpha=32, + lora_dropout=0.1, + task_type=TaskType.SEQ_2_SEQ_LM, + inference_mode=False, + total_step=len(dataset["train"]) * num_epochs, +) + +model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path) +model = get_peft_model(model, peft_config) +model.print_trainable_parameters() + + +# data preprocessing +tokenizer = AutoTokenizer.from_pretrained(model_name_or_path) + + +def preprocess_function(examples): + inputs = examples[text_column] + targets = examples[label_column] + model_inputs = tokenizer(inputs, max_length=max_length, padding="max_length", truncation=True, return_tensors="pt") + labels = tokenizer(targets, max_length=3, padding="max_length", truncation=True, return_tensors="pt") + labels = labels["input_ids"] + labels[labels == tokenizer.pad_token_id] = -100 + model_inputs["labels"] = labels + return model_inputs + + +processed_datasets = dataset.map( + preprocess_function, + batched=True, + num_proc=1, + remove_columns=dataset["train"].column_names, + load_from_cache_file=False, + desc="Running tokenizer on dataset", +) + +train_dataset = processed_datasets["train"] +eval_dataset = processed_datasets["validation"] + +train_dataloader = DataLoader( + train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True +) +eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True) + + +# optimizer and lr scheduler +optimizer = torch.optim.AdamW(model.parameters(), lr=lr) +lr_scheduler = get_linear_schedule_with_warmup( + optimizer=optimizer, + num_warmup_steps=0, + num_training_steps=(len(train_dataloader) * num_epochs), +) +model.base_model.peft_config["default"].total_step = len(train_dataloader) * num_epochs + + +# training and evaluation +model = model.to(device) +global_step = 0 +for epoch in range(num_epochs): + model.train() + total_loss = 0 + for step, batch in enumerate(tqdm(train_dataloader)): + batch = {k: v.to(device) for k, v in batch.items()} + outputs = model(**batch) + loss = outputs.loss + total_loss += loss.detach().float() + loss.backward() + optimizer.step() + lr_scheduler.step() + # Update the importance of low-rank matrices + # and allocate the budget accordingly. + model.base_model.update_and_allocate(global_step) + optimizer.zero_grad() + global_step += 1 + + model.eval() + eval_loss = 0 + eval_preds = [] + for step, batch in enumerate(tqdm(eval_dataloader)): + batch = {k: v.to(device) for k, v in batch.items()} + with torch.no_grad(): + outputs = model(**batch) + loss = outputs.loss + eval_loss += loss.detach().float() + eval_preds.extend( + tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True) + ) + + eval_epoch_loss = eval_loss / len(train_dataloader) + eval_ppl = torch.exp(eval_epoch_loss) + train_epoch_loss = total_loss / len(eval_dataloader) + train_ppl = torch.exp(train_epoch_loss) + print(f"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}") + + +# print accuracy +correct = 0 +total = 0 +for pred, true in zip(eval_preds, dataset["validation"]["text_label"]): + if pred.strip() == true.strip(): + correct += 1 + total += 1 +accuracy = correct / total * 100 +print(f"{accuracy=} % on the evaluation dataset") +print(f"{eval_preds[:10]=}") +print(f"{dataset['validation']['text_label'][:10]=}") + + +# saving model +peft_model_id = f"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}" +model.save_pretrained(peft_model_id) + + +ckpt = f"{peft_model_id}/adapter_model.safetensors" +# get_ipython().system('du -h $ckpt') + + +peft_model_id = f"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}" + +config = PeftConfig.from_pretrained(peft_model_id) +model = AutoModelForSeq2SeqLM.from_pretrained(config.base_model_name_or_path) +model = PeftModel.from_pretrained(model, peft_model_id) + + +model.eval() +i = 13 +inputs = tokenizer(dataset["validation"][text_column][i], return_tensors="pt") +print(dataset["validation"][text_column][i]) +print(inputs) + +with torch.no_grad(): + outputs = model.generate(input_ids=inputs["input_ids"], max_new_tokens=10) + print(outputs) + print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True)) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/peft_ia3_seq2seq.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/peft_ia3_seq2seq.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..c410c15b97116ede05539ae228ec0c562760fb2e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/peft_ia3_seq2seq.ipynb @@ -0,0 +1,2747 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "0c152fc8", + "metadata": { + "id": "5f93b7d1" + }, + "outputs": [], + "source": "from transformers import AutoModelForSeq2SeqLM\nimport peft\nfrom peft import get_peft_config, get_peft_model, get_peft_model_state_dict, IA3Config, TaskType\nimport torch\nfrom datasets import load_dataset\nimport os\n\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\nfrom transformers import AutoTokenizer\nfrom torch.utils.data import DataLoader\nfrom transformers import default_data_collator, get_linear_schedule_with_warmup\nfrom tqdm import tqdm\nfrom datasets import load_dataset\n\ndevice = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\nmodel_name_or_path = \"bigscience/mt0-large\"\ntokenizer_name_or_path = \"bigscience/mt0-large\"\n\ntext_column = \"text\"\nlabel_column = \"text_label\"\nmax_length = 128\nlr = 8e-3\nnum_epochs = 3\nbatch_size = 8" + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4e23624f", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "b9e6368c", + "outputId": "fc2888a8-4fe9-4d61-dd2d-753e751e1416" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import importlib\n", + "\n", + "importlib.reload(peft)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "da74b569", + "metadata": { + "id": "8d0850ac" + }, + "outputs": [], + "source": [ + "# creating model\n", + "peft_config = IA3Config(task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, feedforward_modules=[])\n", + "\n", + "model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "df33fce2", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "e10c3831", + "outputId": "e69c5e07-ae58-446c-8301-e99ac6b85d62" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "MT5ForConditionalGeneration(\n", + " (shared): Embedding(250112, 1024)\n", + " (encoder): MT5Stack(\n", + " (embed_tokens): Embedding(250112, 1024)\n", + " (block): ModuleList(\n", + " (0): MT5Block(\n", + " (layer): ModuleList(\n", + " (0): MT5LayerSelfAttention(\n", + " (SelfAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (v): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (relative_attention_bias): Embedding(32, 16)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (1): MT5LayerFF(\n", + " (DenseReluDense): MT5DenseGatedActDense(\n", + " (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wi_1): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wo): Linear(in_features=2816, out_features=1024, bias=False)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (act): NewGELUActivation()\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (1-23): 23 x MT5Block(\n", + " (layer): ModuleList(\n", + " (0): MT5LayerSelfAttention(\n", + " (SelfAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (v): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (1): MT5LayerFF(\n", + " (DenseReluDense): MT5DenseGatedActDense(\n", + " (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wi_1): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wo): Linear(in_features=2816, out_features=1024, bias=False)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (act): NewGELUActivation()\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (final_layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (decoder): MT5Stack(\n", + " (embed_tokens): Embedding(250112, 1024)\n", + " (block): ModuleList(\n", + " (0): MT5Block(\n", + " (layer): ModuleList(\n", + " (0): MT5LayerSelfAttention(\n", + " (SelfAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (v): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (relative_attention_bias): Embedding(32, 16)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (1): MT5LayerCrossAttention(\n", + " (EncDecAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (v): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (2): MT5LayerFF(\n", + " (DenseReluDense): MT5DenseGatedActDense(\n", + " (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wi_1): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wo): Linear(in_features=2816, out_features=1024, bias=False)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (act): NewGELUActivation()\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (1-23): 23 x MT5Block(\n", + " (layer): ModuleList(\n", + " (0): MT5LayerSelfAttention(\n", + " (SelfAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (v): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (1): MT5LayerCrossAttention(\n", + " (EncDecAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (v): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (2): MT5LayerFF(\n", + " (DenseReluDense): MT5DenseGatedActDense(\n", + " (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wi_1): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wo): Linear(in_features=2816, out_features=1024, bias=False)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (act): NewGELUActivation()\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (final_layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (lm_head): Linear(in_features=1024, out_features=250112, bias=False)\n", + ")" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "63d7bc2d", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "05978e96", + "outputId": "ea9b7d40-010f-4df0-ec64-a7146a5f8b08" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 282,624 || all params: 1,229,863,936 || trainable%: 0.0230\n" + ] + }, + { + "data": { + "text/plain": [ + "PeftModelForSeq2SeqLM(\n", + " (base_model): IA3Model(\n", + " (model): MT5ForConditionalGeneration(\n", + " (shared): Embedding(250112, 1024)\n", + " (encoder): MT5Stack(\n", + " (embed_tokens): Embedding(250112, 1024)\n", + " (block): ModuleList(\n", + " (0): MT5Block(\n", + " (layer): ModuleList(\n", + " (0): MT5LayerSelfAttention(\n", + " (SelfAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (v): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (relative_attention_bias): Embedding(32, 16)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (1): MT5LayerFF(\n", + " (DenseReluDense): MT5DenseGatedActDense(\n", + " (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wi_1): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 2816x1])\n", + " )\n", + " (wo): Linear(in_features=2816, out_features=1024, bias=False)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (act): NewGELUActivation()\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (1-23): 23 x MT5Block(\n", + " (layer): ModuleList(\n", + " (0): MT5LayerSelfAttention(\n", + " (SelfAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (v): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (1): MT5LayerFF(\n", + " (DenseReluDense): MT5DenseGatedActDense(\n", + " (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wi_1): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 2816x1])\n", + " )\n", + " (wo): Linear(in_features=2816, out_features=1024, bias=False)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (act): NewGELUActivation()\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (final_layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (decoder): MT5Stack(\n", + " (embed_tokens): Embedding(250112, 1024)\n", + " (block): ModuleList(\n", + " (0): MT5Block(\n", + " (layer): ModuleList(\n", + " (0): MT5LayerSelfAttention(\n", + " (SelfAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (v): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (relative_attention_bias): Embedding(32, 16)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (1): MT5LayerCrossAttention(\n", + " (EncDecAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (v): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (2): MT5LayerFF(\n", + " (DenseReluDense): MT5DenseGatedActDense(\n", + " (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wi_1): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 2816x1])\n", + " )\n", + " (wo): Linear(in_features=2816, out_features=1024, bias=False)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (act): NewGELUActivation()\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (1-23): 23 x MT5Block(\n", + " (layer): ModuleList(\n", + " (0): MT5LayerSelfAttention(\n", + " (SelfAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (v): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (1): MT5LayerCrossAttention(\n", + " (EncDecAttention): MT5Attention(\n", + " (q): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (k): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (v): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n", + " )\n", + " (o): Linear(in_features=1024, out_features=1024, bias=False)\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (2): MT5LayerFF(\n", + " (DenseReluDense): MT5DenseGatedActDense(\n", + " (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (wi_1): Linear(\n", + " (base_layer): Linear(in_features=1024, out_features=2816, bias=False)\n", + " (ia3_l): ParameterDict( (default): Parameter containing: [torch.FloatTensor of size 2816x1])\n", + " )\n", + " (wo): Linear(in_features=2816, out_features=1024, bias=False)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (act): NewGELUActivation()\n", + " )\n", + " (layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (final_layer_norm): MT5LayerNorm()\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (lm_head): Linear(in_features=1024, out_features=250112, bias=False)\n", + " )\n", + " )\n", + ")" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "155b8728", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 140, + "referenced_widgets": [ + "bbfb7533b5ca459194e171df56b79566", + "c894e8237aa34c56bb250acab1466005", + "a5a126b229064812bf3dcb228118be50", + "661e1b29c59a4295b594edfa4f50ff87", + "1bcba805972b484d8b6aa6542c81841c", + "e71f5c7f1d5d4f83b58c68d2fa310d9c", + "6a567e0a1a5447519c5df10e777520cf", + "7aeca19b84904906a04c12659f84ff9e", + "dd4b895874ce46ceb1ad0d9bc973f98f", + "b138f91be7f94008806eaf0a6988bc3f", + "da14180f51ab44b48470cb9ea74d3864", + "9e12d97af6124a5a8c6627708b300c1e", + "faa18df899c14e9cac6721253e6c9128", + "79d0ede7a5b24756aa6d34fda8c29159", + "3b175b452f4347558aa3c4501cc90030", + "fc4637a1b37e4e90874c71aa4271ac74", + "1b8aada826a0451bb60c418b19178c8c", + "a91916e02e9c424e881e45b3aa978574", + "ca509bd409624c998e555c9a779b8aae", + "9c890fc422954347b86d3bde7a421caf", + "6f9453484ea94587a64d70f1b3a1f6e4", + "48770ef159f44c01be2a75c75aecd80f", + "0c561dab67914ea9b6e1aab803600551", + "1e021a1954b44d69a90101a96c360661", + "013e3343285f437a893bdd673fb90e22", + "28802da68fb04d70b1c6bc511a04676f", + "94174da0d6554be087d4527bea5b511a", + "dc8ab16a1e6c4e6893c95ccd16568f9a", + "72383136663448d89cf3b82b87cbb392", + "5b1bdaf16cbc473081e4237f839167b9", + "51f8fb45485540bb985b606d43ae04ea", + "f760cd4758334ca9a43fd15612fd808b", + "f60e9915d2a74ca7bc010d7684f5acf6" + ] + }, + "id": "4ee2babf", + "outputId": "3c413083-247d-47da-f25c-032764be0beb" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using the latest cached version of the dataset since financial_phrasebank couldn't be found on the Hugging Face Hub\n", + "Found the latest cached dataset configuration 'sentences_allagree' at /root/.cache/huggingface/datasets/financial_phrasebank/sentences_allagree/1.0.0/550bde12e6c30e2674da973a55f57edde5181d53f5a5a34c1531c53f93b7e141 (last modified on Thu Jul 31 03:15:41 2025).\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "43b03e9b6de94bf0921228482d7be1e5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Map: 0%| | 0/2037 [00:00 Tensor(a!)\n", + " registered at /pytorch/build/aten/src/ATen/RegisterSchema.cpp:6\n", + " dispatch key: XPU\n", + " previous kernel: registered at /pytorch/aten/src/ATen/VmapModeRegistrations.cpp:37\n", + " new kernel: registered at /build/intel-pytorch-extension/build/Release/csrc/gpu/csrc/gpu/xpu/ATen/RegisterXPU_0.cpp:172 (function operator())\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2025-07-31 07:06:51,984] [INFO] [real_accelerator.py:254:get_accelerator] Setting ds_accelerator to xpu (auto detect)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/bin/ld: cannot find -laio: No such file or directory\n", + "collect2: error: ld returned 1 exit status\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2025-07-31 07:06:52,955] [INFO] [logging.py:107:log_dist] [Rank -1] [TorchCheckpointEngine] Initialized with serialization = False\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No label_names provided for model class `PeftModelForSeq2SeqLM`. Since `PeftModel` hides base models input arguments, if label_names is not given, label_names can't be set automatically within `Trainer`. Note that empty label_names list will be used instead.\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "

\n", + " \n", + " \n", + " [1275/1275 03:31, Epoch 5/5]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EpochTraining LossValidation LossAccuracy
12.1699000.5071560.621145
20.5377000.4309960.651982
30.4822000.4267180.696035
40.4597000.4708940.682819
50.4360000.4096040.718062

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=1275, training_loss=0.8170911183076747, metrics={'train_runtime': 213.5513, 'train_samples_per_second': 47.693, 'train_steps_per_second': 5.97, 'total_flos': 344546979840000.0, 'train_loss': 0.8170911183076747, 'epoch': 5.0})" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# training and evaluation\n", + "\n", + "\n", + "def compute_metrics(eval_preds):\n", + " preds, labels = eval_preds\n", + " preds = tokenizer.batch_decode(preds, skip_special_tokens=True)\n", + " labels = tokenizer.batch_decode(labels, skip_special_tokens=True)\n", + "\n", + " correct = 0\n", + " total = 0\n", + " for pred, true in zip(preds, labels):\n", + " if pred.strip() == true.strip():\n", + " correct += 1\n", + " total += 1\n", + " accuracy = correct / total\n", + " return {\"accuracy\": accuracy}\n", + "\n", + "\n", + "training_args = Seq2SeqTrainingArguments(\n", + " \"out\",\n", + " per_device_train_batch_size=batch_size,\n", + " learning_rate=lr,\n", + " num_train_epochs=num_epochs,\n", + " eval_strategy=\"epoch\",\n", + " logging_strategy=\"epoch\",\n", + " save_strategy=\"no\",\n", + " report_to=[],\n", + " predict_with_generate=True,\n", + " generation_config=GenerationConfig(max_length=max_length),\n", + ")\n", + "trainer = Seq2SeqTrainer(\n", + " model=model,\n", + " processing_class=tokenizer,\n", + " args=training_args,\n", + " train_dataset=train_dataset,\n", + " eval_dataset=eval_dataset,\n", + " data_collator=default_data_collator,\n", + " compute_metrics=compute_metrics,\n", + ")\n", + "trainer.train()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a8de6005", + "metadata": { + "ExecuteTime": { + "end_time": "2023-05-30T09:53:13.045146Z", + "start_time": "2023-05-30T09:53:13.035612Z" + } + }, + "outputs": [], + "source": [ + "# saving model\n", + "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n", + "model.save_pretrained(peft_model_id)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd20cd4c", + "metadata": { + "ExecuteTime": { + "end_time": "2023-05-30T09:53:15.240763Z", + "start_time": "2023-05-30T09:53:15.059304Z" + } + }, + "outputs": [], + "source": [ + "ckpt = f\"{peft_model_id}/adapter_model.safetensors\"\n", + "!du -h $ckpt" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "76c2fc29", + "metadata": { + "ExecuteTime": { + "end_time": "2023-05-30T09:53:25.055105Z", + "start_time": "2023-05-30T09:53:17.797989Z" + } + }, + "outputs": [], + "source": [ + "from peft import PeftModel, PeftConfig\n", + "\n", + "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n", + "\n", + "config = PeftConfig.from_pretrained(peft_model_id)\n", + "model = AutoModelForSeq2SeqLM.from_pretrained(config.base_model_name_or_path)\n", + "model = PeftModel.from_pretrained(model, peft_model_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d997f1cc", + "metadata": { + "ExecuteTime": { + "end_time": "2023-05-30T09:53:26.777030Z", + "start_time": "2023-05-30T09:53:26.013697Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EPS grew to 0.04 eur from 0.02 eur .\n", + "{'input_ids': tensor([[ 3, 24935, 3, 4774, 12, 4097, 6348, 3, 1238, 45,\n", + " 4097, 4305, 3, 1238, 3, 5, 1]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n", + "tensor([[ 0, 1465, 1]])\n", + "['positive']\n" + ] + } + ], + "source": [ + "model.eval()\n", + "i = 107\n", + "inputs = tokenizer(dataset[\"validation\"][text_column][i], return_tensors=\"pt\")\n", + "print(dataset[\"validation\"][text_column][i])\n", + "print(inputs)\n", + "\n", + "with torch.no_grad():\n", + " outputs = model.generate(input_ids=inputs[\"input_ids\"], max_new_tokens=10)\n", + " print(outputs)\n", + " print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fb746c1e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..9571ec3501248ebd05f2442a9a6d7ba6555f22bf --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/conditional_generation/requirements.txt @@ -0,0 +1,8 @@ +transformers +accelerate +evaluate +deepspeed +tqdm +datasets +safetensors +scikit-learn \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..dd1aab995bcdf204710acf76ac4f2b5babf56f53 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/README.md @@ -0,0 +1,257 @@ +# CorDA: Context-Oriented Decomposition Adaptation of Large Language Models for Task-Aware Parameter-Efficient Fine-tuning + +## Introduction + + +Existing PEFT methods are mostly agnostic of the context of a task of concern, e.g., a downstream task to learn or some pre-trained world knowledge to maintain. +[CorDA](https://openreview.net/pdf?id=Gi00NVru6n) builds task-aware LoRA adapters from weight decomposition oriented by the context of the task concerned. + +Concretely, CorDA randomly collects a few (by default 256 in our `preprocess.py`) data samples from a target task, e.g. questions from a QA dataset or instructions to write a code or solve a math problem, and feeds these samples into a pre-trained LLM. We can obtain the covariance matrix of the input activation of each linear layer, i.e., $C=XX^T\in\mathcal{R}^{d_{in}\times d_{in}}$. +We then perform singular value decomposition (SVD) for the weight $W\in \mathcal{R}^{d_{out}\times d_{in}}$ multiplied by the covariance matrix, i.e., $\verb|SVD|(WC) = U\Sigma V^T$. In this way, the context expressed by these representative covariance matrices is able to orientate the decomposition, such that the principal components (the singular vectors with the largest singular values) are most associated with the task of concern (please refer to Fig.2 of our paper for the advantage of our decomposition over the plain SVD). To ensure the same inference result with the pre-trained model at the start of adaptation, we multiply the inverse of these covariance matrices with the decomposed components, i.e., $\hat{W}=U\Sigma V^T C^{-1}$. + +Thanks to the task-awareness, you can choose how to utilize the task-specific principal components. For examples, if you want to adapt a model to a new task without losing the knowledge of a question-answering dataset, e.g., TriviaQA and NQopen, you can sample questions from this dataset to collect covariance matrices, and keep the principal components frozen because they compact the ability of this dataset, while using the lowest components with the smallest $r$ singular values to initialize the learnable LoRA adapters. This is achieved by the **knowledge-preserved mode (KPM)** of CorDA, which learns new tasks effectively while keeping the world knowledge you are concerned about as sound as possible. Alternatively, when your primary objective is to maximize performance on the finetuning task, disregarding the preservation of world knowledge, the **instruction-previewed mode (IPM**) will be favored. In this mode, CorDA uses the instruction and response from the fine-tuning task (e.g., Math or Code) to produce the covariance matrices. The principal components with the largest $r$ singular values, capturing the characteristics of the finetuning task in advance, can better adapt to the new ability, so they are used to initialize the LoRA adapters, with the remaining components frozen. IPM can further accelerate convergence to enhance the fine-tuning performance on downstream tasks. + + +The implementations of KPM and IPM are compared as follows: + +| Mode | Collect covariance from | LoRA $A$ | LoRA $B$ | +|---|---|---|--- +|KPM | questions from the knowledge benchmark to maintain | $A=\sqrt{\Sigma}\_{[-r:]}(V^T C^{-1})\_{[-r:,:]}$ | $B=U_{[:,-r:]}\sqrt{\Sigma}_{[-r:]}$ | +IPM | instructions and responses from the downstream task to learn | $A= \sqrt{\Sigma}\_{[:r]} (V^T C^{-1})\_{[:r,:]}$ | $B =U_{[:,:r]} \sqrt{\Sigma}_{[:r]}$ | + +### Comparison with alternative methods + +The distinction between CorDA with other similar LoRA initialization methods is summarized as follows: + +| Method | Initialization for | SVD on | Data-driven | Supports knowledge maintenance | +| - | - | - | - | - | +| PiSSA | $A$ and $B$ | weights | no | no | +| EVA | $A$ | activations | yes | no | +|CorDA | $A$ and $B$ | weights (oriented by covariance) | yes | yes | + +"Supports knowledge maintenance" denotes the ability of explicitly associating a knowledge benchmark with some components of the pre-trained weights after decomposition, and keeping these components frozen during fine-tuning. + +### Some Results + +- Performance with knowledge-preserved mode (sample from NQopen, fine-tune on Math) + +| Method | Model | NQ open | GSM8k | Math | Avg. | +|---|---|---|---|---|---| +|Pre-trained|Llama-2-7b| 14.99 | -| - | - | +|LoRA|Llama-2-7b|1.27| 42.68 | 5.88 | 16.61 | +|**CorDA (KPM)** |Llama-2-7b| **8.20** | **46.32** | **7.00** | **20.51** | +|Pre-trained|Llama-2-13b|23.63|-|-|-| +|LoRA|Llama-2-13b| 16.26 | 57.24 | 8.92 | 27.47 | +|**CorDA (KPM)** |Llama-2-13b| **19.86** | **59.29** | **9.62** | **29.59** | +|Pre-trained|Llama-3-8b|13.41|-|-|-| +|LoRA|Llama-3-8b| 8.75 | 72.33 | 24.04| 35.04 | +|**CorDA (KPM)** |Llama-3-8b| **9.61** | **74.68** | **25.34** | **36.54** | +|Pre-trained|Gemma-2-9b|12.85|-|-|-| +|LoRA|Gemma-2-9b| 9.28 | 83.47 | 42.30| 45.02 | +|**CorDA (KPM)** |Gemma-2-9b|**10.17** | **84.08** | **42.64** | **45.63** | + +- Performance with instruction-previewed mode (sample from Math, fine-tune on Math) + +| Method | Model | GSM8k | Math | +| --- | --- | --- | ---| +|LoRA| Llama-2-7b | 42.68 | 5.88 | +|PiSSA | Llama-2-7b | 51.63 | 7.32 | +| **CorDA (IPM)** | Llama-2-7b | **53.45** | **8.64** | +|LoRA| Llama-2-13b | 57.24 | 8.92 | +|PiSSA | Llama-2-13b |60.88 | 11.08| +| **CorDA (IPM)** | Llama-2-13b | **62.47** |**11.54** | +|LoRA| Gemma-2-9b | 83.47 | 42.30 | +|PiSSA | Gemma-2-9b | 84.23 | 43.52| +| **CorDA (IPM)** | Gemma-2-9b | **84.45** | **43.88** | + + +## Quick Start + +### Knowledge-preserved adaptation mode + +```py +import torch +from peft import LoraConfig, get_peft_model +from transformers import AutoTokenizer, AutoModelForCausalLM +from peft.tuners.lora.config import CordaConfig +from peft.tuners.lora.corda import preprocess_corda +from trl import SFTConfig, SFTTrainer +from datasets import load_dataset + +model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf") +tokenizer.pad_token_id = tokenizer.eos_token_id +sampled_dataset = load_dataset("wikitext", "wikitext-2-raw-v1", split="train[:256]") +dataset = load_dataset("imdb", split="train[:256]") + + +def run_model(): + for batch in sampled_dataset: + input_ids = batch["text"] + input_ids = input_ids.to(model.device) + with torch.no_grad(): + model(input_ids) + + +corda_config = CordaConfig( + corda_method="kpm", +) +lora_config = LoraConfig( + init_lora_weights="corda", + corda_config=corda_config, +) + +# Call `preprocess_corda` first to collect covariance matrix and build SVD result for model +# For more details, please refer to documentation of `preprocess_corda` +preprocess_corda(model, lora_config, run_model=run_model) + +# Call `get_peft_model` after preprocessing, or else you'll encounter error +peft_model = get_peft_model(model, lora_config) +peft_model.print_trainable_parameters() + +training_args = SFTConfig(dataset_text_field="text", max_length=128) +trainer = SFTTrainer( + model=peft_model, + args=training_args, + train_dataset=dataset, + processing_class=tokenizer, +) +trainer.train() +peft_model.save_pretrained("corda-llama-2-7b") +``` + +### Instruction-previewed adaptation mode + +```py +# Get model and dataset identically as KPM... + +# Different from KPM, we run the model on dataset of the downstream task to collect covariance matrices +def run_model(): + for batch in dataset: + input_ids = batch["text"] + input_ids = input_ids.to(model.device) + with torch.no_grad(): + model(input_ids) + +# Different from KPM, we set `corda_method` to `"ipm"` +corda_config = CordaConfig( + corda_method="ipm", +) + +# The rest of training process is identical to KPM... +``` + +## Advanced Usage + +### Preprocessing + +`preprocess.py`: This script builds CorDA adapters for a model, and saves the adapters initial weights and residual model weights to a specified directory. Example usage: + +#### Knowledge-preserved adaptation mode + +```bash +export CUDA_VISIBLE_DEVICES=0 # force to use device 0 of CUDA GPU +export ZE_AFFINITY_MASK=0 # force to use device 0 of Intel XPU + +python -u preprocess.py --model_id="meta-llama/Llama-2-7b-hf" \ + --r 128 --seed 233 \ + --save_model --save_path {path_to_residual_model} \ + --calib_dataset "nqopen" +``` +Arguments: + +- `--model_id` is the pre-trained model for decomposition. +- `--r` is the low rank of LoRA, e.g. 128. +- `--calib_dataset` specifies the dataset to sample data to obtain covariance matrices. KPA mode uses QA datasets such as `"nqopen"`, `"traivia_qa"`, or other choices. +- `--save_model` saves the initialized model in `--save_path`. + +#### Instruction-previewed adaptation mode + +```bash +export CUDA_VISIBLE_DEVICES=0 # force to use device 0 of CUDA GPU +export ZE_AFFINITY_MASK=0 # force to use device 0 of Intel XPU + +python -u preprocess.py --model_id="meta-llama/Llama-2-7b-hf" \ + --r 128 --seed 233 \ + --save_model --save_path {path_to_residual_model} \ + --first_eigen --calib_dataset "MetaMATH" +``` + +Arguments: + +- `--first_eigen` uses the largest $r$ singular values and vectors to initialize the learnable adapter for the instruction-previewed adaptation mode. +- `--calib_dataset` specifies the dataset to sample data to obtain covariance matrices. Instruction-previewed mode uses the downstream task dataset you are learning, such as `"MetaMATH"`, `"codefeedback"`, `"WizLMinstruct"`, `"alpaca"`, or other choices. + +#### Note about memory consumption + +The process of collecting covariance matrices is performed in `torch.float32` by default. If you would like to reduce the memory consumption of preprocessing, you can specify `use_float16_for_covariance=True` in `CordaConfig` to collect covariance matrices in `torch.float16`. But this may cause numerical instability only in a few cases, such that the initialized model does not ensure the exact same inference result as the original model. So it is suggested to check, e.g., comparing the inference result of Wiki/PTB perplexity before and after preprocessing, if you choose to perform in `torch.float16`. + +### Fine-tuning + +`corda_finetuning.py`: This script fine-tunes the preprocessed model built above on a downstream task. + +Example usage: + +```bash +python corda_finetuning.py \ + --model_name_or_path {path_to_residual_model} \ + --output_dir {path_to_output_model} \ + --corda_mode True \ + --data_path meta-math/MetaMathQA \ + --dataset_split "train[:100000]" \ + --dataset_field query response \ + --num_train_epochs 1 \ + --per_device_train_batch_size 1 \ + --gradient_accumulation_steps 32 \ + --save_strategy "steps" \ + --save_steps 100 \ + --save_total_limit 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_steps 0.03 \ + --lr_scheduler_type "cosine" \ + --logging_steps 1 \ + --bf16 True \ + --tf32 True \ + --report_to none +``` + +### Convert CorDA to LoRA + +The main advantage of CorDA is concentrated during the training phase. For a trained CorDA adapter, we recommend converting it equivalently to the LoRA adapter for using and sharing. + +```python +# The fine-tuned matrices $A$ and $B$ in CorDA adapter is saved and should be combined with the residual model. +peft_model.save_pretrained(output_dir) +# Given the matrices $A_0$ and $B_0$, initialized by CorDA and untrained, and the trained matrices $A$ and $B$, +# we can convert these to LoRA by setting $\Delta W = A \times B - A_0 \times B_0 = [A \mid A_0] \times [B \mid -B_0]^T = A'B'$. +peft_model.save_pretrained(output_dir, path_initial_model_for_weight_conversion="corda_init") +``` + +This conversion enables the loading of LoRA on top of a standard base model: + +```python +import torch +from peft import PeftModel +from transformers import AutoModelForCausalLM + +model = AutoModelForCausalLM.from_pretrained( + "meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto" +) +# No SVD is performed during this step, and the base model remains unaltered. +peft_model = PeftModel.from_pretrained(model, "corda-llama-2-7b-lora") +``` + +Utilizing the converted LoRA does not require modifying the parameters of the base model. When multiple converted LoRAs are needed simultaneously, each adapter operates independently without interference, allowing for the adapters to be freely deleted or added. + +Note that this conversion is not supported if `rslora` is used in combination with `rank_pattern` or `alpha_pattern`. + +## Citation +``` +@inproceedings{yangcorda, + title={CorDA: Context-Oriented Decomposition Adaptation of Large Language Models for Task-Aware Parameter-Efficient Fine-tuning}, + author={Yang, Yibo and Li, Xiaojie and Zhou, Zhongzhu and Song, Shuaiwen Leon and Wu, Jianlong and Nie, Liqiang and Ghanem, Bernard}, + booktitle={The Thirty-eighth Annual Conference on Neural Information Processing Systems}, + year={2024}, +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/corda_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/corda_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..ef8a23f66e83605db1cbf94846fe1e16105f0111 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/corda_finetuning.py @@ -0,0 +1,276 @@ +# Copyright 2024-present the HuggingFace Inc. team. +# +# 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 copy +import os +from collections.abc import Sequence +from dataclasses import dataclass, field +from typing import Optional + +import torch +import transformers +from datasets import load_dataset +from transformers import Trainer + +from peft import LoraConfig, PeftModel, get_peft_model + + +IGNORE_INDEX = -100 + +PROMPT = ( + "Below is an instruction that describes a task. " + "Write a response that appropriately completes the request.\n\n" + "### Instruction:\n{instruction}\n\n### Response:" +) + + +def get_nb_trainable_parameters(model) -> tuple[int, int]: + r""" + Returns the number of trainable parameters and the number of all parameters in the model. + """ + trainable_params = 0 + all_param = 0 + for _, param in model.named_parameters(): + num_params = param.numel() + # if using DS Zero 3 and the weights are initialized empty + if num_params == 0 and hasattr(param, "ds_numel"): + num_params = param.ds_numel + + # Due to the design of 4bit linear layers from bitsandbytes + # one needs to multiply the number of parameters by 2 to get + # the correct number of parameters + if param.__class__.__name__ == "Params4bit": + num_bytes = param.quant_storage.itemsize if hasattr(param, "quant_storage") else 1 + num_params = num_params * 2 * num_bytes + + all_param += num_params + if param.requires_grad: + trainable_params += num_params + + return trainable_params, all_param + + +@dataclass +class TrainingArguments(transformers.TrainingArguments): + model_name_or_path: Optional[str] = field(default="facebook/opt-125m") + data_path: str = field(default=None, metadata={"help": "Path to the training data."}) + dataset_split: str = field(default="train[:100000]", metadata={"help": "(`['train', 'test', 'eval']`):"}) + dataset_field: list[str] = field(default=None, metadata={"help": "Fields of dataset input and output."}) + dataloader_num_proc: int = field(default=16, metadata={"help": "Number of processes to load dataset"}) + dataloader_batch_size: int = field( + default=3000, + metadata={ + "help": "batch size to load dataset. To set the batch size for training, you should pass --batch_size argument instead." + }, + ) + optim: str = field(default="adamw_torch") + model_max_length: int = field( + default=512, + metadata={"help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."}, + ) + lora_r: int = field( + default=None, + metadata={"help": "The rank of LoRA adapter. When passing `None`, CorDA or full fine-tuning is used."}, + ) + corda_mode: bool = field(default=True, metadata={"help": "True for CorDA mode"}) + + +def safe_save_model_for_hf_trainer(trainer: transformers.Trainer, output_dir: str): + """Collects the state dict and dump to disk.""" + state_dict = trainer.model.state_dict() + if trainer.args.should_save: + cpu_state_dict = {key: value.cpu() for key, value in state_dict.items()} + del state_dict + trainer._save(output_dir, state_dict=cpu_state_dict) + + +def smart_tokenizer_and_embedding_resize( + special_tokens_dict: dict, + tokenizer: transformers.PreTrainedTokenizer, + model: transformers.PreTrainedModel, +): + """Resize tokenizer and embedding. + + Note: This is the unoptimized version that may make your embedding size not be divisible by 64. + """ + num_new_tokens = tokenizer.add_special_tokens(special_tokens_dict) + model.resize_token_embeddings(len(tokenizer)) + + if num_new_tokens > 0: + input_embeddings = model.get_input_embeddings().weight.data + output_embeddings = model.get_output_embeddings().weight.data + + input_embeddings_avg = input_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True) + output_embeddings_avg = output_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True) + + input_embeddings[-num_new_tokens:] = input_embeddings_avg + output_embeddings[-num_new_tokens:] = output_embeddings_avg + + +def _tokenize_fn(strings: Sequence[str], tokenizer: transformers.PreTrainedTokenizer) -> dict: + """Tokenize a list of strings.""" + tokenized_list = [ + tokenizer( + text, + return_tensors="pt", + padding="longest", + max_length=tokenizer.model_max_length, + truncation=True, + ) + for text in strings + ] + input_ids = labels = [tokenized.input_ids[0] for tokenized in tokenized_list] + input_ids_lens = labels_lens = [ + tokenized.input_ids.ne(tokenizer.pad_token_id).sum().item() for tokenized in tokenized_list + ] + return { + "input_ids": input_ids, + "labels": labels, + "input_ids_lens": input_ids_lens, + "labels_lens": labels_lens, + } + + +def preprocess( + sources: Sequence[str], + targets: Sequence[str], + tokenizer: transformers.PreTrainedTokenizer, +) -> dict: + """Preprocess the data by tokenizing.""" + examples = [s + t for s, t in zip(sources, targets)] + examples_tokenized, sources_tokenized = (_tokenize_fn(strings, tokenizer) for strings in (examples, sources)) + input_ids = examples_tokenized["input_ids"] + labels = copy.deepcopy(input_ids) + for label, source_len in zip(labels, sources_tokenized["input_ids_lens"]): + label[:source_len] = IGNORE_INDEX + return { + "input_ids": input_ids, + "labels": labels, + } + + +@dataclass +class DataCollatorForSupervisedDataset: + """Collate examples for supervised fine-tuning.""" + + tokenizer: transformers.PreTrainedTokenizer + + def __call__(self, instances: Sequence[dict]) -> dict[str, torch.Tensor]: + input_ids, labels = tuple([instance[key] for instance in instances] for key in ("input_ids", "labels")) + input_ids = [torch.tensor(x) for x in input_ids] + input_ids = torch.nn.utils.rnn.pad_sequence( + input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id + ) + labels = [torch.tensor(x) for x in labels] + labels = torch.nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=IGNORE_INDEX) + return { + "input_ids": input_ids, + "labels": labels, + "attention_mask": input_ids.ne(self.tokenizer.pad_token_id), + } + + +def train_tokenize_function(examples, tokenizer, query, response): + sources = [ + PROMPT.format_map( + { + "instruction": instruction, + } + ) + for instruction in examples[query] + ] + targets = [f"{output}{tokenizer.eos_token}" for output in examples[response]] + data_dict = preprocess(sources, targets, tokenizer) + return data_dict + + +def train(): + parser = transformers.HfArgumentParser(TrainingArguments) + script_args = parser.parse_args_into_dataclasses()[0] + print(script_args) + + if script_args.corda_mode: + print("Train in CorDA mode") + res_model = transformers.AutoModelForCausalLM.from_pretrained( + script_args.model_name_or_path, + device_map="auto", + ) + model = PeftModel.from_pretrained( + res_model, script_args.model_name_or_path, subfolder="corda_init", is_trainable=True + ) + elif script_args.lora_r is not None: + print("Train in LoRA mode") + model = transformers.AutoModelForCausalLM.from_pretrained( + script_args.model_name_or_path, + device_map="auto", + ) + lora_config = LoraConfig( + r=script_args.lora_r, + lora_alpha=script_args.lora_r, + init_lora_weights=True, # script_args.init_lora_weights, + target_modules=["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"], + lora_dropout=0, + bias="none", + task_type="CAUSAL_LM", + ) + model = get_peft_model(model, lora_config) + else: + print("Train in Full Finetuning mode") + model = transformers.AutoModelForCausalLM.from_pretrained( + script_args.model_name_or_path, + dtype=torch.bfloat16, + device_map="auto", + ) + trainable_params, all_param = get_nb_trainable_parameters(model) + print( + f"trainable params: {trainable_params:,d} || all params: {all_param:,d} || trainable%: {100 * trainable_params / all_param}" + ) + tokenizer = transformers.AutoTokenizer.from_pretrained( + script_args.model_name_or_path, + model_max_length=script_args.model_max_length, + padding_side="right", + use_fast=True, + trust_remote_code=True, + ) + tokenizer.pad_token_id = tokenizer.eos_token_id + + raw_train_datasets = load_dataset(script_args.data_path, split=script_args.dataset_split) + train_dataset = raw_train_datasets.map( + train_tokenize_function, + batched=True, + batch_size=script_args.dataloader_batch_size, + num_proc=script_args.dataloader_num_proc, + remove_columns=raw_train_datasets.column_names, + load_from_cache_file=True, + desc="Running tokenizer on train dataset", + fn_kwargs={ + "tokenizer": tokenizer, + "query": script_args.dataset_field[0], + "response": script_args.dataset_field[1], + }, + ) + + data_collator = DataCollatorForSupervisedDataset(tokenizer=tokenizer) + data_module = { + "train_dataset": train_dataset, + "data_collator": data_collator, + } + trainer = Trainer(model=model, processing_class=tokenizer, args=script_args, **data_module) + trainer.train() + trainer.save_state() + model.save_pretrained(os.path.join(script_args.output_dir, "ft")) + + +if __name__ == "__main__": + train() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/datautils.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/datautils.py new file mode 100644 index 0000000000000000000000000000000000000000..3e612b07af57f57023e8b1a319f38047e2e7c54d --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/datautils.py @@ -0,0 +1,235 @@ +# Copyright 2024-present the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import random + +import numpy as np +import torch +from datasets import load_dataset + + +""" +doc https://huggingface.co/docs/datasets/loading +doc https://huggingface.co/docs/datasets/process +doc https://huggingface.co/blog/llama2#how-to-prompt-llama-2 +""" + + +def set_seed(seed): + np.random.seed(seed) + torch.random.manual_seed(seed) + + +def sample_train_loaders(name, tokenizer, nsamples=128, seed=0, seqlen=2048): + set_seed(seed) + if "wikitext2" in name: + traindata = load_dataset( + "wikitext", + "wikitext-2-raw-v1", + split="train", + ) + traindata = "\n\n".join(traindata["text"]) + elif "c4" in name: + traindata = load_dataset( + "allenai/c4", + "allenai--c4", + data_files={"train": "en/c4-train.00000-of-01024.json.gz"}, + split="train", + ) + traindata = "\n\n".join(traindata["text"]) + else: + raise NotImplementedError + + trainloader = [] + for _ in range(nsamples): + i = random.randint(0, len(traindata) - seqlen * 2 - 1) + j = i + seqlen * 2 + # breakpoint() + trainenc = tokenizer(traindata[i:j], return_tensors="pt") + inp = trainenc.input_ids[:, :seqlen] + trainloader.append(inp) + return trainloader + + +def get_redpajama_train(tokenizer, percent=10, seed=3, batch_size=128, max_length=2048): + def tokenization(example): + return tokenizer(example["text"], truncation=True, max_length=max_length) + + if percent != 100: + split = f"train[:{int(850000 * percent / 100)}]" + else: + split = "train" + dataset = load_dataset("togethercomputer/RedPajama-Data-1T-Sample", split=split) + + processed_dataset = dataset.map(tokenization, batched=True, batch_size=batch_size, num_proc=os.cpu_count()) + return processed_dataset + + +def get_english_quote(dataset_name, tokenizer): + data = load_dataset(dataset_name) + data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True) + return data["train"] + + +def get_qat_dataset(name, tokenizer, data_percent): + if name == "red_pajama": + data = get_redpajama_train(tokenizer, data_percent) + + elif name == "Abirate/english_quotes": + data = get_english_quote(name, tokenizer) + else: + raise NotImplementedError + data = data.shuffle() + return data + + +llama_chat_format = """[INST] <> +"Below is an instruction that describes a task. Write a response that appropriately completes the request." +<> + +{instruction} [/INST] {response} +""" + + +def get_calib_data(name, tokenizer, model_id, nsamples, seqlen=2048, seed=3): + print(f" get_data_from: {name}, nsamples={nsamples}, seqlen={seqlen}, {seed}") + cache_file = f"cache/{name}_{model_id.replace('/', '_')}_{nsamples}_{seqlen}_{seed}.pt" + traindataset = [] + if not os.path.exists("cache"): + os.makedirs("cache") + if os.path.exists(cache_file): + print(f"found data file: {cache_file}") + traindataset = torch.load(cache_file) + print("loaded ...") + return traindataset + if name == "c4": + traindata = load_dataset( + "allenai/c4", + "allenai--c4", + data_files={"train": "en/c4-train.00000-of-01024.json.gz"}, + split="train", + ) + tot_text = "\n\n".join(traindata["text"]) + elif name == "wikitext2": + traindata = load_dataset("wikitext", "wikitext-2-raw-v1", split="train") + tot_text = "\n\n".join(traindata["text"]) + elif name == "ptb": + traindata = load_dataset( + "ptb_text_only", + "penn_treebank", + split="train", + ) + tot_text = "\n\n".join(traindata["sentence"]) + elif name == "traivia_qa": + traindata = load_dataset("trivia_qa", "rc", split="train") + tot_text = "\n\n".join(traindata["question"]) + elif name == "nqopen": + traindata = load_dataset("nq_open", split="train") + tot_text = "\n\n".join(traindata["question"]) + elif name == "alpaca": + selected_data_dict = load_dataset("iboing/alpaca_data", split="train").shuffle(seed=seed).take(nsamples) + for example in selected_data_dict: + if example.get("input", "") == "": + s = llama_chat_format.format(instruction=example["instruction"], response=example["output"]) + trainenc = tokenizer(s, return_tensors="pt") + inp = trainenc.input_ids[:, :seqlen] + attention_mask = torch.ones_like(inp) + traindataset.append({"input_ids": inp, "attention_mask": attention_mask}) + print("example instruction:", s) + torch.save(traindataset, cache_file) + return traindataset + elif name == "MetaMATH": + selected_data_dict = load_dataset("iboing/MetaMathQA-395K", split="train").shuffle(seed=seed).take(nsamples) + for example in selected_data_dict: + if example.get("input", "") == "": + s = llama_chat_format.format(instruction=example["query"], response=example["response"]) + trainenc = tokenizer(s, return_tensors="pt") + inp = trainenc.input_ids[:, :seqlen] + attention_mask = torch.ones_like(inp) + traindataset.append({"input_ids": inp, "attention_mask": attention_mask}) + print("example instruction:", s) + torch.save(traindataset, cache_file) + return traindataset + elif name == "codefeedback": + selected_data_dict = ( + load_dataset("iboing/CodeFeedback-Filtered-Instruction", split="train").shuffle(seed=seed).take(nsamples) + ) + for example in selected_data_dict: + if example.get("input", "") == "": + s = llama_chat_format.format(instruction=example["query"], response=example["answer"]) + trainenc = tokenizer(s, return_tensors="pt") + inp = trainenc.input_ids[:, :seqlen] + attention_mask = torch.ones_like(inp) + traindataset.append({"input_ids": inp, "attention_mask": attention_mask}) + print("example instruction:", s) + torch.save(traindataset, cache_file) + return traindataset + elif name == "WizLMinstruct": + selected_data_dict = ( + load_dataset("iboing/WizardLM_evol_instruct_V2_143k", split="train").shuffle(seed=seed).take(nsamples) + ) + for example in selected_data_dict: + if example.get("input", "") == "": + s = llama_chat_format.format( + instruction=example["conversation"][0]["human"], response=example["conversation"][0]["assistant"] + ) + trainenc = tokenizer(s, return_tensors="pt") + inp = trainenc.input_ids[:, :seqlen] + attention_mask = torch.ones_like(inp) + traindataset.append({"input_ids": inp, "attention_mask": attention_mask}) + print("example instruction:", s) + torch.save(traindataset, cache_file) + return traindataset + else: + raise NotImplementedError + print(f"tot_text={len(tot_text)}") + for _ in range(nsamples): + i = random.randint(0, len(tot_text) - seqlen - 1) + j = i + seqlen * 10 + trainenc = tokenizer(tot_text[i:j], return_tensors="pt") + inp = trainenc.input_ids[:, :seqlen] + attention_mask = torch.ones_like(inp) + traindataset.append({"input_ids": inp, "attention_mask": attention_mask}) + torch.save(traindataset, cache_file) + return traindataset + + +def get_eval_loaders(name, tokenizer): + if "wikitext2" in name: + testdata = load_dataset( + "wikitext", + "wikitext-2-raw-v1", + split="test", + ) + testenc = tokenizer("\n\n".join(testdata["text"]), return_tensors="pt") + return testenc + if "ptb" in name: + valdata = load_dataset( + "ptb_text_only", + "penn_treebank", + split="validation", + ) + testenc = tokenizer("\n\n".join(valdata["sentence"]), return_tensors="pt") + return testenc + if "c4" in name: + testdata = load_dataset( + "allenai/c4", + "allenai--c4", + data_files={"validation": "en/c4-validation.00000-of-00008.json.gz"}, + split="validation", + ) + testenc = tokenizer("\n\n".join(testdata["text"]), return_tensors="pt") + return testenc + raise NotImplementedError diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/preprocess.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/preprocess.py new file mode 100644 index 0000000000000000000000000000000000000000..bcd33efe04c2f26977f313652e1e5934cbaffde0 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/corda_finetuning/preprocess.py @@ -0,0 +1,165 @@ +# Copyright 2024-present the HuggingFace Inc. team. +# +# 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 argparse +import os + +import numpy as np +import torch +from datautils import get_calib_data +from tqdm import tqdm +from transformers import AutoModelForCausalLM, AutoTokenizer + +from peft import get_peft_model +from peft.tuners.lora.config import CordaConfig, LoraConfig +from peft.tuners.lora.corda import preprocess_corda + + +@torch.no_grad() +def run_model(model, calib_loader): + model.eval() + for batch in tqdm(calib_loader): + batch = {k: v.to(model.device) for k, v in batch.items()} + model(**batch) + + +def main(args): + # Setting random seed of numpy and torch + np.random.seed(args.seed) + torch.manual_seed(args.seed) + if torch.cuda.is_available(): + torch.cuda.manual_seed_all(args.seed) + elif torch.xpu.is_available(): + torch.xpu.manual_seed_all(args.seed) + torch.use_deterministic_algorithms(True) + + # Load model + model_id = args.model_id + tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True) + + model = AutoModelForCausalLM.from_pretrained( + model_id, device_map="auto", dtype=torch.float16, trust_remote_code=True + ) + + # Collect data + calib_loader = get_calib_data(args.calib_dataset, tokenizer, model_id, args.calib_loader_size, seed=args.seed) + + # Evaluate the original model + print("\n---- model before svd ---\n") + print(model) + + # Perform decomposition + corda_config = CordaConfig( + corda_method="ipm" if args.first_eigen else "kpm", + ) + lora_config = LoraConfig( + init_lora_weights="corda", + target_modules=["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"], + r=args.r, + lora_alpha=args.r, + corda_config=corda_config, + ) + preprocess_corda( + model, + lora_config, + run_model=lambda: run_model(model, calib_loader), + ) + model = get_peft_model(model, lora_config) + + # Evaluate again to check if the model is consistent + # Using `model.model` here because `get_peft_model` wraps a layer to the model + print("\n---- model after svd ---\n") + print(model) + + # Save as hugging face model + if args.save_model: + assert args.save_path is not None + save_path = args.save_path + + # Save CorDA modules + model.peft_config["default"].init_lora_weights = True + model.save_pretrained(os.path.join(save_path, "corda_init")) + + # Save residual model + model = model.unload() + model.save_pretrained(save_path) + + # Save tokenizer + tokenizer.save_pretrained(save_path) + print(f"Done building CorDA huggingface model in {save_path}") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument( + "--model_id", + type=str, + default="meta-llama/Llama-2-7b-hf", + help="Pretrained model ID", + ) + parser.add_argument( + "--calib_loader_size", + type=int, + default=256, + help="number of samples used for covariance matrices", + ) + parser.add_argument( + "--calib_dataset", + type=str, + default="wikitext2", + choices=[ + "wikitext2", + "c4", + "ptb", + "traivia_qa", + "nqopen", + "MetaMATH", + "codefeedback", + "WizLMinstruct", + "alpaca", + ], + help="calibration dataset", + ) + parser.add_argument( + "--eval_mmlu", + action="store_true", + help="evaluate mmlu", + ) + parser.add_argument( + "--seed", + type=int, + default=233, + help="random seed", + ) + parser.add_argument( + "--r", + type=int, + default=None, + ) + parser.add_argument( + "--first_eigen", + action="store_true", + ) + parser.add_argument( + "--save_model", + action="store_true", + ) + parser.add_argument( + "--save_path", + type=str, + default=None, + ) + args = parser.parse_args() + + main(args) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/cpt_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cpt_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2c84ce91c95e4480168fca7971d3cae188348fea --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cpt_finetuning/README.md @@ -0,0 +1,64 @@ + +# Context-aware Prompt Tuning: Advancing In-Context Learning with Adversarial Methods +## Introduction ([Paper](https://huggingface.co/papers/2410.17222), [Code](https://github.com/tsachiblau/Context-aware-Prompt-Tuning-Advancing-In-Context-Learning-with-Adversarial-Methods), [Notebook](cpt_train_and_inference.ipynb), [Colab](https://colab.research.google.com/drive/1UhQDVhZ9bDlSk1551SuJV8tIUmlIayta?usp=sharing)) + +> Large Language Models (LLMs) can perform few-shot learning using either optimization-based approaches or In-Context Learning (ICL). Optimization-based methods often suffer from overfitting, as they require updating a large number of parameters with limited data. In contrast, ICL avoids overfitting but typically underperforms compared to optimization-based methods and is highly sensitive to the selection, order, and format of demonstration examples. To overcome these challenges, we introduce Context-aware Prompt Tuning (CPT), a method inspired by ICL, Prompt Tuning (PT), and adversarial attacks. CPT builds on the ICL strategy of concatenating examples before the input, extending it by incorporating PT-like learning to refine the context embedding through iterative optimization, extracting deeper insights from the training examples. Our approach carefully modifies specific context tokens, considering the unique structure of the examples within the context. In addition to updating the context with PT-like optimization, CPT draws inspiration from adversarial attacks, adjusting the input based on the labels present in the context while preserving the inherent value of the user-provided data. To ensure robustness and stability during optimization, we employ a projected gradient descent algorithm, constraining token embeddings to remain close to their original values and safeguarding the quality of the context. Our method has demonstrated superior accuracy across multiple classification tasks using various LLM models, outperforming existing baselines and effectively addressing the overfitting challenge in few-shot learning. + + + +

+ +
+CPT optimizing only specific token embeddings while keeping the rest of the model frozen (image source). + +--- + +## Dataset Creation and Collation for CPT + +This document explains how to prepare datasets for CPT, linking the dataset preparation processes in the code to the methods and principles described in the CPT paper, specifically in **Sections 3.1**, **3.2**, and **3.3**. + +--- + +### Template-Based Tokenization + +#### The Role of Templates +Templates define the structure of the input-output pairs, enabling the model to interpret the task within a unified context. + +- **Input Templates**: + Templates like `"input: {sentence}"` structure raw input sentences. The `{sentence}` placeholder is replaced with the actual input text. + +- **Output Templates**: + Templates such as `"output: {label}"` format the labels (e.g., `positive`, `negative`, etc.). + +- **Separator Tokens**: + Separators distinguish different parts of the input, such as the input text and labels, as well as separate examples within the context. + + +#### How CPT Utilizes Context Structure + +CPT leverages the context structure, encoded within the `cpt_tokens_type_mask`, to optimize the context effectively. to optimize the context effectively. By treating different token types based on their roles, the model updates some tokens while using others solely for optimization: + +1. **Refrain from Updating Label Tokens**: + Some context tokens represent label tokens, which contain valuable, unmodifiable information. By excluding these tokens from updates during training, CPT ensures that the labels remain fixed, preserving their integrity. + +2. **Apply Type-Specific Projection Norms**: + CPT employs Projected Gradient Descent (PGD) to update context embeddings, applying tailored norms to different context parts. This approach reduces overfitting while maintaining robustness and generalization by preserving the integrity of user-provided examples. + + + +#### Limitations +CPT is designed for few-shot scenarios, as concatenating more examples increases memory usage due to the self-attention mechanism and additional loss terms. For larger datasets, users can limit the number of context examples and use the remaining samples solely for optimization to manage memory efficiently. + + + + +## Citation +```bib +@article{ + blau2025cpt, + title={Context-Aware Prompt Tuning: Advancing In-Context Learning with Adversarial Methods}, + author={Tsachi Blau, Moshe Kimhi, Yonatan Belinkov, Alexander Bronstein, Chaim Baskin}, + journal={arXiv preprint arXiv:2410.17222}}, + year={2025} +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/cpt_finetuning/cpt_train_and_inference.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cpt_finetuning/cpt_train_and_inference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..d10d3b1a02fab1d1327f1a4cd3f040a787abebf1 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/cpt_finetuning/cpt_train_and_inference.ipynb @@ -0,0 +1,1555 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# CPT Training and Inference\n", + "This notebook demonstrates the training and evaluation process of Context-Aware Prompt Tuning (CPT) using the Hugging Face Trainer. For more details, refer to the [Paper](https://huggingface.co/papers/2410.17222).\n", + "\n", + "\n", + "## Sections Overview:\n", + "1. **Setup**: Import libraries and configure the environment.\n", + "2. **Data Preparation**: Load and preprocess the dataset.\n", + "3. **Model Training**: Configure and train the model.\n", + "4. **Evaluation**: Test the model's performance and visualize results." + ], + "metadata": { + "id": "R_byvXT9lpTU" + }, + "id": "R_byvXT9lpTU" + }, + { + "cell_type": "markdown", + "source": [ + "# Setup\n", + "\n", + "---\n", + "\n", + "\n" + ], + "metadata": { + "collapsed": false, + "id": "11b07b07ac5e472b" + }, + "id": "11b07b07ac5e472b" + }, + { + "cell_type": "markdown", + "source": [ + "## Installation" + ], + "metadata": { + "id": "O8DWZb8ZrGRU" + }, + "id": "O8DWZb8ZrGRU" + }, + { + "cell_type": "code", + "source": [ + "!pip install datasets\n", + "!pip install git+https://github.com/huggingface/peft" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "d6KZ5REDrFiM", + "outputId": "e505bc0e-082a-4720-9117-b730d9fd67fa" + }, + "id": "d6KZ5REDrFiM", + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: datasets in /usr/local/lib/python3.10/dist-packages (3.1.0)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from datasets) (3.16.1)\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from datasets) (1.26.4)\n", + "Requirement already satisfied: pyarrow>=15.0.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (17.0.0)\n", + "Requirement already satisfied: dill<0.3.9,>=0.3.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.3.8)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from datasets) (2.2.2)\n", + "Requirement already satisfied: requests>=2.32.2 in /usr/local/lib/python3.10/dist-packages (from datasets) (2.32.3)\n", + "Requirement already satisfied: tqdm>=4.66.3 in /usr/local/lib/python3.10/dist-packages (from datasets) (4.66.6)\n", + "Requirement already satisfied: xxhash in /usr/local/lib/python3.10/dist-packages (from datasets) (3.5.0)\n", + "Requirement already satisfied: multiprocess<0.70.17 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.70.16)\n", + "Requirement already satisfied: fsspec<=2024.9.0,>=2023.1.0 in /usr/local/lib/python3.10/dist-packages (from fsspec[http]<=2024.9.0,>=2023.1.0->datasets) (2024.9.0)\n", + "Requirement already satisfied: aiohttp in /usr/local/lib/python3.10/dist-packages (from datasets) (3.11.2)\n", + "Requirement already satisfied: huggingface-hub>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.26.2)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from datasets) (24.2)\n", + "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from datasets) (6.0.2)\n", + "Requirement already satisfied: aiohappyeyeballs>=2.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (2.4.3)\n", + "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.3.1)\n", + "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (24.2.0)\n", + "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.5.0)\n", + "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (6.1.0)\n", + "Requirement already satisfied: propcache>=0.2.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (0.2.0)\n", + "Requirement already satisfied: yarl<2.0,>=1.17.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.17.2)\n", + "Requirement already satisfied: async-timeout<6.0,>=4.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (4.0.3)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub>=0.23.0->datasets) (4.12.2)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (3.4.0)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (2.2.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (2024.8.30)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2024.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2024.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas->datasets) (1.16.0)\n", + "Collecting git+https://github.com/huggingface/peft\n", + " Cloning https://github.com/huggingface/peft to /tmp/pip-req-build-0mbyx_z_\n", + " Running command git clone --filter=blob:none --quiet https://github.com/huggingface/peft /tmp/pip-req-build-0mbyx_z_\n", + " Resolved https://github.com/huggingface/peft to commit 131efba5d48753a3355ecd4f3833ae010a0510d6\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (1.26.4)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (24.2)\n", + "Requirement already satisfied: psutil in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (5.9.5)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (6.0.2)\n", + "Requirement already satisfied: torch>=1.13.0 in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (2.5.1+cu121)\n", + "Requirement already satisfied: transformers in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (4.46.2)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (4.66.6)\n", + "Requirement already satisfied: accelerate>=0.21.0 in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (1.1.1)\n", + "Requirement already satisfied: safetensors in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (0.4.5)\n", + "Requirement already satisfied: huggingface_hub>=0.25.0 in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (0.26.2)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from huggingface_hub>=0.25.0->peft==0.13.3.dev0) (3.16.1)\n", + "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub>=0.25.0->peft==0.13.3.dev0) (2024.9.0)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from huggingface_hub>=0.25.0->peft==0.13.3.dev0) (2.32.3)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub>=0.25.0->peft==0.13.3.dev0) (4.12.2)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.0->peft==0.13.3.dev0) (3.4.2)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.0->peft==0.13.3.dev0) (3.1.4)\n", + "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.0->peft==0.13.3.dev0) (1.13.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy==1.13.1->torch>=1.13.0->peft==0.13.3.dev0) (1.3.0)\n", + "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.10/dist-packages (from transformers->peft==0.13.3.dev0) (2024.9.11)\n", + "Requirement already satisfied: tokenizers<0.21,>=0.20 in /usr/local/lib/python3.10/dist-packages (from transformers->peft==0.13.3.dev0) (0.20.3)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.13.0->peft==0.13.3.dev0) (3.0.2)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub>=0.25.0->peft==0.13.3.dev0) (3.4.0)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub>=0.25.0->peft==0.13.3.dev0) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub>=0.25.0->peft==0.13.3.dev0) (2.2.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub>=0.25.0->peft==0.13.3.dev0) (2024.8.30)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Imports" + ], + "metadata": { + "id": "5BerCvfkq_jp" + }, + "id": "5BerCvfkq_jp" + }, + { + "cell_type": "code", + "source": [ + "from typing import Any, Dict, List, Union\n", + "\n", + "import numpy as np\n", + "import torch\n", + "from datasets import load_dataset\n", + "from torch.utils.data import Dataset\n", + "from tqdm import tqdm\n", + "from transformers import (\n", + " AutoModelForCausalLM,\n", + " AutoTokenizer,\n", + " DataCollatorForLanguageModeling,\n", + " Trainer,\n", + " TrainingArguments,\n", + ")\n", + "\n", + "from peft import CPTConfig, TaskType, get_peft_model\n", + "\n", + "\n", + "MAX_INPUT_LENGTH = 1024\n", + "MAX_ICL_SAMPLES = 10\n", + "NUM_TRAINING_SAMPLES = 100\n", + "model_id = 'bigscience/bloom-1b7'" + ], + "metadata": { + "id": "Y0pETNFBl963" + }, + "id": "Y0pETNFBl963", + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Data Preparation\n", + "---" + ], + "metadata": { + "id": "9hO_I3aDmCQu" + }, + "id": "9hO_I3aDmCQu" + }, + { + "cell_type": "code", + "source": [ + "# Initialize the tokenizer\n", + "tokenizer = AutoTokenizer.from_pretrained(\n", + " model_id, # The name or path of the pre-trained tokenizer (e.g., \"bert-base-uncased\").\n", + " cache_dir='.', # Directory to cache the tokenizer files locally.\n", + " padding_side='right', # Specifies that padding should be added to the right side of sequences.\n", + " trust_remote_code=True # Allows loading tokenizer implementations from external sources.\n", + ")" + ], + "metadata": { + "id": "STK5N0LJrZmA", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "4c5c3dda-07ae-4f67-df29-4a2ff499e5ad" + }, + "id": "STK5N0LJrZmA", + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n", + "The secret `HF_TOKEN` does not exist in your Colab secrets.\n", + "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n", + "You will be able to reuse this secret in all of your notebooks.\n", + "Please note that authentication is recommended but still optional to access public models or datasets.\n", + " warnings.warn(\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Load the SST-2 dataset from the GLUE benchmark\n", + "dataset = load_dataset('glue', 'sst2')\n", + "\n", + "def add_string_labels(example):\n", + " \"\"\"\n", + " Converts numerical labels into human-readable string labels.\n", + "\n", + " Args:\n", + " example (dict): A single example from the dataset with a numerical 'label'.\n", + "\n", + " Returns:\n", + " dict: The example augmented with a 'label_text' field.\n", + " \"\"\"\n", + " # Map numerical label to string label\n", + " example['label_text'] = \"positive\" if example['label'] == 1 else \"negative\"\n", + " return example\n", + "\n", + "# Subset and process the training dataset\n", + "context_dataset = dataset['train'].select(range(MAX_ICL_SAMPLES)).map(add_string_labels)\n", + "train_dataset = dataset['train'].select(range(MAX_ICL_SAMPLES, NUM_TRAINING_SAMPLES + MAX_ICL_SAMPLES)).map(add_string_labels)" + ], + "metadata": { + "id": "C3oq4lDDrcUf", + "colab": { + "base_uri": "https://localhost:8080/", + "referenced_widgets": [ + "72a5be4b77ec4d5994bcace9d462da84", + "bed78529ff2c4d08befca97c50cb5efc", + "cf7077acfce04aff8af0a2483dbf094c", + "910462d70d944d00ba54958d77bee755", + "a899818bdad0415b860eaac4afe31f30", + "3d78a6c8923547cf8c75bc8c10125eda", + "8083f95a673a423286ade63051de757d", + "13fc203ab1b44c83b6cfcc1e171d26ad", + "663a0196d2b547fd8a6890b8a86080c2", + "72be01164e974d59b05bee716e9bc978", + "4cedaf37e79e4ff1a10ffb96ec543e81" + ], + "height": 49 + }, + "outputId": "5ae1ff54-d726-4f07-e6d7-cd53145b5d6f" + }, + "id": "C3oq4lDDrcUf", + "execution_count": 4, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Map: 0%| | 0/100 [00:00 0 else 0 # Increment type indices dynamically\n", + " for i in cpt_context_dataset[i]['input_type_mask']\n", + " ]\n", + "\n", + " # Increment the type mask offset after processing the sample\n", + " first_type_mask += 4" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-22T09:24:58.894814Z", + "start_time": "2024-10-22T09:24:58.893841Z" + }, + "id": "aef03bbd5d86d3d8", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "1bb1343b-b5f8-4998-e34b-6a8ae8063381" + }, + "id": "aef03bbd5d86d3d8", + "execution_count": 7 + }, + { + "cell_type": "markdown", + "source": [ + "# Model Training\n", + "\n", + "---" + ], + "metadata": { + "collapsed": false, + "id": "2c40f24774d83372" + }, + "id": "2c40f24774d83372" + }, + { + "cell_type": "markdown", + "source": [ + "## Load model" + ], + "metadata": { + "id": "p0jFTzkisMgN" + }, + "id": "p0jFTzkisMgN" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "# Load a pre-trained causal language model\n", + "base_model = AutoModelForCausalLM.from_pretrained(\n", + " model_id,\n", + " cache_dir='.',\n", + " dtype=torch.float16,\n", + " device_map='auto'\n", + ")\n", + "\n", + "# Initialize the CPT configuration\n", + "config = CPTConfig(\n", + " task_type=TaskType.CAUSAL_LM,\n", + " cpt_token_ids=context_ids,\n", + " cpt_mask=context_attention_mask,\n", + " cpt_tokens_type_mask=context_input_type_mask,\n", + "\n", + " opt_weighted_loss_type='decay',\n", + " opt_loss_decay_factor=0.95, # we choose the exponential decay factor applied to the loss\n", + " opt_projection_epsilon=0.2, # we choose the projection over the input tokens\n", + " opt_projection_format_epsilon=0.1, # we choose the projection over input and output templates\n", + "\n", + " tokenizer_name_or_path=model_id,\n", + ")\n", + "\n", + "# Initialize the CPT model with PEFT\n", + "model = get_peft_model(base_model, config)" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-22T09:25:08.941945Z", + "start_time": "2024-10-22T09:25:04.393323Z" + }, + "id": "17ac445134919a39" + }, + "id": "17ac445134919a39", + "execution_count": 8 + }, + { + "cell_type": "markdown", + "source": [ + "## Setting Collate Function" + ], + "metadata": { + "collapsed": false, + "id": "4e49660c50d98741" + }, + "id": "4e49660c50d98741" + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "class CPTDataCollatorForLanguageModeling(DataCollatorForLanguageModeling):\n", + " def __init__(self, tokenizer, training=True, mlm=False):\n", + " \"\"\"\n", + " Custom collator for CPT-style language modeling.\n", + "\n", + " Args:\n", + " tokenizer: The tokenizer to handle tokenization and special tokens.\n", + " training (bool): If True, operates in training mode; otherwise in evaluation mode.\n", + " mlm (bool): If True, enables masked language modeling.\n", + " \"\"\"\n", + "\n", + " super().__init__(tokenizer, mlm=mlm) # Initialize the parent class\n", + " self.training = training\n", + "\n", + " # Add a special padding token if not already defined\n", + " self.tokenizer.add_special_tokens({\"pad_token\": \"[PAD]\"})\n", + "\n", + " def torch_call(self, examples: List[Union[List[int], Any, Dict[str, Any]]]) -> Dict[str, Any]:\n", + " \"\"\"\n", + " Process a batch of examples for language modeling.\n", + "\n", + " Args:\n", + " examples (List): A batch of examples with tokenized inputs and optional sample masks.\n", + "\n", + " Returns:\n", + " Dict: A dictionary containing padded and tensor-converted inputs, attention masks,\n", + " input type masks, and optional sample masks and labels.\n", + " \"\"\"\n", + "\n", + " # Initialize a list to collect sample masks if provided\n", + " list_sample_mask = []\n", + " for i in range(len(examples)):\n", + " if \"sample_mask\" in examples[i].keys():\n", + " list_sample_mask.append(examples[i].pop(\"sample_mask\"))\n", + "\n", + " # Define a helper function for padding sequences to the maximum length\n", + " max_len = max(len(ex[\"input_ids\"]) for ex in examples)\n", + "\n", + " # Define a helper function for padding sequences to the maximum length\n", + " def pad_sequence(sequence, max_len, pad_value=0):\n", + " return sequence + [pad_value] * (max_len - len(sequence))\n", + "\n", + " # Pad and convert `input_ids`, `attention_mask`, and `input_type_mask` to tensors\n", + " input_ids = torch.tensor([pad_sequence(ex[\"input_ids\"], max_len) for ex in examples])\n", + " attention_mask = torch.tensor([pad_sequence(ex[\"attention_mask\"], max_len) for ex in examples])\n", + " input_type_mask = torch.tensor([pad_sequence(ex[\"input_type_mask\"], max_len) for ex in examples])\n", + "\n", + " # Create the initial batch dictionary\n", + " batch = {\"input_ids\": input_ids, \"attention_mask\": attention_mask, \"input_type_mask\": input_type_mask}\n", + "\n", + " # Create a tensor to store sample masks\n", + " tensor_sample_mask = batch[\"input_ids\"].clone().long()\n", + " tensor_sample_mask[:, :] = 0 # Initialize with zeros\n", + "\n", + " # Populate the tensor with the provided sample masks\n", + " for i in range(len(list_sample_mask)):\n", + " tensor_sample_mask[i, : len(list_sample_mask[i])] = list_sample_mask[i]\n", + "\n", + " # Copy `input_ids` to use as `labels`\n", + " batch[\"labels\"] = batch[\"input_ids\"].clone()\n", + "\n", + " # If in evaluation mode, include the `sample_mask` in the batch\n", + " if not self.training:\n", + " batch[\"sample_mask\"] = tensor_sample_mask\n", + "\n", + " return batch" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-22T09:25:08.953199Z", + "start_time": "2024-10-22T09:25:08.945689Z" + }, + "id": "b0fac840f060e3aa" + }, + "id": "b0fac840f060e3aa", + "execution_count": 9 + }, + { + "cell_type": "markdown", + "source": [ + "## Training" + ], + "metadata": { + "collapsed": false, + "id": "48f535d74e6602b" + }, + "id": "48f535d74e6602b" + }, + { + "cell_type": "code", + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [500/500 01:28, Epoch 5/5]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
1000.400800
2000.036000
3000.026300
4000.016100
5000.011600

" + ] + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "TrainOutput(global_step=500, training_loss=0.09815525007247924, metrics={'train_runtime': 90.6767, 'train_samples_per_second': 5.514, 'train_steps_per_second': 5.514, 'total_flos': 79477977907200.0, 'train_loss': 0.09815525007247924, 'epoch': 5.0})" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ], + "source": [ + "training_args = TrainingArguments(\n", + " output_dir='../.',\n", + " use_cpu=False,\n", + " auto_find_batch_size=False,\n", + " learning_rate=1e-4,\n", + " logging_steps=100,\n", + " per_device_train_batch_size=1,\n", + " save_total_limit=1,\n", + " remove_unused_columns=False,\n", + " num_train_epochs=5,\n", + " fp16=True,\n", + " save_strategy='no',\n", + " report_to=\"none\"\n", + ")\n", + "\n", + "trainer = Trainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=cpt_train_dataset, # Custom CPT training dataset.\n", + " data_collator=CPTDataCollatorForLanguageModeling(tokenizer, training=True, mlm=False)\n", + ")\n", + "\n", + "trainer.train()" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-22T09:25:27.599132Z", + "start_time": "2024-10-22T09:25:13.906685Z" + }, + "colab": { + "base_uri": "https://localhost:8080/", + "height": 268 + }, + "id": "1a865c2ad2dc7218", + "outputId": "c4bfd785-e354-4ee6-a87e-63c17bfd2605" + }, + "id": "1a865c2ad2dc7218", + "execution_count": 10 + }, + { + "cell_type": "markdown", + "source": [ + "# Model Evaluation\n", + "\n", + "---" + ], + "metadata": { + "collapsed": false, + "id": "b799ea89a567590f" + }, + "id": "b799ea89a567590f" + }, + { + "cell_type": "code", + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 100/100 [00:00<00:00, 1972.82it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Sentence: input: it 's a charming and often affecting journey . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: unflinchingly bleak and desperate output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: allows us to hope that nolan is poised to embark a major career as a commercial yet inventive filmmaker . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: the acting , costumes , music , cinematography and sound are all astounding given the production 's austere locales . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: it 's slow -- very , very slow . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: although laced with humor and a few fanciful touches , the film is a refreshingly serious look at young women . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: a sometimes tedious film . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: or doing last year 's taxes with your ex-wife . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: you do n't have to know about music to appreciate the film 's easygoing blend of comedy and romance . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: in exactly 89 minutes , most of which passed as slowly as if i 'd been sitting naked on an igloo , formula 51 sank from quirky to jerky to utter turkey . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: the mesmerizing performances of the leads keep the film grounded and keep the audience riveted . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: it takes a strange kind of laziness to waste the talents of robert forster , anne meara , eugene levy , and reginald veljohnson all in the same movie . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: ... the film suffers from a lack of humor ( something needed to balance out the violence ) ... output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: we root for ( clara and paul ) , even like them , though perhaps it 's an emotion closer to pity . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: even horror fans will most likely not find what they 're seeking with trouble every day ; the movie lacks both thrills and humor . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: a gorgeous , high-spirited musical from india that exquisitely blends music , dance , song , and high drama . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: the emotions are raw and will strike a nerve with anyone who 's ever had family trauma . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: audrey tatou has a knack for picking roles that magnify her outrageous charm , and in this literate french comedy , she 's as morning-glory exuberant as she was in amélie . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: ... the movie is just a plain old monster . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: in its best moments , resembles a bad high school production of grease , without benefit of song . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: pumpkin takes an admirable look at the hypocrisy of political correctness , but it does so with such an uneven tone that you never know when humor ends and tragedy begins . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: the iditarod lasts for days - this just felt like it did . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: holden caulfield did it better . output: negative \n", + " \t The prediction is: positive\n", + " \t The GT is negative\n", + "Sentence: input: a delectable and intriguing thriller filled with surprises , read my lips is an original . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: seldom has a movie so closely matched the spirit of a man and his work . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: nicks , seemingly uncertain what 's going to make people laugh , runs the gamut from stale parody to raunchy sex gags to formula romantic comedy . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: the action switches between past and present , but the material link is too tenuous to anchor the emotional connections that purport to span a 125-year divide . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: it 's an offbeat treat that pokes fun at the democratic exercise while also examining its significance for those who take part . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: it 's a cookie-cutter movie , a cut-and-paste job . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: i had to look away - this was god awful . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: thanks to scott 's charismatic roger and eisenberg 's sweet nephew , roger dodger is one of the most compelling variations on in the company of men . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: ... designed to provide a mix of smiles and tears , `` crossroads '' instead provokes a handful of unintentional howlers and numerous yawns . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: a gorgeous , witty , seductive movie . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: if the movie succeeds in instilling a wary sense of ` there but for the grace of god , ' it is far too self-conscious to draw you deeply into its world . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: it does n't believe in itself , it has no sense of humor ... it 's just plain bored . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: a sequence of ridiculous shoot - 'em - up scenes . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: the weight of the piece , the unerring professionalism of the chilly production , and the fascination embedded in the lurid topic prove recommendation enough . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: ( w ) hile long on amiable monkeys and worthy environmentalism , jane goodall 's wild chimpanzees is short on the thrills the oversize medium demands . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: as surreal as a dream and as detailed as a photograph , as visually dexterous as it is at times imaginatively overwhelming . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: escaping the studio , piccoli is warmly affecting and so is this adroitly minimalist movie . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: there 's ... tremendous energy from the cast , a sense of playfulness and excitement that seems appropriate . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: this illuminating documentary transcends our preconceived vision of the holy land and its inhabitants , revealing the human complexities beneath . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: the subtle strength of `` elling '' is that it never loses touch with the reality of the grim situation . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: holm ... embodies the character with an effortlessly regal charisma . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: the title not only describes its main characters , but the lazy people behind the camera as well . output: negative \n", + " \t The prediction is: positive\n", + " \t The GT is negative\n", + "Sentence: input: it offers little beyond the momentary joys of pretty and weightless intellectual entertainment . output: negative \n", + " \t The prediction is: positive\n", + " \t The GT is negative\n", + "Sentence: input: a synthesis of cliches and absurdities that seems positively decadent in its cinematic flash and emptiness . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: a subtle and well-crafted ( for the most part ) chiller . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: has a lot of the virtues of eastwood at his best . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: it 's hampered by a lifetime-channel kind of plot and a lead actress who is out of her depth . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: it feels like an after-school special gussied up with some fancy special effects , and watching its rote plot points connect is about as exciting as gazing at an egg timer for 93 minutes . output: negative \n", + " \t The prediction is: positive\n", + " \t The GT is negative\n", + "Sentence: input: for the most part , director anne-sophie birot 's first feature is a sensitive , extraordinarily well-acted drama . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: mr. tsai is a very original artist in his medium , and what time is it there ? output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: sade is an engaging look at the controversial eponymous and fiercely atheistic hero . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: so devoid of any kind of intelligible story that it makes films like xxx and collateral damage seem like thoughtful treatises output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: a tender , heartfelt family drama . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: ... a hollow joke told by a cinematic gymnast having too much fun embellishing the misanthropic tale to actually engage it . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: the cold turkey would 've been a far better title . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: manages to be both repulsively sadistic and mundane . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: it 's just disappointingly superficial -- a movie that has all the elements necessary to be a fascinating , involving character study , but never does more than scratch the surface . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: this is a story of two misfits who do n't stand a chance alone , but together they are magnificent . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: schaeffer has to find some hook on which to hang his persistently useless movies , and it might as well be the resuscitation of the middle-aged character . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: the primitive force of this film seems to bubble up from the vast collective memory of the combatants . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: on this tricky topic , tadpole is very much a step in the right direction , with its blend of frankness , civility and compassion . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: the script kicks in , and mr. hartley 's distended pace and foot-dragging rhythms follow . output: negative \n", + " \t The prediction is: positive\n", + " \t The GT is negative\n", + "Sentence: input: you wonder why enough was n't just a music video rather than a full-length movie . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: if you 're hard up for raunchy college humor , this is your ticket right here . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: a fast , funny , highly enjoyable movie . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: good old-fashioned slash-and-hack is back ! output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: this one is definitely one to skip , even for horror movie fanatics . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: for all its impressive craftsmanship , and despite an overbearing series of third-act crescendos , lily chou-chou never really builds up a head of emotional steam . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: exquisitely nuanced in mood tics and dialogue , this chamber drama is superbly acted by the deeply appealing veteran bouquet and the chilling but quite human berling . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: uses high comedy to evoke surprising poignance . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: one of creepiest , scariest movies to come along in a long , long time , easily rivaling blair witch or the others . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: a string of rehashed sight gags based in insipid vulgarity . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: among the year 's most intriguing explorations of alientation . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: the movie fails to live up to the sum of its parts . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: the son 's room is a triumph of gentility that earns its moments of pathos . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: there is nothing outstanding about this film , but it is good enough and will likely be appreciated most by sailors and folks who know their way around a submarine . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: this is a train wreck of an action film -- a stupefying attempt by the filmmakers to force-feed james bond into the mindless xxx mold and throw 40 years of cinematic history down the toilet in favor of bright flashes and loud bangs . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: the draw ( for `` big bad love '' ) is a solid performance by arliss howard . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: green might want to hang onto that ski mask , as robbery may be the only way to pay for his next project . output: negative \n", + " \t The prediction is: positive\n", + " \t The GT is negative\n", + "Sentence: input: it 's one pussy-ass world when even killer-thrillers revolve around group therapy sessions . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: though it 's become almost redundant to say so , major kudos go to leigh for actually casting people who look working-class . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: the band 's courage in the face of official repression is inspiring , especially for aging hippies ( this one included ) . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: the movie achieves as great an impact by keeping these thoughts hidden as ... ( quills ) did by showing them . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: the film flat lines when it should peak and is more missed opportunity and trifle than dark , decadent truffle . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: jaglom ... put ( s ) the audience in the privileged position of eavesdropping on his characters output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: fresnadillo 's dark and jolting images have a way of plying into your subconscious like the nightmare you had a week ago that wo n't go away . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: we know the plot 's a little crazy , but it held my interest from start to finish . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: it 's a scattershot affair , but when it hits its mark it 's brilliant . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: hardly a masterpiece , but it introduces viewers to a good charitable enterprise and some interesting real people . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: you wo n't like roger , but you will quickly recognize him . output: negative \n", + " \t The prediction is: positive\n", + " \t The GT is negative\n", + "Sentence: input: if steven soderbergh 's ` solaris ' is a failure it is a glorious failure . output: positive \n", + " \t The prediction is: negative\n", + " \t The GT is positive\n", + "Sentence: input: byler reveals his characters in a way that intrigues and even fascinates us , and he never reduces the situation to simple melodrama . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: this riveting world war ii moral suspense story deals with the shadow side of american culture : racial prejudice in its ugly and diverse forms . output: negative \n", + " \t The prediction is: positive\n", + " \t The GT is negative\n", + "Sentence: input: it 's difficult to imagine the process that produced such a script , but here 's guessing that spray cheese and underarm noises played a crucial role . output: negative \n", + " \t The prediction is: positive\n", + " \t The GT is negative\n", + "Sentence: input: no sophomore slump for director sam mendes , who segues from oscar winner to oscar-winning potential with a smooth sleight of hand . output: positive \n", + " \t The prediction is: positive\n", + " \t The GT is positive\n", + "Sentence: input: on the whole , the movie lacks wit , feeling and believability to compensate for its incessant coarseness and banality . output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "Sentence: input: why make a documentary about these marginal historical figures ? output: negative \n", + " \t The prediction is: negative\n", + " \t The GT is negative\n", + "The model Acc is 90.0%\n" + ] + } + ], + "source": [ + "model.eval()\n", + "\n", + "# Select relevant columns from the test dataset\n", + "test_dataset = test_dataset.select_columns(['sentence', 'label_text'])\n", + "\n", + "# Convert the test dataset to a CPT-compatible format\n", + "cpt_test_dataset = CPTDataset(test_dataset, tokenizer, templates)\n", + "\n", + "# Get the device where the model is loaded (CPU, GPU or XPU)\n", + "device = model.device\n", + "list_bool_predictions = []\n", + "\n", + "for i in range(len(test_dataset)):\n", + " input_ids, input_type_mask = cpt_test_dataset[i]['input_ids'], cpt_test_dataset[i]['input_type_mask']\n", + "\n", + " # Pass the inputs through the model\n", + " outputs = model(\n", + " input_ids=torch.Tensor(input_ids).long().to(device=device).view(1, -1),\n", + " labels=torch.Tensor(input_ids).long().to(device=device).view(1, -1),\n", + " input_type_mask=torch.Tensor(input_type_mask).long().to(device=device).view(1, -1)\n", + " )\n", + "\n", + " # Shift logits to exclude the last token and match the labels\n", + " shifted_logits = outputs.logits[..., :-1, :].contiguous().to(model.dtype)[0, -len(input_ids) + 1:]\n", + " shift_labels = torch.Tensor(input_ids).long().to(device=device).view(1, -1)[0, 1:].contiguous().to(device)\n", + " shifted_input_type_mask = torch.Tensor(input_type_mask).long().to(device=device).view(1, -1)[..., 1:].contiguous().to(device)\n", + "\n", + " # Create a mask for the type `4` tokens (label tokens)\n", + " mask = torch.Tensor(shifted_input_type_mask).long().to(device=device).view(-1,) == 4\n", + "\n", + " # Extract logits and labels corresponding to the mask\n", + " logit = shifted_logits[mask]\n", + " label = shift_labels[mask]\n", + "\n", + " # All possible label tokens for `negative` and `positive`\n", + " all_labels = torch.Tensor([tokenizer(i, add_special_tokens=False)[\"input_ids\"] for i in ['negative', 'positive']]).long().to(device).view(-1,)\n", + "\n", + " # Compare logits with label tokens and infer prediction\n", + " prediction = logit[0, torch.Tensor([tokenizer(i, add_special_tokens=False)[\"input_ids\"] for i in ['negative', 'positive']]).long().to(device).view(-1,)].argmax()\n", + " prediction_text = 'negative' if prediction == 0 else 'positive'\n", + " print(f\"Sentence: {tokenizer.decode(input_ids)} \\n \\t The prediction is: {prediction_text}\\n \\t The GT is {tokenizer.decode(label)}\")\n", + " list_bool_predictions.append(prediction_text == tokenizer.decode(label))\n", + "\n", + "print(f'The model Acc is {100 * np.mean(list_bool_predictions)}%')" + ], + "metadata": { + "ExecuteTime": { + "end_time": "2024-10-22T09:25:28.252009Z", + "start_time": "2024-10-22T09:25:27.598326Z" + }, + "id": "48e7d976e6e01212", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "40dd1226-fa31-4e77-dc7e-e06a3600304e" + }, + "id": "48e7d976e6e01212", + "execution_count": 11 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + }, + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "72a5be4b77ec4d5994bcace9d462da84": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bed78529ff2c4d08befca97c50cb5efc", + "IPY_MODEL_cf7077acfce04aff8af0a2483dbf094c", + "IPY_MODEL_910462d70d944d00ba54958d77bee755" + ], + "layout": "IPY_MODEL_a899818bdad0415b860eaac4afe31f30" + } + }, + "bed78529ff2c4d08befca97c50cb5efc": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3d78a6c8923547cf8c75bc8c10125eda", + "placeholder": "​", + "style": "IPY_MODEL_8083f95a673a423286ade63051de757d", + "value": "Map: 100%" + } + }, + "cf7077acfce04aff8af0a2483dbf094c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_13fc203ab1b44c83b6cfcc1e171d26ad", + "max": 100, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_663a0196d2b547fd8a6890b8a86080c2", + "value": 100 + } + }, + "910462d70d944d00ba54958d77bee755": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_72be01164e974d59b05bee716e9bc978", + "placeholder": "​", + "style": "IPY_MODEL_4cedaf37e79e4ff1a10ffb96ec543e81", + "value": " 100/100 [00:00<00:00, 1327.06 examples/s]" + } + }, + "a899818bdad0415b860eaac4afe31f30": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3d78a6c8923547cf8c75bc8c10125eda": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8083f95a673a423286ade63051de757d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "13fc203ab1b44c83b6cfcc1e171d26ad": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "663a0196d2b547fd8a6890b8a86080c2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "72be01164e974d59b05bee716e9bc978": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4cedaf37e79e4ff1a10ffb96ec543e81": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/delora_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/delora_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..20c18ae059babcd5664fa7da353b630cf7233bfd --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/delora_finetuning/README.md @@ -0,0 +1,102 @@ +# DeLoRA: Decoupled Low-Rank Adaptation + +## Introduction +[DeLoRA](https://huggingface.co/papers/2503.18225) tackles finetuning in a Frobenius-norm bounded setup: this allows to prevent divergence from the pretrained model, effectively decoupling the learning of angles and magnitudes. + +This is done by (i) normalization of the BA low-rank matrices, which bound the updates' Frobenius norm, (ii) learnable scaling lambda, which controls the update's boundary/magnitude, (iii) layer-wise scaling of ||W||, to adapt each update's norm to the original weights' norm. + +## Quick start + +With respect to your standard PEFT training procedure with LoRA, simply swap your `LoraConfig` for a `DeloraConfig`. Note however that `lora_alpha` parameter is replaced by `delora_lambda` parameter which sets an upper bound to the Frobenius norm of the weight change. + +```python +import torch +from peft import DeloraConfig, get_peft_model +from transformers import AutoTokenizer, AutoModelForCausalLM +from trl import SFTConfig, SFTTrainer +from datasets import load_dataset + +model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B", dtype=torch.bfloat16, device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B") +tokenizer.pad_token_id = tokenizer.eos_token_id +delora_config = DeloraConfig(r=32, delora_lambda=15) + +peft_model = get_peft_model(model, delora_config) +peft_model.print_trainable_parameters() + +dataset = load_dataset("imdb", split="train[:1%]") + +training_args = SFTConfig(dataset_text_field="text", max_length=128) +trainer = SFTTrainer( + model=peft_model, + args=training_args, + train_dataset=dataset, + processing_class=tokenizer, +) +trainer.train() +peft_model.save_pretrained("delora-llama-3-8b") +``` + +To utilize the fine-tuned DeLoRA modules, simply run the following command: +```python +import torch +from peft import PeftModel +from transformers import AutoModelForCausalLM + +model = AutoModelForCausalLM.from_pretrained( + "meta-llama/Meta-Llama-3-8B", dtype=torch.bfloat16, device_map="auto" +) +peft_model = PeftModel.from_pretrained(model, "delora-llama-3-8b") +``` + +## Advanced Usage +In this script the default DeLoRA layers are the query and value layers of the Llama model. Adding adapters on more layers will increase memory usage. If you wish to choose a different set of layers for DeLoRA to be applied on, you can simply define it using: +```bash +python examples/delora_finetuning/delora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --target_modules "q_proj,k_proj,v_proj,o_proj" +``` + +Using different lambdas for different layers is also possible by setting `lambda_pattern`. + +### Fine-tune +```bash +python delora_finetuning.py \ + --base_model "PATH_TO_MODEL" \ + --data_path "PATH_TO_DATASET" \ + --output_dir "PATH_TO_OUTPUT_DIR" \ + --batch_size 1 \ + --num_epochs 3 \ + --learning_rate 3e-3 \ + --cutoff_len 512 \ + --val_set_size 500 \ + --eval_step 10 \ + --save_step 100 \ + --device "auto" \ + --rank 32 \ + --delora_lambda 15 \ + --module_dropout 0.1 \ + --target_modules "q_proj,v_proj" \ + --hub_model_id "YOUR_HF_REPO" \ + --push_to_hub +``` + +## Additional Notes +### Best practices +- use 10-100x larger learning rate than standard LoRA variants (typical values from 1e-3/1e-2/..) +- do not set a too small initial boundary parameter lambda (typical values are around 10/15/..) + + +### DeLoRA vs DoRA +DeLoRA might feel quite similar to DoRA (given the similar target of decoupling angular from magnitude learning), however it presents key differences: (i) DoRA applies normalization and scaling operations on the fully finetuned weights ($W + \Delta W$), (ii) DoRA's normalization operation is performed on the column space of the weight matrices. + +Conversely DeLoRA (i) introduces the normalization and scaling operations directly on the weight updates $\Delta W$, better preventing divergence from the pretrained model, and (ii) normalizes the inner low-dimensional space, which enforces a Frobenius-norm boundary to the weight updates. + + +## Citation +``` +@inproceedings{bini2025decouplinganglesstrengthlowrank, + title={Decoupling Angles and Strength in Low-rank Adaptation}, + author={Massimo Bini and Leander Girrbach and Zeynep Akata}, + year={2025}, + booktitle={International Conference on Learning Representations (ICLR)}, +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/delora_finetuning/delora_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/delora_finetuning/delora_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..01107b06f7dc2caa5d74213d9439e865916fa773 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/delora_finetuning/delora_finetuning.py @@ -0,0 +1,189 @@ +# This script is based on examples/randlora_finetuning/randlora_finetuning.py +import os + +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + DataCollatorForLanguageModeling, + Trainer, + TrainingArguments, +) + +from peft import DeloraConfig, get_peft_model + + +def train_model( + base_model: str, + data_path: str, + output_dir: str, + batch_size: int, + num_epochs: int, + learning_rate: float, + cutoff_len: int, + val_set_size: int, + eval_step: int, + save_step: int, + device: str, + rank: int, + delora_lambda: int, + module_dropout: float, + target_modules: str, + hub_model_id: str, + push_to_hub: bool, +): + os.environ["TOKENIZERS_PARALLELISM"] = "false" + hf_token = os.getenv("HF_TOKEN") + + # Setup device + device = torch.device(device) + print(f"Using device: {device}") + + # load tokenizer + tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token) + + # Compute type + device_type = device.type + device_module = getattr(torch, device_type, torch.cuda) + bf16_supported = device_module.is_available() and device_module.is_bf16_supported() + dtype = torch.bfloat16 if bf16_supported else torch.float32 + + # Load the base model + model = AutoModelForCausalLM.from_pretrained( + base_model, + dtype=dtype, + ) + + # DeLoRA config for the PEFT model + peft_config = DeloraConfig( + r=rank, + delora_lambda=delora_lambda, + target_modules=(target_modules.split(",") if target_modules else None), + module_dropout=module_dropout, + bias="none", + ) + + # get the peft model with DeLoRA config + model = get_peft_model(model, peft_config) + + model.to(device) # MODEL TO ACCELERATOR + tokenizer.pad_token = tokenizer.eos_token + + # Load the dataset + dataset = load_dataset(data_path) + + def tokenize_function(examples): + inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len) + inputs["labels"] = inputs["input_ids"].copy() # setting labels for a language modeling task + return inputs + + # Tokenize the dataset and prepare for training + tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names) + + # Data collator to dynamically pad the batched examples + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + + # Compute the total amount of training step for warmup + max_steps = int((len(dataset) // batch_size) * num_epochs) + + # Define training arguments + training_args = TrainingArguments( + output_dir=output_dir, + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + per_device_eval_batch_size=batch_size, + warmup_steps=int(max_steps * 0.1), # 10% of total trainig steps + weight_decay=0.0, + logging_steps=eval_step, + save_steps=save_step, + save_total_limit=2, + push_to_hub=push_to_hub, + hub_model_id=hub_model_id, + gradient_accumulation_steps=16, + learning_rate=learning_rate, + hub_token=hf_token, + label_names=["labels"], + ) + + # Clear accelerator cache to free memory + device_module.empty_cache() + + # Initialize the Trainer + trainer = Trainer( + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["test"], + data_collator=data_collator, + ) + + # Start model training + trainer.train() + + # Save and push the trained model and tokenizer + if push_to_hub: + # Push the main model to the hub + trainer.push_to_hub(commit_message="Fine-tuned model") + + # Save the model and tokenizer locally + model.save_pretrained(output_dir) + tokenizer.save_pretrained(output_dir) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DeLoRA") + parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name") + parser.add_argument( + "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name" + ) + parser.add_argument( + "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model" + ) + parser.add_argument("--batch_size", type=int, default=1, help="Batch size") + parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs") + parser.add_argument("--learning_rate", type=float, default=3e-3, help="Learning rate") + parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization") + parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size") + parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval") + parser.add_argument("--save_step", type=int, default=100, help="Save step interval") + parser.add_argument("--device", type=str, default="auto", help="Device to use for training") + parser.add_argument("--rank", type=int, default=32, help="DeLoRA basis rank") + parser.add_argument("--delora_lambda", type=int, default=640, help="DeLoRA alpha") + parser.add_argument("--module_dropout", type=float, default=0.05, help="DeLoRA dropout rate") + parser.add_argument( + "--target_modules", type=str, default=None, help="Comma-separated list of target modules for DeLoRA" + ) + parser.add_argument( + "--hub_model_id", + type=str, + default="path/to/repo", + help="Repository name to push the model on the Hugging Face Hub", + ) + parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub") + args = parser.parse_args() + + if args.device == "auto": + args.device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + + train_model( + base_model=args.base_model, + data_path=args.data_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + val_set_size=args.val_set_size, + eval_step=args.eval_step, + save_step=args.save_step, + device=args.device, + rank=args.rank, + delora_lambda=args.delora_lambda, + module_dropout=args.module_dropout, + target_modules=args.target_modules, + hub_model_id=args.hub_model_id, + push_to_hub=args.push_to_hub, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/dna_language_models/dna_lm.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/dna_language_models/dna_lm.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..70360879dec511676290762c6e8bd67a9c6221de --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/dna_language_models/dna_lm.ipynb @@ -0,0 +1,2860 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "db4dc272-88fe-47ad-98fd-b94d4f840dca", + "metadata": { + "id": "db4dc272-88fe-47ad-98fd-b94d4f840dca" + }, + "source": [ + "# PEFT with DNA Language Models" + ] + }, + { + "cell_type": "markdown", + "id": "d381f473-0d37-4b5b-ae9e-d2b32bab7c04", + "metadata": { + "id": "d381f473-0d37-4b5b-ae9e-d2b32bab7c04" + }, + "source": [ + "This notebook demonstrates how to utilize parameter-efficient fine-tuning techniques (PEFT) from the PEFT library to fine-tune a DNA Language Model (DNA-LM). The fine-tuned DNA-LM will be applied to solve a task from the nucleotide benchmark dataset. Parameter-efficient fine-tuning (PEFT) techniques are crucial for adapting large pre-trained models to specific tasks with limited computational resources." + ] + }, + { + "cell_type": "markdown", + "id": "23f460c3-d7e5-437f-a5e9-d029cd225bf8", + "metadata": { + "id": "23f460c3-d7e5-437f-a5e9-d029cd225bf8" + }, + "source": [ + "### 1. Import relevant libraries" + ] + }, + { + "cell_type": "markdown", + "id": "29a35f95-738a-4f5e-88ce-dc5f8f9be5dc", + "metadata": { + "id": "29a35f95-738a-4f5e-88ce-dc5f8f9be5dc" + }, + "source": [ + "We'll start by importing the required libraries, including the PEFT library and other dependencies." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0a40abdf-ca1c-436f-a2af-603cd67a45a4", + "metadata": { + "id": "0a40abdf-ca1c-436f-a2af-603cd67a45a4" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/anaconda3/envs/peft/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import torch\n", + "import transformers\n", + "import peft\n", + "import tqdm\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "a445f8be-545d-4085-a5f9-c64983655224", + "metadata": { + "id": "a445f8be-545d-4085-a5f9-c64983655224" + }, + "source": [ + "### 2. Load models\n" + ] + }, + { + "cell_type": "markdown", + "id": "63782b55-1c38-4e44-b003-e57daa813bed", + "metadata": { + "id": "63782b55-1c38-4e44-b003-e57daa813bed" + }, + "source": [ + "We'll load a pre-trained DNA Language Model, \"SpeciesLM\", that serves as the base for fine-tuning. This is done using the transformers library from HuggingFace.\n", + "\n", + "The tokenizer and the model comes from the paper, \"Species-aware DNA language models capture regulatory elements and their evolution\". [Paper Link](https://www.biorxiv.org/content/10.1101/2023.01.26.525670v2), [Code Link](https://github.com/gagneurlab/SpeciesLM). They introduce a species-aware DNA language model, which is trained on more than 800 species spanning over 500 million years of evolution." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "dac961f4-c450-4124-923e-f4ba9bbd5e07", + "metadata": { + "id": "dac961f4-c450-4124-923e-f4ba9bbd5e07" + }, + "outputs": [], + "source": [ + "from transformers import AutoTokenizer, AutoModelForMaskedLM" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e73fae58-03e9-4acc-b0fc-9bc810c7d366", + "metadata": { + "id": "e73fae58-03e9-4acc-b0fc-9bc810c7d366" + }, + "outputs": [], + "source": [ + "tokenizer = AutoTokenizer.from_pretrained(\"gagneurlab/SpeciesLM\", revision = \"downstream_species_lm\")\n", + "lm = AutoModelForMaskedLM.from_pretrained(\"gagneurlab/SpeciesLM\", revision = \"downstream_species_lm\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca43b893-2d66-4e93-a08f-b17a92040709", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ca43b893-2d66-4e93-a08f-b17a92040709", + "outputId": "ccbac964-a329-414d-f537-3cae7da66cf2" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "BertForMaskedLM(\n", + " (bert): BertModel(\n", + " (embeddings): BertEmbeddings(\n", + " (word_embeddings): Embedding(5504, 768, padding_idx=0)\n", + " (position_embeddings): Embedding(512, 768)\n", + " (token_type_embeddings): Embedding(2, 768)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (encoder): BertEncoder(\n", + " (layer): ModuleList(\n", + " (0-11): 12 x BertLayer(\n", + " (attention): BertAttention(\n", + " (self): BertSdpaSelfAttention(\n", + " (query): Linear(in_features=768, out_features=768, bias=True)\n", + " (key): Linear(in_features=768, out_features=768, bias=True)\n", + " (value): Linear(in_features=768, out_features=768, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (output): BertSelfOutput(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): BertIntermediate(\n", + " (dense): Linear(in_features=768, out_features=3072, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): BertOutput(\n", + " (dense): Linear(in_features=3072, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (cls): BertOnlyMLMHead(\n", + " (predictions): BertLMPredictionHead(\n", + " (transform): BertPredictionHeadTransform(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (transform_act_fn): GELUActivation()\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " )\n", + " (decoder): Linear(in_features=768, out_features=5504, bias=True)\n", + " )\n", + " )\n", + ")" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lm.eval()\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "lm.to(device);" + ] + }, + { + "cell_type": "markdown", + "id": "c1bda6f2-34bb-4ce2-aa3f-3013548b0a28", + "metadata": { + "id": "c1bda6f2-34bb-4ce2-aa3f-3013548b0a28" + }, + "source": [ + "### 2. Prepare datasets" + ] + }, + { + "cell_type": "markdown", + "id": "f4c61e59-457c-47d9-8929-5e8cd32d3125", + "metadata": { + "id": "f4c61e59-457c-47d9-8929-5e8cd32d3125" + }, + "source": [ + "We'll load the `nucleotide_transformer_downstream_tasks` dataset, which contains 18 downstream tasks from the Nucleotide Transformer paper. This dataset provides a consistent genomics benchmark with binary classification tasks." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5c0b3df-911a-4645-9140-99ee489515e8", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 145, + "referenced_widgets": [ + "03bba232d3974119acf8031bc086a072", + "9107f7bfc8d3483390f802b0458e9380", + "f5c80fa70ead4c86aa3b2a046061b901", + "57966a469ca1458daab74e81672ae855", + "1464502dc3dd46308be8b4fcc9d5ddb9", + "92f64c7e088342b9b3c070ba7a295ed0", + "ab0aa8af3816422e9d97934f12af842c", + "ff89a891bd9c42a8be164587a94ccac1", + "e113a50f8ed2410ca12ce7cb38a1681d", + "1afa6e9b69c74136863b7747e62a0608", + "0838d19b226d486285a26ce0b04d7e15", + "7bdab33f4b244fc89408b91755bf17c5", + "4d4ce0d35c124690b3427e84a9a128b1", + "33be6b0ca8fd44188f834a48a9574a72", + "74e9bc1ead434ae78077df6b85f1df58", + "e1acc6e70b9246a5b063b3e262f01c81", + "078c6877377a491d97d6fadd27064a76", + "d46ee1c39bac44c2b541a88c883de1cb", + "12f1de7122a7471e90f01d9e7be81178", + "dad286d42a514c9ca6bb01bfe9e9c4be", + "c028ed977b5e479fbd93b8add588a6dc", + "6d80dec073e449efba272fa9f3527922", + "c311b777514f41ef986756a386c0bb34", + "e2e4bf053ce442f6aee6ffab5f76525f", + "c88cf701e20b4354a63ac7d8645d1df9", + "f71c252ada474be882b0335ed9a0a1c3", + "e059c665229e46ea905dcbd6fc179c88", + "bd5273325a4b453e8053d98a09fe9493", + "8f20ed2b74d84e80a8d403793354adea", + "57c9af47364d48ffbb4ffbdd2c951ede", + "fa9d75fcb1d5400c8ca1d1d13d28d0c7", + "682644a713b145f0b2dcff99790c6d4d", + "9b9b9d573d44464f9a6f5030a40245fe", + "ec165fdbe87a4b00a6c288ef1e85c0a9", + "17859b793a304e389d1ea0b9ccc3646f", + "34921fd116cc42b7b530174d9f61e71e", + "2d5466a5e98849c5a09f16faa98f91da", + "952397f9c91c480184fa57e175ab1b4c", + "86bcccb842244f4f9add58f62facaace", + "78b5bbf4c8ac4fe5961776fded4d5798", + "c80062a855cb41a28ac625ab03635da2", + "aecd740c17c84d45b0615d4fc4196035", + "39640709e7174f84a50da05764abbf99", + "7114a029e75c4ed5b966eddd3a3c919d" + ] + }, + "id": "f5c0b3df-911a-4645-9140-99ee489515e8", + "outputId": "15315be1-9d07-4c46-acda-c65cb5a05250" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "03bba232d3974119acf8031bc086a072", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading data: 0%| | 0.00/3.50M [00:00\n", + " \n", + " \n", + " [65/65 01:43, Epoch 5/5]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EpochTraining LossValidation Loss
10.8874000.685295
20.6447000.682495
30.5996000.680431
40.8928000.679170
50.6638000.678761

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=65, training_loss=0.7263066686116733, metrics={'train_runtime': 104.8696, 'train_samples_per_second': 9.536, 'train_steps_per_second': 0.62, 'total_flos': 0.0, 'train_loss': 0.7263066686116733, 'epoch': 5.0})" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from transformers import Trainer, TrainingArguments\n", + "\n", + "\n", + "# Define training arguments\n", + "training_args = TrainingArguments(\n", + " output_dir='./results',\n", + " eval_strategy=\"epoch\",\n", + " learning_rate=2e-5,\n", + " per_device_train_batch_size=16,\n", + " per_device_eval_batch_size=16,\n", + " num_train_epochs=5,\n", + " weight_decay=0.01,\n", + " eval_steps=1,\n", + " logging_steps=1,\n", + ")\n", + "\n", + "# Initialize Trainer\n", + "trainer = Trainer(\n", + " model=classification_model,\n", + " args=training_args,\n", + " train_dataset=train_dataset,\n", + " eval_dataset=val_dataset,\n", + " tokenizer=tokenizer,\n", + " data_collator=data_collator,\n", + ")\n", + "\n", + "# Train the model\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "id": "ebc7e33a-caad-4412-84e3-3e1ce7d02ccd", + "metadata": { + "id": "ebc7e33a-caad-4412-84e3-3e1ce7d02ccd" + }, + "source": [ + "### 5. Evaluation" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "38eb0273-ce7e-4770-8457-2f9609f6843b", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 124 + }, + "id": "38eb0273-ce7e-4770-8457-2f9609f6843b", + "outputId": "2b0b93c9-0199-4e71-9825-9f6a2bd199d0" + }, + "outputs": [ + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 1 1 1 1 1 1 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 0 1 1 1 1 0 1 0 0 0 1 1 0 1 1\n", + " 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 0 1 0 0 1 1 1 1 1 0 0 0 1 0 1 1 0 1\n", + " 0 1 1 0 1 1 1 0 0 1 0 1 0 1 0 1 1 1 0 1 1 1 1 0 1 0 0 0 0 1 0 1 0 0 1 1 1\n", + " 1 0 1 1 0 0 1 1 1 0 1 1 1 1 0 0 1 1 1 1 0 0 1 1 1 0 0 1 1 0 1 1 0 1 1 0 1\n", + " 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 0 1 1 1 1 1 1 1 0 1 1 1 0 0 1 1 1 1\n", + " 0 1 1 1 1 0 1 1 0 0 1 0 1 1 0]\n" + ] + } + ], + "source": [ + "# Generate predictions\n", + "\n", + "predictions = trainer.predict(test_dataset)\n", + "logits = predictions.predictions\n", + "predicted_labels = logits.argmax(axis=-1)\n", + "print(predicted_labels)" + ] + }, + { + "cell_type": "markdown", + "id": "ae4c7bca", + "metadata": { + "id": "ae4c7bca" + }, + "source": [ + "Then, we create a function to calculate the accuracy from the test and predicted labels." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "327a1c3b-88d6-4430-8978-73a7cbdbb697", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "327a1c3b-88d6-4430-8978-73a7cbdbb697", + "outputId": "f03ad54d-d35f-4fcc-e709-c24d14906e25" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.53\n" + ] + } + ], + "source": [ + "def calculate_accuracy(true_labels, predicted_labels):\n", + "\n", + " assert len(true_labels) == len(predicted_labels), \"Arrays must have the same length\"\n", + " correct_predictions = np.sum(true_labels == predicted_labels)\n", + " accuracy = correct_predictions / len(true_labels)\n", + "\n", + " return accuracy\n", + "\n", + "accuracy = calculate_accuracy(test_labels, predicted_labels)\n", + "print(f\"Accuracy: {accuracy:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9p0fFXKTZz9Q", + "metadata": { + "id": "9p0fFXKTZz9Q" + }, + "source": [ + "The results aren't that good, which we can attribute to the small dataset size." + ] + }, + { + "cell_type": "markdown", + "id": "e681864c-f15a-40a6-ac34-0e631d68d5c8", + "metadata": { + "id": "e681864c-f15a-40a6-ac34-0e631d68d5c8" + }, + "source": [ + "### 7. Parameter Efficient Fine-Tuning Techniques" + ] + }, + { + "cell_type": "markdown", + "id": "9141fabe-417b-4fbb-bd3e-244ad84e3010", + "metadata": { + "id": "9141fabe-417b-4fbb-bd3e-244ad84e3010" + }, + "source": [ + "In this section, we demonstrate how to employ parameter-efficient fine-tuning (PEFT) techniques to adapt a pre-trained model for specific genomics tasks using the PEFT library." + ] + }, + { + "cell_type": "markdown", + "id": "71b8a749-461e-4533-b1d0-cebc924d3dc0", + "metadata": { + "id": "71b8a749-461e-4533-b1d0-cebc924d3dc0" + }, + "source": [ + "The LoraConfig object is instantiated to configure the PEFT parameters:\n", + "\n", + "- task_type: Specifies the type of task, in this case, sequence classification (SEQ_CLS).\n", + "- r: The rank of the LoRA matrices.\n", + "- lora_alpha: Scaling factor for adaptive re-parameterization.\n", + "- target_modules: Modules within the model to apply PEFT re-parameterization (query, key, value in this example).\n", + "- lora_dropout: Dropout rate used during PEFT fine-tuning." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "021641ae-f604-4d69-8724-743b7d7c613c", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "021641ae-f604-4d69-8724-743b7d7c613c", + "outputId": "d7c41fca-1c6b-46fd-9116-01f42d1d6ddf" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "DNA_LM(\n", + " (model): BertModel(\n", + " (embeddings): BertEmbeddings(\n", + " (word_embeddings): Embedding(5504, 768, padding_idx=0)\n", + " (position_embeddings): Embedding(512, 768)\n", + " (token_type_embeddings): Embedding(2, 768)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (encoder): BertEncoder(\n", + " (layer): ModuleList(\n", + " (0-11): 12 x BertLayer(\n", + " (attention): BertAttention(\n", + " (self): BertSdpaSelfAttention(\n", + " (query): lora.Linear(\n", + " (base_layer): Linear(in_features=768, out_features=768, bias=True)\n", + " (lora_dropout): ModuleDict(\n", + " (default): Dropout(p=0.01, inplace=False)\n", + " )\n", + " (lora_A): ModuleDict(\n", + " (default): Linear(in_features=768, out_features=8, bias=False)\n", + " )\n", + " (lora_B): ModuleDict(\n", + " (default): Linear(in_features=8, out_features=768, bias=False)\n", + " )\n", + " (lora_embedding_A): ParameterDict()\n", + " (lora_embedding_B): ParameterDict()\n", + " )\n", + " (key): lora.Linear(\n", + " (base_layer): Linear(in_features=768, out_features=768, bias=True)\n", + " (lora_dropout): ModuleDict(\n", + " (default): Dropout(p=0.01, inplace=False)\n", + " )\n", + " (lora_A): ModuleDict(\n", + " (default): Linear(in_features=768, out_features=8, bias=False)\n", + " )\n", + " (lora_B): ModuleDict(\n", + " (default): Linear(in_features=8, out_features=768, bias=False)\n", + " )\n", + " (lora_embedding_A): ParameterDict()\n", + " (lora_embedding_B): ParameterDict()\n", + " )\n", + " (value): lora.Linear(\n", + " (base_layer): Linear(in_features=768, out_features=768, bias=True)\n", + " (lora_dropout): ModuleDict(\n", + " (default): Dropout(p=0.01, inplace=False)\n", + " )\n", + " (lora_A): ModuleDict(\n", + " (default): Linear(in_features=768, out_features=8, bias=False)\n", + " )\n", + " (lora_B): ModuleDict(\n", + " (default): Linear(in_features=8, out_features=768, bias=False)\n", + " )\n", + " (lora_embedding_A): ParameterDict()\n", + " (lora_embedding_B): ParameterDict()\n", + " )\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (output): BertSelfOutput(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): BertIntermediate(\n", + " (dense): Linear(in_features=768, out_features=3072, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): BertOutput(\n", + " (dense): Linear(in_features=3072, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (classifier): Linear(in_features=768, out_features=2, bias=True)\n", + ")" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Number of classes for your classification task\n", + "num_labels = 2\n", + "classification_model = DNA_LM(lm, num_labels)\n", + "classification_model.to(device);" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "6c223937-86ea-42ef-991a-050f23b21ef9", + "metadata": { + "id": "6c223937-86ea-42ef-991a-050f23b21ef9" + }, + "outputs": [], + "source": [ + "from peft import LoraConfig, TaskType\n", + "\n", + "peft_config = LoraConfig(\n", + " r=8,\n", + " lora_alpha=32,\n", + " target_modules=[\"query\", \"key\", \"value\"],\n", + " lora_dropout=0.01,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "e7a9fe7d-e3ac-4ffa-9a9b-2067fb09b885", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "e7a9fe7d-e3ac-4ffa-9a9b-2067fb09b885", + "outputId": "02a6c65f-7474-4bc1-bfab-c05532e350a5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 442,368 || all params: 90,121,730 || trainable%: 0.4909\n" + ] + } + ], + "source": [ + "from peft import get_peft_model\n", + "\n", + "peft_model = get_peft_model(classification_model, peft_config)\n", + "peft_model.print_trainable_parameters()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "22064519-eaab-4142-8618-d1210d05c6bd", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "22064519-eaab-4142-8618-d1210d05c6bd", + "outputId": "ca3f764d-cdb4-4525-c541-8eabfb4cde57" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "PeftModel(\n", + " (base_model): LoraModel(\n", + " (model): DNA_LM(\n", + " (model): BertModel(\n", + " (embeddings): BertEmbeddings(\n", + " (word_embeddings): Embedding(5504, 768, padding_idx=0)\n", + " (position_embeddings): Embedding(512, 768)\n", + " (token_type_embeddings): Embedding(2, 768)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (encoder): BertEncoder(\n", + " (layer): ModuleList(\n", + " (0-11): 12 x BertLayer(\n", + " (attention): BertAttention(\n", + " (self): BertSdpaSelfAttention(\n", + " (query): lora.Linear(\n", + " (base_layer): Linear(in_features=768, out_features=768, bias=True)\n", + " (lora_dropout): ModuleDict(\n", + " (default): Dropout(p=0.01, inplace=False)\n", + " )\n", + " (lora_A): ModuleDict(\n", + " (default): Linear(in_features=768, out_features=8, bias=False)\n", + " )\n", + " (lora_B): ModuleDict(\n", + " (default): Linear(in_features=8, out_features=768, bias=False)\n", + " )\n", + " (lora_embedding_A): ParameterDict()\n", + " (lora_embedding_B): ParameterDict()\n", + " )\n", + " (key): lora.Linear(\n", + " (base_layer): Linear(in_features=768, out_features=768, bias=True)\n", + " (lora_dropout): ModuleDict(\n", + " (default): Dropout(p=0.01, inplace=False)\n", + " )\n", + " (lora_A): ModuleDict(\n", + " (default): Linear(in_features=768, out_features=8, bias=False)\n", + " )\n", + " (lora_B): ModuleDict(\n", + " (default): Linear(in_features=8, out_features=768, bias=False)\n", + " )\n", + " (lora_embedding_A): ParameterDict()\n", + " (lora_embedding_B): ParameterDict()\n", + " )\n", + " (value): lora.Linear(\n", + " (base_layer): Linear(in_features=768, out_features=768, bias=True)\n", + " (lora_dropout): ModuleDict(\n", + " (default): Dropout(p=0.01, inplace=False)\n", + " )\n", + " (lora_A): ModuleDict(\n", + " (default): Linear(in_features=768, out_features=8, bias=False)\n", + " )\n", + " (lora_B): ModuleDict(\n", + " (default): Linear(in_features=8, out_features=768, bias=False)\n", + " )\n", + " (lora_embedding_A): ParameterDict()\n", + " (lora_embedding_B): ParameterDict()\n", + " )\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (output): BertSelfOutput(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): BertIntermediate(\n", + " (dense): Linear(in_features=768, out_features=3072, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): BertOutput(\n", + " (dense): Linear(in_features=3072, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (classifier): Linear(in_features=768, out_features=2, bias=True)\n", + " )\n", + " )\n", + ")" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "peft_model" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "d3812e96-6b49-4911-8b21-d8871b7c06a5", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 268 + }, + "id": "d3812e96-6b49-4911-8b21-d8871b7c06a5", + "outputId": "8d497e30-1d3f-457a-f62a-244731698cb2" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "

\n", + " \n", + " \n", + " [65/65 01:39, Epoch 5/5]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EpochTraining LossValidation Loss
10.6257000.777132
20.7172000.773871
30.7682000.771541
40.6874000.769679
50.5520000.768947

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=65, training_loss=0.74742647592838, metrics={'train_runtime': 100.8429, 'train_samples_per_second': 9.916, 'train_steps_per_second': 0.645, 'total_flos': 0.0, 'train_loss': 0.74742647592838, 'epoch': 5.0})" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Define training arguments\n", + "training_args = TrainingArguments(\n", + " output_dir='./results',\n", + " eval_strategy=\"epoch\",\n", + " learning_rate=2e-5,\n", + " per_device_train_batch_size=16,\n", + " per_device_eval_batch_size=16,\n", + " num_train_epochs=5,\n", + " weight_decay=0.01,\n", + " eval_steps=1,\n", + " logging_steps=1,\n", + ")\n", + "\n", + "# Initialize Trainer\n", + "trainer = Trainer(\n", + " model=peft_model.model,\n", + " args=training_args,\n", + " train_dataset=train_dataset,\n", + " eval_dataset=val_dataset,\n", + " tokenizer=tokenizer,\n", + " data_collator=data_collator,\n", + ")\n", + "\n", + "# Train the model\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "id": "76dbd948-d919-4ade-a405-cec297979577", + "metadata": { + "id": "76dbd948-d919-4ade-a405-cec297979577" + }, + "source": [ + "### 8. Evaluate PEFT Model" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "58cf70ba-47d5-4111-bb12-830ae04c6285", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 124 + }, + "id": "58cf70ba-47d5-4111-bb12-830ae04c6285", + "outputId": "0abc56a9-bd68-4e4e-9f13-756e8c9ffa3e" + }, + "outputs": [ + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 0 1 0 0 1 1 0 1 1 1 1 0 1 1 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 1\n", + " 1 1 1 0 1 1 0 1 0 0 1 0 0 1 1 0 1 1 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 1 1 0 1\n", + " 1 0 1 0 0 1 1 0 1 0 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 1 0 0 1 1 0 1 1 1 0\n", + " 1 1 0 0 1 0 1 1 1 0 1 1 0 1 1 0 0 0 0 1 1 0 1 1 1 1 1 0 1 0 1 0 1 1 0 1 1\n", + " 0 1 1 1 1 1 1 1 0 1 1 0 1 0 0 0 0 0 0 1 1 0 0 0 1 1 1 1 1 0 0 1 0 1 0 1 0\n", + " 0 1 1 0 0 0 1 0 1 1 1 0 1 1 0]\n" + ] + } + ], + "source": [ + "# Generate predictions\n", + "\n", + "predictions = trainer.predict(test_dataset)\n", + "logits = predictions.predictions\n", + "predicted_labels = logits.argmax(axis=-1)\n", + "print(predicted_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "4bd38fe5-6513-4c88-afee-0cc4e1781fdd", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4bd38fe5-6513-4c88-afee-0cc4e1781fdd", + "outputId": "a50a91d0-d04d-4620-9006-868716bb992d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.52\n" + ] + } + ], + "source": [ + "def calculate_accuracy(true_labels, predicted_labels):\n", + "\n", + " assert len(true_labels) == len(predicted_labels), \"Arrays must have the same length\"\n", + " correct_predictions = np.sum(true_labels == predicted_labels)\n", + " accuracy = correct_predictions / len(true_labels)\n", + "\n", + " return accuracy\n", + "\n", + "accuracy = calculate_accuracy(test_labels, predicted_labels)\n", + "print(f\"Accuracy: {accuracy:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "4ba5af69", + "metadata": {}, + "source": [ + "As we can see, the PEFT model achieves similar performance to the baseline model, demonstrating the effectiveness of PEFT in adapting pre-trained models to specific tasks with limited computational resources.\n", + "\n", + "With PEFT, we only train 442,368 parameters, which is 0.49% of the total parameters in the model. This is a significant reduction in computational resources compared to training the entire model from scratch.\n", + "\n", + "We can improve the results by using a larger dataset, fine-tuning the model for more epochs or changing the hyperparameters (rank, learning rate, etc.).\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "03bba232d3974119acf8031bc086a072": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9107f7bfc8d3483390f802b0458e9380", + "IPY_MODEL_f5c80fa70ead4c86aa3b2a046061b901", + "IPY_MODEL_57966a469ca1458daab74e81672ae855" + ], + "layout": "IPY_MODEL_1464502dc3dd46308be8b4fcc9d5ddb9" + } + }, + "078c6877377a491d97d6fadd27064a76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0838d19b226d486285a26ce0b04d7e15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "12f1de7122a7471e90f01d9e7be81178": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1464502dc3dd46308be8b4fcc9d5ddb9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17859b793a304e389d1ea0b9ccc3646f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_86bcccb842244f4f9add58f62facaace", + "placeholder": "​", + "style": "IPY_MODEL_78b5bbf4c8ac4fe5961776fded4d5798", + "value": "Generating test split: 100%" + } + }, + "1afa6e9b69c74136863b7747e62a0608": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d5466a5e98849c5a09f16faa98f91da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_39640709e7174f84a50da05764abbf99", + "placeholder": "​", + "style": "IPY_MODEL_7114a029e75c4ed5b966eddd3a3c919d", + "value": " 1497/1497 [00:00<00:00, 41394.98 examples/s]" + } + }, + "33be6b0ca8fd44188f834a48a9574a72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_12f1de7122a7471e90f01d9e7be81178", + "max": 390606, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dad286d42a514c9ca6bb01bfe9e9c4be", + "value": 390606 + } + }, + "34921fd116cc42b7b530174d9f61e71e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c80062a855cb41a28ac625ab03635da2", + "max": 1497, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_aecd740c17c84d45b0615d4fc4196035", + "value": 1497 + } + }, + "39640709e7174f84a50da05764abbf99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4d4ce0d35c124690b3427e84a9a128b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_078c6877377a491d97d6fadd27064a76", + "placeholder": "​", + "style": "IPY_MODEL_d46ee1c39bac44c2b541a88c883de1cb", + "value": "Downloading data: 100%" + } + }, + "57966a469ca1458daab74e81672ae855": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1afa6e9b69c74136863b7747e62a0608", + "placeholder": "​", + "style": "IPY_MODEL_0838d19b226d486285a26ce0b04d7e15", + "value": " 3.50M/3.50M [00:00<00:00, 26.3MB/s]" + } + }, + "57c9af47364d48ffbb4ffbdd2c951ede": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "682644a713b145f0b2dcff99790c6d4d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6d80dec073e449efba272fa9f3527922": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7114a029e75c4ed5b966eddd3a3c919d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "74e9bc1ead434ae78077df6b85f1df58": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c028ed977b5e479fbd93b8add588a6dc", + "placeholder": "​", + "style": "IPY_MODEL_6d80dec073e449efba272fa9f3527922", + "value": " 391k/391k [00:00<00:00, 3.34MB/s]" + } + }, + "78b5bbf4c8ac4fe5961776fded4d5798": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7bdab33f4b244fc89408b91755bf17c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4d4ce0d35c124690b3427e84a9a128b1", + "IPY_MODEL_33be6b0ca8fd44188f834a48a9574a72", + "IPY_MODEL_74e9bc1ead434ae78077df6b85f1df58" + ], + "layout": "IPY_MODEL_e1acc6e70b9246a5b063b3e262f01c81" + } + }, + "86bcccb842244f4f9add58f62facaace": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f20ed2b74d84e80a8d403793354adea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9107f7bfc8d3483390f802b0458e9380": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_92f64c7e088342b9b3c070ba7a295ed0", + "placeholder": "​", + "style": "IPY_MODEL_ab0aa8af3816422e9d97934f12af842c", + "value": "Downloading data: 100%" + } + }, + "92f64c7e088342b9b3c070ba7a295ed0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "952397f9c91c480184fa57e175ab1b4c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b9b9d573d44464f9a6f5030a40245fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ab0aa8af3816422e9d97934f12af842c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aecd740c17c84d45b0615d4fc4196035": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bd5273325a4b453e8053d98a09fe9493": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c028ed977b5e479fbd93b8add588a6dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c311b777514f41ef986756a386c0bb34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e2e4bf053ce442f6aee6ffab5f76525f", + "IPY_MODEL_c88cf701e20b4354a63ac7d8645d1df9", + "IPY_MODEL_f71c252ada474be882b0335ed9a0a1c3" + ], + "layout": "IPY_MODEL_e059c665229e46ea905dcbd6fc179c88" + } + }, + "c80062a855cb41a28ac625ab03635da2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c88cf701e20b4354a63ac7d8645d1df9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_57c9af47364d48ffbb4ffbdd2c951ede", + "max": 13468, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fa9d75fcb1d5400c8ca1d1d13d28d0c7", + "value": 13468 + } + }, + "d46ee1c39bac44c2b541a88c883de1cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dad286d42a514c9ca6bb01bfe9e9c4be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e059c665229e46ea905dcbd6fc179c88": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e113a50f8ed2410ca12ce7cb38a1681d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e1acc6e70b9246a5b063b3e262f01c81": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e2e4bf053ce442f6aee6ffab5f76525f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bd5273325a4b453e8053d98a09fe9493", + "placeholder": "​", + "style": "IPY_MODEL_8f20ed2b74d84e80a8d403793354adea", + "value": "Generating train split: 100%" + } + }, + "ec165fdbe87a4b00a6c288ef1e85c0a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_17859b793a304e389d1ea0b9ccc3646f", + "IPY_MODEL_34921fd116cc42b7b530174d9f61e71e", + "IPY_MODEL_2d5466a5e98849c5a09f16faa98f91da" + ], + "layout": "IPY_MODEL_952397f9c91c480184fa57e175ab1b4c" + } + }, + "f5c80fa70ead4c86aa3b2a046061b901": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ff89a891bd9c42a8be164587a94ccac1", + "max": 3495021, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e113a50f8ed2410ca12ce7cb38a1681d", + "value": 3495021 + } + }, + "f71c252ada474be882b0335ed9a0a1c3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_682644a713b145f0b2dcff99790c6d4d", + "placeholder": "​", + "style": "IPY_MODEL_9b9b9d573d44464f9a6f5030a40245fe", + "value": " 13468/13468 [00:00<00:00, 193879.37 examples/s]" + } + }, + "fa9d75fcb1d5400c8ca1d1d13d28d0c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ff89a891bd9c42a8be164587a94ccac1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/QDoRA_finetuning.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/QDoRA_finetuning.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..e0582a9eff8437a27c38bde39a675f9b787efb70 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/QDoRA_finetuning.ipynb @@ -0,0 +1,8545 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "CV_gQs58bsvM" + }, + "source": [ + "# Fine-tuning [Llama-3-8B](https://huggingface.co/meta-llama/Meta-Llama-3-8B) on [timdettmers/openassistant-guanaco](https://huggingface.co/datasets/timdettmers/openassistant-guanaco) Dataset using QDora (quantized Lora w/ use_dora=True)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FuXIFTFapAMI", + "outputId": "b95d8260-65bd-405f-f1e2-8d353aa46814" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m119.8/119.8 MB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.3/21.3 MB\u001b[0m \u001b[31m37.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for transformers (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m309.4/309.4 kB\u001b[0m \u001b[31m6.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Building wheel for peft (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for accelerate (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m547.8/547.8 kB\u001b[0m \u001b[31m7.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m40.8/40.8 MB\u001b[0m \u001b[31m28.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m16.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m64.9/64.9 kB\u001b[0m \u001b[31m10.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m27.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m20.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "cudf-cu12 24.4.1 requires pyarrow<15.0.0a0,>=14.0.1, but you have pyarrow 16.1.0 which is incompatible.\n", + "google-colab 1.0.0 requires requests==2.31.0, but you have requests 2.32.3 which is incompatible.\n", + "ibis-framework 8.0.0 requires pyarrow<16,>=2, but you have pyarrow 16.1.0 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "# Install the libraries\n", + "!pip install -q -U bitsandbytes\n", + "!pip install -q -U git+https://github.com/huggingface/transformers.git\n", + "!pip install -q -U git+https://github.com/huggingface/peft.git\n", + "!pip install -q -U git+https://github.com/huggingface/accelerate.git\n", + "!pip install -q datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 145, + "referenced_widgets": [ + "8cc86330c2af436c9af314e8c04c8c2b", + "e25f9ca445b14e3f8397779df071dfb4", + "8365680c634a44aa880317e36fa5e46e", + "0c4ac7c3db0b431397cc812f7c9e785c", + "c84f542c863043dea8a3675fa153e78d", + "b3b3f4ddd4ed4d938c923887939a0440", + "35186465f87341f683affb9399661540", + "791df472db174df69b8c9f0e200af254", + "6bb9c7182d2a464ea21809e59043562a", + "31c574113731403b88edc5bb0798bc6d", + "3b8bc5b9392e45758813a1db9db824a9", + "90661b333d6f496ca606b3046622660e", + "5f551f9b217e44cf8b5433f314b3844b", + "d2d81cc8296c4b10bf80b86c0a3302d3", + "7e3a386e672f4748882211227b7721a9", + "57f251691b4c453896b2508c431dfc2f", + "4bdb196cd1494f809829651ec5b6cbf8", + "7cd50bcc8fcc4b83abcda6d3604bd4cc", + "7a00aa4a97a34da39cc052c6926dbe13", + "14c73d88df9e46e3bbb6690fdb48ad07", + "0e2beab611114239b6ee48a3cbb09c49", + "006b78b5191b4fb888d98bdf6c20ec1e", + "5f6ffa1d929443a5bd9c7c550f0690f0", + "668a7f88506148a9ba2b48920afc028f", + "57b0096985ab44aea342e52795c4f999", + "a4c404e420cc4ce781ce569f9ab3f987", + "ee4e4af964ec4dd597cb04a90f0697f9", + "974e3687f18a4e1a975969b880d086aa", + "93a50117ece543d4857ba02505dc4514", + "71a3a56edbdb45669d382fef4b097e1b", + "53f287d4927541d08e2ae7d4d0b3c396", + "afa442ab223b46cb82569438c0047823" + ] + }, + "id": "wAAPv5CRmg7e", + "outputId": "687f979a-04c1-4160-d71c-4de8ecdb07d9" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8cc86330c2af436c9af314e8c04c8c2b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HTML(value='

\n", + " \n", + " \n", + " [10/10 03:56, Epoch 0/1]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
11.276300
21.877700
31.983800
42.011400
51.997800
61.648100
71.576000
80.916400
91.523100
101.814500

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=10, training_loss=1.662518608570099, metrics={'train_runtime': 269.3407, 'train_samples_per_second': 0.149, 'train_steps_per_second': 0.037, 'total_flos': 530537216679936.0, 'train_loss': 1.662518608570099, 'epoch': 0.004062563477554337})" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import transformers\n", + "\n", + "tokenizer.pad_token = tokenizer.eos_token\n", + "\n", + "trainer = transformers.Trainer(\n", + " model=model,\n", + " train_dataset=data[\"train\"],\n", + " args=transformers.TrainingArguments(\n", + " per_device_train_batch_size=1,\n", + " gradient_accumulation_steps=4,\n", + " warmup_steps=2,\n", + " max_steps=10,\n", + " learning_rate=2e-4,\n", + " fp16=True,\n", + " logging_steps=1,\n", + " output_dir=\"path/to/your/HF/repo\", # change it to your desired repo!\n", + " optim=\"paged_adamw_8bit\",\n", + " ),\n", + " data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),\n", + ")\n", + "model.config.use_cache = False # silence the warnings. Please re-enable for inference!\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mr3rLrHwqhf6" + }, + "source": [ + "## Usage Example" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true, + "id": "9mrOJ9l8SMHv" + }, + "outputs": [], + "source": [ + "model.config.use_cache = True\n", + "model.eval();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 122 + }, + "id": "AM6FNOFzqKfI", + "outputId": "fdbe28b1-e440-45d3-bd6d-c15e744ad23d" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Setting `pad_token_id` to `eos_token_id`:128001 for open-end generation.\n" + ] + }, + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "\"A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions. ### Human: What is the purpose of quantization in LLMs?### Assistant: Quantization is a technique used to reduce the size of a model without significantly impacting its performance. In the context of language models, quantization is the process of converting floating-point numbers (which are used to represent the weights and activations of a model) to smaller, fixed-point numbers. This can be done by grouping the weights into small chunks and assigning each chunk a single, fixed-point number. Quantization can significantly reduce the size of a model, making it more efficient to train and deploy. In addition, quantization can improve the performance of a model on low-power devices, such as mobile phones\"" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from transformers import GenerationConfig\n", + "\n", + "max_new_tokens = 120\n", + "top_p = 0.9\n", + "temperature = 0.7\n", + "user_question = \"What is the purpose of quantization in LLMs?\"\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "\n", + "\n", + "prompt = (\n", + " \"A chat between a curious human and an artificial intelligence assistant. \"\n", + " \"The assistant gives helpful, detailed, and polite answers to the user's questions. \"\n", + " \"### Human: {user_question}\"\n", + " \"### Assistant: \"\n", + ")\n", + "\n", + "\n", + "def generate(model, user_question, max_new_tokens=max_new_tokens, top_p=top_p, temperature=temperature):\n", + " inputs = tokenizer(prompt.format(user_question=user_question), return_tensors=\"pt\").to(device)\n", + "\n", + " outputs = model.generate(\n", + " **inputs,\n", + " generation_config=GenerationConfig(\n", + " do_sample=True,\n", + " max_new_tokens=max_new_tokens,\n", + " top_p=top_p,\n", + " temperature=temperature,\n", + " ),\n", + " )\n", + "\n", + " text = tokenizer.decode(outputs[0], skip_special_tokens=True)\n", + " # print(text)\n", + " return text\n", + "\n", + "\n", + "generate(model, user_question)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "T5t_gl2_f5OO" + }, + "outputs": [], + "source": [ + "# trainer.push_to_hub()" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.1.-1" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "00371a48e64c45cd97020a78b710e64c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3f9fa554747743f8a86b40a4f7530617", + "placeholder": "​", + "style": "IPY_MODEL_ffe561df8772443ebf40a3b8b656079f", + "value": " 50.6k/50.6k [00:00<00:00, 3.65MB/s]" + } + }, + "006b78b5191b4fb888d98bdf6c20ec1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ee4e4af964ec4dd597cb04a90f0697f9", + "placeholder": "​", + "style": "IPY_MODEL_974e3687f18a4e1a975969b880d086aa", + "value": "Your token has been saved in your configured git credential helpers (store)." + } + }, + "026072374b7d47c194707a50f5c99099": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "02d6cc4c2717434c895798601bda7c86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "03dd6c24f6d94fe7ab85b79d6f6cbeaf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cc5ce633746949ed98418cae9f68afe3", + "placeholder": "​", + "style": "IPY_MODEL_4b1f795c4c004cacbf3660d935e52995", + "value": "Downloading data: 100%" + } + }, + "04188e0cec0542818894ebc6a534fb51": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "061c45266c484ff6807dcaf4722fd73b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "068eb104d5d346b1897f8cbe9860d267": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0711e28e06a440c2a241acbc1f90d1e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f4ca7b63d7d749ff83a848e250f03ec1", + "placeholder": "​", + "style": "IPY_MODEL_8c149bc655a34fe5b91853c66db458a9", + "value": "model.safetensors.index.json: 100%" + } + }, + "076357d4bb9943bdaa1d6846897786af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07e0aed682fd4cc88fa75c0592dc04a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_47944ad8cadf4a57b170193c46d4389c", + "placeholder": "​", + "style": "IPY_MODEL_db05b25cb38140bdb21e6f3b7fde7e66", + "value": "model-00001-of-00004.safetensors: 100%" + } + }, + "082b6990ce5e4812adc0ad6a7b376dac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0aad2d9d1cba40cbb64308ede3242ed7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0711e28e06a440c2a241acbc1f90d1e8", + "IPY_MODEL_77704d2e27e94cd3a0c5f6b5ceeffd1c", + "IPY_MODEL_3b82b8d41b134bec9bd77ed8d4f00eb4" + ], + "layout": "IPY_MODEL_25fef90e209f4b14a73f3e39d226d913" + } + }, + "0b145e421f4840f2872c29256b49f168": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c4ac7c3db0b431397cc812f7c9e785c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "CheckboxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "CheckboxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "CheckboxView", + "description": "Add token as git credential?", + "description_tooltip": null, + "disabled": false, + "indent": true, + "layout": "IPY_MODEL_90661b333d6f496ca606b3046622660e", + "style": "IPY_MODEL_5f551f9b217e44cf8b5433f314b3844b", + "value": true + } + }, + "0d2ae3466a3447c58e23ccd2b3733deb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_921a1a037f7b47f8b57d1da8192a437a", + "placeholder": "​", + "style": "IPY_MODEL_892ff4e2f0e44c23bc5c2be7547cf0bd", + "value": "generation_config.json: 100%" + } + }, + "0e2beab611114239b6ee48a3cbb09c49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_57b0096985ab44aea342e52795c4f999", + "placeholder": "​", + "style": "IPY_MODEL_a4c404e420cc4ce781ce569f9ab3f987", + "value": "Token is valid (permission: write)." + } + }, + "0ec2643d9fd44785addb37d9ecd23989": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0f4c664612364dc89acf78eb1c740980": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f54e8fda93144f6a95493e6ec535e9d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f60f9aa76b941809e013ffcae83604a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "124a70bfad434c5c946f611c04a91c8f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "14bf612f6ad7416c8ddd6085c72eee0e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "14c73d88df9e46e3bbb6690fdb48ad07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1561cd47c42e46368677d34e7b7084cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_04188e0cec0542818894ebc6a534fb51", + "placeholder": "​", + "style": "IPY_MODEL_4a13203d132b45beadf140c02dc8a566", + "value": " 518/518 [00:00<00:00, 976.36 examples/s]" + } + }, + "156f95b0012449e8a0c604e6e03bf35f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17c797e08bd2493fa685918129415309": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "191caf3a38eb4191a35f623ce25238f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ae1d2702da5483a85504f59939ffa39": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8cd63d3908e4411c9fcb42bc32c8dd16", + "max": 73, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_64624b26145b42db82f7afc36c32e117", + "value": 73 + } + }, + "1b2abf90003e4165a3293acd6a5ea9ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cffdf12fbe97462ab74e88ccca943aeb", + "placeholder": "​", + "style": "IPY_MODEL_bcaf4c81ba9d437bb6223dbb22d011ed", + "value": " 73.0/73.0 [00:00<00:00, 4.75kB/s]" + } + }, + "1bd0a270c7ee409c970763398e54fc36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_076357d4bb9943bdaa1d6846897786af", + "placeholder": "​", + "style": "IPY_MODEL_7b3e136fc9e74a699497a947006f4f1d", + "value": " 1.11M/1.11M [00:00<00:00, 8.23MB/s]" + } + }, + "1d27ab2bc6ae463a806292b68b7891f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f0efc167b3744b38ff832b71d529318": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_64911f0e52e74067a1a986c5edfc7f59", + "placeholder": "​", + "style": "IPY_MODEL_b4a274fc9e324b80bf559c4dbd05e319", + "value": "Downloading readme: 100%" + } + }, + "1f59dd66813f419999336e59a3efc56a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f75d85e6c7e4eb6a91b03f0c8adb644": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f82a5685eef4b47a2dbf7618362907c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "21bf14b771c14d2dab9e98a326302e14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "23012118a7314a3f838870a2aee9ec90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e297072ab5d64815b90bc89d22503378", + "placeholder": "​", + "style": "IPY_MODEL_67fbabb9082c4241b8f937b24e0cdd03", + "value": " 395/395 [00:00<00:00, 16.6kB/s]" + } + }, + "2540d57e3bf545e3812da1ee72b85fc8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2558c2dd7d394ecf9fc67a69ce8fc97a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "25fc6aaf37fc49fa822df29236bf2f90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "25fef90e209f4b14a73f3e39d226d913": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "27a587021d854b79a279a510a55f9d73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d4092198673141d3b4a824d629d73f64", + "placeholder": "​", + "style": "IPY_MODEL_d3cbfd564fe8485ba7afdb1cc54abed3", + "value": "Map: 100%" + } + }, + "2a57bb48e1c6475abba242994a79d44a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2ab86b3fbd49488bb02f8205a572e752": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "30b74bd2db8d40d08408013cebcd7661": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "317cda72329c4043ab0b224b46b259d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "31c10fa464e24f97b379675a204a09b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1d27ab2bc6ae463a806292b68b7891f8", + "max": 654, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2a57bb48e1c6475abba242994a79d44a", + "value": 654 + } + }, + "31c574113731403b88edc5bb0798bc6d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "347540dc03d34e65b7ffbb0f5fc569aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34e381adbd9242759b57f2a305c5d2e3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35186465f87341f683affb9399661540": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": "center", + "align_self": null, + "border": null, + "bottom": null, + "display": "flex", + "flex": null, + "flex_flow": "column", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "50%" + } + }, + "353bf45a4bbc46d6a798175f152399cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_740604526cc44cd58b811827d4787d96", + "placeholder": "​", + "style": "IPY_MODEL_2558c2dd7d394ecf9fc67a69ce8fc97a", + "value": "Generating test split: 100%" + } + }, + "35c2c635c2024bcda3265bf95d330f63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "37523a6cac1047e9a261698212d47737": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_191caf3a38eb4191a35f623ce25238f9", + "max": 20877686, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_30b74bd2db8d40d08408013cebcd7661", + "value": 20877686 + } + }, + "3b614b9712874fac990d2c557b0791a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3b82b8d41b134bec9bd77ed8d4f00eb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_14bf612f6ad7416c8ddd6085c72eee0e", + "placeholder": "​", + "style": "IPY_MODEL_f7e59b47f9b74523843f37268212d566", + "value": " 23.9k/23.9k [00:00<00:00, 1.51MB/s]" + } + }, + "3b8bc5b9392e45758813a1db9db824a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3d9d8278667d496aaea1eaaa4d24ae93": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e45aea9f7444a4db885c4cca4c9c4ff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f9fa554747743f8a86b40a4f7530617": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4227474e986546d1a7d31dce35a2410c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7e51e8e0612e46b1a3403d448b39aa50", + "max": 518, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_061c45266c484ff6807dcaf4722fd73b", + "value": 518 + } + }, + "42eb041021214110a860924d28d73409": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4c369386ba5f4862b11a50e50130663b", + "placeholder": "​", + "style": "IPY_MODEL_bbdf3bb657e64fc2b0a90e78e8886480", + "value": " 5.00G/5.00G [00:24<00:00, 249MB/s]" + } + }, + "434fe18d50a14920b30fd2d0650297ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_353bf45a4bbc46d6a798175f152399cb", + "IPY_MODEL_bfcbfe4184774fd3a8320f4f0e1baf54", + "IPY_MODEL_99c5c846cc5e43429905f071670b4310" + ], + "layout": "IPY_MODEL_8d988c86648244788f6dc5aa0fea38fd" + } + }, + "43d12a98d90a4bf7a96c033172c646e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c35b16156253402f90a432f3f07c2e0a", + "IPY_MODEL_1ae1d2702da5483a85504f59939ffa39", + "IPY_MODEL_1b2abf90003e4165a3293acd6a5ea9ff" + ], + "layout": "IPY_MODEL_3e45aea9f7444a4db885c4cca4c9c4ff" + } + }, + "47944ad8cadf4a57b170193c46d4389c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4a13203d132b45beadf140c02dc8a566": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4a7c8dfd88db4bc893da2bced0560d47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_27a587021d854b79a279a510a55f9d73", + "IPY_MODEL_4227474e986546d1a7d31dce35a2410c", + "IPY_MODEL_1561cd47c42e46368677d34e7b7084cd" + ], + "layout": "IPY_MODEL_8b9e961c837a464fb7a8c44756dc41e7" + } + }, + "4b1f795c4c004cacbf3660d935e52995": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4bc1fd9d480a4799954c69031c071b30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_068eb104d5d346b1897f8cbe9860d267", + "placeholder": "​", + "style": "IPY_MODEL_b621c6a8c0e9440fa840d75a1b1b02fc", + "value": " 9846/9846 [00:00<00:00, 38881.08 examples/s]" + } + }, + "4bdb196cd1494f809829651ec5b6cbf8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4c369386ba5f4862b11a50e50130663b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4c8e98294bd240a6869cb199caee66e1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e1f5423311b4dc0930c21c9ad5a88f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "51180cce01564821a170d1d4b8a9a918": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_03dd6c24f6d94fe7ab85b79d6f6cbeaf", + "IPY_MODEL_f2ab2fa803e94328a237e84cd4ea0027", + "IPY_MODEL_1bd0a270c7ee409c970763398e54fc36" + ], + "layout": "IPY_MODEL_e92b30d0b4234af6b5a33bff989b1b45" + } + }, + "51b3af446ace409dbcdf5de499552061": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53f287d4927541d08e2ae7d4d0b3c396": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "546b76a22f1046cd856a8fa2f9ff2d9f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5690d92586494b9187147f32fa708405": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57b0096985ab44aea342e52795c4f999": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57f251691b4c453896b2508c431dfc2f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57f87d4780634d36ae8159d987c22993": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_58ea619f81bf42ddb8b166db3deb0e86", + "IPY_MODEL_8bb83ae3229e4f38b1733f92f536fad0", + "IPY_MODEL_5c0104210ee34ca8a072ee5121f424a1" + ], + "layout": "IPY_MODEL_34e381adbd9242759b57f2a305c5d2e3" + } + }, + "58ea619f81bf42ddb8b166db3deb0e86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4e1a4338c5e46b3ba5a3bb960da7107", + "placeholder": "​", + "style": "IPY_MODEL_9a5072b8d16d4a1eb0652da61bda0ac8", + "value": "Loading checkpoint shards: 100%" + } + }, + "5924b266e95a42039634a334ff561a82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eadeec171e7b4c0f9e26964f031cfb71", + "IPY_MODEL_feae525923d5407bb69a922954c474f7", + "IPY_MODEL_00371a48e64c45cd97020a78b710e64c" + ], + "layout": "IPY_MODEL_156f95b0012449e8a0c604e6e03bf35f" + } + }, + "5962e77eea5a4d88ba6dbc5e9f51c709": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5a8ac674153248999007a713299b2644": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5b2a671976fa446db408d58a215b8249": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_63899ac621ff4e9cb8e215d5ab63bef8", + "max": 4, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6b2b59d2b62b4f7da8c60ff783138397", + "value": 4 + } + }, + "5b56ac3009714a5a84dd8749db4a7bce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_51b3af446ace409dbcdf5de499552061", + "placeholder": "​", + "style": "IPY_MODEL_9a12124915994b70a71ebd64b99e93e9", + "value": " 1.17G/1.17G [00:09<00:00, 45.8MB/s]" + } + }, + "5c0104210ee34ca8a072ee5121f424a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_604582e8cbff4dc9876551a3307b5b77", + "placeholder": "​", + "style": "IPY_MODEL_a98165ee656643ad85ac9ea1447cc775", + "value": " 4/4 [01:13<00:00, 15.74s/it]" + } + }, + "5cf4a57d21a545029b6448258a5ebd84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0d2ae3466a3447c58e23ccd2b3733deb", + "IPY_MODEL_ba7f32c41f9247ec9d4c40e6396b55a9", + "IPY_MODEL_ea1bdb5f2da64332960bccd967a84b4a" + ], + "layout": "IPY_MODEL_b08631e4cffa445c912da0c8eac2ef23" + } + }, + "5f551f9b217e44cf8b5433f314b3844b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5f60910d1e744432bdf87518f0f45874": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5f6ffa1d929443a5bd9c7c550f0690f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_93a50117ece543d4857ba02505dc4514", + "placeholder": "​", + "style": "IPY_MODEL_71a3a56edbdb45669d382fef4b097e1b", + "value": "Your token has been saved to /root/.cache/huggingface/token" + } + }, + "5fb4a4ef8afe4ea4af6655faea17f354": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "604582e8cbff4dc9876551a3307b5b77": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "610e1ddfb7a44d51a54ebea6dad3a5f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6149752353fe4f9cbb7b26bcc25199a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6cb8065803724d80b82b06dc95ded91e", + "placeholder": "​", + "style": "IPY_MODEL_8301c6302df54bbc9f15295f11cec208", + "value": " 654/654 [00:00<00:00, 46.9kB/s]" + } + }, + "63899ac621ff4e9cb8e215d5ab63bef8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63ac7dafeb27446cb30aaddf4cd27c9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "64624b26145b42db82f7afc36c32e117": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "64911f0e52e74067a1a986c5edfc7f59": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "661f76474252493caae8f7d6aa8f99b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_83c355e1418140a5bbad11bf0646b332", + "placeholder": "​", + "style": "IPY_MODEL_84d6d2a6afcd423f9b609cbb2d10f00e", + "value": " 20.9M/20.9M [00:00<00:00, 44.7MB/s]" + } + }, + "668a7f88506148a9ba2b48920afc028f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_53f287d4927541d08e2ae7d4d0b3c396", + "placeholder": "​", + "style": "IPY_MODEL_afa442ab223b46cb82569438c0047823", + "value": "Login successful" + } + }, + "67b4473eb8a44a96ba34983762ab38fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f474268da0f4337a2ccecc1ca2098a1", + "max": 4976698672, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c2ceccfdb59b4336a24003cd6bc2403d", + "value": 4976698672 + } + }, + "67fbabb9082c4241b8f937b24e0cdd03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6b0ec8d5f7294d44a5fa15d8ef12471e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8ea89e52123643268857285e0e1db1c0", + "placeholder": "​", + "style": "IPY_MODEL_a8514e34378d47a28fbf0831a14ede8f", + "value": "tokenizer.json: 100%" + } + }, + "6b2b59d2b62b4f7da8c60ff783138397": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6b6ed29053ec4aaa8fc5526a35f17c2b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6bb9c7182d2a464ea21809e59043562a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6cb8065803724d80b82b06dc95ded91e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f474268da0f4337a2ccecc1ca2098a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7037c32dfce84e70ac86537dbbc6a495": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0f4c664612364dc89acf78eb1c740980", + "placeholder": "​", + "style": "IPY_MODEL_0f60f9aa76b941809e013ffcae83604a", + "value": "config.json: 100%" + } + }, + "71a3a56edbdb45669d382fef4b097e1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7243d8e2e1cc4043a2ee310eabd0ac09": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "740604526cc44cd58b811827d4787d96": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7504986b8d8d4d0da58ad79e80a81948": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7725e9d443e249ada02e5ac7056d00db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "77704d2e27e94cd3a0c5f6b5ceeffd1c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0f54e8fda93144f6a95493e6ec535e9d", + "max": 23950, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_880124db7dc04aaea09edd75e1ec7921", + "value": 23950 + } + }, + "791df472db174df69b8c9f0e200af254": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a00aa4a97a34da39cc052c6926dbe13": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7ac8e88f29f04b859f592a003d39836b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b3e136fc9e74a699497a947006f4f1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7cd50bcc8fcc4b83abcda6d3604bd4cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a00aa4a97a34da39cc052c6926dbe13", + "placeholder": "​", + "style": "IPY_MODEL_14c73d88df9e46e3bbb6690fdb48ad07", + "value": "Connecting..." + } + }, + "7d3a7be9ed6f48988a2c4a1a4a2271cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f86b969ef69b48119619e1a424b50460", + "max": 9085698, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7725e9d443e249ada02e5ac7056d00db", + "value": 9085698 + } + }, + "7e2e097c703a4a0d8556733a0739469c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e0fd6d00f0ba4e59bdaa5779556ec4ea", + "IPY_MODEL_cd318c6bfc8e421a9bfcdab16be5eaa7", + "IPY_MODEL_4bc1fd9d480a4799954c69031c071b30" + ], + "layout": "IPY_MODEL_25fc6aaf37fc49fa822df29236bf2f90" + } + }, + "7e3a386e672f4748882211227b7721a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "button_color": null, + "font_weight": "" + } + }, + "7e51e8e0612e46b1a3403d448b39aa50": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "800e9453214848b69bc4c6ca2d5e8f79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6b0ec8d5f7294d44a5fa15d8ef12471e", + "IPY_MODEL_7d3a7be9ed6f48988a2c4a1a4a2271cf", + "IPY_MODEL_c40f583823574e40b6b29d4914143c0e" + ], + "layout": "IPY_MODEL_a4368e6da8f046aaa32f3152b7d333d1" + } + }, + "8301c6302df54bbc9f15295f11cec208": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8365680c634a44aa880317e36fa5e46e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "PasswordModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "PasswordModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "PasswordView", + "continuous_update": true, + "description": "Token:", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_31c574113731403b88edc5bb0798bc6d", + "placeholder": "​", + "style": "IPY_MODEL_3b8bc5b9392e45758813a1db9db824a9", + "value": "" + } + }, + "83c355e1418140a5bbad11bf0646b332": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "849cdc1912aa4df4b0c721a8c63ca0f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "84d6d2a6afcd423f9b609cbb2d10f00e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "854e35df771f470b82a59f878a2a6a46": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8800c351b6da450eace0c3890d36c8d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7037c32dfce84e70ac86537dbbc6a495", + "IPY_MODEL_31c10fa464e24f97b379675a204a09b5", + "IPY_MODEL_6149752353fe4f9cbb7b26bcc25199a9" + ], + "layout": "IPY_MODEL_0b145e421f4840f2872c29256b49f168" + } + }, + "880124db7dc04aaea09edd75e1ec7921": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "88024cd312ee42c2925ebfbe52077780": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "892ff4e2f0e44c23bc5c2be7547cf0bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8a7c82dcbd414b24b67ccfbc562b2e38": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8b9e961c837a464fb7a8c44756dc41e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8bb83ae3229e4f38b1733f92f536fad0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1f75d85e6c7e4eb6a91b03f0c8adb644", + "max": 4, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9da33f07ea354b5798e85298e132b017", + "value": 4 + } + }, + "8c149bc655a34fe5b91853c66db458a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8c4d6f4eea3742289a2604e66b0c6182": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8cc86330c2af436c9af314e8c04c8c2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0e2beab611114239b6ee48a3cbb09c49", + "IPY_MODEL_006b78b5191b4fb888d98bdf6c20ec1e", + "IPY_MODEL_5f6ffa1d929443a5bd9c7c550f0690f0", + "IPY_MODEL_668a7f88506148a9ba2b48920afc028f" + ], + "layout": "IPY_MODEL_35186465f87341f683affb9399661540" + } + }, + "8cd63d3908e4411c9fcb42bc32c8dd16": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d0f1d547c384094b10aa00a3ede3c06": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_082b6990ce5e4812adc0ad6a7b376dac", + "placeholder": "​", + "style": "IPY_MODEL_610e1ddfb7a44d51a54ebea6dad3a5f0", + "value": "model-00003-of-00004.safetensors: 100%" + } + }, + "8d988c86648244788f6dc5aa0fea38fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ea89e52123643268857285e0e1db1c0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f5b8c513b164dab9e0892422163c483": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cd11fb7d54bb43ae821f2272d075a1b3", + "placeholder": "​", + "style": "IPY_MODEL_fbc6a2834c5442fbb6667f1b3612bb5b", + "value": "Downloading shards: 100%" + } + }, + "90661b333d6f496ca606b3046622660e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "921a1a037f7b47f8b57d1da8192a437a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93a50117ece543d4857ba02505dc4514": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "974e3687f18a4e1a975969b880d086aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "99529129d7f0435da0fdcfc9803a2f11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5a8ac674153248999007a713299b2644", + "max": 1168138808, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1f82a5685eef4b47a2dbf7618362907c", + "value": 1168138808 + } + }, + "99c5c846cc5e43429905f071670b4310": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a2c543008f444cf49972a4f35c32b8e3", + "placeholder": "​", + "style": "IPY_MODEL_bb7b8a9e42f6478f851236685a1392d6", + "value": " 518/518 [00:00<00:00, 13408.85 examples/s]" + } + }, + "9a0b012915c54abeb100f466fa99d303": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fffbf696c07744fc8e3d81ab51dc9c90", + "placeholder": "​", + "style": "IPY_MODEL_a153cc3ca0cc45c18a941bd57e363ec3", + "value": "model-00004-of-00004.safetensors: 100%" + } + }, + "9a12124915994b70a71ebd64b99e93e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9a5072b8d16d4a1eb0652da61bda0ac8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9bdebf06b6874bbb88404f4ad14e1dbc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5f60910d1e744432bdf87518f0f45874", + "max": 4915916176, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2ab86b3fbd49488bb02f8205a572e752", + "value": 4915916176 + } + }, + "9cfaf17064bc49a5aded0fc53dd7cd7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ede66e196fa9482498f58dcdffd494a2", + "IPY_MODEL_a26cc7fea1a64d7bac1769d33cc74e28", + "IPY_MODEL_c2f24a8930be4b70b4bbbcf5d908b01d" + ], + "layout": "IPY_MODEL_1f59dd66813f419999336e59a3efc56a" + } + }, + "9da33f07ea354b5798e85298e132b017": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9f13437a44b8434b9cc3afab998e8d3c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a06b2bd0236249999adffa44e53cf80e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5fb4a4ef8afe4ea4af6655faea17f354", + "max": 395, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b1a03a5e9bae46129830daeeb23bf6ff", + "value": 395 + } + }, + "a153cc3ca0cc45c18a941bd57e363ec3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a2249f364b914662b54045a1f8d6dfd1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f13437a44b8434b9cc3afab998e8d3c", + "placeholder": "​", + "style": "IPY_MODEL_8a7c82dcbd414b24b67ccfbc562b2e38", + "value": " 4.92G/4.92G [00:32<00:00, 171MB/s]" + } + }, + "a26cc7fea1a64d7bac1769d33cc74e28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_854e35df771f470b82a59f878a2a6a46", + "max": 9846, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d1cbe0ab9379453588eb438d13fd272d", + "value": 9846 + } + }, + "a2a7b715b16a41a288209dee1de5d2d1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a2c543008f444cf49972a4f35c32b8e3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a34b3fd5859a441f89cbe7f6e6df9da9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8f5b8c513b164dab9e0892422163c483", + "IPY_MODEL_5b2a671976fa446db408d58a215b8249", + "IPY_MODEL_c934919f617447cfb9226929e7a68d79" + ], + "layout": "IPY_MODEL_124a70bfad434c5c946f611c04a91c8f" + } + }, + "a4368e6da8f046aaa32f3152b7d333d1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4c404e420cc4ce781ce569f9ab3f987": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a53b4776f95f4dd38197193e6c5f649e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aea74071600f483b9e6de1a61743c03a", + "placeholder": "​", + "style": "IPY_MODEL_21bf14b771c14d2dab9e98a326302e14", + "value": "model-00002-of-00004.safetensors: 100%" + } + }, + "a8514e34378d47a28fbf0831a14ede8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a8999d04e4114693bb6be358bdbe9b83": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a98165ee656643ad85ac9ea1447cc775": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aea74071600f483b9e6de1a61743c03a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "afa442ab223b46cb82569438c0047823": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b08631e4cffa445c912da0c8eac2ef23": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b0b7457a8b47496483da1506fb2505b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b1a03a5e9bae46129830daeeb23bf6ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b1de7b283eeb41828e8093e60c83f2c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bb640a5c858349d29c13ce5629e72f22", + "IPY_MODEL_37523a6cac1047e9a261698212d47737", + "IPY_MODEL_661f76474252493caae8f7d6aa8f99b7" + ], + "layout": "IPY_MODEL_849cdc1912aa4df4b0c721a8c63ca0f9" + } + }, + "b2a19b6092c44b20886987b30f1bf48a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1f0efc167b3744b38ff832b71d529318", + "IPY_MODEL_a06b2bd0236249999adffa44e53cf80e", + "IPY_MODEL_23012118a7314a3f838870a2aee9ec90" + ], + "layout": "IPY_MODEL_dcff079d850c423a83eb70105b816ee4" + } + }, + "b3b3f4ddd4ed4d938c923887939a0440": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_57f251691b4c453896b2508c431dfc2f", + "placeholder": "​", + "style": "IPY_MODEL_4bdb196cd1494f809829651ec5b6cbf8", + "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks.

" + } + }, + "b4a274fc9e324b80bf559c4dbd05e319": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b4ba435f6d1c448f99b533bc6df32e76": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_35c2c635c2024bcda3265bf95d330f63", + "max": 4999802720, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ec014d847e394a309b6a82c30a6fdfc5", + "value": 4999802720 + } + }, + "b621c6a8c0e9440fa840d75a1b1b02fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ba7f32c41f9247ec9d4c40e6396b55a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4c8e98294bd240a6869cb199caee66e1", + "max": 177, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4e1f5423311b4dc0930c21c9ad5a88f5", + "value": 177 + } + }, + "bac377ed96ae4e8db9b298bb623888ec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb640a5c858349d29c13ce5629e72f22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5962e77eea5a4d88ba6dbc5e9f51c709", + "placeholder": "​", + "style": "IPY_MODEL_f07c8a6ec12f46ea9e32a2208e70bccd", + "value": "Downloading data: 100%" + } + }, + "bb7b8a9e42f6478f851236685a1392d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bbdf3bb657e64fc2b0a90e78e8886480": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bcaf4c81ba9d437bb6223dbb22d011ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bf77e5aaab0547f7b2beb015687552ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bfcbfe4184774fd3a8320f4f0e1baf54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a2a7b715b16a41a288209dee1de5d2d1", + "max": 518, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bf77e5aaab0547f7b2beb015687552ef", + "value": 518 + } + }, + "c27e8ce031884a90b41d8220b1870bc4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c2ceccfdb59b4336a24003cd6bc2403d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c2f24a8930be4b70b4bbbcf5d908b01d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b0b7457a8b47496483da1506fb2505b3", + "placeholder": "​", + "style": "IPY_MODEL_c7dc386d978a44ff885763ecec94dc38", + "value": " 9846/9846 [00:09<00:00, 1066.17 examples/s]" + } + }, + "c35b16156253402f90a432f3f07c2e0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6b6ed29053ec4aaa8fc5526a35f17c2b", + "placeholder": "​", + "style": "IPY_MODEL_e69cd88ccbae4bb7b238fa112a60f0f9", + "value": "special_tokens_map.json: 100%" + } + }, + "c40f583823574e40b6b29d4914143c0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f81756eb9e554899b0778311f2c407c4", + "placeholder": "​", + "style": "IPY_MODEL_3b614b9712874fac990d2c557b0791a6", + "value": " 9.09M/9.09M [00:00<00:00, 19.3MB/s]" + } + }, + "c56d8289513441688f9bc5f4b52d60a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a53b4776f95f4dd38197193e6c5f649e", + "IPY_MODEL_b4ba435f6d1c448f99b533bc6df32e76", + "IPY_MODEL_42eb041021214110a860924d28d73409" + ], + "layout": "IPY_MODEL_17c797e08bd2493fa685918129415309" + } + }, + "c7dc386d978a44ff885763ecec94dc38": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c7e06fd82f7f4f9fb81c68e8758f2de1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a8999d04e4114693bb6be358bdbe9b83", + "placeholder": "​", + "style": "IPY_MODEL_2540d57e3bf545e3812da1ee72b85fc8", + "value": " 4.98G/4.98G [00:34<00:00, 232MB/s]" + } + }, + "c84f542c863043dea8a3675fa153e78d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ButtonView", + "button_style": "", + "description": "Login", + "disabled": false, + "icon": "", + "layout": "IPY_MODEL_d2d81cc8296c4b10bf80b86c0a3302d3", + "style": "IPY_MODEL_7e3a386e672f4748882211227b7721a9", + "tooltip": "" + } + }, + "c934919f617447cfb9226929e7a68d79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c27e8ce031884a90b41d8220b1870bc4", + "placeholder": "​", + "style": "IPY_MODEL_88024cd312ee42c2925ebfbe52077780", + "value": " 4/4 [01:41<00:00, 22.30s/it]" + } + }, + "cc5ce633746949ed98418cae9f68afe3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd11fb7d54bb43ae821f2272d075a1b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd318c6bfc8e421a9bfcdab16be5eaa7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d10ba011d05045b18bbfeb9660e4d9d3", + "max": 9846, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e56c22f77c884caaacfafd48dfa51a55", + "value": 9846 + } + }, + "cf6d1be81b6c4ffc81ce8fdabfc5ad28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07e0aed682fd4cc88fa75c0592dc04a7", + "IPY_MODEL_67b4473eb8a44a96ba34983762ab38fa", + "IPY_MODEL_c7e06fd82f7f4f9fb81c68e8758f2de1" + ], + "layout": "IPY_MODEL_3d9d8278667d496aaea1eaaa4d24ae93" + } + }, + "cffdf12fbe97462ab74e88ccca943aeb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d10ba011d05045b18bbfeb9660e4d9d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d1508f5cde9a43d8abc26dd2d0c34dbd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9a0b012915c54abeb100f466fa99d303", + "IPY_MODEL_99529129d7f0435da0fdcfc9803a2f11", + "IPY_MODEL_5b56ac3009714a5a84dd8749db4a7bce" + ], + "layout": "IPY_MODEL_546b76a22f1046cd856a8fa2f9ff2d9f" + } + }, + "d1cbe0ab9379453588eb438d13fd272d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d2d81cc8296c4b10bf80b86c0a3302d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d3cbfd564fe8485ba7afdb1cc54abed3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d4092198673141d3b4a824d629d73f64": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7ef74cf4a914ad38a69c84c34fff393": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8d0f1d547c384094b10aa00a3ede3c06", + "IPY_MODEL_9bdebf06b6874bbb88404f4ad14e1dbc", + "IPY_MODEL_a2249f364b914662b54045a1f8d6dfd1" + ], + "layout": "IPY_MODEL_7504986b8d8d4d0da58ad79e80a81948" + } + }, + "db05b25cb38140bdb21e6f3b7fde7e66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dcff079d850c423a83eb70105b816ee4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de3757d6125a4c07b502dd60816bafec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0fd6d00f0ba4e59bdaa5779556ec4ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7ac8e88f29f04b859f592a003d39836b", + "placeholder": "​", + "style": "IPY_MODEL_0ec2643d9fd44785addb37d9ecd23989", + "value": "Generating train split: 100%" + } + }, + "e25f9ca445b14e3f8397779df071dfb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_791df472db174df69b8c9f0e200af254", + "placeholder": "​", + "style": "IPY_MODEL_6bb9c7182d2a464ea21809e59043562a", + "value": "

Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" + } + }, + "e297072ab5d64815b90bc89d22503378": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4e1a4338c5e46b3ba5a3bb960da7107": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e56c22f77c884caaacfafd48dfa51a55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e69cd88ccbae4bb7b238fa112a60f0f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e92b30d0b4234af6b5a33bff989b1b45": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ea1bdb5f2da64332960bccd967a84b4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_347540dc03d34e65b7ffbb0f5fc569aa", + "placeholder": "​", + "style": "IPY_MODEL_7243d8e2e1cc4043a2ee310eabd0ac09", + "value": " 177/177 [00:00<00:00, 11.4kB/s]" + } + }, + "eadeec171e7b4c0f9e26964f031cfb71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_de3757d6125a4c07b502dd60816bafec", + "placeholder": "​", + "style": "IPY_MODEL_8c4d6f4eea3742289a2604e66b0c6182", + "value": "tokenizer_config.json: 100%" + } + }, + "ec014d847e394a309b6a82c30a6fdfc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ede66e196fa9482498f58dcdffd494a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_026072374b7d47c194707a50f5c99099", + "placeholder": "​", + "style": "IPY_MODEL_63ac7dafeb27446cb30aaddf4cd27c9f", + "value": "Map: 100%" + } + }, + "ee4e4af964ec4dd597cb04a90f0697f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f07c8a6ec12f46ea9e32a2208e70bccd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f2ab2fa803e94328a237e84cd4ea0027": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5690d92586494b9187147f32fa708405", + "max": 1105272, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_317cda72329c4043ab0b224b46b259d3", + "value": 1105272 + } + }, + "f4ca7b63d7d749ff83a848e250f03ec1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f7e59b47f9b74523843f37268212d566": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f81756eb9e554899b0778311f2c407c4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f86b969ef69b48119619e1a424b50460": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fbc6a2834c5442fbb6667f1b3612bb5b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "feae525923d5407bb69a922954c474f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bac377ed96ae4e8db9b298bb623888ec", + "max": 50566, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_02d6cc4c2717434c895798601bda7c86", + "value": 50566 + } + }, + "ffe561df8772443ebf40a3b8b656079f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fffbf696c07744fc8e3d81ab51dc9c90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..20250476e44cebe27eb3e817b08f283dbe1570cf --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/README.md @@ -0,0 +1,105 @@ +# DoRA: Weight-Decomposed Low-Rank Adaptation + +![dora](https://i.ytimg.com/vi/m7KQdGSr0Dg/maxresdefault.jpg) + + +## Introduction +[DoRA](https://huggingface.co/papers/2402.09353) is a novel approach that leverages low rank adaptation through weight decomposition analysis to investigate the inherent differences between full fine-tuning and LoRA. DoRA initially decomposes the pretrained weight into its magnitude and directional components and finetunes both of them. Because the directional component is large in terms of parameter numbers, we further decompose it with LoRA for efficient finetuning. This results in enhancing both the learning capacity and training stability of LoRA while avoiding any additional inference overhead. + +## Quick start +```python +import torch +from peft import LoraConfig, get_peft_model +from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer +from datasets import load_dataset + +model = AutoModelForCausalLM.from_pretrained("huggyllama/llama-7b", device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-7b") +dataset = load_dataset("timdettmers/openassistant-guanaco", split="train") +lora_config = LoraConfig( + use_dora=True +) +peft_model = get_peft_model(model, lora_config) +trainer = transformers.Trainer( + model=peft_model, + train_dataset=dataset, + dataset_text_field="text", + max_length=2048, + tokenizer=tokenizer, +) +trainer.train() +peft_model.save_pretrained("dora-llama-3-8b") +``` + +There is no additional change needed to your standard LoRA procedure, except for specifying `use_dora = True` option in your lora configuration. + + +Run the finetuning script simply by running: +```bash +python examples/dora_finetuning/dora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco +``` +This 👆🏻 by default will load the model in peft set up with LoRA config. Now if you wanna quickly compare it with Dora, all you need to do is to input ` --use_dora` in the command line. So same above example would be 👇🏻; + +```bash +python examples/dora_finetuning/dora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco --use_dora +``` + +DoRA also supports quantization. To use 4-bit quantization try: + +```bash +python examples/dora_finetuning/dora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --quantize +``` + +Similarly, by default the LoRA layers are the attention and MLP layers of LLama model, if you get to choose a different set of layers for LoRA to be applied on, you can simply define it using: +```bash +python examples/dora_finetuning/dora_finetuning.py --lora_target_modules "q_proj,k_proj,v_proj,o_proj" +``` + +### Full example of the script +```bash +python dora_finetuning.py \ + --base_model "PATH_TO_MODEL" \ + --data_path "PATH_TO_DATASET" \ + --output_dir "PATH_TO_OUTPUT_DIR" \ + --batch_size 1 \ + --num_epochs 3 \ + --learning_rate 3e-4 \ + --cutoff_len 512 \ + --val_set_size 500 \ + --use_dora \ + --quantize \ + --eval_step 10 \ + --save_step 100 \ + --lora_r 16 \ + --lora_alpha 32 \ + --lora_dropout 0.05 \ + --lora_target_modules "q_proj,k_proj,v_proj,o_proj" \ + --hub_model_id "YOUR_HF_REPO" \ + --push_to_hub +``` +## Use the model on 🤗 +You can load and use the model as any other 🤗 models. +```python +from transformers import AutoModel +model = AutoModel.from_pretrained("ShirinYamani/huggyllama-llama-7b-finetuned") +``` + +## DoRA vs. LoRA +In general, DoRA finetuning on diffusion models is still experimental and is likely to require different hyperparameter values to perform best compared to LoRA. + +Specifically, people have noticed 2 differences to take into account in your training: + +1. LoRA seem to converge faster than DoRA (so a set of parameters that may lead to overfitting when training a LoRA may be working well for a DoRA) + +2. DoRA quality superior to LoRA especially in lower ranks: The difference in quality of DoRA of rank 8 and LoRA of rank 8 appears to be more significant than when training ranks of 32 or 64 for example. + + +## Citation +``` +@article{liu2024dora, + title={DoRA: Weight-Decomposed Low-Rank Adaptation}, + author={Liu, Shih-Yang and Wang, Chien-Yi and Yin, Hongxu and Molchanov, Pavlo and Wang, Yu-Chiang Frank and Cheng, Kwang-Ting and Chen, Min-Hung}, + journal={arXiv preprint arXiv:2402.09353}, + year={2024} +} +``` \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/dora-caching.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/dora-caching.py new file mode 100644 index 0000000000000000000000000000000000000000..bdcff097ac7c7833a77da08f9ec98355d9bc8a68 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/dora-caching.py @@ -0,0 +1,126 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# 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. + +""" +Small script to measure DoRA caching efficiency +""" + +import argparse +import time +from contextlib import contextmanager + +import torch +from transformers import AutoModelForCausalLM + +from peft import LoraConfig, get_peft_model +from peft.helpers import DoraCaching +from peft.utils import infer_device + + +device = infer_device() +# check for CPU +if device == "cpu": + raise ValueError("This benchmark requires a hardware accelerator, only found CPU") +torch_accelerator_module = getattr(torch, device, torch.cuda) + + +@contextmanager +def timeit(logs): + start = time.perf_counter() + yield + end = time.perf_counter() + dur = end - start + logs["time"].append(dur) + + +def run_benchmark(model, num_runs): + logs = { + "time": [], + } + + mem_start = torch_accelerator_module.max_memory_reserved() + for _ in range(num_runs + 1): + with timeit(logs): + for i in range(3): + x = torch.randint(10, 100, (1, 50)).to(device) + model(x) + mem_end = torch_accelerator_module.max_memory_reserved() + logs["memory"] = (mem_end - mem_start) / 1024**2 + + # remove the first run (warm up) + del logs["time"][0] + return logs + + +def main(model_id, num_runs): + model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map=device) + base_memory = torch_accelerator_module.max_memory_reserved() / 1024**2 + + # LORA + config = LoraConfig(init_lora_weights=False, use_dora=False) + model = get_peft_model(model, config) + model.eval() + torch_accelerator_module.reset_peak_memory_stats() + logs_lora = run_benchmark(model, num_runs) + avg_duration_lora = sum(logs_lora["time"]) / num_runs + max_memory_lora = logs_lora["memory"] + base_memory + + # DORA + del model + torch_accelerator_module.empty_cache() + + model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map=device) + base_memory = torch_accelerator_module.max_memory_reserved() / 1024**2 + config = LoraConfig(init_lora_weights=False, use_dora=True) + model = get_peft_model(model, config) + model.eval() + + # WITHOUT CACHING + torch_accelerator_module.reset_peak_memory_stats() + logs_dora_no_caching = run_benchmark(model, num_runs) + avg_duration_no_caching = sum(logs_dora_no_caching["time"]) / num_runs + max_memory_no_caching = logs_dora_no_caching["memory"] + base_memory + + # WITH CACHING + torch_accelerator_module.reset_peak_memory_stats() + with DoraCaching(): + logs_dora_caching = run_benchmark(model, num_runs) + avg_duration_caching = sum(logs_dora_caching["time"]) / num_runs + max_memory_caching = logs_dora_caching["memory"] + base_memory + + print( + f"Benchmark results for model {model_id} with {num_runs} runs:\n\n" + f"avg time LoRA: {avg_duration_lora:.4f} sec\n" + f"avg time DoRA no caching: {avg_duration_no_caching:.4f} sec\n" + f"avg time DoRA with caching: {avg_duration_caching:.4f} sec\n" + f"\n" + f"memory LoRA: {max_memory_lora:.2f} MB\n" + f"memory DoRA no caching: {max_memory_no_caching:.2f} MB\n" + f"memory DoRA with caching: {max_memory_caching:.2f} MB\n" + f"\n" + f"DoRA time overhead no caching: {(avg_duration_no_caching - avg_duration_lora) / avg_duration_lora * 100:.2f}%\n" + f"DoRA time overhead with caching: {(avg_duration_caching - avg_duration_lora) / avg_duration_lora * 100:.2f}%\n" + f"\n" + f"DoRA memory overhead no caching: {(max_memory_no_caching - max_memory_lora) / max_memory_lora * 100:.2f}%\n" + f"DoRA memory overhead with caching: {(max_memory_caching - max_memory_lora) / max_memory_lora * 100:.2f}%" + ) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Benchmark DoRA caching efficiency") + parser.add_argument("--model_id", type=str, default="meta-llama/Llama-3.1-8B", help="Model ID to benchmark") + parser.add_argument("--num_runs", type=int, default=10, help="Number of runs for the benchmark") + args = parser.parse_args() + + main(args.model_id, args.num_runs) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/dora_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/dora_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..c8d281fc617a96958b96fbbb91fb2514a875a03e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/dora_finetuning/dora_finetuning.py @@ -0,0 +1,208 @@ +import os + +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + BitsAndBytesConfig, + DataCollatorForLanguageModeling, + Trainer, + TrainingArguments, +) + +from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training + + +def train_model( + base_model: str, + data_path: str, + output_dir: str, + batch_size: int, + num_epochs: int, + learning_rate: float, + cutoff_len: int, + val_set_size: int, + use_dora: bool, + quantize: bool, + eval_step: int, + save_step: int, + device: str, + lora_r: int, + lora_alpha: int, + lora_dropout: float, + lora_target_modules: str, + hub_model_id: str, + push_to_hub: bool, +): + os.environ["TOKENIZERS_PARALLELISM"] = "false" + hf_token = os.getenv("HF_TOKEN") + + # Setup device + if device == "auto": + device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + else: + device = torch.device(device) + print(f"Using device: {device}") + + # load tokenizer + tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token) + + # QDoRA (quantized dora): IF YOU WANNA QUANTIZE THE MODEL + if quantize: + if (torch.cuda.is_available() and torch.cuda.is_bf16_supported()) or torch.xpu.is_available(): + bnb_4bit_compute_dtype = torch.bfloat16 + else: + bnb_4bit_compute_dtype = torch.float16 + model = AutoModelForCausalLM.from_pretrained( + base_model, + token=hf_token, + quantization_config=BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=bnb_4bit_compute_dtype, + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_type="nf4", + ), + ) + # setup for quantized training + model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True) + else: + model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token) + # LoRa config for the PEFT model + lora_config = LoraConfig( + use_dora=use_dora, # to use Dora OR compare to Lora just set the --use_dora + r=lora_r, # Rank of matrix + lora_alpha=lora_alpha, + target_modules=( + lora_target_modules.split(",") + if lora_target_modules + else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] + ), + lora_dropout=lora_dropout, + bias="none", + ) + + # get the peft model with LoRa config + model = get_peft_model(model, lora_config) + + model.to(device) # MODEL TO GPU/CUDA + tokenizer.pad_token = tokenizer.eos_token + + # Load the dataset + dataset = load_dataset(data_path) + + def tokenize_function(examples): + inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len) + inputs["labels"] = inputs["input_ids"].copy() # setting labels for a language modeling task + return inputs + + # Tokenize the dataset and prepare for training + tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names) + + # Data collator to dynamically pad the batched examples + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + + # Define training arguments + training_args = TrainingArguments( + output_dir=output_dir, + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + per_device_eval_batch_size=batch_size, + warmup_steps=100, + weight_decay=0.01, + logging_dir="./logs", + logging_steps=eval_step, + save_steps=save_step, + save_total_limit=2, + push_to_hub=push_to_hub, + hub_model_id=hub_model_id, + gradient_accumulation_steps=16, + fp16=True, + learning_rate=learning_rate, + hub_token=hf_token, + ) + + # Clear device cache to free memory + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + # Initialize the Trainer + trainer = Trainer( + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["test"], + data_collator=data_collator, + ) + + # Start model training + trainer.train() + + # Save and push the trained model and tokenizer + if push_to_hub: + # Push the main model to the hub + trainer.push_to_hub(commit_message="Fine-tuned model") + + # Save the model and tokenizer locally + model.save_pretrained(output_dir) + tokenizer.save_pretrained(output_dir) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DoRA and PEFT") + parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name") + parser.add_argument( + "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name" + ) + parser.add_argument( + "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model" + ) + parser.add_argument("--batch_size", type=int, default=1, help="Batch size") + parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs") + parser.add_argument("--learning_rate", type=float, default=3e-4, help="Learning rate") + parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization") + parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size") + parser.add_argument("--use_dora", action="store_true", help="Apply Dora") + parser.add_argument("--quantize", action="store_true", help="Use quantization") + parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval") + parser.add_argument("--save_step", type=int, default=100, help="Save step interval") + parser.add_argument("--device", type=str, default="auto", help="Device to use for training") + parser.add_argument("--lora_r", type=int, default=8, help="LoRA rank") + parser.add_argument("--lora_alpha", type=int, default=16, help="LoRA alpha") + parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout rate") + parser.add_argument( + "--lora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA" + ) + parser.add_argument( + "--hub_model_id", + type=str, + default="path/to/repo", + help="Repository name to push the model on the Hugging Face Hub", + ) + parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub") + args = parser.parse_args() + train_model( + base_model=args.base_model, + data_path=args.data_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + val_set_size=args.val_set_size, + use_dora=args.use_dora, + quantize=args.quantize, + eval_step=args.eval_step, + save_step=args.save_step, + device=args.device, + lora_r=args.lora_r, + lora_alpha=args.lora_alpha, + lora_dropout=args.lora_dropout, + lora_target_modules=args.lora_target_modules, + hub_model_id=args.hub_model_id, + push_to_hub=args.push_to_hub, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/ephemeral_gpu_offloading/load_with_dora.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/ephemeral_gpu_offloading/load_with_dora.py new file mode 100644 index 0000000000000000000000000000000000000000..cc61925f9008af2f526c145fca9689587d75cd65 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/ephemeral_gpu_offloading/load_with_dora.py @@ -0,0 +1,103 @@ +# Copyright 2024-present the HuggingFace Inc. team. +# +# 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. + +""" +Example script demonstrating the time difference loading a model with a DoRA using ephemeral GPU offloading vs doing it purely on the CPU. + +Example outputs: +$ python load_with_dora.py +--- Loading model --- +Loading checkpoint shards: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:04<00:00, 1.03s/it] +--- Loading PeftModel --- +--- Done --- +Model loading time: 4.83s +PeftModel loading time: 28.14s +Use ephemeral GPU offloading: False + +(Note: if this was the first time you ran the script, or if your cache was cleared, the times shown above are invalid, due to the time taken to download the model and DoRA files. Just re-run the script in this case.) + +$ python load_with_dora.py --ephemeral_gpu_offload +--- Loading model --- +Loading checkpoint shards: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:03<00:00, 1.11it/s] +--- Loading PeftModel --- +--- Done --- +Model loading time: 4.28s +PeftModel loading time: 16.59s +Use ephemeral GPU offloading: True + +(Note: if this was the first time you ran the script, or if your cache was cleared, the times shown above are invalid, due to the time taken to download the model and DoRA files. Just re-run the script in this case.) +""" + +import argparse +import time + +from huggingface_hub import snapshot_download +from transformers import AutoModelForCausalLM + +from peft import PeftModel + + +def main(): + parser = argparse.ArgumentParser(description="Load a model with DoRA using ephemeral GPU offloading") + parser.add_argument("--model", type=str, default="NousResearch/Hermes-2-Pro-Mistral-7B", help="Model to load") + parser.add_argument( + "--dora", + type=str, + default="peft-internal-testing/DoRA-Hermes-2-Pro-Mistral-7B", + help="DoRA to use", + ) + parser.add_argument("--ephemeral_gpu_offload", action="store_true", help="Use ephemeral GPU offloading") + parser.add_argument( + "--merge_model_path", type=str, help="Merge the model with the DoRA model and save to the given path" + ) + args = parser.parse_args() + + peft_model_kwargs = { + "ephemeral_gpu_offload": args.ephemeral_gpu_offload, + "max_memory": {"cpu": "256GiB"}, + "device_map": {"": "cpu"}, + } + + # Predownload + try: + snapshot_download(repo_id=args.model) + except Exception as e: + print(f"Failed to download model: {e}") + # We continue anyway as this might be e.g. a local directory or something + try: + snapshot_download(repo_id=args.dora) + except Exception as e: + print(f"Failed to download DoRA: {e}") + # We continue anyway as this might be e.g. a local directory or something + + start = time.perf_counter() + print("--- Loading model ---") + model = AutoModelForCausalLM.from_pretrained(args.model) + model_time = time.perf_counter() - start + print("--- Loading PeftModel ---") + peft_model = PeftModel.from_pretrained(model, args.dora, **peft_model_kwargs) + print("--- Done ---") + peft_model_time = time.perf_counter() - start + + print(f"Model loading time: {model_time:.2f}s") + print(f"PeftModel loading time: {peft_model_time:.2f}s") + print(f"Use ephemeral GPU offloading: {args.ephemeral_gpu_offload}") + + if args.merge_model_path is not None: + merged_model = peft_model.merge_and_unload(progressbar=True) + merged_model.save_pretrained(args.merge_model_path) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0c710410059719eb7b50b043fa94437a45bfec28 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/README.md @@ -0,0 +1,159 @@ +# EVA: Explained Variance Adaptation +## Introduction ([Paper](https://huggingface.co/papers/2410.07170), [code](https://github.com/ml-jku/EVA)) +Explained Variance Adaptation (EVA) is a novel initialization method for LoRA style adapters which initializes adapter weights in a data driven manner and adaptively allocates ranks according to the variance they explain. EVA improves average performance on a multitude of tasks across various domains, such as Language generation and understanding, Image classification, and Decision Making. + +The abstract from the paper is: + +*Foundation models (FMs) are pre-trained on large-scale datasets and then fine-tuned on a downstream task for a specific application. The most successful and most commonly used fine-tuning method is to update the pre-trained weights via a low-rank adaptation (LoRA). LoRA introduces new weight matrices that are usually initialized at random with a uniform rank distribution across model weights. Recent works focus on weight-driven initialization or learning of adaptive ranks during training. Both approaches have only been investigated in isolation, resulting in slow convergence or a uniform rank distribution, in turn leading to sub-optimal performance. We propose to enhance LoRA by initializing the new weights in a data-driven manner by computing singular value decomposition on minibatches of activation vectors. Then, we initialize the LoRA matrices with the obtained right-singular vectors and re-distribute ranks among all weight matrices to explain the maximal amount of variance and continue the standard LoRA fine-tuning procedure. This results in our new method **E**xplained **V**ariance **A**daptation (EVA). We apply EVA to a variety of fine-tuning tasks ranging from language generation and understanding to image classification and reinforcement learning. EVA exhibits faster convergence than competitors and attains the highest average score across a multitude of tasks per domain.* + +## Quick Start +Below is an example of how to use EVA with a causal language model. For a more detailed example see [eva_finetuning.py](https://github.com/huggingface/peft/blob/main/examples/eva_finetuning/eva_finetuning.py). +```python +import torch +from datasets import load_dataset +from torch.utils.data import DataLoader +from transformers import AutoModelForCausalLM, AutoTokenizer + +from peft import EvaConfig, LoraConfig, get_peft_model, initialize_lora_eva_weights + + +# config +model_name = "meta-llama/Llama-3.1-8B" +max_seq_len = 512 +rank = 16 +alpha = 1 +rho = 2.0 +target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"] +svd_batch_size = 4 # can be different from the batch size used in finetuning + +# load model and tokenizer +model = AutoModelForCausalLM.from_pretrained(model_name) +tokenizer = AutoTokenizer.from_pretrained(model_name) +tokenizer.pad_token = tokenizer.eos_token + +# load dataset +dataset = load_dataset("Rowan/hellaswag") +dataset = dataset.map( + lambda x: tokenizer(x["ctx"], padding="max_length", truncation=True, max_length=max_seq_len), + batched=True, + remove_columns=dataset["train"].column_names, +) +dataset.set_format(type="torch") + +# create dataloader for SVD +# typically this is the same as the dataloader used for finetuning +dataloader = DataLoader( + dataset["train"], + batch_size=svd_batch_size, + collate_fn=lambda examples: {k: torch.stack([v[k] for v in examples], dim=0) for k in examples[0].keys()}, +) + +# setup peft config +eva_config = EvaConfig( + rho=rho +) +peft_config = LoraConfig( + r=rank, + lora_alpha=alpha, + target_modules=target_modules, + init_lora_weights="eva", + eva_config=eva_config +) + +# move model to accelerator +device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" +model = model.to(device) + +# to optimize memory usage during EVA initialization, set low_cpu_mem_usage=True +peft_model = get_peft_model(model, peft_config, low_cpu_mem_usage=True) + +initialize_lora_eva_weights(peft_model, dataloader) +``` +`initialize_lora_eva_weights` will compute the SVD and load the components into the model. After this continue with standard LoRA finetuning. + +## Using EVA with Bitsandbytes +EVA is fully compatible with bitsandbytes. Simply initialize the pretrained model with a BitsAndBytesConfig and then use the peft model with EVA. +```python +from transformers import BitsAndBytesConfig +from peft import prepare_model_for_kbit_training + +model = AutoModelForCausalLM.from_pretrained( + "meta-llama/Llama-3.1-8B", + quantization_config=BitsAndBytesConfig(load_in_4bit=True) +) +model = prepare_model_for_kbit_training(model) +peft_model = get_peft_model(model, peft_config) +initialize_lora_eva_weights(peft_model, dataloader) +``` + +## Getting the EVA state_dict without loading the adapter weights +In some cases you might just want to get the state_dict after EVA initialization without loading the adapter weights. This can be useful for example if: +- you want to precompute and store the state_dict for different downstream tasks. +- you need to quantize the model for finetuning but want to perform EVA initialization with model weights in full/half precision. +- you do not intend to use a peft model for LoRA finetuning. +- you would like to leverage multiple accelerators for EVA initialization. (At the moment this is not directly supported by `initialize_lora_eva_weights`) + +You can do this by calling `get_eva_state_dict` directly (you only need to pass `peft_config` if `model` is not a PeftModel): +```python +from peft import get_eva_state_dict + +eva_state_dict = get_eva_state_dict(model, dataloader, peft_config) +``` +Later you can load the state_dict into a `PeftModel` by using the `eva_state_dict` argument in `initialize_lora_eva_weights`: +```python +initialize_lora_eva_weights(peft_model, eva_state_dict=eva_state_dict) +``` + +## Leveraging multiple accelerators + +EVA initialization can be parallelized across multiple accelerators. In this case inputs from multiple accelerators are gathered before computing the SVD for the batch. This requires that the model is wrapped in a `torch.nn.DataParallel` or `torch.nn.DistributedDataParallel` class. An example of how to use this can be found in [eva_finetuning_multi_accelerator.py](https://github.com/huggingface/peft/blob/main/examples/eva_finetuning/eva_finetuning_multi_accelerator.py). + +## Customizing EVA + +By default, EVA is designed to work with standard transformer language models. However we integrated three different parameters which can be used to customize EVA for other types of models. +1. `forward_fn`: Defines how the forward pass during EVA initialization should be computed. +2. `prepare_model_inputs_fn`: Can be used if it is necessary to use information contained in the original model_input to prepare the input for SVD in individual layers. +3. `prepare_layer_inputs_fn`: Defines how layer inputs should be prepared for SVD. + +All three parameters can be passed to `initialize_lora_eva_weights` and `get_eva_state_dict`. + +### forward_fn + +`forward_fn` defines how the forward pass during EVA initialization should be computed. `forward_fn` receives two arguments: `model` and `inputs`. By default this is set to `forward_fn_dict` which simply returns `model(**inputs)`. + +### prepare_model_inputs_fn + +`prepare_model_inputs_fn` can be used if it is necessary to use information contained in the original model_input to prepare the input for SVD in individual layers. `prepare_model_inputs_fn` receives two arguments: `model_input` and `peft_config`. This component is separate from `prepare_layer_inputs_fn` as the output only needs to be computed once per batch. By default this parameter is set to `prepare_model_inputs_fn_language_modeling` which is used get a subset of indices based on attention and label mask to avoid including padding tokens in the SVD computation. If you would like to not use this component set `prepare_model_inputs_fn` to None. The default logic is: +```python +def prepare_model_inputs_fn_language_modeling(model_input, peft_config: LoraConfig): + mask = model_input.get("attention_mask", torch.ones_like(model_input["input_ids"])).bool() + if peft_config.eva_config.use_label_mask and hasattr(model_input, "labels"): + mask = torch.logical_and(mask, model_input["labels"] != peft_config.eva_config.label_mask_value) + return mask.nonzero() +``` + +### prepare_layer_inputs_fn + +`prepare_layer_inputs_fn` can be used to preprocess the layer inputs before passing them to the SVD algorithm. `prepare_layer_inputs_fn` receives three arguments: `layer_input`, `model_input` and `layer_name`. It can either be a callable or a dictionary where the keys are the layer names and the values are callables. If it is a dictionary, functions are assigned to adapter layers based on the layer names. By default a language modeling setting is assumed where model_inputs are the outputs of `prepare_model_inputs_fn_language_modeling` which is a mask of indices. If this parameter is set to None, only two modifications are made to the layer inputs +- take the first element incase of a tuple or list. +- if the input has more than 2 dimensions, we flatten all but the last dimension. + +Must always return a tensor. The default logic is: +```python +def prepare_layer_inputs_fn_default(layer_input, model_input, layer_name) -> torch.Tensor: + if isinstance(layer_input, (tuple, list)): + layer_input = layer_input[0] + return layer_input[model_input.T.unbind()] +``` + +## Citation +In case you find our work useful, please consider citing it. + +``` +@article{paischer2024eva, + title={One Initialization to Rule them All: Fine-tuning via Explained Variance Adaptation}, + author={Fabian Paischer, Lukas Hauzenberger, Thomas Schmied, Benedikt Alkin, Marc Peter Deisenroth, Sepp Hochreiter}, + journal={arXiv preprint arXiv:2410.07170}, + year={2024} +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/eva_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/eva_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..4901770f0b58170fea3e2ecb9bb5fb6746d2be9e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/eva_finetuning.py @@ -0,0 +1,96 @@ +# Copyright 2024-present the HuggingFace Inc. team. +# +# 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 torch +from datasets import load_dataset +from torch.utils.data import DataLoader +from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments +from utils import DataCollator, TokenizerMetaMath + +from peft import EvaConfig, LoraConfig, get_peft_model, initialize_lora_eva_weights + + +DEVICE = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + +# config +model_name = "meta-llama/Llama-3.1-8B" +max_seq_len = 512 +rank = 16 +alpha = 1 +rho = 2.0 +target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"] +svd_batch_size = 4 # can be different from the batch size used in finetuning +batch_size = 4 +learning_rate = 5e-4 +gradient_accumulation_steps = 8 +num_epochs = 1 +output_dir = "outputs" +bf16 = True + + +# load model and tokenizer +model = AutoModelForCausalLM.from_pretrained(model_name) +tokenizer = AutoTokenizer.from_pretrained(model_name) + +# load dataset +dataset = load_dataset("meta-math/MetaMathQA") +dataset = dataset.map( + TokenizerMetaMath(model_name), + batched=True, + remove_columns=dataset["train"].column_names, +) +dataset.set_format(type="torch") + +# data collator +data_collator = DataCollator(tokenizer.eos_token_id, max_length=max_seq_len) + +# dataloader +dataloader = DataLoader( + dataset["train"], + batch_size=svd_batch_size, + collate_fn=data_collator, +) + +# setup peft config +eva_config = EvaConfig(rho=rho) +peft_config = LoraConfig( + r=rank, lora_alpha=alpha, target_modules=target_modules, init_lora_weights="eva", eva_config=eva_config +) + +# move model to accelerator +model = model.to(DEVICE) + +# to optimize memory usage during eva initialization, set low_cpu_mem_usage=True +peft_model = get_peft_model(model, peft_config, low_cpu_mem_usage=True) +initialize_lora_eva_weights(peft_model, dataloader) + +# setup training arguments +training_args = TrainingArguments( + per_device_train_batch_size=batch_size, + learning_rate=learning_rate, + gradient_accumulation_steps=gradient_accumulation_steps, + num_train_epochs=num_epochs, + output_dir=output_dir, + remove_unused_columns=False, + bf16=bf16, +) + +# continue with standard finetuning +trainer = Trainer( + model=peft_model, + args=training_args, + train_dataset=dataset["train"], + data_collator=data_collator, +) +trainer.train() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/eva_finetuning_multi_accelerator.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/eva_finetuning_multi_accelerator.py new file mode 100644 index 0000000000000000000000000000000000000000..8a77eb6e606f1a46e1cada8dd5f5f1dd446fdfe1 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/eva_finetuning_multi_accelerator.py @@ -0,0 +1,132 @@ +# Copyright 2024-present the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os + +import torch +import torch.distributed as dist +from datasets import load_dataset +from torch.nn.parallel import DistributedDataParallel as DDP +from torch.utils.data import DataLoader +from torch.utils.data.distributed import DistributedSampler +from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments +from utils import DataCollator, TokenizerMetaMath + +from peft import EvaConfig, LoraConfig, get_eva_state_dict, get_peft_model, initialize_lora_eva_weights + + +# run this script e.g. with: torchrun --nproc_per_node=4 eva_finetuning_multi_gpu.py + +# config +model_name = "meta-llama/Llama-2-7b-hf" +max_seq_len = 512 +rank = 16 +alpha = 1 +rho = 2.0 +target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"] +svd_batch_size = 4 # can be different from the batch size used in finetuning +batch_size = 4 +learning_rate = 5e-4 +gradient_accumulation_steps = 8 +num_epochs = 1 +output_dir = "outputs" +bf16 = True + + +# Initialize distributed environment +if torch.cuda.is_available(): + local_rank = int(os.environ.get("LOCAL_RANK", "-1")) + torch.cuda.set_device(local_rank) + dist.init_process_group("nccl") + world_size = dist.get_world_size() +elif torch.xpu.is_available(): + local_rank = int(os.environ.get("LOCAL_RANK", "-1")) + torch.xpu.set_device(local_rank) + dist.init_process_group("xccl") + world_size = dist.get_world_size() +else: + local_rank = -1 + world_size = 1 + + +# load model and tokenizer +model = AutoModelForCausalLM.from_pretrained(model_name) +tokenizer = AutoTokenizer.from_pretrained(model_name) + +# load dataset +dataset = load_dataset("meta-math/MetaMathQA") +dataset = dataset.map( + TokenizerMetaMath(model_name), + batched=True, + remove_columns=dataset["train"].column_names, +) +dataset.set_format(type="torch") + +# data collator +data_collator = DataCollator(tokenizer.eos_token_id, max_length=max_seq_len) + +# Create sampler for distributed training +sampler = DistributedSampler(dataset["train"], num_replicas=world_size, rank=local_rank) + +# dataloader +dataloader = DataLoader( + dataset["train"], + batch_size=svd_batch_size, + collate_fn=data_collator, + sampler=sampler, + shuffle=False, +) + +sampler.set_epoch(0) + +# Wrap model in DDP +model = model.to(local_rank) +model = DDP(model, device_ids=[local_rank], output_device=local_rank) + +# setup peft config +eva_config = EvaConfig(rho=rho) +peft_config = LoraConfig( + r=rank, lora_alpha=alpha, target_modules=target_modules, init_lora_weights="eva", eva_config=eva_config +) + +# EVA initialization +eva_state_dict = get_eva_state_dict(model, dataloader, peft_config) +eva_state_dict = {".".join(["base_model.model"] + k.split(".")[1:]): v for k, v in eva_state_dict.items()} + +# cleanup ddp +model = model.module + +# initialize peft model +peft_model = get_peft_model(model, peft_config, low_cpu_mem_usage=True) +initialize_lora_eva_weights(peft_model, eva_state_dict=eva_state_dict) + +# setup training arguments +training_args = TrainingArguments( + per_device_train_batch_size=batch_size, + learning_rate=learning_rate, + gradient_accumulation_steps=gradient_accumulation_steps, + num_train_epochs=num_epochs, + output_dir=output_dir, + remove_unused_columns=False, + bf16=bf16, +) + +# continue with standard finetuning +trainer = Trainer( + model=peft_model, + args=training_args, + train_dataset=dataset["train"], + data_collator=data_collator, +) +trainer.train() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/utils.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..df7f069a07e461e7851e9515cf912497ff28c310 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/eva_finetuning/utils.py @@ -0,0 +1,76 @@ +# Copyright 2024-present the HuggingFace Inc. team. +# +# 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 torch +from transformers import AutoTokenizer + + +class TokenizerMetaMath: + PROMPT_NO_INPUT = ( + "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n" + "### Instruction:\n{query}\n\n### Response: " + ) + PROMPT = ( + "Below is an instruction that describes a task, paired with an input that provides further context. " + "Write a response that appropriately completes the request.\n\n" + "### Instruction:\n{query}\n\n### Input:\n{input}\n\n### Response: " + ) + + def format_prompt(self, query): + query = query.split("\n", 1) + if len(query) == 1 or query[1].strip("\n") == "": + return self.PROMPT_NO_INPUT.format(query=query[0]) + else: + return self.PROMPT.format(query=query[0], input=query[1]) + + def __init__(self, tokenizer_path): + self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_path) + + def __call__(self, examples): + prompts = [self.format_prompt(text) for text in examples["query"]] + completions = examples["response"] + return self._tokenize_fn(prompts, completions) + + def _tokenize_fn(self, prompts, completions): + prompt_tokens = self.tokenizer(prompts, add_special_tokens=False)["input_ids"] + input_tokens = self.tokenizer([x + y for x, y in zip(prompts, completions)], add_special_tokens=False)[ + "input_ids" + ] + input_tokens = [[self.tokenizer.bos_token_id] + x + [self.tokenizer.eos_token_id] for x in input_tokens] + prompt_length = [len(x) + 1 for x in prompt_tokens] # +1 for the bos token + input_length = [len(x) for x in input_tokens] + return {"input_ids": input_tokens, "prompt_length": prompt_length, "input_length": input_length} + + +class DataCollator: + def __init__(self, eos_token_id, max_length=None): + self.eos_token_id = eos_token_id + self.max_length = max_length + + def __call__(self, batch): + batch = {k: [item[k] for item in batch] for k in batch[0]} + input_lengths = torch.stack(batch["input_length"]) + prompt_lengths = torch.stack(batch["prompt_length"]) + input_ids = torch.nn.utils.rnn.pad_sequence( + batch["input_ids"], batch_first=True, padding_value=self.eos_token_id + ) + col_indices = torch.arange(input_ids.size(1)).unsqueeze(0) + attention_mask = col_indices < input_lengths.unsqueeze(1) + label_mask = torch.logical_or(col_indices < prompt_lengths.unsqueeze(1), ~attention_mask) + labels = input_ids.masked_fill(label_mask, -100) + if self.max_length is not None: + input_ids = input_ids[:, : self.max_length] + attention_mask = attention_mask[:, : self.max_length] + labels = labels[:, : self.max_length] + return {"input_ids": input_ids, "attention_mask": attention_mask, "labels": labels} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/evaluation/lora-lm-eval.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/evaluation/lora-lm-eval.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..253c6da49b9a3346f3a8e27c6c83282f57efadb3 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/evaluation/lora-lm-eval.ipynb @@ -0,0 +1,4252 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "qAkXdLL2D25p" + }, + "source": [ + "## Peft model evaluation using [lm-eval-harness](https://github.com/EleutherAI/lm-evaluation-harness)\n", + "\n", + "In this notebook, we are going to learn how to evaluate the finetuned lora model on the hellaswag task using lm-eval-harness toolkit." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "o52TJHcYD25q", + "outputId": "c5482c79-ff56-4ffa-d20c-46c3d30d2cd5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33m DEPRECATION: Building 'rouge-score' using the legacy setup.py bdist_wheel mechanism, which will be removed in a future version. pip 25.3 will enforce this behaviour change. A possible replacement is to use the standardized build interface by setting the `--use-pep517` option, (possibly combined with `--no-build-isolation`), or adding a `pyproject.toml` file to the source tree of 'rouge-score'. Discussion can be found at https://github.com/pypa/pip/issues/6334\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33m DEPRECATION: Building 'sqlitedict' using the legacy setup.py bdist_wheel mechanism, which will be removed in a future version. pip 25.3 will enforce this behaviour change. A possible replacement is to use the standardized build interface by setting the `--use-pep517` option, (possibly combined with `--no-build-isolation`), or adding a `pyproject.toml` file to the source tree of 'sqlitedict'. Discussion can be found at https://github.com/pypa/pip/issues/6334\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33m DEPRECATION: Building 'word2number' using the legacy setup.py bdist_wheel mechanism, which will be removed in a future version. pip 25.3 will enforce this behaviour change. A possible replacement is to use the standardized build interface by setting the `--use-pep517` option, (possibly combined with `--no-build-isolation`), or adding a `pyproject.toml` file to the source tree of 'word2number'. Discussion can be found at https://github.com/pypa/pip/issues/6334\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.\u001b[0m\u001b[33m\n", + "\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.1.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.2\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython3 -m pip install --upgrade pip\u001b[0m\n" + ] + } + ], + "source": [ + "# Install LM-Eval\n", + "!pip install -q datasets evaluate lm_eval" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uhUflrJXD25q" + }, + "source": [ + "### First we will check the accuracy score on the hellaswag task for the base bert without finetuning" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hwJIYD5KD25q", + "outputId": "51e69f81-d048-46b2-9699-658d3ffc5f08" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "If you want to use `BertLMHeadModel` as a standalone, add `is_decoder=True.`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7b1ea8948a0747bc98795d6459270044", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "README.md: 0.00B [00:00, ?B/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4ec51e06812446899b66826c41697f8d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "data/train-00000-of-00001.parquet: 0%| | 0.00/24.4M [00:00\n", + " \n", + " \n", + " [3910/3910 40:13, Epoch 5/5]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EpochTraining LossValidation LossAccuracy
10.3538000.2612580.901160
20.2774000.2216510.912480
30.2445000.2161070.918200
40.1970000.2152570.920040
50.1577000.2150500.923240

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7298a140779d4fd88a65a191af265821", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading builder script: 0.00B [00:00, ?B/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3c6b99b4b5854527a8b34b92a8d2986b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading builder script: 0.00B [00:00, ?B/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=3910, training_loss=0.24082870385835847, metrics={'train_runtime': 2416.0772, 'train_samples_per_second': 51.737, 'train_steps_per_second': 1.618, 'total_flos': 3.300271872e+16, 'train_loss': 0.24082870385835847, 'epoch': 5.0})" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Configure training arguments\n", + "training_args = TrainingArguments(\"bert-lora-imdb\",\n", + " eval_strategy=\"epoch\",\n", + " per_device_train_batch_size=32, # decrease this for OOM error\n", + " per_device_eval_batch_size=64,\n", + " save_strategy=\"epoch\",\n", + " learning_rate=2e-3,\n", + " num_train_epochs=5,\n", + " weight_decay=0.01,\n", + " load_best_model_at_end=True,\n", + " do_eval=True,\n", + " do_predict=True,\n", + " metric_for_best_model=\"accuracy\",\n", + " report_to=\"none\")\n", + "\n", + "# Initialize the Trainer for the model training loop\n", + "trainer = Trainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=train_dataset,\n", + " eval_dataset=eval_dataset,\n", + " compute_metrics=compute_metrics,\n", + ")\n", + "\n", + "#start training\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "34h3g_eED25s" + }, + "source": [ + "### Now take the finetuned lora checkpoint and check the accuracy score on hellaswag task." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7tgAq7nLD25s" + }, + "outputs": [], + "source": [ + "# use the path of your checkpoint here\n", + "output = lm_eval.simple_evaluate(model = 'hf',\n", + " model_args = {\n", + " 'pretrained' : 'bert-base-cased',\n", + " 'peft' : './bert-lora-imdb/checkpoint-3910',\n", + " 'dtype' : 'bfloat16'},\n", + " tasks = 'hellaswag',\n", + " device = device,\n", + " batch_size = 128,\n", + " log_samples = False)\n", + "\n", + "output[\"results\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kaggle": { + "accelerator": "nvidiaTeslaT4", + "dataSources": [], + "dockerImageVersionId": 30787, + "isGpuEnabled": true, + "isInternetEnabled": true, + "language": "python", + "sourceType": "notebook" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "00a9858d90d6430eaab54f9e013f077b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "03f7cfca9e634cf69e3cc70f24832ba3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_886443acd2f14cff93059c093f98cc1b", + "placeholder": "​", + "style": "IPY_MODEL_24abe5089abc4ecfab75f7601bc98e68", + "value": " 25000/25000 [00:25<00:00, 1037.33 examples/s]" + } + }, + "0649702ad9764ad8bf3dfbaa6739686e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0bee940b8667495f9e685f7ba6c3706f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0dc109378f1c43a7b18b1be03cce32ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_db789da312a24fc9944ecb8b617109e7", + "placeholder": "​", + "style": "IPY_MODEL_0bee940b8667495f9e685f7ba6c3706f", + "value": " 7.81k/7.81k [00:00<00:00, 580kB/s]" + } + }, + "10335d3ada7f428588c4faa3f57bbd51": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "122d7dd4d02d4df0b6573e100b5e46e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_db0b4bb4c7a642fb9e8d5c7738e90afc", + "IPY_MODEL_f8b71d5cb37549fba6559e2d83531319", + "IPY_MODEL_30d18e09421b42c985904750e68740d1" + ], + "layout": "IPY_MODEL_f67b5bbf7ccb475abe41e08316dc5b37" + } + }, + "15dc2c4e42ab48c9ad09aafff29f9278": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1fea1738e9fe48629b09e2ec9351fcd2", + "IPY_MODEL_2e2fc856557e40df8400e4b69f7143fc", + "IPY_MODEL_bce88474ca6745da99d79bc07216333c" + ], + "layout": "IPY_MODEL_99bab394a68140f79def33bc6f6499b2" + } + }, + "16afa8cf9ca64a59afd7a4c4f293b479": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17c7d8bb89184c26966a33dc27ef5517": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1882e91f0b264cbeb90b99a69c7de7f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8e862faf12804eaebfd7692db348842b", + "placeholder": "​", + "style": "IPY_MODEL_7812641b79ae46d48bc88b4c773344c0", + "value": " 21.0M/21.0M [00:00<00:00, 189MB/s]" + } + }, + "1c07d8f701604da0989d5f8d88d4bbcd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f8d90231390a4211b698e700a66fcb0f", + "placeholder": "​", + "style": "IPY_MODEL_aa7697dbb00641f19491f13b1a643197", + "value": " 50000/50000 [00:00<00:00, 142668.00 examples/s]" + } + }, + "1dfc470241c44ce1a0f9ae71fdfdbdf6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_da7f0a799616427ba7e93b0080d26d37", + "placeholder": "​", + "style": "IPY_MODEL_9931cc064e2c400e9830e448c8ef4655", + "value": " 20.5M/20.5M [00:00<00:00, 214MB/s]" + } + }, + "1fea1738e9fe48629b09e2ec9351fcd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_60695bb251124317a897a6fc56b754ac", + "placeholder": "​", + "style": "IPY_MODEL_d0582455fe3c449dbde19a47561770b4", + "value": "Generating train split: 100%" + } + }, + "20cd23dc1cd840c89741957f3fcbfdb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_16afa8cf9ca64a59afd7a4c4f293b479", + "max": 50000, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4a025adc548b4fcb8c5637f8f6dabc81", + "value": 50000 + } + }, + "24abe5089abc4ecfab75f7601bc98e68": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "24cbed7481774ef793a8f204ba5b604b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2bbd92cebbf445d087bcadf82625c6d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2be4c676b5834100b31d7f42ab8bab85": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2cd718fb166641d59c8df64cbc637d9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2d2adb2b7a3b41d28736a8b7aba258b1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d46765961fe453597645a0b56a9cbc7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d76c76bc4a6433b8fe2b28a1c887ada": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_31aa04d4f32a411293f2f729889984b8", + "IPY_MODEL_87de47c8821f423d9efc5c7e85297e32", + "IPY_MODEL_5f0dfd26cb484695b85d021a5d687503" + ], + "layout": "IPY_MODEL_d1414b66bc0f4a088c5e4551e8f4ee72" + } + }, + "2e2fc856557e40df8400e4b69f7143fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_92b9e59f9038485e839598237ec3fd8c", + "max": 25000, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d69df0074246435f8481fd803863cdb1", + "value": 25000 + } + }, + "30d18e09421b42c985904750e68740d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_71a7cf52600f4288bd725b7bb93e7299", + "placeholder": "​", + "style": "IPY_MODEL_e3082a5e8a4144f5982ad478d9a54a2c", + "value": " 50000/50000 [00:44<00:00, 1214.24 examples/s]" + } + }, + "3142f29a154c4a33a161237d4c605c50": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9b39cdb9f7a14ab4865f360f3c1537dc", + "IPY_MODEL_798c00bf640e483cbc4fea744b268461", + "IPY_MODEL_1882e91f0b264cbeb90b99a69c7de7f5" + ], + "layout": "IPY_MODEL_17c7d8bb89184c26966a33dc27ef5517" + } + }, + "31664fd452bb43e3aefb87542c747b74": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "31aa04d4f32a411293f2f729889984b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_da58efd0f2b5442c8a284a948f2614f8", + "placeholder": "​", + "style": "IPY_MODEL_2cd718fb166641d59c8df64cbc637d9c", + "value": "Map: 100%" + } + }, + "31bad1f4c7c047a280d490b854a6e911": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "336ffca0a89e4255a62564ec2600318c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34f8bcc1d9954fb8ba8ecca7a6bd04cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_336ffca0a89e4255a62564ec2600318c", + "max": 25000, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2bbd92cebbf445d087bcadf82625c6d5", + "value": 25000 + } + }, + "38fd040b3a0d44d2adf13c2476f4505a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a9548c2f9fd54f73abc3e9c3c0bc9fda", + "placeholder": "​", + "style": "IPY_MODEL_faa9b111dd9745a29bf7494b95619a1b", + "value": "test-00000-of-00001.parquet: 100%" + } + }, + "3a99edeb7d5e43048fdce29b880c19a5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_81eef7f1d0c7461cb443b996a5d5163f", + "max": 20470363, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b832fdc7655b4f88a15e19fc8381db47", + "value": 20470363 + } + }, + "3cc5521074d3411cbc24d0348d3fc314": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3d6b95a9f8774341be1976f10fb74679": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3ec913f1b93d4097ad9729156295f9e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "404088a4057546968f4e8cfc9e7461e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "47789088bcfa4c96a5fd898812c23d17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8ac5b5baeefb4078a74d8c8b2fed6d93", + "placeholder": "​", + "style": "IPY_MODEL_4bbb4bf49e50489abc875881958c00aa", + "value": "Map: 100%" + } + }, + "4a025adc548b4fcb8c5637f8f6dabc81": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4bbb4bf49e50489abc875881958c00aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4c55b2c1daa4497abf9c9f53e23f83b8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4f7b2a1359bf41cab2ed5663643509a6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4fe02a8771814e22b8d954cfdd8b9f86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d52e5c49b80348fbb55ab39ce0a13f7e", + "IPY_MODEL_51f4dabc59d04f0c89128d41d4c184a1", + "IPY_MODEL_803fcea81b7b47fb91fb108e2170fa75" + ], + "layout": "IPY_MODEL_ee5722120e1045e985e5e4ca29a2e192" + } + }, + "51f4dabc59d04f0c89128d41d4c184a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3d6b95a9f8774341be1976f10fb74679", + "max": 41996509, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3ec913f1b93d4097ad9729156295f9e9", + "value": 41996509 + } + }, + "55cab288802d49efb930c7641b036f44": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "568c0efe6ced432d81f45af4acaa921e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "580a3b71b23f4a72be9e8633c04e9276": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5b346ce1eaf649d195fa7dd6058dd196", + "max": 25000, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d7b4684e53d445e58de1fe155315e093", + "value": 25000 + } + }, + "5b346ce1eaf649d195fa7dd6058dd196": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5ce04c799bb0430386e39af4734e80e6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5f0dfd26cb484695b85d021a5d687503": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b1c37874948c459583a9f33dc77a6f55", + "placeholder": "​", + "style": "IPY_MODEL_24cbed7481774ef793a8f204ba5b604b", + "value": " 25000/25000 [00:23<00:00, 1166.56 examples/s]" + } + }, + "60695bb251124317a897a6fc56b754ac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6eea630bd65745739ff646fbb172f426": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "716d24b9c1b340a2bf9045b0bf4e7e34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_47789088bcfa4c96a5fd898812c23d17", + "IPY_MODEL_580a3b71b23f4a72be9e8633c04e9276", + "IPY_MODEL_03f7cfca9e634cf69e3cc70f24832ba3" + ], + "layout": "IPY_MODEL_987a633e24594228b82e162397a63141" + } + }, + "71a7cf52600f4288bd725b7bb93e7299": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7812641b79ae46d48bc88b4c773344c0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7823f9d79e1d4350b385e6dfef84b021": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c006e4b791204d10a9d8e7fbc4bceb81", + "placeholder": "​", + "style": "IPY_MODEL_31664fd452bb43e3aefb87542c747b74", + "value": "Generating unsupervised split: 100%" + } + }, + "798c00bf640e483cbc4fea744b268461": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d406b18b855d488cac92b9b96073ba43", + "max": 20979968, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_eee89779493748d38c01bb0a74b29e38", + "value": 20979968 + } + }, + "7f78e58f4e9c457a9c2d121759efdb09": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f1574df0debf4e1b8617e24ffcc39e16", + "placeholder": "​", + "style": "IPY_MODEL_a9cbf2bbb1f14894886617ce8e60de12", + "value": " 25000/25000 [00:00<00:00, 104177.91 examples/s]" + } + }, + "803fcea81b7b47fb91fb108e2170fa75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b29cde97f90f4c489c5cdfd007c96d4f", + "placeholder": "​", + "style": "IPY_MODEL_d8c8ee9f63b14182a9ded152435c510f", + "value": " 42.0M/42.0M [00:00<00:00, 163MB/s]" + } + }, + "806a2b3f4c4c4ba59370a46c0f8faa85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_38fd040b3a0d44d2adf13c2476f4505a", + "IPY_MODEL_3a99edeb7d5e43048fdce29b880c19a5", + "IPY_MODEL_1dfc470241c44ce1a0f9ae71fdfdbdf6" + ], + "layout": "IPY_MODEL_feb83525a43a4c2d818f3ef1ae69d581" + } + }, + "81eef7f1d0c7461cb443b996a5d5163f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87de47c8821f423d9efc5c7e85297e32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2be4c676b5834100b31d7f42ab8bab85", + "max": 25000, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6eea630bd65745739ff646fbb172f426", + "value": 25000 + } + }, + "886443acd2f14cff93059c093f98cc1b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ac5b5baeefb4078a74d8c8b2fed6d93": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8e862faf12804eaebfd7692db348842b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8fcd7e9ed5f54287b5cda0ad52a277f4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "92b9e59f9038485e839598237ec3fd8c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93dd1cc84f26479caaa1ded80bbea5ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b3cde05a07b2437b935083d6aac25913", + "max": 7809, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_31bad1f4c7c047a280d490b854a6e911", + "value": 7809 + } + }, + "987a633e24594228b82e162397a63141": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9931cc064e2c400e9830e448c8ef4655": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "99bab394a68140f79def33bc6f6499b2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b39cdb9f7a14ab4865f360f3c1537dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_55cab288802d49efb930c7641b036f44", + "placeholder": "​", + "style": "IPY_MODEL_0649702ad9764ad8bf3dfbaa6739686e", + "value": "train-00000-of-00001.parquet: 100%" + } + }, + "9b4b309603db4847a0d94da76db15116": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_568c0efe6ced432d81f45af4acaa921e", + "placeholder": "​", + "style": "IPY_MODEL_f402e8e510d64d0ca4d4ae2c09a7ddfc", + "value": "README.md: 100%" + } + }, + "a9548c2f9fd54f73abc3e9c3c0bc9fda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a9cbf2bbb1f14894886617ce8e60de12": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aa7697dbb00641f19491f13b1a643197": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b1c37874948c459583a9f33dc77a6f55": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b29cde97f90f4c489c5cdfd007c96d4f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b3cde05a07b2437b935083d6aac25913": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b832fdc7655b4f88a15e19fc8381db47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bce88474ca6745da99d79bc07216333c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3cc5521074d3411cbc24d0348d3fc314", + "placeholder": "​", + "style": "IPY_MODEL_4c55b2c1daa4497abf9c9f53e23f83b8", + "value": " 25000/25000 [00:00<00:00, 113831.51 examples/s]" + } + }, + "c006e4b791204d10a9d8e7fbc4bceb81": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d0582455fe3c449dbde19a47561770b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d1414b66bc0f4a088c5e4551e8f4ee72": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d406b18b855d488cac92b9b96073ba43": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d52e5c49b80348fbb55ab39ce0a13f7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8fcd7e9ed5f54287b5cda0ad52a277f4", + "placeholder": "​", + "style": "IPY_MODEL_10335d3ada7f428588c4faa3f57bbd51", + "value": "unsupervised-00000-of-00001.parquet: 100%" + } + }, + "d69df0074246435f8481fd803863cdb1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d7b4684e53d445e58de1fe155315e093": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d8c8ee9f63b14182a9ded152435c510f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "da58efd0f2b5442c8a284a948f2614f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "da7f0a799616427ba7e93b0080d26d37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "db0b4bb4c7a642fb9e8d5c7738e90afc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0e6445a2a774ae89729b7e2fb4a14b3", + "placeholder": "​", + "style": "IPY_MODEL_fdd99c599f9c4ac88c09939ec397ca46", + "value": "Map: 100%" + } + }, + "db1b2639fc4944bcbbdfbdaf9150409f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "db789da312a24fc9944ecb8b617109e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0e6445a2a774ae89729b7e2fb4a14b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e3082a5e8a4144f5982ad478d9a54a2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e85940da7bc24b8bb29ce609ba6e5613": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4f7b2a1359bf41cab2ed5663643509a6", + "placeholder": "​", + "style": "IPY_MODEL_db1b2639fc4944bcbbdfbdaf9150409f", + "value": "Generating test split: 100%" + } + }, + "ebf724c3ad1443e98763dd279e6fc996": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9b4b309603db4847a0d94da76db15116", + "IPY_MODEL_93dd1cc84f26479caaa1ded80bbea5ff", + "IPY_MODEL_0dc109378f1c43a7b18b1be03cce32ce" + ], + "layout": "IPY_MODEL_2d2adb2b7a3b41d28736a8b7aba258b1" + } + }, + "ee5722120e1045e985e5e4ca29a2e192": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eee89779493748d38c01bb0a74b29e38": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f1574df0debf4e1b8617e24ffcc39e16": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f402e8e510d64d0ca4d4ae2c09a7ddfc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f4d35fb98b0048ca8bdbe856d182d561": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e85940da7bc24b8bb29ce609ba6e5613", + "IPY_MODEL_34f8bcc1d9954fb8ba8ecca7a6bd04cd", + "IPY_MODEL_7f78e58f4e9c457a9c2d121759efdb09" + ], + "layout": "IPY_MODEL_2d46765961fe453597645a0b56a9cbc7" + } + }, + "f67b5bbf7ccb475abe41e08316dc5b37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f8b71d5cb37549fba6559e2d83531319": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5ce04c799bb0430386e39af4734e80e6", + "max": 50000, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_404088a4057546968f4e8cfc9e7461e1", + "value": 50000 + } + }, + "f8d90231390a4211b698e700a66fcb0f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "faa9b111dd9745a29bf7494b95619a1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fdd4b9937b7744d98ba1163efbe1310b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7823f9d79e1d4350b385e6dfef84b021", + "IPY_MODEL_20cd23dc1cd840c89741957f3fcbfdb8", + "IPY_MODEL_1c07d8f701604da0989d5f8d88d4bbcd" + ], + "layout": "IPY_MODEL_00a9858d90d6430eaab54f9e013f077b" + } + }, + "fdd99c599f9c4ac88c09939ec397ca46": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "feb83525a43a4c2d818f3ef1ae69d581": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/feature_extraction/peft_lora_embedding_semantic_search.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/feature_extraction/peft_lora_embedding_semantic_search.py new file mode 100644 index 0000000000000000000000000000000000000000..8ed8babb7ea00acf556d16e3abc60c85d650f3d9 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/feature_extraction/peft_lora_embedding_semantic_search.py @@ -0,0 +1,502 @@ +# Copyright 2023-present the HuggingFace Inc. team. +# +# 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 argparse +import logging +import math +import os +import random +from pathlib import Path + +import datasets +import evaluate +import torch +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import set_seed +from datasets import DatasetDict, load_dataset +from huggingface_hub import HfApi +from torch import nn +from torch.utils.data import DataLoader +from tqdm import tqdm +from transformers import AutoModel, AutoTokenizer, SchedulerType, default_data_collator, get_scheduler + +from peft import LoraConfig, TaskType, get_peft_model + + +logger = get_logger(__name__) + + +def parse_args(): + parser = argparse.ArgumentParser(description="Training a PEFT model for Semantic Search task") + parser.add_argument("--dataset_name", type=str, default=None, help="dataset name on HF hub") + parser.add_argument( + "--max_length", + type=int, + default=128, + help=( + "The maximum total input sequence length after tokenization. Sequences longer than this will be truncated," + " sequences shorter will be padded if `--pad_to_max_length` is passed." + ), + ) + parser.add_argument( + "--model_name_or_path", + type=str, + help="Path to pretrained model or model identifier from huggingface.co/models.", + required=True, + ) + parser.add_argument( + "--per_device_train_batch_size", + type=int, + default=8, + help="Batch size (per device) for the training dataloader.", + ) + parser.add_argument( + "--per_device_eval_batch_size", + type=int, + default=8, + help="Batch size (per device) for the evaluation dataloader.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=5e-5, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument("--weight_decay", type=float, default=0.0, help="Weight decay to use.") + parser.add_argument("--num_train_epochs", type=int, default=3, help="Total number of training epochs to perform.") + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--lr_scheduler_type", + type=SchedulerType, + default="linear", + help="The scheduler type to use.", + choices=["linear", "cosine", "cosine_with_restarts", "polynomial", "constant", "constant_with_warmup"], + ) + parser.add_argument( + "--num_warmup_steps", type=int, default=0, help="Number of steps for the warmup in the lr scheduler." + ) + parser.add_argument("--output_dir", type=str, default=None, help="Where to store the final model.") + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.") + parser.add_argument( + "--hub_model_id", type=str, help="The name of the repository to keep in sync with the local `output_dir`." + ) + parser.add_argument("--hub_token", type=str, help="The token to use to push to the Model Hub.") + parser.add_argument( + "--checkpointing_steps", + type=str, + default=None, + help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.", + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help="If the training should continue from a checkpoint folder.", + ) + parser.add_argument( + "--with_tracking", + action="store_true", + help="Whether to enable experiment trackers for logging.", + ) + parser.add_argument( + "--report_to", + type=str, + default="all", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`,' + ' `"wandb"`, `"comet_ml"` and `"clearml"`. Use `"all"` (default) to report to all integrations.' + "Only applicable when `--with_tracking` is passed." + ), + ) + parser.add_argument( + "--sanity_test", + action="store_true", + help="Whether to enable sanity test.", + ) + parser.add_argument( + "--use_peft", + action="store_true", + help="Whether to use PEFT.", + ) + args = parser.parse_args() + + if args.push_to_hub: + assert args.output_dir is not None, "Need an `output_dir` to create a repo when `--push_to_hub` is passed." + + return args + + +def save_model_hook(models, weights, output_dir): + for i, model in enumerate(models): + model.save_pretrained(output_dir, state_dict=weights[i]) + # make sure to pop weight so that corresponding model is not saved again + weights.pop() + + +def load_model_hook(models, input_dir): + while len(models) > 0: + model = models.pop() + # pop models so that they are not loaded again + if hasattr(model, "active_adapter") and hasattr(model, "load_adapter"): + model.load_adapter(input_dir, model.active_adapter, is_trainable=True) + + +class AutoModelForSentenceEmbedding(nn.Module): + def __init__(self, model_name, tokenizer, normalize=True): + super().__init__() + + self.model = AutoModel.from_pretrained( + model_name + ) # , quantizaton_config=BitsAndBytesConfig(load_in_8bit=True), device_map={"":0}) + self.normalize = normalize + self.tokenizer = tokenizer + + def forward(self, **kwargs): + model_output = self.model(**kwargs) + embeddings = self.mean_pooling(model_output, kwargs["attention_mask"]) + if self.normalize: + embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1) + + return embeddings + + def mean_pooling(self, model_output, attention_mask): + token_embeddings = model_output[0] # First element of model_output contains all token embeddings + input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float() + return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9) + + def __getattr__(self, name: str): + """Forward missing attributes to the wrapped module.""" + try: + return super().__getattr__(name) # defer to nn.Module's logic + except AttributeError: + if name == "model": # see #1892: prevent infinite recursion if class is not initialized + raise + return getattr(self.model, name) + + +def get_cosing_embeddings(query_embs, product_embs): + return torch.sum(query_embs * product_embs, axis=1) + + +def get_loss(cosine_score, labels): + return torch.mean(torch.square(labels * (1 - cosine_score) + torch.clamp((1 - labels) * cosine_score, min=0.0))) + + +def main(): + args = parse_args() + + accelerator_kwargs = {"gradient_accumulation_steps": args.gradient_accumulation_steps} + if args.with_tracking: + accelerator_kwargs["log_with"] = args.report_to + accelerator_kwargs["project_dir"] = args.output_dir + accelerator = Accelerator(**accelerator_kwargs) + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + datasets.utils.logging.set_verbosity_warning() + transformers.utils.logging.set_verbosity_info() + else: + datasets.utils.logging.set_verbosity_error() + transformers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + set_seed(args.seed) + + # Handle the repository creation + if accelerator.is_main_process: + if args.push_to_hub: + api = HfApi(token=args.hub_token) + + # Create repo (repo_name from args or inferred) + repo_name = args.hub_model_id + if repo_name is None: + repo_name = Path(args.output_dir).absolute().name + repo_id = api.create_repo(repo_name, exist_ok=True).repo_id + + with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore: + if "step_*" not in gitignore: + gitignore.write("step_*\n") + if "epoch_*" not in gitignore: + gitignore.write("epoch_*\n") + elif args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + accelerator.wait_for_everyone() + + # get the tokenizer + tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path) + + # dataset download and preprocessing + if args.sanity_test: + train_dataset = load_dataset("smangrul/amazon_esci", split="train[:1024]") + val_dataset = load_dataset("smangrul/amazon_esci", split="validation[:1024]") + + dataset = DatasetDict({"train": train_dataset, "validation": val_dataset}) + else: + dataset = load_dataset(args.dataset_name, revision="main") + + def preprocess_function(examples): + queries = examples["query"] + result = tokenizer(queries, padding="max_length", max_length=70, truncation=True) + result = {f"query_{k}": v for k, v in result.items()} + + products = examples["product_title"] + result_products = tokenizer(products, padding="max_length", max_length=70, truncation=True) + for k, v in result_products.items(): + result[f"product_{k}"] = v + + result["labels"] = examples["relevance_label"] + return result + + processed_datasets = dataset.map( + preprocess_function, + batched=True, + remove_columns=dataset["train"].column_names, + desc="Running tokenizer on dataset", + ) + + # Log a few random samples from the training set: + for index in random.sample(range(len(processed_datasets["train"])), 3): + logger.info(f"Sample {index} of the training set: {processed_datasets['train'][index]}.") + + # base model + model = AutoModelForSentenceEmbedding(args.model_name_or_path, tokenizer) + + if args.use_peft: + # peft config and wrapping + peft_config = LoraConfig( + r=8, + lora_alpha=16, + bias="none", + task_type=TaskType.FEATURE_EXTRACTION, + target_modules=["key", "query", "value"], + ) + model = get_peft_model(model, peft_config) + model.print_trainable_parameters() + + accelerator.print(model) + + # get dataloaders + train_dataloader = DataLoader( + processed_datasets["train"], + shuffle=True, + collate_fn=default_data_collator, + batch_size=args.per_device_train_batch_size, + pin_memory=True, + ) + + eval_dataloader = DataLoader( + processed_datasets["validation"], + shuffle=False, + collate_fn=default_data_collator, + batch_size=args.per_device_eval_batch_size, + pin_memory=True, + ) + + optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate) + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + name=args.lr_scheduler_type, + optimizer=optimizer, + num_warmup_steps=args.num_warmup_steps, + num_training_steps=args.max_train_steps, + ) + + # Prepare everything with our `accelerator`. + model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare( + model, optimizer, train_dataloader, eval_dataloader, lr_scheduler + ) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # Figure out how many steps we should save the Accelerator states + checkpointing_steps = args.checkpointing_steps + if checkpointing_steps is not None and checkpointing_steps.isdigit(): + checkpointing_steps = int(checkpointing_steps) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if args.with_tracking: + experiment_config = vars(args) + # TensorBoard cannot log Enums, need the raw value + experiment_config["lr_scheduler_type"] = experiment_config["lr_scheduler_type"].value + accelerator.init_trackers("peft_semantic_search", experiment_config) + + metric = evaluate.load("roc_auc") + + total_batch_size = args.per_device_train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + + if args.use_peft: + # saving and loading checkpoints for resuming training + accelerator.register_save_state_pre_hook(save_model_hook) + accelerator.register_load_state_pre_hook(load_model_hook) + + logger.info("***** Running training *****") + logger.info(f" Num examples = {len(processed_datasets['train'])}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.per_device_train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {args.max_train_steps}") + + # Only show the progress bar once on each machine. + progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process) + completed_steps = 0 + starting_epoch = 0 + # Potentially load in the weights and states from a previous save + if args.resume_from_checkpoint: + if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "": + accelerator.print(f"Resumed from checkpoint: {args.resume_from_checkpoint}") + accelerator.load_state(args.resume_from_checkpoint) + path = os.path.basename(args.resume_from_checkpoint) + else: + # Get the most recent checkpoint + dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()] + dirs.sort(key=os.path.getctime) + path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last + # Extract `epoch_{i}` or `step_{i}` + training_difference = os.path.splitext(path)[0] + + if "epoch" in training_difference: + starting_epoch = int(training_difference.replace("epoch_", "")) + 1 + resume_step = None + completed_steps = starting_epoch * num_update_steps_per_epoch + else: + # need to multiply `gradient_accumulation_steps` to reflect real steps + resume_step = int(training_difference.replace("step_", "")) * args.gradient_accumulation_steps + starting_epoch = resume_step // len(train_dataloader) + resume_step -= starting_epoch * len(train_dataloader) + completed_steps = resume_step // args.gradient_accumulation_steps + + # update the progress_bar if load from checkpoint + progress_bar.update(completed_steps) + + for epoch in range(starting_epoch, args.num_train_epochs): + model.train() + total_loss = 0 + if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None: + # We skip the first `n` batches in the dataloader when resuming from a checkpoint + active_dataloader = accelerator.skip_first_batches(train_dataloader, resume_step) + else: + active_dataloader = train_dataloader + for step, batch in enumerate(active_dataloader): + with accelerator.accumulate(model): + query_embs = model(**{k.replace("query_", ""): v for k, v in batch.items() if "query" in k}) + product_embs = model(**{k.replace("product_", ""): v for k, v in batch.items() if "product" in k}) + loss = get_loss(get_cosing_embeddings(query_embs, product_embs), batch["labels"]) + total_loss += accelerator.reduce(loss.detach().float(), reduction="sum") + accelerator.backward(loss) + optimizer.step() + lr_scheduler.step() + model.zero_grad() + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + completed_steps += 1 + + if (step + 1) % 100 == 0: + logger.info(f"Step: {step + 1}, Loss: {total_loss / (step + 1)}") + if args.with_tracking: + accelerator.log({"train/loss": total_loss / (step + 1)}, step=completed_steps) + + if isinstance(checkpointing_steps, int): + if completed_steps % checkpointing_steps == 0: + output_dir = f"step_{completed_steps}" + if args.output_dir is not None: + output_dir = os.path.join(args.output_dir, output_dir) + accelerator.save_state(output_dir) + + if completed_steps >= args.max_train_steps: + break + + model.eval() + for step, batch in enumerate(eval_dataloader): + with torch.no_grad(): + query_embs = model(**{k.replace("query_", ""): v for k, v in batch.items() if "query" in k}) + product_embs = model(**{k.replace("product_", ""): v for k, v in batch.items() if "product" in k}) + prediction_scores = get_cosing_embeddings(query_embs, product_embs) + prediction_scores, references = accelerator.gather_for_metrics((prediction_scores, batch["labels"])) + metric.add_batch( + prediction_scores=prediction_scores, + references=references, + ) + + result = metric.compute() + result = {f"eval/{k}": v for k, v in result.items()} + # Use accelerator.print to print only on the main process. + accelerator.print(f"epoch {epoch}:", result) + if args.with_tracking: + result["train/epoch_loss"] = total_loss.item() / len(train_dataloader) + accelerator.log(result, step=completed_steps) + + if args.output_dir is not None: + accelerator.wait_for_everyone() + if accelerator.is_main_process: + if isinstance(checkpointing_steps, str): + accelerator.save_state(os.path.join(args.output_dir, f"epoch_{epoch}")) + accelerator.unwrap_model(model).save_pretrained( + args.output_dir, state_dict=accelerator.get_state_dict(accelerator.unwrap_model(model)) + ) + tokenizer.save_pretrained(args.output_dir) + if args.push_to_hub: + commit_message = ( + f"Training in progress epoch {epoch}" + if epoch < args.num_train_epochs - 1 + else "End of training" + ) + api.upload_folder( + repo_id=repo_id, + folder_path=args.output_dir, + commit_message=commit_message, + run_as_future=True, + ) + accelerator.wait_for_everyone() + accelerator.end_training() + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/feature_extraction/peft_lora_embedding_semantic_similarity_inference.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/feature_extraction/peft_lora_embedding_semantic_similarity_inference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..ded221bbce4417334a5129e6e1deb1cd6859347f --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/feature_extraction/peft_lora_embedding_semantic_similarity_inference.ipynb @@ -0,0 +1,1808 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "3e7b6247", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-06-29 09:08:24,868] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "\n", + "===================================BUG REPORT===================================\n", + "Welcome to bitsandbytes. For bug reports, please run\n", + "\n", + "python -m bitsandbytes\n", + "\n", + " and submit this information together with your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n", + "================================================================================\n", + "bin /home/sourab/miniconda3/envs/ml/lib/python3.11/site-packages/bitsandbytes/libbitsandbytes_cuda118.so\n", + "CUDA SETUP: CUDA runtime path found: /home/sourab/miniconda3/envs/ml/lib/libcudart.so\n", + "CUDA SETUP: Highest compute capability among GPUs detected: 7.5\n", + "CUDA SETUP: Detected CUDA version 118\n", + "CUDA SETUP: Loading binary /home/sourab/miniconda3/envs/ml/lib/python3.11/site-packages/bitsandbytes/libbitsandbytes_cuda118.so...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sourab/miniconda3/envs/ml/lib/python3.11/site-packages/bitsandbytes/cuda_setup/main.py:149: UserWarning: Found duplicate ['libcudart.so', 'libcudart.so.11.0', 'libcudart.so.12.0'] files: {PosixPath('/home/sourab/miniconda3/envs/ml/lib/libcudart.so'), PosixPath('/home/sourab/miniconda3/envs/ml/lib/libcudart.so.11.0')}.. We'll flip a coin and try one of these, in order to fail forward.\n", + "Either way, this might cause trouble in the future:\n", + "If you get `CUDA error: invalid device function` errors, the above might be the cause and the solution is to make sure only one ['libcudart.so', 'libcudart.so.11.0', 'libcudart.so.12.0'] in the paths that we search based on your env.\n", + " warn(msg)\n" + ] + } + ], + "source": [ + "import argparse\n", + "import json\n", + "import logging\n", + "import math\n", + "import os\n", + "import random\n", + "from pathlib import Path\n", + "from tqdm import tqdm\n", + "\n", + "import datasets\n", + "from datasets import load_dataset, DatasetDict\n", + "\n", + "import evaluate\n", + "import torch\n", + "from torch import nn\n", + "from torch.utils.data import DataLoader\n", + "\n", + "import transformers\n", + "from transformers import AutoTokenizer, AutoModel, default_data_collator, SchedulerType, get_scheduler\n", + "from transformers.utils import check_min_version, get_full_repo_name, send_example_telemetry\n", + "from transformers.utils.versions import require_version\n", + "\n", + "from huggingface_hub import Repository, create_repo\n", + "\n", + "from accelerate import Accelerator\n", + "from accelerate.logging import get_logger\n", + "from accelerate.utils import set_seed\n", + "\n", + "from peft import PeftModel\n", + "\n", + "import hnswlib" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c939b4fd", + "metadata": {}, + "outputs": [], + "source": [ + "class AutoModelForSentenceEmbedding(nn.Module):\n", + " def __init__(self, model_name, tokenizer, normalize=True):\n", + " super(AutoModelForSentenceEmbedding, self).__init__()\n", + "\n", + " self.model = AutoModel.from_pretrained(model_name) # , quantizaton_config=BitsAndBytesConfig(load_in_8bit=True), device_map={\"\":0})\n", + " self.normalize = normalize\n", + " self.tokenizer = tokenizer\n", + "\n", + " def forward(self, **kwargs):\n", + " model_output = self.model(**kwargs)\n", + " embeddings = self.mean_pooling(model_output, kwargs[\"attention_mask\"])\n", + " if self.normalize:\n", + " embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)\n", + "\n", + " return embeddings\n", + "\n", + " def mean_pooling(self, model_output, attention_mask):\n", + " token_embeddings = model_output[0] # First element of model_output contains all token embeddings\n", + " input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()\n", + " return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)\n", + "\n", + " def __getattr__(self, name: str):\n", + " \"\"\"Forward missing attributes to the wrapped module.\"\"\"\n", + " try:\n", + " return super().__getattr__(name) # defer to nn.Module's logic\n", + " except AttributeError:\n", + " return getattr(self.model, name)\n", + "\n", + "\n", + "def get_cosing_embeddings(query_embs, product_embs):\n", + " return torch.sum(query_embs * product_embs, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8b5d9256", + "metadata": {}, + "outputs": [], + "source": [ + "model_name_or_path = \"intfloat/e5-large-v2\"\n", + "peft_model_id = \"smangrul/peft_lora_e5_semantic_search\"\n", + "dataset_name = \"smangrul/amazon_esci\"\n", + "max_length = 70\n", + "batch_size = 256" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f190e1ee", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Found cached dataset parquet (/raid/sourab/.cache/huggingface/datasets/smangrul___parquet/smangrul--amazon_esci-321288cabf0cc045/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "43b84641575e4ce6899a3e6f61d7e126", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/2 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexproduct_title
00RamPro 10\" All Purpose Utility Air Tires/Wheel...
11MaxAuto 2-Pack 13x5.00-6 2PLY Turf Mower Tract...
22NEIKO 20601A 14.5 inch Steel Tire Spoon Lever ...
332PK 13x5.00-6 13x5.00x6 13x5x6 13x5-6 2PLY Tur...
44(Set of 2) 15x6.00-6 Husqvarna/Poulan Tire Whe...
.........
476273476273Chanel No.5 Eau Premiere Spray 50ml/1.7oz
476274476274Steve Madden Designer 15 Inch Carry on Suitcas...
476275476275CHANEL Le Lift Creme Yeux, Black, 0.5 Ounce
476276476276Coco Mademoiselle by Chanel for Women - 3.4 oz...
476277476277Chânél No. 5 by Chânél Eau De Parfum Premiere ...
\n", + "

476278 rows × 2 columns

\n", + "" + ], + "text/plain": [ + " index product_title\n", + "0 0 RamPro 10\" All Purpose Utility Air Tires/Wheel...\n", + "1 1 MaxAuto 2-Pack 13x5.00-6 2PLY Turf Mower Tract...\n", + "2 2 NEIKO 20601A 14.5 inch Steel Tire Spoon Lever ...\n", + "3 3 2PK 13x5.00-6 13x5.00x6 13x5x6 13x5-6 2PLY Tur...\n", + "4 4 (Set of 2) 15x6.00-6 Husqvarna/Poulan Tire Whe...\n", + "... ... ...\n", + "476273 476273 Chanel No.5 Eau Premiere Spray 50ml/1.7oz\n", + "476274 476274 Steve Madden Designer 15 Inch Carry on Suitcas...\n", + "476275 476275 CHANEL Le Lift Creme Yeux, Black, 0.5 Ounce\n", + "476276 476276 Coco Mademoiselle by Chanel for Women - 3.4 oz...\n", + "476277 476277 Chânél No. 5 by Chânél Eau De Parfum Premiere ...\n", + "\n", + "[476278 rows x 2 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "product_dataset_for_indexing" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "85840ec6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexproduct_title
3471034710ROK 4-1/2 inch Diamond Saw Blade Set, Pack of 3
277590277590WSGG Medical Goggles, FDA registered, Safety Goggles, Fit Over Glasses, Anti-Fog, Anti-Splash (1 pack)
474000474000iJDMTOY 15W CREE High Power LED Angel Eye Bulbs Compatible With BMW 5 6 7 Series X3 X5 (E39 E60 E63 E65 E53), 7000K Xenon White Headlight Ring Marker Lights
1899718997USB Charger, Anker Elite Dual Port 24W Wall Charger, PowerPort 2 with PowerIQ and Foldable Plug, for iPhone 11/Xs/XS Max/XR/X/8/7/6/Plus, iPad Pro/Air 2/Mini 3/Mini 4, Samsung S4/S5, and More
208666208666AOGGY Compatible with MacBook Air 13 inch Case A1466/A1369 (2010-2017 Release) Glitter Fluorescent Color Plastic Hard Case， with Older Version MacBook Air 13 inch Keyboard Cover - Gold
326614326614CUTE STONE Little Kitchen Playset, Kitchen Toy Set with Realistic Sound &Light, Play Sink, Cooking Stove with Steam, Play Food and Kitchen Accessories, Great Kitchen Toys for Toddlers Kids
105637105637Milwaukee Electric Tool 2470-21 M12 Cordless Shear Kit, 12 V, Li-Ion
342392342392chouyatou Women's Short Sleeve/Strap Open Bust Bodysuit Shapewear Firm Control Body Shaper (X-Small, Nude Sleeve)
319970319970AMT 256 Hz Medical-Grade Tuning Fork Instrument with Fixed Weights, Non-Magnetic Aluminum Alloy (C 256)
416956416956Timberland HIKER-ROUND 54 BROWN
\n", + "
" + ], + "text/plain": [ + " index \\\n", + "34710 34710 \n", + "277590 277590 \n", + "474000 474000 \n", + "18997 18997 \n", + "208666 208666 \n", + "326614 326614 \n", + "105637 105637 \n", + "342392 342392 \n", + "319970 319970 \n", + "416956 416956 \n", + "\n", + " product_title \n", + "34710 ROK 4-1/2 inch Diamond Saw Blade Set, Pack of 3 \n", + "277590 WSGG Medical Goggles, FDA registered, Safety Goggles, Fit Over Glasses, Anti-Fog, Anti-Splash (1 pack) \n", + "474000 iJDMTOY 15W CREE High Power LED Angel Eye Bulbs Compatible With BMW 5 6 7 Series X3 X5 (E39 E60 E63 E65 E53), 7000K Xenon White Headlight Ring Marker Lights \n", + "18997 USB Charger, Anker Elite Dual Port 24W Wall Charger, PowerPort 2 with PowerIQ and Foldable Plug, for iPhone 11/Xs/XS Max/XR/X/8/7/6/Plus, iPad Pro/Air 2/Mini 3/Mini 4, Samsung S4/S5, and More \n", + "208666 AOGGY Compatible with MacBook Air 13 inch Case A1466/A1369 (2010-2017 Release) Glitter Fluorescent Color Plastic Hard Case， with Older Version MacBook Air 13 inch Keyboard Cover - Gold \n", + "326614 CUTE STONE Little Kitchen Playset, Kitchen Toy Set with Realistic Sound &Light, Play Sink, Cooking Stove with Steam, Play Food and Kitchen Accessories, Great Kitchen Toys for Toddlers Kids \n", + "105637 Milwaukee Electric Tool 2470-21 M12 Cordless Shear Kit, 12 V, Li-Ion \n", + "342392 chouyatou Women's Short Sleeve/Strap Open Bust Bodysuit Shapewear Firm Control Body Shaper (X-Small, Nude Sleeve) \n", + "319970 AMT 256 Hz Medical-Grade Tuning Fork Instrument with Fixed Weights, Non-Magnetic Aluminum Alloy (C 256) \n", + "416956 Timberland HIKER-ROUND 54 BROWN " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.set_option(\"max_colwidth\", 300)\n", + "product_dataset_for_indexing.sample(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "408b6e00", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running tokenizer on dataset: 0%| | 0/476278 [00:00 k\n", + "\n", + " # Query dataset, k - number of the closest elements (returns 2 numpy arrays)\n", + " labels, distances = search_index.knn_query(query_embeddings, k=k)\n", + "\n", + " return [\n", + " (ids_to_products_dict[label], (1 - distance))\n", + " for label, distance in zip(labels[0], distances[0])\n", + " if (1 - distance) >= threshold\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "1c47f12d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "query='NLP and ML books'\n", + "cosine_sim_score=0.92 product='Machine Learning: A Journey from Beginner to Advanced Including Deep Learning, Scikit-learn and Tensorflow'\n", + "cosine_sim_score=0.91 product='Mastering Machine Learning with scikit-learn'\n", + "cosine_sim_score=0.91 product='Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems'\n", + "cosine_sim_score=0.91 product='Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems'\n", + "cosine_sim_score=0.91 product='Practical Deep Learning: A Python-Based Introduction'\n", + "cosine_sim_score=0.9 product='Machine Learning: A Hands-On, Project-Based Introduction to Machine Learning for Absolute Beginners: Mastering Engineering ML Systems using Scikit-Learn and TensorFlow'\n", + "cosine_sim_score=0.9 product='Mastering Machine Learning with scikit-learn - Second Edition: Apply effective learning algorithms to real-world problems using scikit-learn'\n", + "cosine_sim_score=0.9 product='Mastering Machine Learning on AWS: Advanced machine learning in Python using SageMaker, Apache Spark, and TensorFlow'\n", + "cosine_sim_score=0.9 product='Machine Learning Algorithms: Naive Bayes'\n", + "cosine_sim_score=0.9 product='Fundamentals of Machine Learning for Predictive Data Anayltics: Algorithms, Worked Examples, and Case Studies'\n" + ] + } + ], + "source": [ + "query = \"NLP and ML books\"\n", + "k = 10\n", + "query_embeddings = get_query_embeddings(query, model, tokenizer, device)\n", + "search_results = get_nearest_neighbours(k, product_search_index, query_embeddings, ids_to_products_dict, threshold=0.7)\n", + "\n", + "print(f\"{query=}\")\n", + "for product, cosine_sim_score in search_results:\n", + " print(f\"cosine_sim_score={round(cosine_sim_score,2)} {product=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e9e2dd2c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/feature_extraction/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/feature_extraction/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..2bb3bc04de57a3b75cdb5f5f856c40daed0fcdf9 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/feature_extraction/requirements.txt @@ -0,0 +1,10 @@ +peft +accelerate +transformers +datasets==2.18.0 +evaluate +hnswlib +pandas +tqdm +huggingface_hub +wandb \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/fp4_finetuning/finetune_fp4_opt_bnb_peft.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/fp4_finetuning/finetune_fp4_opt_bnb_peft.py new file mode 100644 index 0000000000000000000000000000000000000000..8f5eee04af4b5676a665f4d8bf8a82b8c9de01b1 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/fp4_finetuning/finetune_fp4_opt_bnb_peft.py @@ -0,0 +1,195 @@ +import os + +import torch +import transformers +from datasets import load_dataset +from torch import nn +from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig + +from peft import LoraConfig, get_peft_model + + +os.environ["CUDA_VISIBLE_DEVICES"] = "0" # force to use CUDA GPU device 0 +os.environ["ZE_AFFINITY_MASK"] = "0" # force to use Intel XPU device 0 +# -*- coding: utf-8 -*- +"""Finetune-opt-bnb-peft.ipynb + +Automatically generated by Colaboratory. + +Original file is located at + https://colab.research.google.com/drive/1jCkpikz0J2o20FBQmYmAGdiKmJGOMo-o + +## Fine-tune large models using 🤗 `peft` adapters, `transformers` & `bitsandbytes` + +In this tutorial we will cover how we can fine-tune large language models using the very recent `peft` library and `bitsandbytes` for loading large models in 8-bit. +The fine-tuning method will rely on a recent method called "Low Rank Adapters" (LoRA), instead of fine-tuning the entire model you just have to fine-tune these adapters and load them properly inside the model. +After fine-tuning the model you can also share your adapters on the 🤗 Hub and load them very easily. Let's get started! + +### Install requirements + +First, run the cells below to install the requirements: +""" + + +"""### Model loading + +Here let's load the `opt-6.7b` model, its weights in half-precision (float16) are about 13GB on the Hub! If we load them in 8-bit we would require around 7GB of memory instead. +""" + +device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" +device_module = getattr(torch, device_type, torch.cuda) +free_in_GB = int(device_module.mem_get_info()[0] / 1024**3) +max_memory = f"{free_in_GB - 2}GB" + +n_gpus = device_module.device_count() +max_memory = {i: max_memory for i in range(n_gpus)} + +model = AutoModelForCausalLM.from_pretrained( + "facebook/opt-350m", + max_memory=max_memory, + quantization_config=BitsAndBytesConfig( + load_in_4bit=True, + llm_int8_threshold=6.0, + llm_int8_has_fp16_weight=False, + bnb_4bit_compute_dtype=torch.float16, + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_type="nf4", + ), + dtype=torch.float16, +) + +tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m") + +"""### Post-processing on the model + +Finally, we need to apply some post-processing on the 8-bit model to enable training, let's freeze all our layers, and cast the layer-norm in `float32` for stability. We also cast the output of the last layer in `float32` for the same reasons. +""" + +print(model) + +for param in model.parameters(): + param.requires_grad = False # freeze the model - train adapters later + if param.ndim == 1: + # cast the small parameters (e.g. layernorm) to fp32 for stability + param.data = param.data.to(torch.float32) + +# model.gradient_checkpointing_enable() # reduce number of stored activations +# model.model.decoder.project_in = lambda x: x.requires_grad_(True) + + +class CastOutputToFloat(nn.Sequential): + def forward(self, x): + return super().forward(x).to(torch.float32) + + +model.lm_head = CastOutputToFloat(model.lm_head) + +"""### Apply LoRA + +Here comes the magic with `peft`! Let's load a `PeftModel` and specify that we are going to use low-rank adapters (LoRA) using `get_peft_model` utility function from `peft`. +""" + + +def print_trainable_parameters(model): + """ + Prints the number of trainable parameters in the model. + """ + trainable_params = 0 + all_param = 0 + for _, param in model.named_parameters(): + all_param += param.numel() + if param.requires_grad: + trainable_params += param.numel() + print( + f"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}" + ) + + +config = LoraConfig( + r=64, + lora_alpha=32, + target_modules=["q_proj", "v_proj", "out_proj", "fc1", "fc2"], + lora_dropout=0.01, + bias="none", + task_type="CAUSAL_LM", +) + +model = get_peft_model(model, config) +print_trainable_parameters(model) + +# Verifying the datatypes. +dtypes = {} +for _, p in model.named_parameters(): + dtype = p.dtype + if dtype not in dtypes: + dtypes[dtype] = 0 + dtypes[dtype] += p.numel() +total = 0 +for k, v in dtypes.items(): + total += v +for k, v in dtypes.items(): + print(k, v, v / total) + +"""### Training""" + +data = load_dataset("Abirate/english_quotes") +data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True) + +trainer = transformers.Trainer( + model=model, + train_dataset=data["train"], + args=transformers.TrainingArguments( + per_device_train_batch_size=4, + gradient_accumulation_steps=4, + warmup_steps=10, + max_steps=20, + learning_rate=3e-4, + fp16=True, + logging_steps=1, + output_dir="outputs", + ), + data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False), +) +model.config.use_cache = False # silence the warnings. Please re-enable for inference! +trainer.train() + +# from huggingface_hub import notebook_login + +# notebook_login() + +# model.push_to_hub("ybelkada/opt-6.7b-lora", use_auth_token=True) + +"""## Load adapters from the Hub + +You can also directly load adapters from the Hub using the commands below: +""" + +# import torch +# from peft import PeftModel, PeftConfig +# from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig +# +# peft_model_id = "ybelkada/opt-6.7b-lora" +# config = PeftConfig.from_pretrained(peft_model_id) +# model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, return_dict=True, quantization_config=BitsAndBytesConfig(load_in_8bit=True), device_map='auto') +# tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path) +# +## Load the Lora model +# model = PeftModel.from_pretrained(model, peft_model_id) +# +# """## Inference +# +# You can then directly use the trained model or the model that you have loaded from the 🤗 Hub for inference as you would do it usually in `transformers`. +# """ +# +batch = tokenizer("Two things are infinite: ", return_tensors="pt").to(model.device) + +model.config.use_cache = False # silence the warnings. Please re-enable for inference! +model.eval() + +with torch.amp.autocast(device_type=device_type): + output_tokens = model.generate(**batch, max_new_tokens=50) + +print("\n\n", tokenizer.decode(output_tokens[0], skip_special_tokens=True)) +# model.save('./test.pt') + +# """As you can see by fine-tuning for few steps we have almost recovered the quote from Albert Einstein that is present in the [training data](https://huggingface.co/datasets/Abirate/english_quotes).""" diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..57ed96508374d1a85ddb06ac272f08cbd070d3d6 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/README.md @@ -0,0 +1,27 @@ +# FRoD fine-tuning examples + +These examples show minimal FRoD fine-tuning with the Transformers `Trainer`. + +Install the example dependencies and run either script directly: + +```bash +pip install -r examples/frod_finetuning/requirements.txt +python examples/frod_finetuning/frod_text_classification.py +python examples/frod_finetuning/frod_image_classification.py +``` + +The text example fine-tunes `google-bert/bert-base-uncased` on `nyu-mll/glue` with the `sst2` configuration. The image +example fine-tunes `openai/clip-vit-base-patch32` on the train and test parquet splits from `tanganke/stanford_cars`. + +Both scripts use separate optimizer learning rates for FRoD diagonal coefficients, FRoD sparse coefficients, and the +classification head. FRoD dropout is set to `0.0` because the sparse rotational parameterization is the main +regularizer in these examples. + +To use local mirrors of the image model or dataset, pass the paths as CLI arguments: + +```bash +python examples/frod_finetuning/frod_image_classification.py \ + --model_name_or_path /path/to/local/clip-vit-model \ + --data_dir /path/to/local/stanford_cars \ + --output_dir clip-vit-local-frod-stanford-cars +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/frod_image_classification.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/frod_image_classification.py new file mode 100644 index 0000000000000000000000000000000000000000..a378f21ae1b0de447d51acf80441444ca2cac290 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/frod_image_classification.py @@ -0,0 +1,180 @@ +# Copyright 2026-present the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); + +import os +from dataclasses import dataclass, field +from typing import Optional + +import numpy as np +import torch +from datasets import load_dataset +from transformers import ( + AutoImageProcessor, + AutoModelForImageClassification, + HfArgumentParser, + Trainer, + TrainingArguments, +) + +from peft import FrodConfig, get_peft_model + + +@dataclass +class FrodImageArguments: + model_name_or_path: str = field( + default="openai/clip-vit-base-patch32", + metadata={"help": "Model checkpoint used for image classification."}, + ) + data_dir: Optional[str] = field( + default=None, + metadata={"help": "Optional local Stanford Cars dataset directory containing the parquet data files."}, + ) + target_modules: list[str] = field( + default_factory=lambda: ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"], + metadata={"help": "Module names to replace with FRoD adapters."}, + ) + sparse_rate: float = field( + default=0.01, + metadata={"help": "Fraction of off-diagonal entries trained in the sparse FRoD matrix."}, + ) + frod_dropout: float = field( + default=0.0, + metadata={"help": "Dropout probability applied before the FRoD adapter branch."}, + ) + frod_lambda_l_lr: float = field( + default=5e-4, + metadata={"help": "Learning rate for the trainable diagonal FRoD coefficients."}, + ) + frod_lambda_s_lr: float = field( + default=5e-5, + metadata={"help": "Learning rate for the trainable sparse FRoD coefficients."}, + ) + classifier_lr: float = field(default=1e-4, metadata={"help": "Learning rate for the classification head."}) + projection_prng_key: int = field(default=3, metadata={"help": "Random seed used for FRoD projection masks."}) + runtime_offload_base_weight: bool = field( + default=False, + metadata={"help": "Keep target base weights on CPU when active FRoD training does not need them."}, + ) + + +@dataclass +class FrodImageTrainingArguments(TrainingArguments): + output_dir: str = "clip-vit-base-patch32-frod-stanford-cars" + learning_rate: float = 5e-4 + per_device_train_batch_size: int = 64 + per_device_eval_batch_size: int = 64 + num_train_epochs: float = 3 + eval_strategy: str = "epoch" + save_strategy: str = "epoch" + load_best_model_at_end: bool = True + metric_for_best_model: str = "accuracy" + lr_scheduler_type: str = "constant" + remove_unused_columns: bool = False + report_to: str = "none" + + +def main(): + parser = HfArgumentParser((FrodImageArguments, FrodImageTrainingArguments)) + frod_args, training_args = parser.parse_args_into_dataclasses() + + if frod_args.data_dir: + data_files = { + "train": [ + os.path.join(frod_args.data_dir, "data", "train-00000-of-00002.parquet"), + os.path.join(frod_args.data_dir, "data", "train-00001-of-00002.parquet"), + ], + "test": [ + os.path.join(frod_args.data_dir, "data", "test-00000-of-00002.parquet"), + os.path.join(frod_args.data_dir, "data", "test-00001-of-00002.parquet"), + ], + } + else: + data_files = { + "train": [ + "hf://datasets/tanganke/stanford_cars/data/train-00000-of-00002.parquet", + "hf://datasets/tanganke/stanford_cars/data/train-00001-of-00002.parquet", + ], + "test": [ + "hf://datasets/tanganke/stanford_cars/data/test-00000-of-00002.parquet", + "hf://datasets/tanganke/stanford_cars/data/test-00001-of-00002.parquet", + ], + } + + dataset = load_dataset("parquet", data_files=data_files) + train_split = dataset["train"] + eval_split = dataset["test"] + image_processor = AutoImageProcessor.from_pretrained(frod_args.model_name_or_path) + label_feature = train_split.features["label"] + label_names = ( + label_feature.names if hasattr(label_feature, "names") else [str(i) for i in sorted(set(train_split["label"]))] + ) + id2label = dict(enumerate(label_names)) + label2id = {name: idx for idx, name in id2label.items()} + + model = AutoModelForImageClassification.from_pretrained( + frod_args.model_name_or_path, + num_labels=len(label_names), + id2label=id2label, + label2id=label2id, + ignore_mismatched_sizes=True, + ) + peft_config = FrodConfig( + target_modules=frod_args.target_modules, + modules_to_save=["classifier"], + frod_dropout=frod_args.frod_dropout, + sparse_rate=frod_args.sparse_rate, + projection_prng_key=frod_args.projection_prng_key, + runtime_offload_base_weight=frod_args.runtime_offload_base_weight, + ) + model = get_peft_model(model, peft_config) + model.print_trainable_parameters() + + def transform(batch): + images = [image.convert("RGB") for image in batch["image"]] + inputs = image_processor(images, return_tensors="pt") + inputs["labels"] = batch["label"] + return inputs + + train_dataset = train_split.with_transform(transform) + eval_dataset = eval_split.with_transform(transform) + + def collate_fn(examples): + pixel_values = torch.stack([example["pixel_values"] for example in examples]) + labels = torch.tensor([example["labels"] for example in examples]) + return {"pixel_values": pixel_values, "labels": labels} + + def compute_metrics(eval_pred): + predictions = np.argmax(eval_pred.predictions, axis=-1) + return {"accuracy": (predictions == eval_pred.label_ids).mean().item()} + + optimizer = torch.optim.AdamW( + [ + { + "params": [p for n, p in model.named_parameters() if "frod_lambda_l" in n], + "lr": frod_args.frod_lambda_l_lr, + }, + { + "params": [p for n, p in model.named_parameters() if "frod_lambda_s_values" in n], + "lr": frod_args.frod_lambda_s_lr, + }, + {"params": [p for n, p in model.named_parameters() if "classifier" in n], "lr": frod_args.classifier_lr}, + ] + ) + + trainer = Trainer( + model=model, + args=training_args, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + data_collator=collate_fn, + compute_metrics=compute_metrics, + optimizers=(optimizer, None), + ) + trainer.train() + trainer.evaluate() + model.save_pretrained(training_args.output_dir) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/frod_text_classification.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/frod_text_classification.py new file mode 100644 index 0000000000000000000000000000000000000000..55d50ecdacaaf5e05f3754f320a5c0687a7bdb9c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/frod_text_classification.py @@ -0,0 +1,130 @@ +# Copyright 2026-present the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); + +from dataclasses import dataclass, field + +import numpy as np +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForSequenceClassification, + AutoTokenizer, + DataCollatorWithPadding, + HfArgumentParser, + Trainer, + TrainingArguments, +) + +from peft import FrodConfig, TaskType, get_peft_model + + +@dataclass +class FrodTextArguments: + model_name_or_path: str = field( + default="google-bert/bert-base-uncased", + metadata={"help": "Model checkpoint used for sequence classification."}, + ) + dataset_name: str = field(default="nyu-mll/glue", metadata={"help": "Dataset name or local dataset path."}) + task_name: str = field(default="sst2", metadata={"help": "Dataset configuration name."}) + target_modules: list[str] = field( + default_factory=lambda: ["query", "value"], + metadata={"help": "Module names to replace with FRoD adapters."}, + ) + sparse_rate: float = field( + default=0.02, + metadata={"help": "Fraction of off-diagonal entries trained in the sparse FRoD matrix."}, + ) + frod_dropout: float = field( + default=0.0, + metadata={"help": "Dropout probability applied before the FRoD adapter branch."}, + ) + frod_lambda_l_lr: float = field( + default=2e-2, + metadata={"help": "Learning rate for the trainable diagonal FRoD coefficients."}, + ) + frod_lambda_s_lr: float = field( + default=2e-3, + metadata={"help": "Learning rate for the trainable sparse FRoD coefficients."}, + ) + classifier_lr: float = field(default=1e-2, metadata={"help": "Learning rate for the classification head."}) + runtime_offload_base_weight: bool = field( + default=False, + metadata={"help": "Keep target base weights on CPU when active FRoD training does not need them."}, + ) + + +@dataclass +class FrodTextTrainingArguments(TrainingArguments): + output_dir: str = "bert-base-uncased-frod-sst2" + learning_rate: float = 2e-2 + per_device_train_batch_size: int = 32 + per_device_eval_batch_size: int = 64 + num_train_epochs: float = 1 + eval_strategy: str = "epoch" + save_strategy: str = "epoch" + load_best_model_at_end: bool = True + metric_for_best_model: str = "accuracy" + report_to: str = "none" + + +def main(): + parser = HfArgumentParser((FrodTextArguments, FrodTextTrainingArguments)) + frod_args, training_args = parser.parse_args_into_dataclasses() + + dataset = load_dataset(frod_args.dataset_name, frod_args.task_name) + tokenizer = AutoTokenizer.from_pretrained(frod_args.model_name_or_path) + + def preprocess(batch): + return tokenizer(batch["sentence"], truncation=True) + + tokenized = dataset.map(preprocess, batched=True) + tokenized = tokenized.rename_column("label", "labels") + + model = AutoModelForSequenceClassification.from_pretrained(frod_args.model_name_or_path, num_labels=2) + peft_config = FrodConfig( + task_type=TaskType.SEQ_CLS, + target_modules=frod_args.target_modules, + modules_to_save=["classifier"], + frod_dropout=frod_args.frod_dropout, + sparse_rate=frod_args.sparse_rate, + runtime_offload_base_weight=frod_args.runtime_offload_base_weight, + ) + model = get_peft_model(model, peft_config) + model.print_trainable_parameters() + + def compute_metrics(eval_pred): + predictions = np.argmax(eval_pred.predictions, axis=-1) + return {"accuracy": (predictions == eval_pred.label_ids).mean().item()} + + optimizer = torch.optim.AdamW( + [ + { + "params": [p for n, p in model.named_parameters() if "frod_lambda_l" in n], + "lr": frod_args.frod_lambda_l_lr, + }, + { + "params": [p for n, p in model.named_parameters() if "frod_lambda_s_values" in n], + "lr": frod_args.frod_lambda_s_lr, + }, + {"params": [p for n, p in model.named_parameters() if "classifier" in n], "lr": frod_args.classifier_lr}, + ] + ) + + trainer = Trainer( + model=model, + args=training_args, + train_dataset=tokenized["train"], + eval_dataset=tokenized["validation"], + processing_class=tokenizer, + data_collator=DataCollatorWithPadding(tokenizer=tokenizer), + compute_metrics=compute_metrics, + optimizers=(optimizer, None), + ) + trainer.train() + trainer.evaluate() + model.save_pretrained(training_args.output_dir) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..8bcaa7461939455eda48336e06d02bf58ac05208 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/frod_finetuning/requirements.txt @@ -0,0 +1,6 @@ +peft +transformers +accelerate>=1.0.0 +datasets +numpy +Pillow diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/glora_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/glora_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5049bc260d98d29fb762d25a36cffef2dc2a4732 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/glora_finetuning/README.md @@ -0,0 +1,20 @@ +# GLoRA causal language modeling fine-tuning + +This example demonstrates how to fine-tune a causal language model with [GLoRA](https://arxiv.org/abs/2306.07967) adapters using the Alpaca-style instruction data from `yahma/alpaca-cleaned`. GLoRA generalizes LoRA by introducing configurable paths for weight and bias corrections: `W_eff = W0 + W0 * A + B` and `b_eff = b0 + b0 * D + E + W0 @ C`. + +## Running the script + +```bash +python examples/glora_finetuning/glora_finetuning.py \ + --base_model meta-llama/Meta-Llama-3-8B-Instruct \ + --data_path yahma/alpaca-cleaned \ + --output_dir glora-alpaca \ + --glora_r 8 \ + --config_A_B lora \ + --config_C lora \ + --config_D_E constant \ + --learning_rate 3e-4 \ + --num_epochs 3 +``` + +Each path (`config_A_B`, `config_C`, `config_D_E`) can be set to different parameterization modes (`lora`, `vector`, `constant`, `none`) to trade off expressiveness against parameter count. The default configuration uses `lora` for A/B and C, and `constant` for D/E. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/gralora_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/gralora_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..616141e1c8a03a3b42263a099593c9ade70a35bd --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/gralora_finetuning/README.md @@ -0,0 +1,73 @@ +# GraLoRA: Granular Low-Rank Adaptation + +![GraLoRA Overview](https://github.com/SqueezeBits/GraLoRA/raw/main/figure/gralora_overview.png) + +## Introduction +[**Granular Low-Rank Adaptation (GraLoRA)**](https://huggingface.co/papers/2505.20355) is a PEFT method designed to enhance the **expressivity** of low-rank adaptation while improving **robustness to outlier** activations, based on insights from well-known issues in quantization. + +GraLoRA introduces a structured and fine-grained adaptation scheme. It divides the adaptation space into a grid of $𝑘^2$ smaller, independent adapter pairs, each responsible for a localized subset of the input and output dimensions. + +## Quick start + +With respect to your standard PEFT training procedure with LoRA, simply swap your `LoraConfig` for a `GraloraConfig`. + +```python +import torch +from datasets import load_dataset +from transformers import AutoTokenizer, AutoModelForCausalLM +from trl import SFTTrainer, SFTConfig +from peft import GraloraConfig + +model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B") +dataset = load_dataset("timdettmers/openassistant-guanaco", split="train") +gralora_config = GraloraConfig() + +trainer = SFTTrainer( + model=model, + train_dataset=dataset, + processing_class=tokenizer, + peft_config=gralora_config, + args=SFTConfig( + max_length=2048, + dataset_text_field="text", + per_device_train_batch_size=2, + ), +) +trainer.train() +trainer.model.save_pretrained("gralora-llama-3.2-3b") +``` + +Run the finetuning script simply by running: +```sh +python examples/gralora_finetuning/gralora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco +``` + +## Use the model on 🤗 +You can load and use the model as any other 🤗 models. +```python +import torch +from peft import PeftModel +from transformers import AutoModelForCausalLM + +model = AutoModelForCausalLM.from_pretrained( + "meta-llama/Meta-Llama-3-8B", dtype=torch.bfloat16, device_map="auto" +) +peft_model = PeftModel.from_pretrained(model, "gralora-llama-3-8b") +``` + +## Additional Notes +While `gralora_k` is set to 2 for default, you can increase this value to create more fine-grained adapters. `gralora_k` of 4 is recommended when the total rank (`r + hybrid_r`) is 64 or higher. + +## Citation +``` +@misc{jung2025graloragranularlowrankadaptation, + title={GraLoRA: Granular Low-Rank Adaptation for Parameter-Efficient Fine-Tuning}, + author={Yeonjoon Jung and Daehyun Ahn and Hyungjun Kim and Taesu Kim and Eunhyeok Park}, + year={2025}, + eprint={2505.20355}, + archivePrefix={arXiv}, + primaryClass={cs.LG}, + url={https://arxiv.org/abs/2505.20355}, +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/gralora_finetuning/gralora_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/gralora_finetuning/gralora_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..666cc5bb91b0589adf79f0bcc1377284e3a56b8e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/gralora_finetuning/gralora_finetuning.py @@ -0,0 +1,189 @@ +# This script is based on examples/dora_finetuning/dora_finetuning.py +import os + +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + DataCollatorForLanguageModeling, + Trainer, + TrainingArguments, +) + +from peft import GraloraConfig, get_peft_model + + +def train_model( + base_model: str, + data_path: str, + output_dir: str, + batch_size: int, + num_epochs: int, + learning_rate: float, + cutoff_len: int, + val_set_size: int, + eval_step: int, + save_step: int, + device: str, + gralora_r: int, + gralora_alpha: int, + gralora_dropout: float, + gralora_target_modules: str, + gralora_k: int, + hybrid_r: int, + hub_model_id: str, + push_to_hub: bool, +): + os.environ["TOKENIZERS_PARALLELISM"] = "false" + hf_token = os.getenv("HF_TOKEN") + + # Setup device + if device == "auto": + device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + else: + device = torch.device(device) + print(f"Using device: {device}") + + # load tokenizer + tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token) + + model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token) + # GraLoRA config for the PEFT model + gralora_config = GraloraConfig( + r=gralora_r, # Rank of matrix + alpha=gralora_alpha, + target_modules=( + gralora_target_modules.split(",") + if gralora_target_modules + else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] + ), + gralora_dropout=gralora_dropout, + gralora_k=gralora_k, + hybrid_r=hybrid_r, + bias="none", + ) + + # get the peft model with GraLoRA config + model = get_peft_model(model, gralora_config) + + model.to(device) # MODEL TO GPU/CUDA + tokenizer.pad_token = tokenizer.eos_token + + # Load the dataset + dataset = load_dataset(data_path) + + def tokenize_function(examples): + inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len) + inputs["labels"] = inputs["input_ids"].copy() # setting labels for a language modeling task + return inputs + + # Tokenize the dataset and prepare for training + tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names) + + # Data collator to dynamically pad the batched examples + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + + # Define training arguments + training_args = TrainingArguments( + output_dir=output_dir, + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + per_device_eval_batch_size=batch_size, + warmup_steps=100, + weight_decay=0.01, + logging_steps=eval_step, + save_steps=save_step, + save_total_limit=2, + push_to_hub=push_to_hub, + hub_model_id=hub_model_id, + gradient_accumulation_steps=16, + fp16=True, + learning_rate=learning_rate, + hub_token=hf_token, + ) + + # Clear device cache to free memory + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + # Initialize the Trainer + trainer = Trainer( + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["test"], + data_collator=data_collator, + ) + + # Start model training + trainer.train() + + # Save and push the trained model and tokenizer + if push_to_hub: + # Push the main model to the hub + trainer.push_to_hub(commit_message="Fine-tuned model") + + # Save the model and tokenizer locally + model.save_pretrained(output_dir) + tokenizer.save_pretrained(output_dir) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Fine-tune LLaMA with GraLoRA and PEFT") + parser.add_argument("--base_model", type=str, default="meta-llama/Llama-3.2-3B", help="Base model path or name") + parser.add_argument( + "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name" + ) + parser.add_argument( + "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model" + ) + parser.add_argument("--batch_size", type=int, default=1, help="Batch size") + parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs") + parser.add_argument("--learning_rate", type=float, default=1e-4, help="Learning rate") + parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization") + parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size") + parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval") + parser.add_argument("--save_step", type=int, default=100, help="Save step interval") + parser.add_argument("--device", type=str, default="auto", help="Device to use for training") + parser.add_argument("--gralora_r", type=int, default=8, help="LoRA rank") + parser.add_argument("--gralora_alpha", type=int, default=16, help="LoRA alpha") + parser.add_argument("--gralora_dropout", type=float, default=0.05, help="LoRA dropout rate") + parser.add_argument( + "--gralora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA" + ) + parser.add_argument("--gralora_k", type=int, default=2, help="GraLoRA k") + parser.add_argument("--hybrid_r", type=int, default=0, help="Hybrid rank") + parser.add_argument( + "--hub_model_id", + type=str, + default="path/to/repo", + help="Repository name to push the model on the Hugging Face Hub", + ) + parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub") + args = parser.parse_args() + train_model( + base_model=args.base_model, + data_path=args.data_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + val_set_size=args.val_set_size, + eval_step=args.eval_step, + save_step=args.save_step, + device=args.device, + gralora_r=args.gralora_r, + gralora_alpha=args.gralora_alpha, + gralora_dropout=args.gralora_dropout, + gralora_target_modules=args.gralora_target_modules, + gralora_k=args.gralora_k, + hybrid_r=args.hybrid_r, + hub_model_id=args.hub_model_id, + push_to_hub=args.push_to_hub, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hira_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hira_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bccdb8aa1bb5e3cf6704d5c54f4496809049fe89 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hira_finetuning/README.md @@ -0,0 +1,18 @@ +# HiRA causal language modeling fine-tuning + +This example demonstrates how to fine-tune a causal language model with [HiRA](https://openreview.net/pdf?id=TwJrTz9cRS) adapters using the Alpaca-style instruction data from `yahma/alpaca-cleaned`. The script mirrors the common LoRA flow and shows how to configure HiRA-specific parameters such as the Hadamard modulation rank (`r`) and dropout. + +## Running the script + +```bash +python examples/hira_finetuning/hira_finetuning.py \ + --base_model meta-llama/Meta-Llama-3-8B-Instruct \ + --data_path yahma/alpaca-cleaned \ + --output_dir hira-alpaca \ + --hira_r 16 \ + --hira_dropout 0.05 \ + --learning_rate 3e-4 \ + --num_epochs 3 +``` + +The default target modules cover the attention projections and MLP blocks typically present in decoder-style architectures. Adjust them if your base model uses different module names. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hira_finetuning/hira_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hira_finetuning/hira_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..696072fe037b0467a20a74efe144da6cfdbe391c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hira_finetuning/hira_finetuning.py @@ -0,0 +1,217 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from typing import Optional + +import torch +import transformers +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed + +from peft import HiraConfig, PeftModel, get_peft_model + + +def train( + base_model: str = "path/to/model", + data_path: str = "yahma/alpaca-cleaned", + output_dir: str = "hira", + batch_size: int = 16, + num_epochs: int = 1, + learning_rate: float = 3e-4, + cutoff_len: int = 256, + val_set_size: int = 16, + eval_step: int = 100, + save_step: int = 100, + device_map: str = "auto", + hira_r: int = 32, + hira_dropout: float = 0.0, + hira_target_modules: Optional[list[str]] = None, + dtype: str = "float16", + seed: Optional[int] = None, + init_weights: bool = True, +): + """ + Fine-tunes a causal language model with HiRA adapters on Alpaca-style instruction data. + """ + + world_size = int(os.environ.get("WORLD_SIZE", "0")) or int(os.environ.get("PMI_SIZE", "0")) + if world_size > 1 and device_map != "cpu": + from accelerate import Accelerator + + device_map = {"": Accelerator().process_index} + + if seed is not None: + set_seed(seed) + + model_kwargs = {"dtype": getattr(torch, dtype), "device_map": device_map} + model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs) + + tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + def tokenize(prompt, add_eos_token: bool = True): + result = tokenizer( + prompt, + truncation=True, + max_length=cutoff_len, + padding=False, + return_tensors=None, + ) + if ( + result["input_ids"][-1] != tokenizer.eos_token_id + and len(result["input_ids"]) < cutoff_len + and add_eos_token + ): + result["input_ids"].append(tokenizer.eos_token_id) + result["attention_mask"].append(1) + + result["labels"] = result["input_ids"].copy() + + return result + + def generate_and_tokenize_prompt(example): + full_prompt = generate_prompt(example) + tokenized_full_prompt = tokenize(full_prompt) + return tokenized_full_prompt + + default_target_modules = [ + "q_proj", + "k_proj", + "v_proj", + "o_proj", + "gate_proj", + "down_proj", + "up_proj", + ] + config = HiraConfig( + r=hira_r, + target_modules=hira_target_modules or default_target_modules, + hira_dropout=hira_dropout, + init_weights=init_weights, + task_type="CAUSAL_LM", + ) + model = get_peft_model(model, config) + + data = load_dataset(data_path) + + train_val = data["train"].train_test_split(test_size=val_set_size, shuffle=True, seed=42) + train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt) + val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt) + + trainer = transformers.Trainer( + model=model, + train_dataset=train_data, + eval_dataset=val_data, + args=transformers.TrainingArguments( + per_device_train_batch_size=batch_size, + warmup_steps=100, + num_train_epochs=num_epochs, + learning_rate=learning_rate, + logging_steps=100, + optim="adamw_torch", + eval_strategy="steps", + save_strategy="steps", + eval_steps=eval_step, + save_steps=save_step, + output_dir=output_dir, + save_total_limit=3, + load_best_model_at_end=True, + ddp_find_unused_parameters=False if world_size > 1 else None, + ), + data_collator=transformers.DataCollatorForSeq2Seq( + tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True + ), + ) + trainer.train() + model.save_pretrained(output_dir) + + del model + model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs) + model = PeftModel.from_pretrained(model, output_dir) + + +def generate_prompt(example): + return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request. + ### Instruction: + {example["instruction"]} + ### Response: + {example["output"]}""" + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("--base_model", type=str, default="path/to/model") + parser.add_argument("--data_path", type=str, default="yahma/alpaca-cleaned") + parser.add_argument("--output_dir", type=str, default="hira") + parser.add_argument("--batch_size", type=int, default=16) + parser.add_argument("--num_epochs", type=int, default=1) + parser.add_argument("--learning_rate", type=float, default=3e-4) + parser.add_argument("--cutoff_len", type=int, default=256) + parser.add_argument("--val_set_size", type=int, default=16) + parser.add_argument("--eval_step", type=int, default=100) + parser.add_argument("--save_step", type=int, default=100) + parser.add_argument("--device_map", type=str, default="auto") + parser.add_argument("--hira_r", type=int, default=32) + parser.add_argument("--hira_dropout", type=float, default=0.0) + parser.add_argument( + "--hira_target_modules", + type=str, + default=None, + help="Comma-separated list of module names to apply HiRA to. Defaults to a standard decoder block set.", + ) + parser.add_argument("--dtype", type=str, default="float16") + parser.add_argument("--seed", type=int, default=None) + parser.add_argument( + "--init_weights", + dest="init_weights", + action="store_true", + default=True, + help="Initialize HiRA weights as a no-op (default).", + ) + parser.add_argument( + "--no_init_weights", + dest="init_weights", + action="store_false", + help="Disable no-op initialization to use Gaussian initialization instead.", + ) + + args = parser.parse_args() + + hira_target_modules = None + if args.hira_target_modules is not None: + hira_target_modules = [module.strip() for module in args.hira_target_modules.split(",") if module.strip()] + + train( + base_model=args.base_model, + data_path=args.data_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + val_set_size=args.val_set_size, + eval_step=args.eval_step, + save_step=args.save_step, + device_map=args.device_map, + hira_r=args.hira_r, + hira_dropout=args.hira_dropout, + hira_target_modules=hira_target_modules, + dtype=args.dtype, + seed=args.seed, + init_weights=args.init_weights, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1c93b7f1c9f496cec330bcab04e593df6a71cbf2 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/README.md @@ -0,0 +1,98 @@ + + +# DreamBooth fine-tuning with HRA + +This guide demonstrates how to use Householder reflection adaptation (HRA) method, to fine-tune Dreambooth with `stabilityai/stable-diffusion-2-1` model. + +HRA provides a new perspective connecting LoRA to OFT and achieves encouraging performance in various downstream tasks. +HRA adapts a pre-trained model by multiplying each frozen weight matrix with a chain of r learnable Householder reflections (HRs). +HRA can be interpreted as either an OFT adapter or an adaptive LoRA. +Consequently, it harnesses the advantages of both strategies, reducing parameters and computation costs while penalizing the loss of pre-training knowledge. +For further details on HRA, please consult the [original HRA paper](https://huggingface.co/papers/2405.17484). + +In this guide we provide a Dreambooth fine-tuning script that is available in [PEFT's GitHub repo examples](https://github.com/huggingface/peft/tree/main/examples/hra_dreambooth). This implementation is adapted from [peft's boft_dreambooth](https://github.com/huggingface/peft/tree/main/examples/boft_dreambooth). + +You can try it out and fine-tune on your custom images. + +## Set up your environment + +Start by cloning the PEFT repository: + +```bash +git clone --recursive https://github.com/huggingface/peft +``` + +Navigate to the directory containing the training scripts for fine-tuning Dreambooth with HRA: + +```bash +cd peft/examples/hra_dreambooth +``` + +Set up your environment: install PEFT, and all the required libraries. At the time of writing this guide we recommend installing PEFT from source. The following environment setup should work on A100 and H100: + +```bash +conda create --name peft python=3.10 +conda activate peft +conda install pytorch==2.1.2 torchvision==0.16.2 torchaudio==2.1.2 pytorch-cuda=11.8 -c pytorch -c nvidia +conda install xformers -c xformers +pip install -r requirements.txt +pip install git+https://github.com/huggingface/peft +``` + +## Download the data + +[dreambooth](https://github.com/google/dreambooth) dataset should have been automatically cloned in the following structure when running the training script. + +``` +hra_dreambooth +├── data +│ └── dreambooth +│ └── dataset +│ ├── backpack +│ └── backpack_dog +│ ... +``` + +You can also put your custom images into `hra_dreambooth/data/dreambooth/dataset`. + +## Fine-tune Dreambooth with HRA + +```bash +class_idx=0 +bash ./train_dreambooth.sh $class_idx +``` + +where the `$class_idx` corresponds to different subjects ranging from 0 to 29. + +Launch the training script with `accelerate` and pass hyperparameters, as well as LoRa-specific arguments to it such as: + +- `use_hra`: Enables HRA in the training script. +- `hra_r`: the number of HRs (i.e., r) across different layers, expressed in `int`. +As r increases, the number of trainable parameters increases, which generally leads to improved performance. +However, this also results in higher memory consumption and longer computation times. +Therefore, r is usually set to 8. +**Note**, please set r to an even number to avoid potential issues during initialization. +- `hra_apply_GS`: Applies Gram-Schmidt orthogonalization. Default is `false`. +- `hra_bias`: specify if the `bias` parameters should be trained. Can be `none`, `all` or `hra_only`. + +If you are running this script on Windows, you may need to set the `--num_dataloader_workers` to 0. + +To learn more about DreamBooth fine-tuning with prior-preserving loss, check out the [Diffusers documentation](https://huggingface.co/docs/diffusers/training/dreambooth#finetuning-with-priorpreserving-loss). + +## Generate images with the fine-tuned model + +To generate images with the fine-tuned model, simply run the jupyter notebook `dreambooth_inference.ipynb` for visualization with `jupyter notebook` under `./examples/hra_dreambooth`. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/a_purple_qwe_backpack.png b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/a_purple_qwe_backpack.png new file mode 100644 index 0000000000000000000000000000000000000000..7ccda8db974ffe842d0f520df3e852648fde2eea --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/a_purple_qwe_backpack.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3854fc16938a9c0b77ff7172e9dbbbd03c2ff137f9e5c277d0716218f7638411 +size 477707 diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/dreambooth_inference.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/dreambooth_inference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..fb80b1cb2f8e4e7d5d37fddd148408c0c09e4e7b --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/dreambooth_inference.ipynb @@ -0,0 +1,222 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 19, + "id": "acab479f", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from PIL import Image\n", + "\n", + "import torch\n", + "from accelerate.logging import get_logger\n", + "from diffusers import StableDiffusionPipeline\n", + "from diffusers.utils import check_min_version\n", + "\n", + "from peft import PeftModel\n", + "\n", + "\n", + "# Will error if the minimal version of diffusers is not installed. Remove at your own risks.\n", + "check_min_version(\"0.10.0.dev0\")\n", + "\n", + "logger = get_logger(__name__)\n", + "\n", + "MODEL_NAME = \"stabilityai/stable-diffusion-2-1\"\n", + "\n", + "PEFT_TYPE=\"hra\"\n", + "HRA_R=8\n", + "SELECTED_SUBJECT=\"backpack\"\n", + "EPOCH_IDX = 1000\n", + "\n", + "PROJECT_NAME=f\"dreambooth_{PEFT_TYPE}\"\n", + "RUN_NAME=f\"{SELECTED_SUBJECT}_{PEFT_TYPE}_{HRA_R}\"\n", + "OUTPUT_DIR=f\"./data/output/{PEFT_TYPE}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "06cfd506", + "metadata": {}, + "outputs": [], + "source": [ + "def get_hra_sd_pipeline(\n", + " ckpt_dir, base_model_name_or_path=None, epoch=int, dtype=torch.float32, device=\"cuda\", adapter_name=\"default\"\n", + "):\n", + "\n", + " if base_model_name_or_path is None:\n", + " raise ValueError(\"Please specify the base model name or path\")\n", + "\n", + " pipe = StableDiffusionPipeline.from_pretrained(\n", + " base_model_name_or_path, torch_dtype=dtype, requires_safety_checker=False\n", + " ).to(device)\n", + " \n", + " load_adapter(pipe, ckpt_dir, epoch, adapter_name)\n", + "\n", + " if dtype in (torch.float16, torch.bfloat16):\n", + " pipe.unet.half()\n", + " pipe.text_encoder.half()\n", + "\n", + " pipe.to(device)\n", + " return pipe\n", + "\n", + "\n", + "def load_adapter(pipe, ckpt_dir, epoch, adapter_name=\"default\"):\n", + " \n", + " unet_sub_dir = os.path.join(ckpt_dir, f\"unet/{epoch}\", adapter_name)\n", + " text_encoder_sub_dir = os.path.join(ckpt_dir, f\"text_encoder/{epoch}\", adapter_name)\n", + " \n", + " if isinstance(pipe.unet, PeftModel):\n", + " pipe.unet.load_adapter(unet_sub_dir, adapter_name=adapter_name)\n", + " else:\n", + " pipe.unet = PeftModel.from_pretrained(pipe.unet, unet_sub_dir, adapter_name=adapter_name)\n", + " \n", + " if os.path.exists(text_encoder_sub_dir):\n", + " if isinstance(pipe.text_encoder, PeftModel):\n", + " pipe.text_encoder.load_adapter(text_encoder_sub_dir, adapter_name=adapter_name)\n", + " else:\n", + " pipe.text_encoder = PeftModel.from_pretrained(pipe.text_encoder, text_encoder_sub_dir, adapter_name=adapter_name)\n", + " \n", + "\n", + "def set_adapter(pipe, adapter_name):\n", + " pipe.unet.set_adapter(adapter_name)\n", + " if isinstance(pipe.text_encoder, PeftModel):\n", + " pipe.text_encoder.set_adapter(adapter_name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98a0d8ac", + "metadata": {}, + "outputs": [], + "source": [ + "prompt = \"a purple qwe backpack.\"\n", + "negative_prompt = \"low quality, blurry, unfinished\"\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4e888d2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading pipeline components...: 100%|██████████| 6/6 [00:00<00:00, 14.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.72 s, sys: 495 ms, total: 2.22 s\n", + "Wall time: 2.28 s\n" + ] + } + ], + "source": [ + "%%time\n", + "pipe = get_hra_sd_pipeline(OUTPUT_DIR, MODEL_NAME, EPOCH_IDX, adapter_name=RUN_NAME, device=device)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "f1c1a1c0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "image = pipe(prompt, num_inference_steps=50, guidance_scale=7.5, negative_prompt=negative_prompt).images[0]\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "60fa38d2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# This is an example.\n", + "example_image = Image.open(\"./a_purple_qwe_backpack.png\")\n", + "example_image" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "llama", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..b708ee824f01255eedf720763483deabf3798d17 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/requirements.txt @@ -0,0 +1,12 @@ +transformers==4.55.0 +accelerate==1.9.0 +evaluate +tqdm +datasets==4.0.0 +diffusers==0.38.0 +Pillow +huggingface_hub +safetensors +ipykernel +ipywidgets +wandb==0.21.0 \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/train_dreambooth.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/train_dreambooth.py new file mode 100644 index 0000000000000000000000000000000000000000..be9e1390502de603a111c63c03f2add61003a121 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/train_dreambooth.py @@ -0,0 +1,620 @@ +# Copyright 2024-present the HuggingFace Inc. team. +# +# 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. + +# The implementation is based on "Bridging The Gap between Low-rank and Orthogonal +# Adaptation via Householder Reflection Adaptation" (https://huggingface.co/papers/2405.17484). + +import hashlib +import itertools +import logging +import math +import os +from contextlib import nullcontext +from pathlib import Path + +import datasets +import diffusers +import numpy as np +import torch +import torch.nn.functional as F +import torch.utils.checkpoint +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import ProjectConfiguration, set_seed +from diffusers import ( + AutoencoderKL, + DDIMScheduler, + DiffusionPipeline, + DPMSolverMultistepScheduler, + UNet2DConditionModel, +) +from diffusers.optimization import get_scheduler +from diffusers.utils import check_min_version +from diffusers.utils.import_utils import is_xformers_available +from huggingface_hub import Repository +from tqdm.auto import tqdm +from transformers import AutoTokenizer +from utils.args_loader import ( + get_full_repo_name, + import_model_class_from_model_name_or_path, + parse_args, +) +from utils.dataset import DreamBoothDataset, PromptDataset, collate_fn +from utils.tracemalloc import TorchTracemalloc, b2mb + +from peft import HRAConfig, get_peft_model + + +# Will error if the minimal version of diffusers is not installed. Remove at your own risks. +check_min_version("0.16.0.dev0") + +logger = get_logger(__name__) + +UNET_TARGET_MODULES = ["to_q", "to_v", "to_k", "query", "value", "key", "to_out.0", "add_k_proj", "add_v_proj"] +TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"] + + +def save_adaptor(accelerator, step, unet, text_encoder, args): + unwarpped_unet = accelerator.unwrap_model(unet) + unwarpped_unet.save_pretrained( + os.path.join(args.output_dir, f"unet/{step}"), state_dict=accelerator.get_state_dict(unet) + ) + if args.train_text_encoder: + unwarpped_text_encoder = accelerator.unwrap_model(text_encoder) + unwarpped_text_encoder.save_pretrained( + os.path.join(args.output_dir, f"text_encoder/{step}"), + state_dict=accelerator.get_state_dict(text_encoder), + ) + + +def main(args): + validation_prompts = list(filter(None, args.validation_prompt[0].split("."))) + + logging_dir = Path(args.output_dir, args.logging_dir) + accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir) + + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to if args.report_to != "none" else None, + project_dir=accelerator_project_config, + ) + if args.report_to == "wandb": + import wandb + + args.wandb_project_name = args.project_name + args.wandb_run_name = args.run_name + wandb_init = { + "wandb": { + "name": args.wandb_run_name, + "mode": "online", + } + } + + # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate + # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models. + # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate. + if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1: + raise ValueError( + "Gradient accumulation is not supported when training the text encoder in distributed training. " + "Please set gradient_accumulation_steps to 1. This feature will be supported in the future." + ) + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + datasets.utils.logging.set_verbosity_warning() + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + datasets.utils.logging.set_verbosity_error() + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + global_seed = hash(args.run_name) % (2**32) + set_seed(global_seed) + + # Generate class images if prior preservation is enabled. + if args.with_prior_preservation: + class_images_dir = Path(args.class_data_dir) + if not class_images_dir.exists(): + class_images_dir.mkdir(parents=True) + cur_class_images = len(list(class_images_dir.iterdir())) + + if cur_class_images < args.num_class_images: + dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32 + if args.prior_generation_precision == "fp32": + dtype = torch.float32 + elif args.prior_generation_precision == "fp16": + dtype = torch.float16 + elif args.prior_generation_precision == "bf16": + dtype = torch.bfloat16 + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + dtype=dtype, + safety_checker=None, + revision=args.revision, + ) + pipeline.set_progress_bar_config(disable=True) + + num_new_images = args.num_class_images - cur_class_images + logger.info(f"Number of class images to sample: {num_new_images}.") + + sample_dataset = PromptDataset(args.class_prompt, num_new_images) + sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size) + + sample_dataloader = accelerator.prepare(sample_dataloader) + pipeline.to(accelerator.device) + + for example in tqdm( + sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process + ): + images = pipeline(example["prompt"]).images + + for i, image in enumerate(images): + hash_image = hashlib.sha1(image.tobytes()).hexdigest() + image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg" + image.save(image_filename) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + # Handle the repository creation + if accelerator.is_main_process: + if args.push_to_hub: + if args.hub_model_id is None: + repo_name = get_full_repo_name(Path(args.output_dir).name, token=args.hub_token) + else: + repo_name = args.hub_model_id + repo = Repository(args.output_dir, clone_from=repo_name) + + with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore: + if "step_*" not in gitignore: + gitignore.write("step_*\n") + if "epoch_*" not in gitignore: + gitignore.write("epoch_*\n") + elif args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + # Load the tokenizer + if args.tokenizer_name: + tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False) + elif args.pretrained_model_name_or_path: + tokenizer = AutoTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.revision, + use_fast=False, + ) + + # import correct text encoder class + text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision) + + # Load scheduler and models + noise_scheduler = DDIMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler") + + text_encoder = text_encoder_cls.from_pretrained( + args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision + ) + vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision) + unet = UNet2DConditionModel.from_pretrained( + args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision + ) + + if args.use_hra: + config = HRAConfig( + r=args.hra_r, + apply_GS=args.hra_apply_GS, + target_modules=UNET_TARGET_MODULES, + bias=args.hra_bias, + ) + unet = get_peft_model(unet, config, adapter_name=args.run_name) + unet.print_trainable_parameters() + + vae.requires_grad_(False) + unet.train() + + if args.train_text_encoder and args.use_hra: + config = HRAConfig( + r=args.hra_r, + apply_GS=args.hra_apply_GS, + target_modules=UNET_TARGET_MODULES, + bias=args.hra_bias, + ) + text_encoder = get_peft_model(text_encoder, config, adapter_name=args.run_name) + text_encoder.print_trainable_parameters() + text_encoder.train() + else: + text_encoder.requires_grad_(False) + + # For mixed precision training we cast the text_encoder and vae weights to half-precision + # as these models are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + # Move unet, vae and text_encoder to device and cast to weight_dtype + unet.to(accelerator.device, dtype=weight_dtype) + vae.to(accelerator.device, dtype=weight_dtype) + text_encoder.to(accelerator.device, dtype=weight_dtype) + + if args.enable_xformers_memory_efficient_attention: + if accelerator.device.type == "xpu": + logger.warning("XPU hasn't support xformers yet, ignore it.") + elif is_xformers_available(): + unet.enable_xformers_memory_efficient_attention() + else: + raise ValueError("xformers is not available. Make sure it is installed correctly") + + if args.gradient_checkpointing: + unet.enable_gradient_checkpointing() + # below fails when using hra so commenting it out + if args.train_text_encoder and not args.use_hra: + text_encoder.gradient_checkpointing_enable() + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.allow_tf32: + torch.backends.cuda.matmul.allow_tf32 = True + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes + ) + + # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB GPUs + if args.use_8bit_adam: + try: + import bitsandbytes as bnb + except ImportError: + raise ImportError( + "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`." + ) + + optimizer_class = bnb.optim.AdamW8bit + else: + optimizer_class = torch.optim.AdamW + + # Optimizer creation + params_to_optimize = [param for param in unet.parameters() if param.requires_grad] + + if args.train_text_encoder: + params_to_optimize += [param for param in text_encoder.parameters() if param.requires_grad] + + optimizer = optimizer_class( + params_to_optimize, + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + # Download the official dreambooth dataset from the official repository: https://github.com/google/dreambooth.git + data_path = os.path.join(os.getcwd(), "data", "dreambooth") + if not os.path.exists(data_path): + os.makedirs(os.path.join(os.getcwd(), "data"), exist_ok=True) + os.system(f"git clone https://github.com/google/dreambooth.git '{data_path}'") + + # Dataset and DataLoaders creation: + train_dataset = DreamBoothDataset( + instance_data_root=args.instance_data_dir, + instance_prompt=args.instance_prompt, + class_data_root=args.class_data_dir if args.with_prior_preservation else None, + class_prompt=args.class_prompt, + tokenizer=tokenizer, + size=args.resolution, + center_crop=args.center_crop, + ) + + train_dataloader = torch.utils.data.DataLoader( + train_dataset, + batch_size=args.train_batch_size, + shuffle=True, + collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation), + num_workers=args.num_dataloader_workers, + ) + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, + num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, + num_cycles=args.lr_num_cycles, + power=args.lr_power, + ) + + # Prepare everything with our `accelerator`. + if args.train_text_encoder: + unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, text_encoder, optimizer, train_dataloader, lr_scheduler + ) + else: + unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, optimizer, train_dataloader, lr_scheduler + ) + + # For mixed precision training we cast the text_encoder and vae weights to half-precision + # as these models are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + # Move vae and text_encoder to device and cast to weight_dtype + vae.to(accelerator.device, dtype=weight_dtype) + if not args.train_text_encoder: + text_encoder.to(accelerator.device, dtype=weight_dtype) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + if args.report_to == "wandb": + accelerator.init_trackers(args.wandb_project_name, config=vars(args), init_kwargs=wandb_init) + else: + accelerator.init_trackers(args.project_name, config=vars(args)) + + # Train! + total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + + logger.info("***** Running training *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num batches each epoch = {len(train_dataloader)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {args.max_train_steps}") + global_step = 0 + first_epoch = 0 + + # Potentially load in the weights and states from a previous save + if args.resume_from_checkpoint: + if args.resume_from_checkpoint != "latest": + path = os.path.basename(args.resume_from_checkpoint) + else: + # Get the most recent checkpoint + dirs = os.listdir(args.output_dir) + dirs = [d for d in dirs if d.startswith("checkpoint")] + dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) + path = dirs[-1] if len(dirs) > 0 else None + accelerator.print(f"Resuming from checkpoint {path}") + accelerator.load_state(os.path.join(args.output_dir, path)) + global_step = int(path.split("-")[1]) + + resume_global_step = global_step * args.gradient_accumulation_steps + first_epoch = resume_global_step // num_update_steps_per_epoch + resume_step = resume_global_step % num_update_steps_per_epoch + + # Only show the progress bar once on each machine. + progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process) + progress_bar.set_description("Steps") + + if args.train_text_encoder: + text_encoder.train() + + for epoch in range(first_epoch, args.num_train_epochs): + unet.train() + + with TorchTracemalloc() if not args.no_tracemalloc else nullcontext() as tracemalloc: + for step, batch in enumerate(train_dataloader): + # Skip steps until we reach the resumed step + if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step: + if step % args.gradient_accumulation_steps == 0: + progress_bar.update(1) + if args.report_to == "wandb": + accelerator.print(progress_bar) + continue + + with accelerator.accumulate(unet): + # Convert images to latent space + latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample() + latents = latents * vae.config.scaling_factor + + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + bsz = latents.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint( + 0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device + ) + timesteps = timesteps.long() + + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + # Get the text embedding for conditioning + encoder_hidden_states = text_encoder(batch["input_ids"])[0] + + # Predict the noise residual + model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample + + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + if args.with_prior_preservation: + # Chunk the noise and model_pred into two parts and compute the loss on each part separately. + model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0) + target, target_prior = torch.chunk(target, 2, dim=0) + + # Compute instance loss + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + # Compute prior loss + prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean") + + # Add the prior loss to the instance loss. + loss = loss + args.prior_loss_weight * prior_loss + else: + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + accelerator.backward(loss) + + if accelerator.sync_gradients: + params_to_clip = ( + itertools.chain(unet.parameters(), text_encoder.parameters()) + if args.train_text_encoder + else unet.parameters() + ) + accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm) + + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + if args.report_to == "wandb": + accelerator.print(progress_bar) + global_step += 1 + + if global_step % args.checkpointing_steps == 0 and global_step != 0: + if accelerator.is_main_process: + save_adaptor(accelerator, global_step, unet, text_encoder, args) + + logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + accelerator.log(logs, step=global_step) + + if ( + args.validation_prompt is not None + and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0 + and global_step > 10 + ): + unet.eval() + + logger.info( + f"Running validation... \n Generating {len(validation_prompts)} images with prompt:" + f" {validation_prompts[0]}, ......" + ) + # create pipeline + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + safety_checker=None, + revision=args.revision, + ) + # set `keep_fp32_wrapper` to True because we do not want to remove + # mixed precision hooks while we are still training + pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True) + pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True) + pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config) + pipeline = pipeline.to(accelerator.device) + pipeline.set_progress_bar_config(disable=True) + + # run inference + if args.seed is not None: + generator = torch.Generator(device=accelerator.device).manual_seed(args.seed) + else: + generator = None + + images = [] + val_img_dir = os.path.join( + args.output_dir, + f"validation/{global_step}", + args.run_name, + ) + os.makedirs(val_img_dir, exist_ok=True) + + for val_promot in validation_prompts: + image = pipeline(val_promot, num_inference_steps=50, generator=generator).images[0] + image.save(os.path.join(val_img_dir, f"{'_'.join(val_promot.split(' '))}.png"[1:])) + images.append(image) + + for tracker in accelerator.trackers: + if tracker.name == "tensorboard": + np_images = np.stack([np.asarray(img) for img in images]) + tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC") + if tracker.name == "wandb": + import wandb + + tracker.log( + { + "validation": [ + wandb.Image(image, caption=f"{i}: {validation_prompts[i]}") + for i, image in enumerate(images) + ] + } + ) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + if global_step >= args.max_train_steps: + break + + # Printing the device memory usage details such as allocated memory, peak memory, and total memory usage + if not args.no_tracemalloc: + accelerator.print( + f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}" + ) + + accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}") + accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}") + accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}") + accelerator.print( + f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}" + ) + + if args.push_to_hub: + repo.push_to_hub(commit_message="End of training", blocking=False, auto_lfs_prune=True) + accelerator.end_training() + + +if __name__ == "__main__": + args = parse_args() + main(args) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/train_dreambooth.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/train_dreambooth.sh new file mode 100644 index 0000000000000000000000000000000000000000..c45915b4033bee36a1e7e46c855736c18499e2d4 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/train_dreambooth.sh @@ -0,0 +1,185 @@ + +CLASS_IDX=$1 + +# Define the UNIQUE_TOKEN, CLASS_TOKENs, and SUBJECT_NAMES +UNIQUE_TOKEN="qwe" + +SUBJECT_NAMES=( + "backpack" "backpack_dog" "bear_plushie" "berry_bowl" "can" + "candle" "cat" "cat2" "clock" "colorful_sneaker" + "dog" "dog2" "dog3" "dog5" "dog6" + "dog7" "dog8" "duck_toy" "fancy_boot" "grey_sloth_plushie" + "monster_toy" "pink_sunglasses" "poop_emoji" "rc_car" "red_cartoon" + "robot_toy" "shiny_sneaker" "teapot" "vase" "wolf_plushie" +) + +CLASS_TOKENs=( + "backpack" "backpack" "stuffed animal" "bowl" "can" + "candle" "cat" "cat" "clock" "sneaker" + "dog" "dog" "dog" "dog" "dog" + "dog" "dog" "toy" "boot" "stuffed animal" + "toy" "glasses" "toy" "toy" "cartoon" + "toy" "sneaker" "teapot" "vase" "stuffed animal" +) + +CLASS_TOKEN=${CLASS_TOKENs[$CLASS_IDX]} +SELECTED_SUBJECT=${SUBJECT_NAMES[$CLASS_IDX]} + +if [[ $CLASS_IDX =~ ^(0|1|2|3|4|5|8|9|17|18|19|20|21|22|23|24|25|26|27|28|29)$ ]]; then + PROMPT_LIST=( + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the jungle." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the snow." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on the beach." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on a cobblestone street." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of pink fabric." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a wooden floor." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a city in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a mountain in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a blue house in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a purple rug in a forest." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a wheat field in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a tree and autumn leaves in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with the Eiffel Tower in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} floating on top of water." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} floating in an ocean of milk." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of green grass with sunflowers around it." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a mirror." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of the sidewalk in a crowded street." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a dirt road." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a white rug." + "a red ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a purple ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a shiny ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a wet ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a cube shaped ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + ) + + prompt_test_list=( + "a ${CLASS_TOKEN} in the jungle" + "a ${CLASS_TOKEN} in the snow" + "a ${CLASS_TOKEN} on the beach" + "a ${CLASS_TOKEN} on a cobblestone street" + "a ${CLASS_TOKEN} on top of pink fabric" + "a ${CLASS_TOKEN} on top of a wooden floor" + "a ${CLASS_TOKEN} with a city in the background" + "a ${CLASS_TOKEN} with a mountain in the background" + "a ${CLASS_TOKEN} with a blue house in the background" + "a ${CLASS_TOKEN} on top of a purple rug in a forest" + "a ${CLASS_TOKEN} with a wheat field in the background" + "a ${CLASS_TOKEN} with a tree and autumn leaves in the background" + "a ${CLASS_TOKEN} with the Eiffel Tower in the background" + "a ${CLASS_TOKEN} floating on top of water" + "a ${CLASS_TOKEN} floating in an ocean of milk" + "a ${CLASS_TOKEN} on top of green grass with sunflowers around it" + "a ${CLASS_TOKEN} on top of a mirror" + "a ${CLASS_TOKEN} on top of the sidewalk in a crowded street" + "a ${CLASS_TOKEN} on top of a dirt road" + "a ${CLASS_TOKEN} on top of a white rug" + "a red ${CLASS_TOKEN}" + "a purple ${CLASS_TOKEN}" + "a shiny ${CLASS_TOKEN}" + "a wet ${CLASS_TOKEN}" + "a cube shaped ${CLASS_TOKEN}" + ) + +else + PROMPT_LIST=( + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the jungle." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the snow." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on the beach." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on a cobblestone street." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of pink fabric." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a wooden floor." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a city in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a mountain in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a blue house in the background." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a purple rug in a forest." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a red hat." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a santa hat." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a rainbow scarf." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a black top hat and a monocle." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a chef outfit." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a firefighter outfit." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a police outfit." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing pink glasses." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a yellow shirt." + "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a purple wizard outfit." + "a red ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a purple ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a shiny ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a wet ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + "a cube shaped ${UNIQUE_TOKEN} ${CLASS_TOKEN}." + ) + + prompt_test_list=( + "a ${CLASS_TOKEN} in the jungle" + "a ${CLASS_TOKEN} in the snow" + "a ${CLASS_TOKEN} on the beach" + "a ${CLASS_TOKEN} on a cobblestone street" + "a ${CLASS_TOKEN} on top of pink fabric" + "a ${CLASS_TOKEN} on top of a wooden floor" + "a ${CLASS_TOKEN} with a city in the background" + "a ${CLASS_TOKEN} with a mountain in the background" + "a ${CLASS_TOKEN} with a blue house in the background" + "a ${CLASS_TOKEN} on top of a purple rug in a forest" + "a ${CLASS_TOKEN} wearing a red hat" + "a ${CLASS_TOKEN} wearing a santa hat" + "a ${CLASS_TOKEN} wearing a rainbow scarf" + "a ${CLASS_TOKEN} wearing a black top hat and a monocle" + "a ${CLASS_TOKEN} in a chef outfit" + "a ${CLASS_TOKEN} in a firefighter outfit" + "a ${CLASS_TOKEN} in a police outfit" + "a ${CLASS_TOKEN} wearing pink glasses" + "a ${CLASS_TOKEN} wearing a yellow shirt" + "a ${CLASS_TOKEN} in a purple wizard outfit" + "a red ${CLASS_TOKEN}" + "a purple ${CLASS_TOKEN}" + "a shiny ${CLASS_TOKEN}" + "a wet ${CLASS_TOKEN}" + "a cube shaped ${CLASS_TOKEN}" + ) +fi + +VALIDATION_PROMPT=${PROMPT_LIST[@]} +INSTANCE_PROMPT="a photo of ${UNIQUE_TOKEN} ${CLASS_TOKEN}" +CLASS_PROMPT="a photo of ${CLASS_TOKEN}" + +export MODEL_NAME="stabilityai/stable-diffusion-2-1" + +PEFT_TYPE="hra" +HRA_R=8 + +export PROJECT_NAME="dreambooth_${PEFT_TYPE}" +export RUN_NAME="${SELECTED_SUBJECT}_${PEFT_TYPE}_${HRA_R}" +export INSTANCE_DIR="./data/dreambooth/dataset/${SELECTED_SUBJECT}" +export CLASS_DIR="./data/class_data/${CLASS_TOKEN}" +export OUTPUT_DIR="./data/output/${PEFT_TYPE}" + + +accelerate launch train_dreambooth.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --class_data_dir="$CLASS_DIR" \ + --output_dir=$OUTPUT_DIR \ + --project_name=$PROJECT_NAME \ + --run_name=$RUN_NAME \ + --with_prior_preservation \ + --prior_loss_weight=1.0 \ + --instance_prompt="$INSTANCE_PROMPT" \ + --validation_prompt="$VALIDATION_PROMPT" \ + --class_prompt="$CLASS_PROMPT" \ + --resolution=512 \ + --train_batch_size=1 \ + --num_dataloader_workers=2 \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --num_class_images=200 \ + --use_hra \ + --hra_r=$HRA_R \ + --hra_bias="hra_only" \ + --learning_rate=5e-3 \ + --max_train_steps=510 \ + --checkpointing_steps=200 \ + --validation_steps=200 \ + --enable_xformers_memory_efficient_attention \ + --report_to="none" \ \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/utils/__init__.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/utils/args_loader.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/utils/args_loader.py new file mode 100644 index 0000000000000000000000000000000000000000..64e230764f939c968cbeec8a4dcd27b8572d1df4 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/utils/args_loader.py @@ -0,0 +1,377 @@ +# adapted from [peft's boft_dreambooth](https://github.com/huggingface/peft/tree/main/examples/boft_dreambooth) + +import argparse +import os +import warnings +from typing import Optional + +from huggingface_hub import HfFolder, whoami +from transformers import PretrainedConfig + + +def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str): + text_encoder_config = PretrainedConfig.from_pretrained( + pretrained_model_name_or_path, + subfolder="text_encoder", + revision=revision, + ) + model_class = text_encoder_config.architectures[0] + + if model_class == "CLIPTextModel": + from transformers import CLIPTextModel + + return CLIPTextModel + elif model_class == "RobertaSeriesModelWithTransformation": + from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation + + return RobertaSeriesModelWithTransformation + else: + raise ValueError(f"{model_class} is not supported.") + + +def get_full_repo_name(model_id: str, organization: Optional[str] = None, token: Optional[str] = None): + if token is None: + token = HfFolder.get_token() + if organization is None: + username = whoami(token)["name"] + return f"{username}/{model_id}" + else: + return f"{organization}/{model_id}" + + +def parse_args(input_args=None): + parser = argparse.ArgumentParser(description="Simple example of a Dreambooth training script.") + parser.add_argument( + "--pretrained_model_name_or_path", + type=str, + default=None, + required=True, + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--tokenizer_name", + type=str, + default=None, + help="Pretrained tokenizer name or path if not the same as model_name", + ) + parser.add_argument( + "--instance_data_dir", + type=str, + default=None, + required=True, + help="A folder containing the training data of instance images.", + ) + parser.add_argument( + "--class_data_dir", + type=str, + default=None, + required=False, + help="A folder containing the training data of class images.", + ) + parser.add_argument( + "--instance_prompt", + type=str, + default=None, + required=True, + help="The prompt with identifier specifying the instance", + ) + parser.add_argument( + "--class_prompt", + type=str, + default=None, + help="The prompt to specify images in the same class as provided instance images.", + ) + parser.add_argument( + "--with_prior_preservation", + default=False, + action="store_true", + help="Flag to add prior preservation loss.", + ) + parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.") + parser.add_argument( + "--num_class_images", + type=int, + default=100, + help=( + "Minimal class images for prior preservation loss. If there are not enough images already present in" + " class_data_dir, additional images will be sampled with class_prompt." + ), + ) + parser.add_argument( + "--validation_prompt", + nargs="+", + help="A prompt that is used during validation to verify that the model is learning.", + ) + parser.add_argument( + "--num_validation_images", + type=int, + default=4, + help="Number of images that should be generated during validation with `validation_prompt`.", + ) + parser.add_argument( + "--validation_steps", + type=int, + default=500, + help=( + "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt" + " `args.validation_prompt` multiple times: `args.num_validation_images`." + ), + ) + parser.add_argument( + "--output_dir", + type=str, + default="text-inversion-model", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution" + ) + parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder") + + parser.add_argument( + "--set_grads_to_none", + action="store_true", + help=( + "Save more memory by using setting grads to None instead of zero. Be aware, that this changes certain" + " behaviors, so disable this argument if it causes any problems. More info:" + " https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html" + ), + ) + + # hra args + parser.add_argument("--use_hra", action="store_true", help="Whether to use HRA for parameter efficient tuning.") + parser.add_argument("--hra_r", type=int, default=8, help="The rank of HRA across different layers.") + parser.add_argument( + "--hra_apply_GS", default=False, action="store_true", help="Whether to apply Gram-Schmidt orthogonalization." + ) + parser.add_argument( + "--hra_bias", + type=str, + default="none", + help="Bias type for HRA. Can be 'none', 'all' or 'hra_only', only used if use_hra is True.", + ) + parser.add_argument( + "--num_dataloader_workers", type=int, default=1, help="Num of workers for the training dataloader." + ) + parser.add_argument( + "--no_tracemalloc", + default=False, + action="store_true", + help="Flag to stop memory allocation tracing during training. This could speed up training on Windows.", + ) + + parser.add_argument( + "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader." + ) + parser.add_argument( + "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images." + ) + parser.add_argument("--num_train_epochs", type=int, default=1) + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help=( + "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final" + " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming" + " training using `--resume_from_checkpoint`." + ), + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help=( + "Whether training should be resumed from a previous checkpoint. Use a path saved by" + ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.' + ), + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=5e-6, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler." + ) + parser.add_argument( + "--lr_num_cycles", + type=int, + default=1, + help="Number of hard resets of the lr in cosine_with_restarts scheduler.", + ) + parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.") + parser.add_argument( + "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes." + ) + parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.") + parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.") + parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.") + parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer") + parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.") + parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.") + parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.") + parser.add_argument( + "--hub_model_id", + type=str, + default=None, + help="The name of the repository to keep in sync with the local `output_dir`.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument( + "--project_name", + type=str, + default=None, + help=("The project name for log tracking"), + ) + parser.add_argument( + "--run_name", + type=str, + default=None, + help=("The run name for log tracking"), + ) + parser.add_argument( + "--report_to", + type=str, + default="wandb", + help=( + 'The integration to report the results and logs to. Supported platforms are `"wandb"`' + ' (default), `"tensorboard"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument( + "--wandb_key", + type=str, + default=None, + help=("If report to option is set to wandb, api-key for wandb used for login to wandb "), + ) + parser.add_argument( + "--wandb_project_name", + type=str, + default=None, + help=("If report to option is set to wandb, project name in wandb for log tracking "), + ) + parser.add_argument( + "--wandb_run_name", + type=str, + default=None, + help=("If report to option is set to wandb, project name in wandb for log tracking "), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default=None, + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--prior_generation_precision", + type=str, + default=None, + choices=["no", "fp32", "fp16", "bf16"], + help=( + "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to fp16 if a GPU is available else fp32." + ), + ) + parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank") + parser.add_argument( + "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers." + ) + + if input_args is not None: + args = parser.parse_args(input_args) + else: + args = parser.parse_args() + + env_local_rank = int(os.environ.get("LOCAL_RANK", "-1")) + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + # Sanity checks + # if args.dataset_name is None and args.train_data_dir is None: + # raise ValueError("Need either a dataset name or a training folder.") + + if args.with_prior_preservation: + if args.class_data_dir is None: + raise ValueError("You must specify a data directory for class images.") + if args.class_prompt is None: + raise ValueError("You must specify prompt for class images.") + else: + # logger is not available yet + if args.class_data_dir is not None: + warnings.warn("You need not use --class_data_dir without --with_prior_preservation.") + if args.class_prompt is not None: + warnings.warn("You need not use --class_prompt without --with_prior_preservation.") + + return args diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/utils/dataset.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/utils/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..eaf8c99f10551e46d6a7bde01a13bb9391343b58 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/utils/dataset.py @@ -0,0 +1,128 @@ +# adapted from [peft's boft_dreambooth](https://github.com/huggingface/peft/tree/main/examples/boft_dreambooth) + +from pathlib import Path + +import torch +from PIL import Image +from torch.utils.data import Dataset +from torchvision import transforms + + +class DreamBoothDataset(Dataset): + """ + A dataset to prepare the instance and class images with the prompts for fine-tuning the model. + It pre-processes the images and the tokenizes prompts. + """ + + def __init__( + self, + instance_data_root, + instance_prompt, + tokenizer, + class_data_root=None, + class_prompt=None, + size=512, + center_crop=False, + ): + self.size = size + self.center_crop = center_crop + self.tokenizer = tokenizer + + self.instance_data_root = Path(instance_data_root) + if not self.instance_data_root.exists(): + raise ValueError("Instance images root doesn't exists.") + + self.instance_images_path = list(Path(instance_data_root).iterdir()) + self.num_instance_images = len(self.instance_images_path) + self.instance_prompt = instance_prompt + self._length = self.num_instance_images + + if class_data_root is not None: + self.class_data_root = Path(class_data_root) + self.class_data_root.mkdir(parents=True, exist_ok=True) + self.class_images_path = list(self.class_data_root.iterdir()) + self.num_class_images = len(self.class_images_path) + self._length = max(self.num_class_images, self.num_instance_images) + self.class_prompt = class_prompt + else: + self.class_data_root = None + + self.image_transforms = transforms.Compose( + [ + transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR), + transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + + def __len__(self): + return self._length + + def __getitem__(self, index): + example = {} + instance_image = Image.open(self.instance_images_path[index % self.num_instance_images]) + if instance_image.mode != "RGB": + instance_image = instance_image.convert("RGB") + example["instance_images"] = self.image_transforms(instance_image) + example["instance_prompt_ids"] = self.tokenizer( + self.instance_prompt, + truncation=True, + padding="max_length", + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + if self.class_data_root: + class_image = Image.open(self.class_images_path[index % self.num_class_images]) + if class_image.mode != "RGB": + class_image = class_image.convert("RGB") + example["class_images"] = self.image_transforms(class_image) + example["class_prompt_ids"] = self.tokenizer( + self.class_prompt, + truncation=True, + padding="max_length", + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + return example + + +def collate_fn(examples, with_prior_preservation=False): + input_ids = [example["instance_prompt_ids"] for example in examples] + pixel_values = [example["instance_images"] for example in examples] + + # Concat class and instance examples for prior preservation. + # We do this to avoid doing two forward passes. + if with_prior_preservation: + input_ids += [example["class_prompt_ids"] for example in examples] + pixel_values += [example["class_images"] for example in examples] + + pixel_values = torch.stack(pixel_values) + pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float() + + input_ids = torch.cat(input_ids, dim=0) + + batch = { + "input_ids": input_ids, + "pixel_values": pixel_values, + } + return batch + + +class PromptDataset(Dataset): + "A simple dataset to prepare the prompts to generate class images on multiple GPUs." + + def __init__(self, prompt, num_samples): + self.prompt = prompt + self.num_samples = num_samples + + def __len__(self): + return self.num_samples + + def __getitem__(self, index): + example = {} + example["prompt"] = self.prompt + example["index"] = index + return example diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/utils/tracemalloc.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/utils/tracemalloc.py new file mode 100644 index 0000000000000000000000000000000000000000..c47ef31e9e956b63fec5dd819ef63edcef50430d --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/hra_dreambooth/utils/tracemalloc.py @@ -0,0 +1,62 @@ +# adapted from [peft's boft_dreambooth](https://github.com/huggingface/peft/tree/main/examples/boft_dreambooth) + +import gc +import threading + +import psutil +import torch + + +# Converting Bytes to Megabytes +def b2mb(x): + return int(x / 2**20) + + +# This context manager is used to track the peak memory usage of the process +class TorchTracemalloc: + def __enter__(self): + self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + self.device_module = getattr(torch, self.device_type, torch.cuda) + gc.collect() + self.device_module.empty_cache() + self.device_module.reset_peak_memory_stats() # reset the peak gauge to zero + self.begin = self.device_module.memory_allocated() + self.process = psutil.Process() + + self.cpu_begin = self.cpu_mem_used() + self.peak_monitoring = True + peak_monitor_thread = threading.Thread(target=self.peak_monitor_func) + peak_monitor_thread.daemon = True + peak_monitor_thread.start() + return self + + def cpu_mem_used(self): + """get resident set size memory for the current process""" + return self.process.memory_info().rss + + def peak_monitor_func(self): + self.cpu_peak = -1 + + while True: + self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak) + + # can't sleep or will not catch the peak right (this comment is here on purpose) + # time.sleep(0.001) # 1msec + + if not self.peak_monitoring: + break + + def __exit__(self, *exc): + self.peak_monitoring = False + + gc.collect() + self.device_module.empty_cache() + self.end = self.device_module.memory_allocated() + self.peak = self.device_module.max_memory_allocated() + self.used = b2mb(self.end - self.begin) + self.peaked = b2mb(self.peak - self.begin) + + self.cpu_end = self.cpu_mem_used() + self.cpu_used = b2mb(self.cpu_end - self.cpu_begin) + self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin) + # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}") diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/image_classification/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/image_classification/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3ebc5e0e9b25471b0c30d750646bfeb6d21d6ff0 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/image_classification/README.md @@ -0,0 +1,15 @@ +# Fine-tuning for image classification using LoRA and 🤗 PEFT + +## Vision Transformer model from transformers + +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/image_classification/image_classification_peft_lora.ipynb) + +We provide a notebook (`image_classification_peft_lora.ipynb`) where we learn how to use [LoRA](https://huggingface.co/papers/2106.09685) from 🤗 PEFT to fine-tune an image classification model by ONLY using **0.7%** of the original trainable parameters of the model. + +LoRA adds low-rank "update matrices" to certain blocks in the underlying model (in this case the attention blocks) and ONLY trains those matrices during fine-tuning. During inference, these update matrices are _merged_ with the original model parameters. For more details, check out the [original LoRA paper](https://huggingface.co/papers/2106.09685). + +## PoolFormer model from timm + +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/image_classification/image_classification_timm_peft_lora.ipynb) + +The notebook `image_classification_timm_peft_lora.ipynb` showcases fine-tuning an image classification model using from the [timm](https://huggingface.co/docs/timm/index) library. Again, LoRA is used to reduce the numberof trainable parameters to a fraction of the total. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/image_classification/image_classification_peft_lora.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/image_classification/image_classification_peft_lora.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..02e97d9bcead1053c7359b0fbe5c2f49a3c1e5e3 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/image_classification/image_classification_peft_lora.ipynb @@ -0,0 +1,14951 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "71GTxOD71mEn" + }, + "source": [ + "## Introduction\n", + "\n", + "In this notebook, we will learn how to use [LoRA](https://huggingface.co/papers/2106.09685) from 🤗 PEFT to fine-tune an image classification model by ONLY using **0.77%** of the original trainable parameters of the model. \n", + "\n", + "LoRA adds low-rank \"update matrices\" to certain blocks in the underlying model (in this case the attention blocks) and ONLY trains those matrices during fine-tuning. During inference, these update matrices are _merged_ with the original model parameters. For more details, check out the [original LoRA paper](https://huggingface.co/papers/2106.09685). \n", + "\n", + "Let's get started by installing the dependencies. \n", + "\n", + "__*Note that this notebook builds on top the [official image classification example notebook](https://github.com/huggingface/notebooks/blob/main/examples/image_classification.ipynb).*__" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0a_bETbqv4P7" + }, + "source": [ + "## Install dependencies\n", + "\n", + "Here we're installing `peft` from source to ensure we have access to all the bleeding edge features of `peft`. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Z0_5BYt8hobv", + "outputId": "aafcbc39-b972-493a-8922-2141b1621926" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.3/6.3 MB\u001b[0m \u001b[31m53.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m199.7/199.7 KB\u001b[0m \u001b[31m24.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m81.4/81.4 KB\u001b[0m \u001b[31m11.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m462.8/462.8 KB\u001b[0m \u001b[31m46.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m190.3/190.3 KB\u001b[0m \u001b[31m23.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.6/7.6 MB\u001b[0m \u001b[31m102.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m213.0/213.0 KB\u001b[0m \u001b[31m25.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m132.0/132.0 KB\u001b[0m \u001b[31m15.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.3/76.3 MB\u001b[0m \u001b[31m23.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m140.6/140.6 KB\u001b[0m \u001b[31m20.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Building wheel for peft (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n" + ] + } + ], + "source": [ + "!pip install transformers accelerate evaluate datasets git+https://github.com/huggingface/peft -q" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Y8dSVHoIv7HC" + }, + "source": [ + "## Authentication\n", + "\n", + "We will share our fine-tuned model at the end of training. So, to do that we just authenticate using our 🤗 token. This token is available from [here](https://huggingface.co/settings/tokens). If you don't have a 🤗 account already, we highly encourage you to do so; it's free!" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 359, + "referenced_widgets": [ + "5d2f5fb454bc4c16b520e4e96381758f", + "dfd2baceac524fe29c0f4a8443b60a71", + "90d8e83a6af54184a82e0b81ae7054b9", + "1f96ca356b6f41b59275abe93df33f43", + "eef81e9bea0c4f5d85e7efa8ebe0463a", + "cab6d36980c0423fb75299c09c33facc", + "dd38a658218d42d7b051c66de4d4180a", + "f34be236ef9c42448ecf2957160990f7", + "38deee504dab482983a8b8f340472282", + "b2688e34899a449e8d1f6ddb5a66bb85", + "dd4edb4de5e14dfbbee418dba0bb3573", + "516c6d75bc654d62b95ac235ce84c59c", + "14c23f636609458ca4493854826c1a8e", + "c778798c234d45b5a4ae2f250e3706f9", + "d5c5396ea2f54ff0aeb9be58b59c253b", + "15bd2dcdbf4b4e74b9db09bdb8822e61", + "ecf73dd75420460399bfd04d8cd81f90" + ] + }, + "id": "31Zv6rFYr37d", + "outputId": "6476ebcf-6d71-4b7d-ee38-dc4f8e8d024e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Token is valid.\n", + "Your token has been saved in your configured git credential helpers (store).\n", + "Your token has been saved to /root/.cache/huggingface/token\n", + "Login successful\n" + ] + } + ], + "source": [ + "from huggingface_hub import notebook_login\n", + "\n", + "notebook_login()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AX7aJaIKjbCF" + }, + "source": [ + "## Check the library versions" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ejkn8GBzh_DB", + "outputId": "777afbdf-e026-43d8-8efa-80bb958d0ca3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "===================================BUG REPORT===================================\n", + "Welcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n", + "================================================================================\n" + ] + } + ], + "source": [ + "import transformers\n", + "import accelerate\n", + "import peft" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "A833xxo3ir28", + "outputId": "da71ef1c-b6d7-43e2-a78b-23556785ef02" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transformers version: 4.26.0\n", + "Accelerate version: 0.16.0\n", + "PEFT version: 0.1.0.dev0\n" + ] + } + ], + "source": [ + "print(f\"Transformers version: {transformers.__version__}\")\n", + "print(f\"Accelerate version: {accelerate.__version__}\")\n", + "print(f\"PEFT version: {peft.__version__}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Po1Ve9u5v_Ul" + }, + "source": [ + "## Select a model checkpoint to fine-tune" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "vhvCQpP-isJr" + }, + "outputs": [], + "source": [ + "model_checkpoint = \"google/vit-base-patch16-224-in21k\" # pre-trained model from which to fine-tune" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UKN3rMAsjgEz" + }, + "source": [ + "## Load a dataset\n", + "\n", + "We're only loading the first 5000 instances from the training set of the [Food-101 dataset](https://huggingface.co/datasets/food101) to keep this example runtime short. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 379, + "referenced_widgets": [ + "61b957d3b51643f78a921979072fe3b6", + "d7136a7b3d0040d580508fc665b9fb00", + "5ee5e11191fc46dd92d4c2f1a7d6d9da", + "3587d42fa09b4fcdb365956a9bb07c77", + "c1ed0b68884c4d4291cd67c0e685ef18", + "9102cc38ee9942ac91dc66eda069ddcb", + "416c65eedcea4a6ea69dae317de79bca", + "128677e1b5b14e63b06b0f81c9cc4df0", + "22da54e68b1d48f9b3ba55ac1ca56873", + "16c7db587b8e475fa3aa9677385b092a", + "23c608994006427caca7975e0d81271f", + "71f7296ec9be4d9abe1af581722b40fe", + "b98e53eefc1944f193169c4f7a72b799", + "1d4a5a5b7d1645a8bf8133935e173082", + "d29e3b9102f14f3385e47ae6e27d1ab1", + "1e3e374b08964a689cfaac9c826f207b", + "b377e94780fb4e1db3b9678717e04fc1", + "86103f87819b440b8464f4460f50375e", + "c3178221dc074657bc0e585c4cfe326d", + "3c6842e0158b4dcc9b93eddfe3279d2a", + "fc612aaed5644b84959a1958b0240dda", + "36c8300bcbb84627a03b94f0eea86ce9", + "f0b0cad40fbd461ca7bdcdbb5f442f57", + "76cf84387a7c43608ad018188eef4114", + "68ef0c8550ee4c00aa8b284d48572610", + "58e7f5c36d8b4836a868ce89838f1896", + "9b216287b8694bcc9960a356adf15504", + "4d653faaedcd497d863bbf2c429ce925", + "d10f2e9c25f2417f9728aa8e43acf677", + "7a35d0ddc2da4dd69068214b87bcdd7f", + "9aac38a8c8694c67a34b2fced0e1a706", + "9d1dff20634a403fb8829469d74301aa", + "b2e64f35be2d4fa3bc95c769b78e1dd1", + "fdf282b234fe4a1a8ab452ac04511b7d", + "59792e1ee7074f998d5d4494c09061c6", + "cd5b2433cc404ac7b1bb35c6a55f6874", + "7c1b6f271fff4d60be39d291c73bfb75", + "074f38bd3a9d49719188e8860fb1b5d3", + "3ff84efe0edc491c884898424be4ae71", + "5a79a196fd7b49128a9647347f85b364", + "851fb5ac25db4bb287a6dbe948278eec", + "471d44c8e49e42b89302ef53ab0eb316", + "4089323832d04dc2a40e238b5fa256cc", + "2d867c65533e482a96db93bc5a09b8cb", + "849ac914c3cc49d29d619dd4f532d74c", + "4cb3d75f80434b48beb6aa4b07c86dfe", + "ff39519704b64e68b69ec06aea02791e", + "e0f2599ed04c424f896e503630034e84", + "1674d568877048368c842c21ffaac811", + "0957e36be17c43fd89462c5d5ddcec1b", + "dffe636233c84dcd9d75f34baf40fa1d", + "dcefc9ba538e4da2b75f9372a4c5b5bf", + "77df794cb4e4491e80ee20bbd2801a89", + "7e243f4a30c645b080e688fb706b4548", + "db6b68a237cf4e93ae6383448b773e47", + "c580d3a6e99e48fab09b3ce799711802", + "4afba780d0f244548a7f28db15b41dc9", + "4e3d482feec9485590d277dfc1d0b3d3", + "23436ea247dd43d8829ca143a49637c5", + "9609eaf0792345b2ab457cb7188ee14a", + "1839e4ed1d3c4975b34c3c050052693f", + "1b31bfb0ef4c404698eb2205414170af", + "6350637718344d65a757d2919de8c1ab", + "42a16474e41343b2a7d46e5930b41b89", + "ce16ac2b3ff244e6bd7dd58daa9f4f7f", + "d25f3ebb577749d89e2e6d2a72f6ca5f", + "13279e67c4d847e4846e2d34e8aac589", + "d7d43177c750412cb1522eb08c01d2d9", + "70b04a3579a5446f94acd422c70ac50a", + "43940212a87d410c82cc9cd15f38a97e", + "19fd7c60287b43bbb6e0b12c25b4b375", + "9013fd35e17f44bfb7a068833adaf167", + "a849dcc9c7f742d49c874597d8c693c5", + "039dd9a4b99e433088a0acd8ba7b519b", + "17235d013b7c4cee996d0bbc1cc6c70c", + "3db63ba25e7349a785244c367d53813e", + "4748461200ae4af883577e2fbb8cb686", + "19ec79f5a5174aa3b26861a9662951d3", + "57c15c64c2374f06a1e0a36bab953ef7", + "06cf9f29b929412a8092044e25861f1c", + "c2032e5054ac4604832957cb6e2e69ca", + "d1ff50e1b871429a85df8cf10e73ffb1", + "10c4f5677d1c4af8b3370b7fb1255065", + "603dd1541db345879295edc16ace2b0c", + "375ac7a15cea4ce3aa484a806cc82717", + "6b6459f123ef4f24a550cd9ec3c9f809", + "e3047557ae7f40e2aecccf1afad36f3f", + "4fc212af0c9b45ebbe334e3dd7f11b59", + "fee4fba960ac41ed97984467da41f319", + "ee103846621b4c0e8e1266599b99f6ee", + "dcd1c1f4fc014c4aa9ebdaf3c533a061", + "a29d758fb7f147c7ad1108f140caf23a", + "cb52fa97c659430a8bd71dcd76245a7f", + "e7144551e74b46529b00a61f580a183d", + "9b1bfa11ee3746c38155c4505abfaa86", + "26520bc6555d41d9951ea0219dc4b5d7", + "60472b5a360f43e89e39d641dabba57b", + "aa9b6ac2785c4a5abd1189edd60698eb", + "cfab815edc1f42898b656c0f4a3b366b", + "c5718d031b9942f4b8bf331a8543db29", + "35d862a4f00c4493920da3e2eb92b043", + "16b464f168d844cba5eb0c91ab4fb91c", + "af5231ecf6e2489b80cdcd435b5e3451", + "62a0f83cf75d4c59a0601c5ad3a817a7", + "b48f685dc91540f38690f39eace724d5", + "ce4b6a4b6fec4ceb907fa436ff940bd2", + "28f82c8fc9cf46c7858132a77e45834b", + "ce18faf7b68140a3a8247330b356e05b", + "af6a4a054a5d451b9fe256bf60a09c21", + "afb1f0681bce47e1ba718900d0430f34" + ] + }, + "id": "rI0d2_liitUr", + "outputId": "4ae986eb-6cbb-4d9f-bb99-1ffbb05ee835" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "61b957d3b51643f78a921979072fe3b6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading builder script: 0%| | 0.00/6.21k [00:00\n", + " \n", + " \n", + " [45/45 04:44, Epoch 5/5]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EpochTraining LossValidation LossAccuracy
1No log0.5068710.896000
22.1627000.1891410.946000
30.3451000.1447590.960000
40.2116000.1508860.958000
50.1711000.1497510.958000

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "***** Running Evaluation *****\n", + " Num examples = 500\n", + " Batch size = 128\n", + "Saving model checkpoint to vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-9\n", + "Configuration saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-9/config.json\n", + "Model weights saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-9/pytorch_model.bin\n", + "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-9/preprocessor_config.json\n", + "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/preprocessor_config.json\n", + "***** Running Evaluation *****\n", + " Num examples = 500\n", + " Batch size = 128\n", + "Saving model checkpoint to vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-18\n", + "Configuration saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-18/config.json\n", + "Model weights saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-18/pytorch_model.bin\n", + "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-18/preprocessor_config.json\n", + "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/preprocessor_config.json\n", + "***** Running Evaluation *****\n", + " Num examples = 500\n", + " Batch size = 128\n", + "Saving model checkpoint to vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-27\n", + "Configuration saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-27/config.json\n", + "Model weights saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-27/pytorch_model.bin\n", + "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-27/preprocessor_config.json\n", + "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/preprocessor_config.json\n", + "***** Running Evaluation *****\n", + " Num examples = 500\n", + " Batch size = 128\n", + "Saving model checkpoint to vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-36\n", + "Configuration saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-36/config.json\n", + "Model weights saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-36/pytorch_model.bin\n", + "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-36/preprocessor_config.json\n", + "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/preprocessor_config.json\n", + "***** Running Evaluation *****\n", + " Num examples = 500\n", + " Batch size = 128\n", + "Saving model checkpoint to vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-45\n", + "Configuration saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-45/config.json\n", + "Model weights saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-45/pytorch_model.bin\n", + "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-45/preprocessor_config.json\n", + "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/preprocessor_config.json\n", + "\n", + "\n", + "Training completed. Do not forget to share your model on huggingface.co/models =)\n", + "\n", + "\n", + "Loading best model from vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-27 (score: 0.96).\n" + ] + } + ], + "source": [ + "trainer = Trainer(\n", + " lora_model,\n", + " args,\n", + " train_dataset=train_ds,\n", + " eval_dataset=val_ds,\n", + " processing_class=image_processor,\n", + " compute_metrics=compute_metrics,\n", + " data_collator=collate_fn,\n", + ")\n", + "train_results = trainer.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b2NENHxHCejv" + }, + "source": [ + "In just a few minutes, we have a fine-tuned model with 96% validation accuracy. Also, note that we used a very small subset of the training dataset which is definitely impacting the results. " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 198 + }, + "id": "_MAd2906jQKG", + "outputId": "7b825531-4e8d-4666-d6fc-eaa1accf3bb6" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "***** Running Evaluation *****\n", + " Num examples = 500\n", + " Batch size = 128\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "

\n", + " \n", + " \n", + " [4/4 01:48]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "{'eval_loss': 0.14475855231285095,\n", + " 'eval_accuracy': 0.96,\n", + " 'eval_runtime': 3.5725,\n", + " 'eval_samples_per_second': 139.958,\n", + " 'eval_steps_per_second': 1.12,\n", + " 'epoch': 5.0}" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trainer.evaluate(val_ds)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qo_scDEyAQER" + }, + "source": [ + "## Sharing your model and inference \n", + "\n", + "Once the fine-tuning is done, we can share the LoRA parameters with the community like so: " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 172, + "referenced_widgets": [ + "980d2f61332f414d9888b76e78774be4", + "cbc0ba8e49a740fcae7b94fe7edb8107", + "b3f07ef160a7425880ffe362008d4400", + "49ed3330fa9645eda8b5aed0fd7cbafe", + "f96302d0c2d849c5b5a0206b65e461ab", + "fcc7ad16a0b14d96acd9be9e03ac6af9", + "1a08961f063346ccae206a863ab7df6b", + "1150e391e753424da7d65bda10463da4", + "e6e36d744e1244aeb7eb0c4ce392372d", + "b2ad992db5a045668fa55c7393ec7870", + "b5fad0f3f2d543ecaed726e52d2d86bb", + "e83fd078f467406da0baf26e18b39e89", + "9b4b67731a7a4bc59be132b53c24eae8", + "e33243b001274d02a25f5940ba41ecf6", + "06e4c619e366427a8ff4c358196ecd12", + "bacd429b42d843299cb75224db3afb1e", + "c53429e699e64b3d8895a355bbd947a6", + "2bfd04824f2e4fd6844dd38e46dbbbdf", + "40a5a50aeca24f0d8990da97971004d1", + "be71e6438e0e49759d2f72feec520cae", + "1902fbc4c1da4ffe90f0947e58eb5d48", + "12a94351242444d7b0d23b8accc1824a" + ] + }, + "id": "TyQvIcnFzLIV", + "outputId": "7ac2819e-080e-4940-9755-15c32832d9a6" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Uploading the following files to sayakpaul/vit-base-patch16-224-in21k-finetuned-lora-food101: adapter_config.json,adapter_model.bin\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "980d2f61332f414d9888b76e78774be4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Upload 1 LFS files: 0%| | 0/1 [00:00" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from PIL import Image\n", + "import requests\n", + "\n", + "url = \"https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/beignets.jpeg\"\n", + "image = Image.open(requests.get(url, stream=True).raw)\n", + "image" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dFuqZgmCW4cu" + }, + "source": [ + "We first instantiate an `image_processor` from the underlying model repo. " + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dN4x_pj-VQx8", + "outputId": "b4fddd49-2f10-48e2-de31-0cefd20d405d" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "loading configuration file preprocessor_config.json from cache at /root/.cache/huggingface/hub/models--sayakpaul--vit-base-patch16-224-in21k-finetuned-lora-food101/snapshots/fa2503cc7d91e0dd69728c1dc66ed80d7bd3289b/preprocessor_config.json\n", + "Image processor ViTImageProcessor {\n", + " \"do_normalize\": true,\n", + " \"do_rescale\": true,\n", + " \"do_resize\": true,\n", + " \"image_mean\": [\n", + " 0.5,\n", + " 0.5,\n", + " 0.5\n", + " ],\n", + " \"image_processor_type\": \"ViTImageProcessor\",\n", + " \"image_std\": [\n", + " 0.5,\n", + " 0.5,\n", + " 0.5\n", + " ],\n", + " \"resample\": 2,\n", + " \"rescale_factor\": 0.00392156862745098,\n", + " \"size\": {\n", + " \"height\": 224,\n", + " \"width\": 224\n", + " }\n", + "}\n", + "\n" + ] + } + ], + "source": [ + "image_processor = AutoImageProcessor.from_pretrained(repo_name)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Dc0rCwC5XAaL" + }, + "source": [ + "We then prepare the sample for inference." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "57C6tcdnVYu1", + "outputId": "f164dd91-8679-482e-fb10-2f530d4ea9f4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# prepare image for the model\n", + "encoding = image_processor(image.convert(\"RGB\"), return_tensors=\"pt\")\n", + "print(encoding.pixel_values.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Pn4T1GyTXC47" + }, + "source": [ + "And run inference!" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YyQznW5WViMc", + "outputId": "d1b7a77c-68b3-4f6b-a945-4b32e85baabe" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class: beignets\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "# forward pass\n", + "with torch.no_grad():\n", + " outputs = inference_model(**encoding)\n", + " logits = outputs.logits\n", + "\n", + "predicted_class_idx = logits.argmax(-1).item()\n", + "print(\"Predicted class:\", inference_model.config.id2label[predicted_class_idx])" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [ + "0a_bETbqv4P7", + "Y8dSVHoIv7HC", + "qo_scDEyAQER" + ], + "machine_shape": "hm", + "provenance": [] + }, + "gpuClass": "premium", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + }, + "vscode": { + "interpreter": { + "hash": "62ba1781de76fc6672ab4d41176558d38a2895b3007f2161f5f79f77fdcaf8cf" + } + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "02a0b01d31a34a1c924786037fecba09": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "02ac19466e24404a92e769ed60604881": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "039dd9a4b99e433088a0acd8ba7b519b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "041f73c9a038411aa6d59cf8a93f6d47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_de92f68231294aefb249f400475bc9a4", + "placeholder": "​", + "style": "IPY_MODEL_f981fb4aae504045aa10889dceeb6cac", + "value": " 357/357 [01:17<?, ?B/s]" + } + }, + "0465571b25714ecda9dfe6ff1a495a87": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "06cf9f29b929412a8092044e25861f1c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_375ac7a15cea4ce3aa484a806cc82717", + "max": 489429, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6b6459f123ef4f24a550cd9ec3c9f809", + "value": 489429 + } + }, + "06e4c619e366427a8ff4c358196ecd12": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1902fbc4c1da4ffe90f0947e58eb5d48", + "placeholder": "​", + "style": "IPY_MODEL_12a94351242444d7b0d23b8accc1824a", + "value": " 2.69M/2.69M [00:00<00:00, 2.27MB/s]" + } + }, + "070a734e268045098977db14c6565777": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ad2068dd9c2040f6ae44bc873fa7b6e7", + "placeholder": "​", + "style": "IPY_MODEL_9434b43de9954c83a4311432bdd68376", + "value": " 330M/330M [00:39<00:00, 11.7MB/s]" + } + }, + "070fdaf418de43a3a5ee0592e8aca103": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "074f38bd3a9d49719188e8860fb1b5d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07f5e653fe6740e8a71fb9de101884f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0957e36be17c43fd89462c5d5ddcec1b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "098770d5a36540dea54d27d7fa9bcd56": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5da11a8c37ae41458ea4491ccdfb4db8", + "IPY_MODEL_23ec20ee5f0e48be9470415810cd0b4b", + "IPY_MODEL_e88c3ad56ef24e4d8281898b08ff6f4b" + ], + "layout": "IPY_MODEL_c5670295387a4c199571a2a21a6b69dc" + } + }, + "0a0e75829d6c4031bc917ac2044d9e47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b82dbc29d514f4e9e012fd755948e52": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aa68207e72b0467cb9a4354dc231db2f", + "placeholder": "​", + "style": "IPY_MODEL_60e6952873524186aad05661a00bd240", + "value": "Download file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738403.319afa680fd7.10047.2: 100%" + } + }, + "0ba38362cf8647c08b0beb21a2c39442": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0bc5c81047994f5b976a927b8ed47cbc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0cd35b1092064f42908ce4123b79a8af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0d75dd458e3448a58ea4e19c28e787c0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "10c4f5677d1c4af8b3370b7fb1255065": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1150e391e753424da7d65bda10463da4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "128677e1b5b14e63b06b0f81c9cc4df0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "12a94351242444d7b0d23b8accc1824a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "13279e67c4d847e4846e2d34e8aac589": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d7d43177c750412cb1522eb08c01d2d9", + "IPY_MODEL_70b04a3579a5446f94acd422c70ac50a", + "IPY_MODEL_43940212a87d410c82cc9cd15f38a97e" + ], + "layout": "IPY_MODEL_19fd7c60287b43bbb6e0b12c25b4b375" + } + }, + "136a56e1f70c431bae0a3ac01751a814": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "138198ec50a9494889319d6c94da92bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "148c9912cec5473bb6f8533add143cd3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "14c23f636609458ca4493854826c1a8e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "15bd2dcdbf4b4e74b9db09bdb8822e61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1639075b181f4945ac32af116b22d1d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cf024daa51f74777b98028df10dbc9c5", + "placeholder": "​", + "style": "IPY_MODEL_eaf2c76a172d4da6846c6face18a3b58", + "value": " 9.99k/9.99k [01:17<?, ?B/s]" + } + }, + "16620105b32f434eb77b0df56ed49e45": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_edb0d1ba5e114af9b6705969f58ece7b", + "placeholder": "​", + "style": "IPY_MODEL_1954a636239b40169659e2ae8ef3b127", + "value": " 9.99k/9.99k [01:17<00:00, 119B/s]" + } + }, + "1674d568877048368c842c21ffaac811": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "16b464f168d844cba5eb0c91ab4fb91c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_28f82c8fc9cf46c7858132a77e45834b", + "max": 25250, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ce18faf7b68140a3a8247330b356e05b", + "value": 25250 + } + }, + "16c7db587b8e475fa3aa9677385b092a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17235d013b7c4cee996d0bbc1cc6c70c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1839e4ed1d3c4975b34c3c050052693f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1902fbc4c1da4ffe90f0947e58eb5d48": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "194dd0bcc350480c9ddd3e4ef17efc3a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1954a636239b40169659e2ae8ef3b127": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "19ec79f5a5174aa3b26861a9662951d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_57c15c64c2374f06a1e0a36bab953ef7", + "IPY_MODEL_06cf9f29b929412a8092044e25861f1c", + "IPY_MODEL_c2032e5054ac4604832957cb6e2e69ca" + ], + "layout": "IPY_MODEL_d1ff50e1b871429a85df8cf10e73ffb1" + } + }, + "19fd7c60287b43bbb6e0b12c25b4b375": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1a08961f063346ccae206a863ab7df6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1a4ab138be9940f081514b914fdc4623": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8b9f5bca0898404b91032befbd019fa3", + "placeholder": "​", + "style": "IPY_MODEL_e4694cffcb574863a255e9022c8ddf5d", + "value": "Downloading (…)lve/main/config.json: 100%" + } + }, + "1b31bfb0ef4c404698eb2205414170af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1c208beced884b9291c5bcb7b4f71680": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_63c07a01593f467f9c0e7c5e283d58ae", + "placeholder": "​", + "style": "IPY_MODEL_972f831792cd4e89af109462dd5b9210", + "value": " 9.99k/9.99k [01:17<?, ?B/s]" + } + }, + "1d4a5a5b7d1645a8bf8133935e173082": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c3178221dc074657bc0e585c4cfe326d", + "max": 5560, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3c6842e0158b4dcc9b93eddfe3279d2a", + "value": 5560 + } + }, + "1e3e374b08964a689cfaac9c826f207b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f8c65025b63466192897a32a92182e9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f96ca356b6f41b59275abe93df33f43": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "CheckboxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "CheckboxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "CheckboxView", + "description": "Add token as git credential?", + "description_tooltip": null, + "disabled": false, + "indent": true, + "layout": "IPY_MODEL_516c6d75bc654d62b95ac235ce84c59c", + "style": "IPY_MODEL_14c23f636609458ca4493854826c1a8e", + "value": true + } + }, + "1fdc59cbb8724c618ce6e586e2c9723f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21c75049df804ac4ac7bc6349a639056": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5fd1cd8bf125446a96b9438fbbe52710", + "max": 357, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_eb864284052c46b28b93fc79bfed740f", + "value": 357 + } + }, + "223a13f77e2e49a09660890eb4213b30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_47cf3db935ba4e109843b03a9577c184", + "max": 10227, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_be1ec4b9b8964810867b0e00bcc4868f", + "value": 10227 + } + }, + "22da54e68b1d48f9b3ba55ac1ca56873": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "23436ea247dd43d8829ca143a49637c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ce16ac2b3ff244e6bd7dd58daa9f4f7f", + "placeholder": "​", + "style": "IPY_MODEL_d25f3ebb577749d89e2e6d2a72f6ca5f", + "value": " 2/2 [00:01<00:00, 1.95it/s]" + } + }, + "236638d673934823828ee57face78184": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_920293e203f14b45b61233e1bb6f1214", + "placeholder": "​", + "style": "IPY_MODEL_a1981bfcdb6d401e9a521e18b511cf9d", + "value": " 502/502 [00:00<00:00, 27.9kB/s]" + } + }, + "23c608994006427caca7975e0d81271f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "23ec20ee5f0e48be9470415810cd0b4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d7c394bc6a3249e9b3fcbae2ebd25eb7", + "max": 5777, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fea27a80cd2f4b4dba84ecdfefd2722c", + "value": 5777 + } + }, + "245c5418ca084fb6bc0b027576a1f789": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_431174d906f640baa17842fdb3a8714b", + "placeholder": "​", + "style": "IPY_MODEL_638b918aaacc4c4782b9e16ca66549e8", + "value": "Clean file runs/Feb07_03-56-51_319afa680fd7/events.out.tfevents.1675742272.319afa680fd7.27769.0: 100%" + } + }, + "24b3737dc76c4d4f9ba2603c653a3ce2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_397dc640630841d7845bf5a8739ce5eb", + "placeholder": "​", + "style": "IPY_MODEL_07f5e653fe6740e8a71fb9de101884f3", + "value": " 5.64k/5.64k [01:17<00:00, 61.5B/s]" + } + }, + "260fdda06c214ed499f69fac4077d476": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "26520bc6555d41d9951ea0219dc4b5d7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "28f82c8fc9cf46c7858132a77e45834b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "29de968ad50543418c6865fdf003a568": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ab85fcc8de042d0bdb9ca79b8e404a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_77deda3ef342432f9b0f684a9b32e248", + "IPY_MODEL_f3991aaad13a4c50a7809483b7907b7b", + "IPY_MODEL_eca3b1f4ad76430483a221470e592c13" + ], + "layout": "IPY_MODEL_a1d5bc95f1e24e3293414e08aa5c8bd5" + } + }, + "2ab99fb38f8d4bef85d9833bb628fa00": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b8bc04ac3104592bf950e349c034c2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5e51957908eb48489357a7c3924ec5c7", + "max": 3579, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_41320a22032c4884affc456f7c6db1c1", + "value": 3579 + } + }, + "2bfd04824f2e4fd6844dd38e46dbbbdf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2c86eb6c67f44af590937d0f1db09333": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2d13b401dcf94089a4a78a62f05bdce3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_070fdaf418de43a3a5ee0592e8aca103", + "placeholder": "​", + "style": "IPY_MODEL_62818f9421694139bbe1d9ad6e822b10", + "value": "Download file runs/Feb07_02-43-38_319afa680fd7/1675737843.2328734/events.out.tfevents.1675737843.319afa680fd7.7189.1: 100%" + } + }, + "2d867c65533e482a96db93bc5a09b8cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2d8a53b2a2bf42b9aa9cb2d9978ccee2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e0bb2dcd85640d7b85d80469ea9f9f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_136a56e1f70c431bae0a3ac01751a814", + "max": 10230, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7a3daf19ee744c7b8baeb028db05009a", + "value": 10230 + } + }, + "2e24b7250ee04fbb810e5d6ade107c51": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2e31d27cc694434aa869896041c72bee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d75dd458e3448a58ea4e19c28e787c0", + "placeholder": "​", + "style": "IPY_MODEL_0bc5c81047994f5b976a927b8ed47cbc", + "value": " 330M/330M [01:17<00:00, 671kB/s]" + } + }, + "2eae62f1cc46449dba93f5eda0cb3f1c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "323eb0d9dade4c4fa3a9ad2b973dcbe1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_484f7a55438c47f59365242c4753edba", + "IPY_MODEL_c5665d0bc652405c8754474871baab06", + "IPY_MODEL_82f96ac9299a4841a550ad3daa0099d0" + ], + "layout": "IPY_MODEL_f031aaf7fbc648a7b8a2e5faf37df14d" + } + }, + "3587d42fa09b4fcdb365956a9bb07c77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_16c7db587b8e475fa3aa9677385b092a", + "placeholder": "​", + "style": "IPY_MODEL_23c608994006427caca7975e0d81271f", + "value": " 6.21k/6.21k [00:00<00:00, 412kB/s]" + } + }, + "35d862a4f00c4493920da3e2eb92b043": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b48f685dc91540f38690f39eace724d5", + "placeholder": "​", + "style": "IPY_MODEL_ce4b6a4b6fec4ceb907fa436ff940bd2", + "value": "Generating validation split: 100%" + } + }, + "36c8300bcbb84627a03b94f0eea86ce9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "375ac7a15cea4ce3aa484a806cc82717": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "38deee504dab482983a8b8f340472282": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "38f30da546444f8199673003d0a92dda": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "397dc640630841d7845bf5a8739ce5eb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a71257db7bc408d8e4d1fbcaf1dff93": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c0cacee5997480cbedc0e9d59a62544": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c33964c8d804600ab5a26d0717c508d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3c6842e0158b4dcc9b93eddfe3279d2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3db63ba25e7349a785244c367d53813e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3efccb526dec44bf9801ac13dcc1068d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f188d6d34774154afc297b13a3eb9e8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f6394cb0ea242f28c4ba6b3b2d37e9f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3ff84efe0edc491c884898424be4ae71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4089323832d04dc2a40e238b5fa256cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "40a5a50aeca24f0d8990da97971004d1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "41320a22032c4884affc456f7c6db1c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "416c65eedcea4a6ea69dae317de79bca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "42a16474e41343b2a7d46e5930b41b89": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "431174d906f640baa17842fdb3a8714b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "43940212a87d410c82cc9cd15f38a97e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3db63ba25e7349a785244c367d53813e", + "placeholder": "​", + "style": "IPY_MODEL_4748461200ae4af883577e2fbb8cb686", + "value": " 1.47M/1.47M [00:00<00:00, 1.21MB/s]" + } + }, + "4533e8ce655649cba93553c8a2b17f37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "471d44c8e49e42b89302ef53ab0eb316": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4748461200ae4af883577e2fbb8cb686": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "47659b15eb284f06bf9735ca2e425646": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "47cf3db935ba4e109843b03a9577c184": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4825c09098e1446a9ed3b653b77894f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_148c9912cec5473bb6f8533add143cd3", + "placeholder": "​", + "style": "IPY_MODEL_92dfb889fd22439bb7b5fd31e4991c93", + "value": "Clean file runs/Feb07_03-56-51_319afa680fd7/1675742273.001745/events.out.tfevents.1675742273.319afa680fd7.27769.1: 100%" + } + }, + "483b46ed1e8148498d54e4d6f4c0ca8d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "484f7a55438c47f59365242c4753edba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f22598cf4ade4427a1b437fd45aabcc4", + "placeholder": "​", + "style": "IPY_MODEL_0cd35b1092064f42908ce4123b79a8af", + "value": "Downloading (…)"adapter_model.bin";: 100%" + } + }, + "49ed3330fa9645eda8b5aed0fd7cbafe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b2ad992db5a045668fa55c7393ec7870", + "placeholder": "​", + "style": "IPY_MODEL_b5fad0f3f2d543ecaed726e52d2d86bb", + "value": " 1/1 [00:00<00:00, 1.24it/s]" + } + }, + "4a118fa87e424664a2d2ed7c7f58f3fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4a3ff00e64b548ce89355778907e48c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4a44332ff1224a19a5f1c18e2b827759": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4afba780d0f244548a7f28db15b41dc9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1839e4ed1d3c4975b34c3c050052693f", + "placeholder": "​", + "style": "IPY_MODEL_1b31bfb0ef4c404698eb2205414170af", + "value": "Downloading data files: 100%" + } + }, + "4bb8b2d7000f464ba3ff18ce03fcfef4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4cb3d75f80434b48beb6aa4b07c86dfe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0957e36be17c43fd89462c5d5ddcec1b", + "placeholder": "​", + "style": "IPY_MODEL_dffe636233c84dcd9d75f34baf40fa1d", + "value": "Computing checksums: 100%" + } + }, + "4d1f6114d4034f758bf8cc35485e0056": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0ba38362cf8647c08b0beb21a2c39442", + "placeholder": "​", + "style": "IPY_MODEL_65a0aed816c84164a6ee6a41d300fad0", + "value": "Download file runs/Feb07_02-43-38_319afa680fd7/events.out.tfevents.1675737843.319afa680fd7.7189.0: 100%" + } + }, + "4d653faaedcd497d863bbf2c429ce925": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e3d482feec9485590d277dfc1d0b3d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6350637718344d65a757d2919de8c1ab", + "max": 2, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_42a16474e41343b2a7d46e5930b41b89", + "value": 2 + } + }, + "4ee1fde44dcf49eda97e1a05173e5bb1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4fc212af0c9b45ebbe334e3dd7f11b59": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "516c6d75bc654d62b95ac235ce84c59c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "52d00532eeee40aa91e8a5c2a10e50a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a65e650113e476a8cb66caa92973dd3", + "placeholder": "​", + "style": "IPY_MODEL_d0c95a20c2664c149886b72fa665d3cf", + "value": "Clean file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738403.319afa680fd7.10047.2: 100%" + } + }, + "5634fd283a9e45d9a55c02ca1b7c784c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4a44332ff1224a19a5f1c18e2b827759", + "placeholder": "​", + "style": "IPY_MODEL_7e1ac6f28fb340d3bde1e7b4893bb0aa", + "value": " 346M/346M [00:02<00:00, 202MB/s]" + } + }, + "57c15c64c2374f06a1e0a36bab953ef7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_10c4f5677d1c4af8b3370b7fb1255065", + "placeholder": "​", + "style": "IPY_MODEL_603dd1541db345879295edc16ace2b0c", + "value": "Downloading data: 100%" + } + }, + "58e7f5c36d8b4836a868ce89838f1896": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9d1dff20634a403fb8829469d74301aa", + "placeholder": "​", + "style": "IPY_MODEL_b2e64f35be2d4fa3bc95c769b78e1dd1", + "value": " 10.3k/10.3k [00:00<00:00, 770kB/s]" + } + }, + "59792e1ee7074f998d5d4494c09061c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3ff84efe0edc491c884898424be4ae71", + "placeholder": "​", + "style": "IPY_MODEL_5a79a196fd7b49128a9647347f85b364", + "value": "Downloading data: 100%" + } + }, + "5a79a196fd7b49128a9647347f85b364": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5b7be0df4db54866a3b6ef9204ba5a89": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cde9d5cbadf14a5abe294dba0fa5bd2d", + "IPY_MODEL_835db77232e74cc18a6b5db2ace40bfd", + "IPY_MODEL_6099227eddde44009582b9f24fc96150" + ], + "layout": "IPY_MODEL_9eb912a195f3461297b7143cb1b04678" + } + }, + "5d2f5fb454bc4c16b520e4e96381758f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dfd2baceac524fe29c0f4a8443b60a71", + "IPY_MODEL_90d8e83a6af54184a82e0b81ae7054b9", + "IPY_MODEL_1f96ca356b6f41b59275abe93df33f43", + "IPY_MODEL_eef81e9bea0c4f5d85e7efa8ebe0463a", + "IPY_MODEL_cab6d36980c0423fb75299c09c33facc" + ], + "layout": "IPY_MODEL_dd38a658218d42d7b051c66de4d4180a" + } + }, + "5da11a8c37ae41458ea4491ccdfb4db8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6dac696d99a44ea399a1bd5e18f08428", + "placeholder": "​", + "style": "IPY_MODEL_b3a8eebed60f4ecab7d508c976e2e56b", + "value": "Download file runs/Feb07_03-56-51_319afa680fd7/1675742273.001745/events.out.tfevents.1675742273.319afa680fd7.27769.1: 100%" + } + }, + "5dc4129160514a479ffb2f0564aee071": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4074e524a19455fab810ec454fe8bf1", + "max": 10230, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d67dc70cfc9246f79a59261a69b28b41", + "value": 10230 + } + }, + "5e51957908eb48489357a7c3924ec5c7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5ee5e11191fc46dd92d4c2f1a7d6d9da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_128677e1b5b14e63b06b0f81c9cc4df0", + "max": 6208, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_22da54e68b1d48f9b3ba55ac1ca56873", + "value": 6208 + } + }, + "5fd1cd8bf125446a96b9438fbbe52710": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "603dd1541db345879295edc16ace2b0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "60472b5a360f43e89e39d641dabba57b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6099227eddde44009582b9f24fc96150": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_af7ee2bb7ccc4c00838a2c6b937e4e8b", + "placeholder": "​", + "style": "IPY_MODEL_84c281446c5b424090a5eecbd733b050", + "value": " 9.99k/9.99k [01:17<00:00, 119B/s]" + } + }, + "60e6952873524186aad05661a00bd240": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "61b957d3b51643f78a921979072fe3b6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d7136a7b3d0040d580508fc665b9fb00", + "IPY_MODEL_5ee5e11191fc46dd92d4c2f1a7d6d9da", + "IPY_MODEL_3587d42fa09b4fcdb365956a9bb07c77" + ], + "layout": "IPY_MODEL_c1ed0b68884c4d4291cd67c0e685ef18" + } + }, + "62818f9421694139bbe1d9ad6e822b10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "62a0f83cf75d4c59a0601c5ad3a817a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "6350637718344d65a757d2919de8c1ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "638b918aaacc4c4782b9e16ca66549e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "63b53da916fe479e8cd495eff8d16df8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "63c07a01593f467f9c0e7c5e283d58ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "65a0aed816c84164a6ee6a41d300fad0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "68ef0c8550ee4c00aa8b284d48572610": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a35d0ddc2da4dd69068214b87bcdd7f", + "max": 10337, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9aac38a8c8694c67a34b2fced0e1a706", + "value": 10337 + } + }, + "6932d2462135413cbc293964eb1c8317": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3c0cacee5997480cbedc0e9d59a62544", + "max": 5777, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fee3db0deefb410db4c572efd95575bf", + "value": 5777 + } + }, + "6940a405215c4e2caadbe209c677bde0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "69dcd4770fbc428cb56498b6577e237e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6b6459f123ef4f24a550cd9ec3c9f809": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6dac696d99a44ea399a1bd5e18f08428": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6e4983016e4f465b85ab7a472d0e986e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f19448725b84be4bacc3b699cd065a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3c33964c8d804600ab5a26d0717c508d", + "placeholder": "​", + "style": "IPY_MODEL_f5041033ddf94f459ed8d1747f6b2d6e", + "value": "Downloading (…)"pytorch_model.bin";: 100%" + } + }, + "6f1a325b02f54352a0b412d7f4420bbb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "70af909af7de4161b4a72a8e15d116f3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "70b04a3579a5446f94acd422c70ac50a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_039dd9a4b99e433088a0acd8ba7b519b", + "max": 1468812, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_17235d013b7c4cee996d0bbc1cc6c70c", + "value": 1468812 + } + }, + "71f7296ec9be4d9abe1af581722b40fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b98e53eefc1944f193169c4f7a72b799", + "IPY_MODEL_1d4a5a5b7d1645a8bf8133935e173082", + "IPY_MODEL_d29e3b9102f14f3385e47ae6e27d1ab1" + ], + "layout": "IPY_MODEL_1e3e374b08964a689cfaac9c826f207b" + } + }, + "7541b2304cc5466cb2369c0025d2d243": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "75b76841f06249a0a77c7e38b85a14c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e6ce3e626b1744c7ba3da26d1fde5fa5", + "placeholder": "​", + "style": "IPY_MODEL_8e1237963bb5479f93318c5cdc6a8593", + "value": "Download file runs/Feb07_03-56-51_319afa680fd7/events.out.tfevents.1675742272.319afa680fd7.27769.0: 100%" + } + }, + "7654b707840e4afb9bab8218418fd096": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "76cf84387a7c43608ad018188eef4114": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4d653faaedcd497d863bbf2c429ce925", + "placeholder": "​", + "style": "IPY_MODEL_d10f2e9c25f2417f9728aa8e43acf677", + "value": "Downloading readme: 100%" + } + }, + "77deda3ef342432f9b0f684a9b32e248": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b48fcbe51098482aad8798670111d60d", + "placeholder": "​", + "style": "IPY_MODEL_7654b707840e4afb9bab8218418fd096", + "value": "Clean file runs/Feb07_02-43-38_319afa680fd7/1675737843.2328734/events.out.tfevents.1675737843.319afa680fd7.7189.1: 100%" + } + }, + "77df794cb4e4491e80ee20bbd2801a89": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "77f7230186b14c628f5094f9fd8d82da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_855a0f70b9ac489a86b53792e119329a", + "IPY_MODEL_9005e9db560d4e89880bdd18403ef9e1", + "IPY_MODEL_070a734e268045098977db14c6565777" + ], + "layout": "IPY_MODEL_91ec8a3f10804d629cdfd47c61411c91" + } + }, + "79351db5d2e1468e9b91d7bd2274612e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2d8a53b2a2bf42b9aa9cb2d9978ccee2", + "max": 10824, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_69dcd4770fbc428cb56498b6577e237e", + "value": 10824 + } + }, + "793ebaa3acc6482bb135ca0ca864be4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7a35d0ddc2da4dd69068214b87bcdd7f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a3daf19ee744c7b8baeb028db05009a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7a65e650113e476a8cb66caa92973dd3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b8f0cbb552447549aed602f937fcfb4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7bd32cf88c154303a76759d674795856": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a907de6474cf45cb91b3f2efc40821b9", + "IPY_MODEL_5dc4129160514a479ffb2f0564aee071", + "IPY_MODEL_16620105b32f434eb77b0df56ed49e45" + ], + "layout": "IPY_MODEL_7b8f0cbb552447549aed602f937fcfb4" + } + }, + "7c038ffcc1dc4e3fbfed17d94327353a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7c1b6f271fff4d60be39d291c73bfb75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4089323832d04dc2a40e238b5fa256cc", + "placeholder": "​", + "style": "IPY_MODEL_2d867c65533e482a96db93bc5a09b8cb", + "value": " 5.00G/5.00G [03:32<00:00, 24.6MB/s]" + } + }, + "7d5831ee2a1c4e649f5508631d64e7cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2eae62f1cc46449dba93f5eda0cb3f1c", + "placeholder": "​", + "style": "IPY_MODEL_e8026bcb0e2c4b14bc6c84537c8c4ae9", + "value": " 5.64k/5.64k [01:17<?, ?B/s]" + } + }, + "7e1ac6f28fb340d3bde1e7b4893bb0aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7e243f4a30c645b080e688fb706b4548": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "828a652d92724ba4888d924846a79374": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4bb8b2d7000f464ba3ff18ce03fcfef4", + "max": 4203, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_793ebaa3acc6482bb135ca0ca864be4d", + "value": 4203 + } + }, + "82f96ac9299a4841a550ad3daa0099d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3a71257db7bc408d8e4d1fbcaf1dff93", + "placeholder": "​", + "style": "IPY_MODEL_ccd34ccf2c864c609a0b4fcee7327b31", + "value": " 2.69M/2.69M [00:00<00:00, 13.0MB/s]" + } + }, + "835db77232e74cc18a6b5db2ace40bfd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d2469e1f1daf4d4cb0faf35ce90f6445", + "max": 10227, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e667b14a3c0e41c6a16c4be453f10378", + "value": 10227 + } + }, + "8378c214cd044bfb97c452d811df748f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b6a1b7db4afe44c792907f6377cde35c", + "placeholder": "​", + "style": "IPY_MODEL_dca7d0a0d2aa479083d81a54489d3717", + "value": "Downloading builder script: 100%" + } + }, + "83d6fbf463264c71a4ec8775e26c7c38": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "849ac914c3cc49d29d619dd4f532d74c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4cb3d75f80434b48beb6aa4b07c86dfe", + "IPY_MODEL_ff39519704b64e68b69ec06aea02791e", + "IPY_MODEL_e0f2599ed04c424f896e503630034e84" + ], + "layout": "IPY_MODEL_1674d568877048368c842c21ffaac811" + } + }, + "84c281446c5b424090a5eecbd733b050": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "851fb5ac25db4bb287a6dbe948278eec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "852b01d8592b4d8aa2c4297d6cf75f78": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "855a0f70b9ac489a86b53792e119329a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0465571b25714ecda9dfe6ff1a495a87", + "placeholder": "​", + "style": "IPY_MODEL_dc078f0db3e54199bef0c11ee5e6297e", + "value": "Clean file pytorch_model.bin: 100%" + } + }, + "86103f87819b440b8464f4460f50375e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "864b6bb42f0b46a2a7bcd0d8cbac3837": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c1af5e6c4259480eac652f6c6269ff5f", + "max": 345636463, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_194dd0bcc350480c9ddd3e4ef17efc3a", + "value": 345636463 + } + }, + "86fca0e29e7a4dc8b2234134014958f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8378c214cd044bfb97c452d811df748f", + "IPY_MODEL_828a652d92724ba4888d924846a79374", + "IPY_MODEL_cfd59ddfe85f4585865df8df47fd491f" + ], + "layout": "IPY_MODEL_94f39a2f3baa4bb2bffd1b99e8a31367" + } + }, + "87581c98cd174bb684ec259066d047ea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87aad727ec964c9d97346ac02ed0caae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8886c333aa104900a3bb4a1904756661": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8934f66530644f0882e292bfd5458b0f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8a0a77b9ebd74caabb8f8a764c289a5c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b7713310a814991aec7929fa715ec7c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b9f5bca0898404b91032befbd019fa3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ba66e043f8a4975bd77ecd343401260": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1f8c65025b63466192897a32a92182e9", + "placeholder": "​", + "style": "IPY_MODEL_ffc13c11355b46bb9cafcb17f3e1535e", + "value": "Download file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738246.319afa680fd7.10047.0: 100%" + } + }, + "8bf8a843d65142bbad81de74aa8573f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8da58936a6e64529af9a3e3f314e49cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8e1237963bb5479f93318c5cdc6a8593": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8ecde04d15ab47f9b78d561615ca567d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9005e9db560d4e89880bdd18403ef9e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c3f7788abe754cb3bfbee3fadda54916", + "max": 345949677, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fe93399cc15f4f29b6a37f6a65cf8c9b", + "value": 345949677 + } + }, + "9013fd35e17f44bfb7a068833adaf167": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "90d8e83a6af54184a82e0b81ae7054b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "PasswordModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "PasswordModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "PasswordView", + "continuous_update": true, + "description": "Token:", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_b2688e34899a449e8d1f6ddb5a66bb85", + "placeholder": "​", + "style": "IPY_MODEL_dd4edb4de5e14dfbbee418dba0bb3573", + "value": "" + } + }, + "9102cc38ee9942ac91dc66eda069ddcb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9123141f7c164d458a21e54fc579fa66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "91ec8a3f10804d629cdfd47c61411c91": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "91f6edc592394a0bad250e68d3c22017": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "920293e203f14b45b61233e1bb6f1214": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "923cf8641a7946f69ff41fb88b2b86f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9d14ba8675fb4c689dd821ce7794abb6", + "IPY_MODEL_6932d2462135413cbc293964eb1c8317", + "IPY_MODEL_7d5831ee2a1c4e649f5508631d64e7cc" + ], + "layout": "IPY_MODEL_70af909af7de4161b4a72a8e15d116f3" + } + }, + "9281c5aec5b84411a05e4762125388d9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "92dfb889fd22439bb7b5fd31e4991c93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "93788683ef8e4c71bc1c0b3b9cc7219c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a2671f512e404f64bfa3f376449f6947", + "placeholder": "​", + "style": "IPY_MODEL_a61a30ebaac846c1b7a03c6a93127aad", + "value": " 357/357 [01:17<?, ?B/s]" + } + }, + "9397ebc3ad2e4141a1405bb1bd0aa315": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6f19448725b84be4bacc3b699cd065a9", + "IPY_MODEL_864b6bb42f0b46a2a7bcd0d8cbac3837", + "IPY_MODEL_5634fd283a9e45d9a55c02ca1b7c784c" + ], + "layout": "IPY_MODEL_87aad727ec964c9d97346ac02ed0caae" + } + }, + "93c81a011c0a435aa90a3f4f1d549510": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bcbb4d8ce16b473eae2ad03f1bea2520", + "max": 160, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2c86eb6c67f44af590937d0f1db09333", + "value": 160 + } + }, + "9434b43de9954c83a4311432bdd68376": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "94f39a2f3baa4bb2bffd1b99e8a31367": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95449e7030324f99b148bbaedc15c155": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_be1ae63f3e804e23abe7739e9f4577fb", + "IPY_MODEL_d5b95aa9cab446f88d61e9f4a25a8e2f", + "IPY_MODEL_2e31d27cc694434aa869896041c72bee" + ], + "layout": "IPY_MODEL_4a3ff00e64b548ce89355778907e48c9" + } + }, + "9609eaf0792345b2ab457cb7188ee14a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "972f831792cd4e89af109462dd5b9210": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "980d2f61332f414d9888b76e78774be4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_cbc0ba8e49a740fcae7b94fe7edb8107", + "IPY_MODEL_b3f07ef160a7425880ffe362008d4400", + "IPY_MODEL_49ed3330fa9645eda8b5aed0fd7cbafe" + ], + "layout": "IPY_MODEL_f96302d0c2d849c5b5a0206b65e461ab" + } + }, + "98d32ec7fbf54effadb886bc4ec6ce79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9a5e108d8b5a41ae95a619bfc6c8f3a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9aac38a8c8694c67a34b2fced0e1a706": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9b1bfa11ee3746c38155c4505abfaa86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9b216287b8694bcc9960a356adf15504": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9b4b67731a7a4bc59be132b53c24eae8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c53429e699e64b3d8895a355bbd947a6", + "placeholder": "​", + "style": "IPY_MODEL_2bfd04824f2e4fd6844dd38e46dbbbdf", + "value": "adapter_model.bin: 100%" + } + }, + "9d14ba8675fb4c689dd821ce7794abb6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d04c1c4d04fc4928b4a2a0e860f996e0", + "placeholder": "​", + "style": "IPY_MODEL_98d32ec7fbf54effadb886bc4ec6ce79", + "value": "Download file runs/Feb07_02-50-30_319afa680fd7/1675738246.1183074/events.out.tfevents.1675738246.319afa680fd7.10047.1: 100%" + } + }, + "9d1b9ac29dcc41e08ada578916f20a3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ef7c7fe37c8d459da6d20f4ccbea3fb8", + "IPY_MODEL_93c81a011c0a435aa90a3f4f1d549510", + "IPY_MODEL_da87efdf06d74b0aba268320ba7882f9" + ], + "layout": "IPY_MODEL_0a0e75829d6c4031bc917ac2044d9e47" + } + }, + "9d1dff20634a403fb8829469d74301aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9eb912a195f3461297b7143cb1b04678": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9fb3579ca9714141a7857a513c379f03": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a0929e66406644dbb09bbdc9c58d488d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a100435005a34d428b9ae615f49bb1a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a1981bfcdb6d401e9a521e18b511cf9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a1d5bc95f1e24e3293414e08aa5c8bd5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a1df731c5c5f4f9cafa19323a750ebea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_260fdda06c214ed499f69fac4077d476", + "placeholder": "​", + "style": "IPY_MODEL_aed3b4e6110442398c25d37456b78b5d", + "value": "Clean file runs/Feb07_02-50-30_319afa680fd7/1675738246.1183074/events.out.tfevents.1675738246.319afa680fd7.10047.1: 100%" + } + }, + "a2671f512e404f64bfa3f376449f6947": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a29d758fb7f147c7ad1108f140caf23a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aa9b6ac2785c4a5abd1189edd60698eb", + "placeholder": "​", + "style": "IPY_MODEL_cfab815edc1f42898b656c0f4a3b366b", + "value": " 75750/75750 [00:59<00:00, 1687.83 examples/s]" + } + }, + "a2b51be9304342e39431b82957eb4b25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a450c318d99a477c9f7341458ad4bc8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4533e8ce655649cba93553c8a2b17f37", + "placeholder": "​", + "style": "IPY_MODEL_63b53da916fe479e8cd495eff8d16df8", + "value": " 10.6k/10.6k [01:17<00:00, 127B/s]" + } + }, + "a61a30ebaac846c1b7a03c6a93127aad": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a849dcc9c7f742d49c874597d8c693c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a907de6474cf45cb91b3f2efc40821b9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3f6394cb0ea242f28c4ba6b3b2d37e9f", + "placeholder": "​", + "style": "IPY_MODEL_02a0b01d31a34a1c924786037fecba09", + "value": "Clean file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738246.319afa680fd7.10047.0: 100%" + } + }, + "aa68207e72b0467cb9a4354dc231db2f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aa9b6ac2785c4a5abd1189edd60698eb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "acae77f181ed43a1b29412c575435a7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e54b7fc2f9b94118ab97f2736862f77d", + "placeholder": "​", + "style": "IPY_MODEL_dfe97442852c4338843c65333b25623d", + "value": " 5.64k/5.64k [01:17<00:00, 61.5B/s]" + } + }, + "ad2068dd9c2040f6ae44bc873fa7b6e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ad6adbe84ac940ffbf89017a269a3e75": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "adb09cebab13484a8d75a338eaba7b0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9fb3579ca9714141a7857a513c379f03", + "max": 3579, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_edc0742a08a445a594139200c7f03c60", + "value": 3579 + } + }, + "aed3b4e6110442398c25d37456b78b5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "af1a42626ba7452189fbb5987b159b9c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d4aa1670fdab463bb0a0e6fe104988bc", + "max": 357, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8934f66530644f0882e292bfd5458b0f", + "value": 357 + } + }, + "af5231ecf6e2489b80cdcd435b5e3451": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_af6a4a054a5d451b9fe256bf60a09c21", + "placeholder": "​", + "style": "IPY_MODEL_afb1f0681bce47e1ba718900d0430f34", + "value": " 25250/25250 [00:42<00:00, 617.60 examples/s]" + } + }, + "af6a4a054a5d451b9fe256bf60a09c21": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "af7ee2bb7ccc4c00838a2c6b937e4e8b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "afb1f0681bce47e1ba718900d0430f34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b1b6922df40c4af69b00b4e85db770c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f6a9243d46cb4c0fbdf3f80f7074f6c5", + "placeholder": "​", + "style": "IPY_MODEL_a2b51be9304342e39431b82957eb4b25", + "value": "Clean file training_args.bin: 100%" + } + }, + "b21331417d084aba80f919b71933bc2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b2688e34899a449e8d1f6ddb5a66bb85": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b2ad992db5a045668fa55c7393ec7870": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b2e64f35be2d4fa3bc95c769b78e1dd1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b377e94780fb4e1db3b9678717e04fc1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b3a8eebed60f4ecab7d508c976e2e56b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b3f07ef160a7425880ffe362008d4400": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1150e391e753424da7d65bda10463da4", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e6e36d744e1244aeb7eb0c4ce392372d", + "value": 1 + } + }, + "b48f685dc91540f38690f39eace724d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b48fcbe51098482aad8798670111d60d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b5fad0f3f2d543ecaed726e52d2d86bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b6a1b7db4afe44c792907f6377cde35c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b8e180259fd94096884f7e48a53b0fce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b98e53eefc1944f193169c4f7a72b799": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b377e94780fb4e1db3b9678717e04fc1", + "placeholder": "​", + "style": "IPY_MODEL_86103f87819b440b8464f4460f50375e", + "value": "Downloading metadata: 100%" + } + }, + "bacd429b42d843299cb75224db3afb1e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb453686ce9f4342aaae9a9fb3500d2c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1a4ab138be9940f081514b914fdc4623", + "IPY_MODEL_cc59f6643acb4054ad6df56e90d3d2a8", + "IPY_MODEL_236638d673934823828ee57face78184" + ], + "layout": "IPY_MODEL_29de968ad50543418c6865fdf003a568" + } + }, + "bc71a433928e4870b56a3d81e35e6351": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bcbb4d8ce16b473eae2ad03f1bea2520": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bcef9cf2b00c46878f07c48875f7d194": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bd9e7cb0f25445739ebcdff0d3112052": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_52d00532eeee40aa91e8a5c2a10e50a7", + "IPY_MODEL_21c75049df804ac4ac7bc6349a639056", + "IPY_MODEL_041f73c9a038411aa6d59cf8a93f6d47" + ], + "layout": "IPY_MODEL_b8e180259fd94096884f7e48a53b0fce" + } + }, + "bda7e5662f2e4fa292752efd4947c5f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4825c09098e1446a9ed3b653b77894f4", + "IPY_MODEL_f544720498e44c49add78550b46edb3a", + "IPY_MODEL_24b3737dc76c4d4f9ba2603c653a3ce2" + ], + "layout": "IPY_MODEL_2ab99fb38f8d4bef85d9833bb628fa00" + } + }, + "be1ae63f3e804e23abe7739e9f4577fb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d947ec84b16c4781959427b610328ab9", + "placeholder": "​", + "style": "IPY_MODEL_9123141f7c164d458a21e54fc579fa66", + "value": "Download file pytorch_model.bin: 100%" + } + }, + "be1ec4b9b8964810867b0e00bcc4868f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "be29ee88a7ec489b8320f7306d78931d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a1df731c5c5f4f9cafa19323a750ebea", + "IPY_MODEL_bf2e140f54d74df09663d3fcf1660d0c", + "IPY_MODEL_acae77f181ed43a1b29412c575435a7f" + ], + "layout": "IPY_MODEL_87581c98cd174bb684ec259066d047ea" + } + }, + "be71e6438e0e49759d2f72feec520cae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bf2e140f54d74df09663d3fcf1660d0c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8da58936a6e64529af9a3e3f314e49cb", + "max": 5777, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9a5e108d8b5a41ae95a619bfc6c8f3a9", + "value": 5777 + } + }, + "c1af5e6c4259480eac652f6c6269ff5f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c1ed0b68884c4d4291cd67c0e685ef18": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c2032e5054ac4604832957cb6e2e69ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e3047557ae7f40e2aecccf1afad36f3f", + "placeholder": "​", + "style": "IPY_MODEL_4fc212af0c9b45ebbe334e3dd7f11b59", + "value": " 489k/489k [00:00<00:00, 2.24MB/s]" + } + }, + "c2f4b407a47f4d958986035188c6ece8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_75b76841f06249a0a77c7e38b85a14c8", + "IPY_MODEL_79351db5d2e1468e9b91d7bd2274612e", + "IPY_MODEL_c6ce0e9bdd90400f9cf2debf9165758c" + ], + "layout": "IPY_MODEL_138198ec50a9494889319d6c94da92bd" + } + }, + "c3178221dc074657bc0e585c4cfe326d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c3f7788abe754cb3bfbee3fadda54916": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c53429e699e64b3d8895a355bbd947a6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5665d0bc652405c8754474871baab06": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8b7713310a814991aec7929fa715ec7c", + "max": 2688263, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_fcc8254622324f8ea965e12e4d4966cd", + "value": 2688263 + } + }, + "c5670295387a4c199571a2a21a6b69dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5718d031b9942f4b8bf331a8543db29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_35d862a4f00c4493920da3e2eb92b043", + "IPY_MODEL_16b464f168d844cba5eb0c91ab4fb91c", + "IPY_MODEL_af5231ecf6e2489b80cdcd435b5e3451" + ], + "layout": "IPY_MODEL_62a0f83cf75d4c59a0601c5ad3a817a7" + } + }, + "c580d3a6e99e48fab09b3ce799711802": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4afba780d0f244548a7f28db15b41dc9", + "IPY_MODEL_4e3d482feec9485590d277dfc1d0b3d3", + "IPY_MODEL_23436ea247dd43d8829ca143a49637c5" + ], + "layout": "IPY_MODEL_9609eaf0792345b2ab457cb7188ee14a" + } + }, + "c6ce0e9bdd90400f9cf2debf9165758c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb3ab56aa43e4b94b978764caa6057a7", + "placeholder": "​", + "style": "IPY_MODEL_2e24b7250ee04fbb810e5d6ade107c51", + "value": " 10.6k/10.6k [01:17<?, ?B/s]" + } + }, + "c778798c234d45b5a4ae2f250e3706f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c8267c689fb14afc9a8eb3ecb6f4fd4c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fc9d0c314ca14826993fe1f24b070b5d", + "placeholder": "​", + "style": "IPY_MODEL_bc71a433928e4870b56a3d81e35e6351", + "value": "Download file training_args.bin: 100%" + } + }, + "c910ae80ec1a4718915e9a861215f27c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_245c5418ca084fb6bc0b027576a1f789", + "IPY_MODEL_d0bc0e6038eb46dbbc5f5593d4c285ca", + "IPY_MODEL_a450c318d99a477c9f7341458ad4bc8d" + ], + "layout": "IPY_MODEL_02ac19466e24404a92e769ed60604881" + } + }, + "cab6d36980c0423fb75299c09c33facc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_15bd2dcdbf4b4e74b9db09bdb8822e61", + "placeholder": "​", + "style": "IPY_MODEL_ecf73dd75420460399bfd04d8cd81f90", + "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. " + } + }, + "cb3ab56aa43e4b94b978764caa6057a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb52fa97c659430a8bd71dcd76245a7f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "cbc0ba8e49a740fcae7b94fe7edb8107": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fcc7ad16a0b14d96acd9be9e03ac6af9", + "placeholder": "​", + "style": "IPY_MODEL_1a08961f063346ccae206a863ab7df6b", + "value": "Upload 1 LFS files: 100%" + } + }, + "cc59f6643acb4054ad6df56e90d3d2a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a0a77b9ebd74caabb8f8a764c289a5c", + "max": 502, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d8ac6df8420a423eb048b4db04c8925c", + "value": 502 + } + }, + "ccd34ccf2c864c609a0b4fcee7327b31": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cd5b2433cc404ac7b1bb35c6a55f6874": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_851fb5ac25db4bb287a6dbe948278eec", + "max": 4996278331, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_471d44c8e49e42b89302ef53ab0eb316", + "value": 4996278331 + } + }, + "cde9d5cbadf14a5abe294dba0fa5bd2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f1a325b02f54352a0b412d7f4420bbb", + "placeholder": "​", + "style": "IPY_MODEL_e8c2cfdaf0eb413189d93924eae757c7", + "value": "Clean file runs/Feb07_02-43-38_319afa680fd7/events.out.tfevents.1675737843.319afa680fd7.7189.0: 100%" + } + }, + "ce16ac2b3ff244e6bd7dd58daa9f4f7f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce18faf7b68140a3a8247330b356e05b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ce4b6a4b6fec4ceb907fa436ff940bd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cf024daa51f74777b98028df10dbc9c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf815c0979644cd6ad2c681fa96c0648": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6940a405215c4e2caadbe209c677bde0", + "placeholder": "​", + "style": "IPY_MODEL_b21331417d084aba80f919b71933bc2c", + "value": " 3.50k/3.50k [01:17<00:00, 33.0B/s]" + } + }, + "cfab815edc1f42898b656c0f4a3b366b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cfd59ddfe85f4585865df8df47fd491f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bcef9cf2b00c46878f07c48875f7d194", + "placeholder": "​", + "style": "IPY_MODEL_47659b15eb284f06bf9735ca2e425646", + "value": " 4.20k/4.20k [00:00<00:00, 321kB/s]" + } + }, + "d04c1c4d04fc4928b4a2a0e860f996e0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d0bc0e6038eb46dbbc5f5593d4c285ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7c038ffcc1dc4e3fbfed17d94327353a", + "max": 10824, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_91f6edc592394a0bad250e68d3c22017", + "value": 10824 + } + }, + "d0c95a20c2664c149886b72fa665d3cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d10f2e9c25f2417f9728aa8e43acf677": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d1ff50e1b871429a85df8cf10e73ffb1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d2469e1f1daf4d4cb0faf35ce90f6445": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d25f3ebb577749d89e2e6d2a72f6ca5f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d29e3b9102f14f3385e47ae6e27d1ab1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fc612aaed5644b84959a1958b0240dda", + "placeholder": "​", + "style": "IPY_MODEL_36c8300bcbb84627a03b94f0eea86ce9", + "value": " 5.56k/5.56k [00:00<00:00, 399kB/s]" + } + }, + "d4aa1670fdab463bb0a0e6fe104988bc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d5b95aa9cab446f88d61e9f4a25a8e2f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_83d6fbf463264c71a4ec8775e26c7c38", + "max": 345949677, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f02443fbda394fefa162f4ff5b2d2ce7", + "value": 345949677 + } + }, + "d5c5396ea2f54ff0aeb9be58b59c253b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "button_color": null, + "font_weight": "" + } + }, + "d67dc70cfc9246f79a59261a69b28b41": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d68194cf7d264df7820f27eb4d070de2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d9329cb3c1704691b6a36c293bcbf41b", + "placeholder": "​", + "style": "IPY_MODEL_dfa468dd89174d97bcaabbda0ed8e117", + "value": " 3.50k/3.50k [01:17<?, ?B/s]" + } + }, + "d7136a7b3d0040d580508fc665b9fb00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9102cc38ee9942ac91dc66eda069ddcb", + "placeholder": "​", + "style": "IPY_MODEL_416c65eedcea4a6ea69dae317de79bca", + "value": "Downloading builder script: 100%" + } + }, + "d7c394bc6a3249e9b3fcbae2ebd25eb7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7d43177c750412cb1522eb08c01d2d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9013fd35e17f44bfb7a068833adaf167", + "placeholder": "​", + "style": "IPY_MODEL_a849dcc9c7f742d49c874597d8c693c5", + "value": "Downloading data: 100%" + } + }, + "d8ac6df8420a423eb048b4db04c8925c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d9329cb3c1704691b6a36c293bcbf41b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d947ec84b16c4781959427b610328ab9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d9c15769da2b49e4b67d43d95be30cd5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4d1f6114d4034f758bf8cc35485e0056", + "IPY_MODEL_223a13f77e2e49a09660890eb4213b30", + "IPY_MODEL_1639075b181f4945ac32af116b22d1d7" + ], + "layout": "IPY_MODEL_ad6adbe84ac940ffbf89017a269a3e75" + } + }, + "da13543779034424aaf6f5c4a96f0457": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2d13b401dcf94089a4a78a62f05bdce3", + "IPY_MODEL_dbc00727fa1c4e00aacf627c04527649", + "IPY_MODEL_e0d98c36e5d242b2905adf8167ac348a" + ], + "layout": "IPY_MODEL_483b46ed1e8148498d54e4d6f4c0ca8d" + } + }, + "da87efdf06d74b0aba268320ba7882f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a100435005a34d428b9ae615f49bb1a1", + "placeholder": "​", + "style": "IPY_MODEL_8886c333aa104900a3bb4a1904756661", + "value": " 160/160 [00:00<00:00, 8.36kB/s]" + } + }, + "db6b68a237cf4e93ae6383448b773e47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dbaa70ad4f1d4496a670601fe447116d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dbc00727fa1c4e00aacf627c04527649": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3efccb526dec44bf9801ac13dcc1068d", + "max": 5773, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8ecde04d15ab47f9b78d561615ca567d", + "value": 5773 + } + }, + "dc078f0db3e54199bef0c11ee5e6297e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dca7d0a0d2aa479083d81a54489d3717": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dcd1c1f4fc014c4aa9ebdaf3c533a061": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_26520bc6555d41d9951ea0219dc4b5d7", + "max": 75750, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_60472b5a360f43e89e39d641dabba57b", + "value": 75750 + } + }, + "dcefc9ba538e4da2b75f9372a4c5b5bf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd38a658218d42d7b051c66de4d4180a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": "center", + "align_self": null, + "border": null, + "bottom": null, + "display": "flex", + "flex": null, + "flex_flow": "column", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "50%" + } + }, + "dd4edb4de5e14dfbbee418dba0bb3573": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ddf88cbfaaef4a55babf480816db7d28": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de92f68231294aefb249f400475bc9a4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dfa468dd89174d97bcaabbda0ed8e117": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dfd2baceac524fe29c0f4a8443b60a71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f34be236ef9c42448ecf2957160990f7", + "placeholder": "​", + "style": "IPY_MODEL_38deee504dab482983a8b8f340472282", + "value": "

Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" + } + }, + "dfe97442852c4338843c65333b25623d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dffe636233c84dcd9d75f34baf40fa1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e0d98c36e5d242b2905adf8167ac348a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ddf88cbfaaef4a55babf480816db7d28", + "placeholder": "​", + "style": "IPY_MODEL_38f30da546444f8199673003d0a92dda", + "value": " 5.64k/5.64k [01:17<?, ?B/s]" + } + }, + "e0f2599ed04c424f896e503630034e84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7e243f4a30c645b080e688fb706b4548", + "placeholder": "​", + "style": "IPY_MODEL_db6b68a237cf4e93ae6383448b773e47", + "value": " 1/1 [00:14<00:00, 14.25s/it]" + } + }, + "e302923a9df24e5fa8fff79c203ead9f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e3047557ae7f40e2aecccf1afad36f3f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e33243b001274d02a25f5940ba41ecf6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_40a5a50aeca24f0d8990da97971004d1", + "max": 2688263, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_be71e6438e0e49759d2f72feec520cae", + "value": 2688263 + } + }, + "e4074e524a19455fab810ec454fe8bf1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4694cffcb574863a255e9022c8ddf5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e4a4122ff32a41a1917459709224fc6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8ba66e043f8a4975bd77ecd343401260", + "IPY_MODEL_2e0bb2dcd85640d7b85d80469ea9f9f3", + "IPY_MODEL_1c208beced884b9291c5bcb7b4f71680" + ], + "layout": "IPY_MODEL_3f188d6d34774154afc297b13a3eb9e8" + } + }, + "e54b7fc2f9b94118ab97f2736862f77d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e667b14a3c0e41c6a16c4be453f10378": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e6ce3e626b1744c7ba3da26d1fde5fa5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e6e36d744e1244aeb7eb0c4ce392372d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e7144551e74b46529b00a61f580a183d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e8026bcb0e2c4b14bc6c84537c8c4ae9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e83fd078f467406da0baf26e18b39e89": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9b4b67731a7a4bc59be132b53c24eae8", + "IPY_MODEL_e33243b001274d02a25f5940ba41ecf6", + "IPY_MODEL_06e4c619e366427a8ff4c358196ecd12" + ], + "layout": "IPY_MODEL_bacd429b42d843299cb75224db3afb1e" + } + }, + "e88c3ad56ef24e4d8281898b08ff6f4b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1fdc59cbb8724c618ce6e586e2c9723f", + "placeholder": "​", + "style": "IPY_MODEL_dbaa70ad4f1d4496a670601fe447116d", + "value": " 5.64k/5.64k [01:17<?, ?B/s]" + } + }, + "e8c2cfdaf0eb413189d93924eae757c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ea2217bba8574c7890a411f27da0c147": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b1b6922df40c4af69b00b4e85db770c4", + "IPY_MODEL_2b8bc04ac3104592bf950e349c034c2d", + "IPY_MODEL_cf815c0979644cd6ad2c681fa96c0648" + ], + "layout": "IPY_MODEL_7541b2304cc5466cb2369c0025d2d243" + } + }, + "eaf2c76a172d4da6846c6face18a3b58": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "eb864284052c46b28b93fc79bfed740f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eca3b1f4ad76430483a221470e592c13": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e302923a9df24e5fa8fff79c203ead9f", + "placeholder": "​", + "style": "IPY_MODEL_f7b9abca32ec42edad5ec6e52882f732", + "value": " 5.64k/5.64k [01:17<00:00, 61.4B/s]" + } + }, + "ecf73dd75420460399bfd04d8cd81f90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "edb0d1ba5e114af9b6705969f58ece7b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "edc0742a08a445a594139200c7f03c60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ee103846621b4c0e8e1266599b99f6ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e7144551e74b46529b00a61f580a183d", + "placeholder": "​", + "style": "IPY_MODEL_9b1bfa11ee3746c38155c4505abfaa86", + "value": "Generating train split: 100%" + } + }, + "eef81e9bea0c4f5d85e7efa8ebe0463a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ButtonView", + "button_style": "", + "description": "Login", + "disabled": false, + "icon": "", + "layout": "IPY_MODEL_c778798c234d45b5a4ae2f250e3706f9", + "style": "IPY_MODEL_d5c5396ea2f54ff0aeb9be58b59c253b", + "tooltip": "" + } + }, + "ef7c7fe37c8d459da6d20f4ccbea3fb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4ee1fde44dcf49eda97e1a05173e5bb1", + "placeholder": "​", + "style": "IPY_MODEL_a0929e66406644dbb09bbdc9c58d488d", + "value": "Downloading (…)rocessor_config.json: 100%" + } + }, + "f02443fbda394fefa162f4ff5b2d2ce7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f031aaf7fbc648a7b8a2e5faf37df14d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f0b0cad40fbd461ca7bdcdbb5f442f57": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_76cf84387a7c43608ad018188eef4114", + "IPY_MODEL_68ef0c8550ee4c00aa8b284d48572610", + "IPY_MODEL_58e7f5c36d8b4836a868ce89838f1896" + ], + "layout": "IPY_MODEL_9b216287b8694bcc9960a356adf15504" + } + }, + "f22598cf4ade4427a1b437fd45aabcc4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f34be236ef9c42448ecf2957160990f7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f3991aaad13a4c50a7809483b7907b7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4a118fa87e424664a2d2ed7c7f58f3fd", + "max": 5773, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_852b01d8592b4d8aa2c4297d6cf75f78", + "value": 5773 + } + }, + "f5041033ddf94f459ed8d1747f6b2d6e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f544720498e44c49add78550b46edb3a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9281c5aec5b84411a05e4762125388d9", + "max": 5777, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f5b5d6ace35a4a82bfcf2549b93c8558", + "value": 5777 + } + }, + "f5b5d6ace35a4a82bfcf2549b93c8558": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f6a9243d46cb4c0fbdf3f80f7074f6c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f7b9abca32ec42edad5ec6e52882f732": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f96302d0c2d849c5b5a0206b65e461ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f981fb4aae504045aa10889dceeb6cac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fc612aaed5644b84959a1958b0240dda": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fc9d0c314ca14826993fe1f24b070b5d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fcc7ad16a0b14d96acd9be9e03ac6af9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fcc8254622324f8ea965e12e4d4966cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fd9df81594724b88b54b4e3e1b19370a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c8267c689fb14afc9a8eb3ecb6f4fd4c", + "IPY_MODEL_adb09cebab13484a8d75a338eaba7b0c", + "IPY_MODEL_d68194cf7d264df7820f27eb4d070de2" + ], + "layout": "IPY_MODEL_8bf8a843d65142bbad81de74aa8573f6" + } + }, + "fdb3673fdbf24468a9965f13196b78ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0b82dbc29d514f4e9e012fd755948e52", + "IPY_MODEL_af1a42626ba7452189fbb5987b159b9c", + "IPY_MODEL_93788683ef8e4c71bc1c0b3b9cc7219c" + ], + "layout": "IPY_MODEL_6e4983016e4f465b85ab7a472d0e986e" + } + }, + "fdf282b234fe4a1a8ab452ac04511b7d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_59792e1ee7074f998d5d4494c09061c6", + "IPY_MODEL_cd5b2433cc404ac7b1bb35c6a55f6874", + "IPY_MODEL_7c1b6f271fff4d60be39d291c73bfb75" + ], + "layout": "IPY_MODEL_074f38bd3a9d49719188e8860fb1b5d3" + } + }, + "fe93399cc15f4f29b6a37f6a65cf8c9b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fea27a80cd2f4b4dba84ecdfefd2722c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fee3db0deefb410db4c572efd95575bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fee4fba960ac41ed97984467da41f319": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ee103846621b4c0e8e1266599b99f6ee", + "IPY_MODEL_dcd1c1f4fc014c4aa9ebdaf3c533a061", + "IPY_MODEL_a29d758fb7f147c7ad1108f140caf23a" + ], + "layout": "IPY_MODEL_cb52fa97c659430a8bd71dcd76245a7f" + } + }, + "ff39519704b64e68b69ec06aea02791e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dcefc9ba538e4da2b75f9372a4c5b5bf", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_77df794cb4e4491e80ee20bbd2801a89", + "value": 1 + } + }, + "ffc13c11355b46bb9cafcb17f3e1535e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/image_classification/image_classification_timm_peft_lora.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/image_classification/image_classification_timm_peft_lora.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..1e2f2225055ef8d0542d66b77d089806ae9015cd --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/image_classification/image_classification_timm_peft_lora.ipynb @@ -0,0 +1,744 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4ef57047", + "metadata": {}, + "source": [ + "# Using PEFT with timm" + ] + }, + { + "cell_type": "markdown", + "id": "80561acc", + "metadata": {}, + "source": [ + "`peft` allows us to train any model with LoRA as long as the layer type is supported. Since `Conv2D` is one of the supported layer types, it makes sense to test it on image models.\n", + "\n", + "In this short notebook, we will demonstrate this with an image classification task using [`timm`](https://huggingface.co/docs/timm/index)." + ] + }, + { + "cell_type": "markdown", + "id": "aa26c285", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "markdown", + "id": "552b9040", + "metadata": {}, + "source": [ + "Make sure that you have the latest version of `peft` installed. To ensure that, run this in your Python environment:\n", + " \n", + " python -m pip install --upgrade peft\n", + " \n", + "Also, ensure that `timm` is installed:\n", + "\n", + " python -m pip install --upgrade timm" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e600b7d5", + "metadata": {}, + "outputs": [], + "source": [ + "import timm\n", + "import torch\n", + "from PIL import Image\n", + "from timm.data import resolve_data_config\n", + "from timm.data.transforms_factory import create_transform" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "73a2ae54", + "metadata": {}, + "outputs": [], + "source": [ + "import peft\n", + "from datasets import load_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "82c628fd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.manual_seed(0)" + ] + }, + { + "cell_type": "markdown", + "id": "701ab69c", + "metadata": {}, + "source": [ + "## Loading the pre-trained base model" + ] + }, + { + "cell_type": "markdown", + "id": "20bff51a", + "metadata": {}, + "source": [ + "We use a small pretrained `timm` model, `PoolFormer`. Find more info on its [model card](https://huggingface.co/timm/poolformer_m36.sail_in1k)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "495cb3d6", + "metadata": {}, + "outputs": [], + "source": [ + "model_id_timm = \"timm/poolformer_m36.sail_in1k\"" + ] + }, + { + "cell_type": "markdown", + "id": "2dc06f9b", + "metadata": {}, + "source": [ + "We tell `timm` that we deal with 3 classes, to ensure that the classification layer has the correct size." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "090564bc", + "metadata": {}, + "outputs": [], + "source": [ + "model = timm.create_model(model_id_timm, pretrained=True, num_classes=3)" + ] + }, + { + "cell_type": "markdown", + "id": "beca5794", + "metadata": {}, + "source": [ + "These are the transformations steps necessary to process the image." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9df2e113", + "metadata": {}, + "outputs": [], + "source": [ + "transform = create_transform(**resolve_data_config(model.pretrained_cfg, model=model))" + ] + }, + { + "cell_type": "markdown", + "id": "3f809dfa", + "metadata": {}, + "source": [ + "## Data" + ] + }, + { + "cell_type": "markdown", + "id": "a398fe22", + "metadata": {}, + "source": [ + "For this exercise, we use the \"beans\" dataset. More details on the dataset can be found on [its datasets page](https://huggingface.co/datasets/beans). For our purposes, what's important is that we have image inputs and the target we're trying to predict is one of three classes for each image." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0fddc704", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Found cached dataset beans (/home/vinh/.cache/huggingface/datasets/beans/default/0.0.0/90c755fb6db1c0ccdad02e897a37969dbf070bed3755d4391e269ff70642d791)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "05592574da474b81ab736d6babb5e19d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/3 [00:00" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds_train[0][\"image\"]" + ] + }, + { + "cell_type": "markdown", + "id": "880ea6c4", + "metadata": {}, + "source": [ + "We define a small processing function which is responsible for loading and transforming the images, as well as extracting the labels." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "142df842", + "metadata": {}, + "outputs": [], + "source": [ + "def process(batch):\n", + " x = torch.cat([transform(img).unsqueeze(0) for img in batch[\"image\"]])\n", + " y = torch.tensor(batch[\"labels\"])\n", + " return {\"x\": x, \"y\": y}" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9744257b", + "metadata": {}, + "outputs": [], + "source": [ + "ds_train.set_transform(process)\n", + "ds_valid.set_transform(process)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "282374be", + "metadata": {}, + "outputs": [], + "source": [ + "train_loader = torch.utils.data.DataLoader(ds_train, batch_size=32)\n", + "valid_loader = torch.utils.data.DataLoader(ds_valid, batch_size=32)" + ] + }, + { + "cell_type": "markdown", + "id": "5dcd3329", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "markdown", + "id": "969bc374", + "metadata": {}, + "source": [ + "This is just a function that performs the train loop, nothing fancy happening." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b9fc9588", + "metadata": {}, + "outputs": [], + "source": [ + "def train(model, optimizer, criterion, train_dataloader, valid_dataloader, epochs):\n", + " for epoch in range(epochs):\n", + " model.train()\n", + " train_loss = 0\n", + " for batch in train_dataloader:\n", + " xb, yb = batch[\"x\"], batch[\"y\"]\n", + " xb, yb = xb.to(device), yb.to(device)\n", + " outputs = model(xb)\n", + " lsm = torch.nn.functional.log_softmax(outputs, dim=-1)\n", + " loss = criterion(lsm, yb)\n", + " train_loss += loss.detach().float()\n", + " loss.backward()\n", + " optimizer.step()\n", + " optimizer.zero_grad()\n", + "\n", + " model.eval()\n", + " valid_loss = 0\n", + " correct = 0\n", + " n_total = 0\n", + " for batch in valid_dataloader:\n", + " xb, yb = batch[\"x\"], batch[\"y\"]\n", + " xb, yb = xb.to(device), yb.to(device)\n", + " with torch.no_grad():\n", + " outputs = model(xb)\n", + " lsm = torch.nn.functional.log_softmax(outputs, dim=-1)\n", + " loss = criterion(lsm, yb)\n", + " valid_loss += loss.detach().float()\n", + " correct += (outputs.argmax(-1) == yb).sum().item()\n", + " n_total += len(yb)\n", + "\n", + " train_loss_total = (train_loss / len(train_dataloader)).item()\n", + " valid_loss_total = (valid_loss / len(valid_dataloader)).item()\n", + " valid_acc_total = correct / n_total\n", + " print(f\"{epoch=:<2} {train_loss_total=:.4f} {valid_loss_total=:.4f} {valid_acc_total=:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "3fd58357", + "metadata": {}, + "source": [ + "### Selecting which layers to fine-tune with LoRA" + ] + }, + { + "cell_type": "markdown", + "id": "7987321c", + "metadata": {}, + "source": [ + "Let's take a look at the layers of our model. We only print the first 30, since there are quite a few:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "55a7be4d", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('', timm.models.metaformer.MetaFormer),\n", + " ('stem', timm.models.metaformer.Stem),\n", + " ('stem.conv', torch.nn.modules.conv.Conv2d),\n", + " ('stem.norm', torch.nn.modules.linear.Identity),\n", + " ('stages', torch.nn.modules.container.Sequential),\n", + " ('stages.0', timm.models.metaformer.MetaFormerStage),\n", + " ('stages.0.downsample', torch.nn.modules.linear.Identity),\n", + " ('stages.0.blocks', torch.nn.modules.container.Sequential),\n", + " ('stages.0.blocks.0', timm.models.metaformer.MetaFormerBlock),\n", + " ('stages.0.blocks.0.norm1', timm.layers.norm.GroupNorm1),\n", + " ('stages.0.blocks.0.token_mixer', timm.models.metaformer.Pooling),\n", + " ('stages.0.blocks.0.token_mixer.pool', torch.nn.modules.pooling.AvgPool2d),\n", + " ('stages.0.blocks.0.drop_path1', torch.nn.modules.linear.Identity),\n", + " ('stages.0.blocks.0.layer_scale1', timm.models.metaformer.Scale),\n", + " ('stages.0.blocks.0.res_scale1', torch.nn.modules.linear.Identity),\n", + " ('stages.0.blocks.0.norm2', timm.layers.norm.GroupNorm1),\n", + " ('stages.0.blocks.0.mlp', timm.layers.mlp.Mlp),\n", + " ('stages.0.blocks.0.mlp.fc1', torch.nn.modules.conv.Conv2d),\n", + " ('stages.0.blocks.0.mlp.act', torch.nn.modules.activation.GELU),\n", + " ('stages.0.blocks.0.mlp.drop1', torch.nn.modules.dropout.Dropout),\n", + " ('stages.0.blocks.0.mlp.norm', torch.nn.modules.linear.Identity),\n", + " ('stages.0.blocks.0.mlp.fc2', torch.nn.modules.conv.Conv2d),\n", + " ('stages.0.blocks.0.mlp.drop2', torch.nn.modules.dropout.Dropout),\n", + " ('stages.0.blocks.0.drop_path2', torch.nn.modules.linear.Identity),\n", + " ('stages.0.blocks.0.layer_scale2', timm.models.metaformer.Scale),\n", + " ('stages.0.blocks.0.res_scale2', torch.nn.modules.linear.Identity),\n", + " ('stages.0.blocks.1', timm.models.metaformer.MetaFormerBlock),\n", + " ('stages.0.blocks.1.norm1', timm.layers.norm.GroupNorm1),\n", + " ('stages.0.blocks.1.token_mixer', timm.models.metaformer.Pooling),\n", + " ('stages.0.blocks.1.token_mixer.pool', torch.nn.modules.pooling.AvgPool2d)]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[(n, type(m)) for n, m in model.named_modules()][:30]" + ] + }, + { + "cell_type": "markdown", + "id": "09af9349", + "metadata": {}, + "source": [ + "Most of these layers are not good targets for LoRA, but we see a couple that should interest us. Their names are `'stages.0.blocks.0.mlp.fc1'`, etc. With a bit of regex, we can match them easily.\n", + "\n", + "Also, we should inspect the name of the classification layer, since we want to train that one too!" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8b98d9ef", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('head.global_pool.flatten', torch.nn.modules.linear.Identity),\n", + " ('head.norm', timm.layers.norm.LayerNorm2d),\n", + " ('head.flatten', torch.nn.modules.flatten.Flatten),\n", + " ('head.drop', torch.nn.modules.linear.Identity),\n", + " ('head.fc', torch.nn.modules.linear.Linear)]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[(n, type(m)) for n, m in model.named_modules()][-5:]" + ] + }, + { + "cell_type": "markdown", + "id": "00e75b78", + "metadata": {}, + "source": [ + " config = peft.LoraConfig(\n", + " r=8,\n", + " target_modules=r\".*\\.mlp\\.fc\\d|head\\.fc\",\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "23814d70", + "metadata": {}, + "source": [ + "Okay, this gives us all the information we need to fine-tune this model. With a bit of regex, we match the convolutional layers that should be targeted for LoRA. We also want to train the classification layer `'head.fc'` (without LoRA), so we add it to the `modules_to_save`." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "81029587", + "metadata": {}, + "outputs": [], + "source": [ + "config = peft.LoraConfig(r=8, target_modules=r\".*\\.mlp\\.fc\\d\", modules_to_save=[\"head.fc\"])" + ] + }, + { + "cell_type": "markdown", + "id": "e05876bc", + "metadata": {}, + "source": [ + "Finally, let's create the `peft` model, the optimizer and criterion, and we can get started. As shown below, less than 2% of the model's total parameters are updated thanks to `peft`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8cc5c5db", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 1,064,454 || all params: 56,467,974 || trainable%: 1.88505789139876\n" + ] + } + ], + "source": [ + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "peft_model = peft.get_peft_model(model, config).to(device)\n", + "optimizer = torch.optim.Adam(peft_model.parameters(), lr=2e-4)\n", + "criterion = torch.nn.CrossEntropyLoss()\n", + "peft_model.print_trainable_parameters()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9e557e42", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=0 train_loss_total=1.2999 valid_loss_total=1.0624 valid_acc_total=0.4436\n", + "epoch=1 train_loss_total=1.0200 valid_loss_total=0.8906 valid_acc_total=0.7594\n", + "epoch=2 train_loss_total=0.8874 valid_loss_total=0.6894 valid_acc_total=0.8045\n", + "epoch=3 train_loss_total=0.7440 valid_loss_total=0.4797 valid_acc_total=0.8045\n", + "epoch=4 train_loss_total=0.6025 valid_loss_total=0.3419 valid_acc_total=0.8120\n", + "epoch=5 train_loss_total=0.4820 valid_loss_total=0.2589 valid_acc_total=0.8421\n", + "epoch=6 train_loss_total=0.3567 valid_loss_total=0.2101 valid_acc_total=0.8722\n", + "epoch=7 train_loss_total=0.2835 valid_loss_total=0.1385 valid_acc_total=0.9098\n", + "epoch=8 train_loss_total=0.1815 valid_loss_total=0.1108 valid_acc_total=0.9474\n", + "epoch=9 train_loss_total=0.1341 valid_loss_total=0.0785 valid_acc_total=0.9699\n", + "CPU times: user 4min 3s, sys: 36.3 s, total: 4min 40s\n", + "Wall time: 3min 32s\n" + ] + } + ], + "source": [ + "%time train(peft_model, optimizer, criterion, train_loader, valid_dataloader=valid_loader, epochs=10)" + ] + }, + { + "cell_type": "markdown", + "id": "94162859", + "metadata": {}, + "source": [ + "We get an accuracy of ~0.97, despite only training a tiny amount of parameters. That's a really nice result." + ] + }, + { + "cell_type": "markdown", + "id": "9c16bad8", + "metadata": {}, + "source": [ + "## Sharing the model through Hugging Face Hub" + ] + }, + { + "cell_type": "markdown", + "id": "2e1e16c7", + "metadata": {}, + "source": [ + "### Pushing the model to Hugging Face Hub" + ] + }, + { + "cell_type": "markdown", + "id": "ec596b3b", + "metadata": {}, + "source": [ + "If we want to share the fine-tuned weights with the world, we can upload them to Hugging Face Hub like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b583579d", + "metadata": {}, + "outputs": [], + "source": [ + "user = \"BenjaminB\" # put your user name here\n", + "model_name = \"peft-lora-with-timm-model\"\n", + "model_id = f\"{user}/{model_name}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "f1db67e4", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "aed1f9c3fa334be1b5f208efe5ba27e6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Upload 1 LFS files: 0%| | 0/1 [00:00\n", + " \n", + " \n", + " [255/255 06:13, Epoch 1/1]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EpochTraining LossValidation Loss
1No log0.017228

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Saving model checkpoint to temp/checkpoint-100\n", + "Trainer.model is not a `PreTrainedModel`, only saving its state dict.\n", + "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n", + " warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n", + "Saving model checkpoint to temp/checkpoint-200\n", + "Trainer.model is not a `PreTrainedModel`, only saving its state dict.\n", + "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n", + " warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n", + "***** Running Evaluation *****\n", + " Num examples = 227\n", + " Batch size = 8\n", + "\n", + "\n", + "Training completed. Do not forget to share your model on huggingface.co/models =)\n", + "\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=255, training_loss=0.2569344015682445, metrics={'train_runtime': 377.3565, 'train_samples_per_second': 5.398, 'train_steps_per_second': 0.676, 'total_flos': 1181084919791616.0, 'train_loss': 0.2569344015682445, 'epoch': 1.0})" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "id": "r98VtofiGXtO", + "metadata": { + "id": "r98VtofiGXtO" + }, + "source": [ + "## Qualitatively test our model" + ] + }, + { + "cell_type": "markdown", + "id": "NIm7z3UNzGPP", + "metadata": { + "id": "NIm7z3UNzGPP" + }, + "source": [ + "Let's have a quick qualitative evaluation of the model, by taking a sample from the dataset that corresponds to a positive label. Run your generation similarly as you were running your model from `transformers`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c95d6173", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "c95d6173", + "outputId": "ed03a1dc-597a-4053-99d6-eca2cc6da253" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generate config GenerationConfig {\n", + " \"_from_model_config\": true,\n", + " \"decoder_start_token_id\": 0,\n", + " \"eos_token_id\": 1,\n", + " \"pad_token_id\": 0,\n", + " \"transformers_version\": \"4.27.0.dev0\",\n", + " \"use_cache\": false\n", + "}\n", + "\n", + "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n", + " warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n", + "/usr/local/lib/python3.8/dist-packages/transformers/generation/utils.py:1374: UserWarning: You are calling .generate() with the `input_ids` being on a device type different than your model's device. `input_ids` is on cpu, whereas the model is on cuda. You may experience unexpected behaviors or slower generation. Please make sure that you have put `input_ids` to the correct device by calling for example input_ids = input_ids.to('cuda') before running `.generate()`.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input sentence: In January-September 2009 , the Group 's net interest income increased to EUR 112.4 mn from EUR 74.3 mn in January-September 2008 .\n", + " output prediction: ['positive']\n" + ] + } + ], + "source": [ + "model.eval()\n", + "input_text = \"In January-September 2009 , the Group 's net interest income increased to EUR 112.4 mn from EUR 74.3 mn in January-September 2008 .\"\n", + "inputs = tokenizer(input_text, return_tensors=\"pt\").to(model.device)\n", + "\n", + "outputs = model.generate(input_ids=inputs[\"input_ids\"], max_new_tokens=10)\n", + "\n", + "print(\"input sentence: \", input_text)\n", + "print(\" output prediction: \", tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))" + ] + }, + { + "cell_type": "markdown", + "id": "9QqBlwzoGZ3f", + "metadata": { + "id": "9QqBlwzoGZ3f" + }, + "source": [ + "## Share your adapters on 🤗 Hub" + ] + }, + { + "cell_type": "markdown", + "id": "NT-C8SjcKqUx", + "metadata": { + "id": "NT-C8SjcKqUx" + }, + "source": [ + "Once you have trained your adapter, you can easily share it on the Hub using the method `push_to_hub` . Note that only the adapter weights and config will be pushed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bcbfa1f9", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 359, + "referenced_widgets": [ + "5bb29f3102954b06bec825f6b3a7aaa7", + "90516032070a40979181d1d27db10c4f", + "4b7dc0fb222b4e2a9bb2ef2501e9fd30", + "06069855ef82484f9985e4619095dbe8", + "1ece69c53e37413caad8db70d9160ad5", + "7ce90db727ea47cc9344176858a2225b", + "64f2b70b63cd4e7eb9e22ac2de5589c9", + "57dea1b3e04142bb91868a474774d86a", + "8ac43334e0ad4a78acda3b876fead058", + "04da98e400514cf2847d172916cd0081", + "4dbe49547fe94010ad5a30818cfc35bc", + "99091ca45c1b4809ba0a1b01af85f528", + "06ec124c3dac4fe6b152fb812d20d86d", + "7561c47a97444666816422a0418e1675", + "45ab5d7049e34dfd8a067643ae887a31", + "434e308cac5847f0bee431c7dbb4c04a", + "dd993a4a7cdf40448098544c95468a10" + ] + }, + "id": "bcbfa1f9", + "outputId": "91ef770e-9fc4-4eb2-b02b-24e635101f97" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Token is valid.\n", + "Your token has been saved in your configured git credential helpers (store).\n", + "Your token has been saved to /root/.cache/huggingface/token\n", + "Login successful\n" + ] + } + ], + "source": [ + "from huggingface_hub import notebook_login\n", + "\n", + "notebook_login()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "rFKJ4vHNGkJw", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 152, + "referenced_widgets": [ + "00f7d043cb184d69b828c204dac2c0ab", + "1e409cd3d3a04b558d989d63f0b3b5f7", + "d48cbb38078b456fab1634bec5b0a1ba", + "9030744dbca9427ba8a036a76b5c8bf7", + "53dd4444c0e14e16a912532898b32d92", + "5287ac638c22412ab91c55f3316c9b63", + "a43ddb478f044f17adbcfae841ec2114", + "45141234ce584f208a9d301faadf75d2", + "f62ffbdc24734b999f36058d9edca81f", + "972ddebd536d4685bfc3c7c13e5bd8be", + "64156e2c54b44fb9aec661d9b57da962", + "050de732f51f4af8bb41ab3cad0090a4", + "7960ed3beb2a429ba2aca1c6ed032f64", + "726a2eedc7434210bc5aa4d0a772b313", + "07bf5d621cf944258aaf13954669df56", + "93a0896ca66b4111bc4cabe6e1278440", + "cfc78731f7d543ce8529cc254d92ddf5", + "eacf8e9ed6e847faae2b8ecab283ddc4", + "bef1971d92e6479696e3f9a27a757b8a", + "821f2f296acb40ae9bb40fc3faf4103d", + "11efd993475a4f2aabe7df605bab04dd", + "406e4d8561f64d2a94d93a606d02d7d3" + ] + }, + "id": "rFKJ4vHNGkJw", + "outputId": "07425379-64ad-47e8-ba8f-8d9dc26252b6" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Uploading the following files to ybelkada/flan-t5-large-lora: adapter_model.bin,adapter_config.json\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "00f7d043cb184d69b828c204dac2c0ab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Upload 1 LFS files: 0%| | 0/1 [00:00Pro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. " + } + }, + "7cfda0921e5a4f378e90e057447f3b3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_10aa4e3aca57438ea7af97b60208ac81", + "placeholder": "​", + "style": "IPY_MODEL_f14657da8e1e4298a96e3885eb4eee93", + "value": "Downloading builder script: 100%" + } + }, + "7fb7e3e2c75d4d03a98e581d4ead0f00": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_43d7a9b421be430286b5eb8441d6d465", + "max": 2201, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ebc26228160046c48279d71770c928d8", + "value": 2201 + } + }, + "8035fd17e29a48d7b415c531607216a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "808a41f78a7c4ae0b6aafee59c6234ae": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "808cea6c94264f0c9990d6dbcf538419": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "81d2f0953e104fc1ad57295819b6b689": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bcda86e43607436583f1fbfee08a9786", + "placeholder": "​", + "style": "IPY_MODEL_55cf3bcee7c745948b39eea5f65fc62b", + "value": " 3.13G/3.13G [00:18<00:00, 182MB/s]" + } + }, + "821f2f296acb40ae9bb40fc3faf4103d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8252a05cb70b46ec8b0480062ea1cb71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8669a890db6c456cbc3ada28976be30b", + "placeholder": "​", + "style": "IPY_MODEL_9e5afa2048c74754816b34a34171fcb0", + "value": "Downloading (…)lve/main/config.json: 100%" + } + }, + "82849bb4d5da452e87a18ca749ce5d7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2b4d68606bdf4758b812f5a8057af595", + "placeholder": "​", + "style": "IPY_MODEL_f9620e01cd6749f88b722a42ff68c502", + "value": "Downloading (…)"spiece.model";: 100%" + } + }, + "83f196eb5d9549cda4d48008fa7b1386": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "85ae7ed1ec244a89aeb9f4552c2c9462": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "85e5c1a9b7ac4e6e884213a636d0aaa1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8669a890db6c456cbc3ada28976be30b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87ce7c58b18146f3ac73970d7f8079ac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a2bd1b4d9ba47ef9e77048e3d2d1e83": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ac43334e0ad4a78acda3b876fead058": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8b41d2e9f7424dc898446e7f428dc757": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d35a041dbfb4747aea427e76890551a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_74efd6bfe71e4dc599a7fc76574ff154", + "IPY_MODEL_1ed1bfefa6534085869130ea533ff4b1", + "IPY_MODEL_fd08c4fbe5d84dd893d87a5e2f2d082d" + ], + "layout": "IPY_MODEL_87ce7c58b18146f3ac73970d7f8079ac" + } + }, + "8d79b7d0c3cb4f8d99fb20941c35856f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ef94158b0584f0eb55582bf8b6594c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8f339c9070f046dab46ebc35c1cc2dba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d618ec6be7d14a239b3bc74172616bf2", + "max": 13677, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3c8349539946412a93a51d9087306ea4", + "value": 13677 + } + }, + "8fceec1018574003884e082b2a5c23bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9030744dbca9427ba8a036a76b5c8bf7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_972ddebd536d4685bfc3c7c13e5bd8be", + "placeholder": "​", + "style": "IPY_MODEL_64156e2c54b44fb9aec661d9b57da962", + "value": " 1/1 [00:02<00:00, 2.11s/it]" + } + }, + "90516032070a40979181d1d27db10c4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_57dea1b3e04142bb91868a474774d86a", + "placeholder": "​", + "style": "IPY_MODEL_8ac43334e0ad4a78acda3b876fead058", + "value": "


Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" + } + }, + "924e6a8308fc47af929aca1987a12f09": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93a0896ca66b4111bc4cabe6e1278440": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93fe5a8fafbc44b496309d1a8da77ac5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "94437f56e5a44fa3bb08c9d798b2eaeb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0f091d25adf34ade835b094eb5b952a3", + "IPY_MODEL_9d599c2a4d9f4f2db1e4b3183c18eb94", + "IPY_MODEL_aa91ad725da147bc8cab70f931d82672" + ], + "layout": "IPY_MODEL_fb6877c376e0430296b2746513f60931" + } + }, + "945ac449c2e84fd6b5a7805b017343f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "96e2d208830f48cd821be7e59643c93e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2fe0a2fa22a0498da983ec38150216e6", + "placeholder": "​", + "style": "IPY_MODEL_f3784e85cef34bdba64b611a1f5883e4", + "value": " 792k/792k [00:00<00:00, 7.01MB/s]" + } + }, + "96e4e44a789a46ce8239b260bf6e3dc8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "972ddebd536d4685bfc3c7c13e5bd8be": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "978bbbf33d304588af971d22bb2a3690": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "99091ca45c1b4809ba0a1b01af85f528": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d0500a0f5f74be39e5edfbbcd7a64fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9d599c2a4d9f4f2db1e4b3183c18eb94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bf7a49e0e4a64df6b1b1c66e5e73c3a6", + "max": 8862, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d27ff6c2869242b98564b0e03d68b413", + "value": 8862 + } + }, + "9d68afcb8e26420cb91ea1eb872c80c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a72073cfb8b4422a98ca581c4e5d18b8", + "placeholder": "​", + "style": "IPY_MODEL_3a5712c976b04af0975804b34344dfcf", + "value": "100%" + } + }, + "9e5afa2048c74754816b34a34171fcb0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a0186b2194df4a0a9cd1ac49054d68da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a10078c15aae4ec6a849f1b58c6b1cc2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_223848818aff4af1ab5d5e14271408e3", + "placeholder": "​", + "style": "IPY_MODEL_4b4b31109a9746e88ffa9b47bab00e53", + "value": " 1/1 [00:00<00:00, 12.10ba/s]" + } + }, + "a38c0fedf90a4f3cbb4680b5f85bbf2f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a3bb3f44c1754082a4f5169431c5b760": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a43ddb478f044f17adbcfae841ec2114": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a4857f97132a41acbe4535b03cd8d94a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4d6de73a37148bf9303a273d13cd091": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a72073cfb8b4422a98ca581c4e5d18b8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a9effc13b52044a5bc0d6a2a1088396f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aa2c51ad05c14a02a13e5c047779fc05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2ce6779fa5904471945fa5738510af64", + "IPY_MODEL_bdff3b35dcdf49e5ba2c5c2498773cb7", + "IPY_MODEL_6994741f3113493b9d5bba278b8732f5" + ], + "layout": "IPY_MODEL_808a41f78a7c4ae0b6aafee59c6234ae" + } + }, + "aa91ad725da147bc8cab70f931d82672": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8a2bd1b4d9ba47ef9e77048e3d2d1e83", + "placeholder": "​", + "style": "IPY_MODEL_dbd908538859410f9c20536fe5acb328", + "value": " 8.86k/8.86k [00:00<00:00, 381kB/s]" + } + }, + "aaa1477cfabb4767b755e902d3b99e61": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a38c0fedf90a4f3cbb4680b5f85bbf2f", + "max": 6036, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c6a28dcd88c1487ab17aef6946ada876", + "value": 6036 + } + }, + "b560fc36ee8f424f9590e04a042046fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f2a36b126c1b41848e61b0c581ff8c4b", + "placeholder": "​", + "style": "IPY_MODEL_6a40d6535f9e4b5b9c9283a1cd67687a", + "value": "Downloading (…)okenizer_config.json: 100%" + } + }, + "b718fba0f1514025a0ca22e7f780a2fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0271e1cc4e2d43c69d4959e46eddec9a", + "IPY_MODEL_601fb3752e134641b28da908d4e7b65a", + "IPY_MODEL_e002207d6982491cbef196f25fc891f8" + ], + "layout": "IPY_MODEL_a4857f97132a41acbe4535b03cd8d94a" + } + }, + "b77afc7c1f184de0970feb2df8ac5285": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5bfebc75ec424c6cb41b33d210d28d2b", + "max": 662, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ef2fa44d0105457c9aed3812633dd329", + "value": 662 + } + }, + "b8087054f46c44cab9bd62fa23fbf9de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5192bc282c4847cb9df8365fc22a6cc2", + "placeholder": "​", + "style": "IPY_MODEL_608e9f7a14054573b9bd07f0f74b6345", + "value": " 2.20k/2.20k [00:00<00:00, 84.9kB/s]" + } + }, + "b8944b7027d449b4a7fc752978f463b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_390b88f67b84451999b0845483905144", + "placeholder": "​", + "style": "IPY_MODEL_be9c243b74d944eb82ca1fe4ada6721d", + "value": " 1303/2264 [00:00<00:00, 4889.47 examples/s]" + } + }, + "b8bb0aed01d04e8dad560df1b051e1e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_93fe5a8fafbc44b496309d1a8da77ac5", + "placeholder": "​", + "style": "IPY_MODEL_a9effc13b52044a5bc0d6a2a1088396f", + "value": " 3/3 [00:00<00:00, 17.02ba/s]" + } + }, + "baf53867f52046c182a2b1755f02e136": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "bc24304c057d4b5898e832818de55caa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bca79be79b6d4a68b148255bba86ea96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_74e88bd01bf14e0e9f772f993c92eb77", + "placeholder": "​", + "style": "IPY_MODEL_401bd48c5b2d48eb86a1499912ee2b44", + "value": " 682k/682k [00:00<00:00, 6.99MB/s]" + } + }, + "bcda86e43607436583f1fbfee08a9786": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bdfb4a04e48246a4b0890f52d6dd424b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bdff3b35dcdf49e5ba2c5c2498773cb7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_df8fbdbe9bc341e3a39a7bda99b70be2", + "max": 147, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_179a912bbd1e454eba503782b675efa8", + "value": 147 + } + }, + "be11f6865f6c41b5a57b2b7f4a85e14c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_85e5c1a9b7ac4e6e884213a636d0aaa1", + "placeholder": "​", + "style": "IPY_MODEL_216e5237b31944cbab006d9761ade0a1", + "value": "Downloading data: 100%" + } + }, + "be9c243b74d944eb82ca1fe4ada6721d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bef1971d92e6479696e3f9a27a757b8a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bf7a49e0e4a64df6b1b1c66e5e73c3a6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c0deb08457be4a3ebb3947e33f7ce1df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cba58e0b316b439ab035b917a40c630c", + "placeholder": "​", + "style": "IPY_MODEL_de6718209a7a42b0809e97fcd97e09ed", + "value": "100%" + } + }, + "c149c1c53e9d44008a86944ef8c261c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c1757a5b684f4496a4b0e3db544bf44b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c31cffaa6934407399856235a2f3af54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a4d6de73a37148bf9303a273d13cd091", + "max": 681890, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f79eeece093f4b0e9de6dbc346a3fa19", + "value": 681890 + } + }, + "c6a28dcd88c1487ab17aef6946ada876": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c708031a279e4e55ac7833e6697f93bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c7771479ae4e4efab744fad6da586fd3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cba58e0b316b439ab035b917a40c630c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cce112d791dd4b748908756e785ab555": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_be11f6865f6c41b5a57b2b7f4a85e14c", + "IPY_MODEL_c31cffaa6934407399856235a2f3af54", + "IPY_MODEL_bca79be79b6d4a68b148255bba86ea96" + ], + "layout": "IPY_MODEL_5093700dd3a14cc1a283d18a4a0e17a7" + } + }, + "ce0213e9d6aa45c5a9ac9954fbe15f62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7cfda0921e5a4f378e90e057447f3b3d", + "IPY_MODEL_aaa1477cfabb4767b755e902d3b99e61", + "IPY_MODEL_7b6bddd4ca51495dbc2fceba7c50706f" + ], + "layout": "IPY_MODEL_6317d49813234f5b9103b249cf648c2c" + } + }, + "cfc78731f7d543ce8529cc254d92ddf5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cfc7aa04c11d408c9c12cdbd9cff4bb5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d27ff6c2869242b98564b0e03d68b413": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d48cbb38078b456fab1634bec5b0a1ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_45141234ce584f208a9d301faadf75d2", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f62ffbdc24734b999f36058d9edca81f", + "value": 1 + } + }, + "d5b57d3c74d14e5d80d1ef634c103a40": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d618ec6be7d14a239b3bc74172616bf2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d72e8b3419f240f2bdce253cce9d24e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d7d9e2e2090d4226ad89e5ba9cec33df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5cc620a232bf4d418c3fc882f4c1cd0c", + "IPY_MODEL_f742450a607c4ed0bff98ac9b7685d40", + "IPY_MODEL_e87b05e685b040f7a99450bfbab72433" + ], + "layout": "IPY_MODEL_e1c8e6f843604161bbb6cbd269488469" + } + }, + "da99eed13d524b8fb95dbc563eb2d044": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dbd908538859410f9c20536fe5acb328": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dbdb787728184aa1a6906f96c5e6f929": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e3be963920c84c7fbe7e0bc61b8e778d", + "IPY_MODEL_1275c5a5c88b435a897f88a19c54a0a5", + "IPY_MODEL_81d2f0953e104fc1ad57295819b6b689" + ], + "layout": "IPY_MODEL_61ab054f49884b1fadf529a39ccc37dc" + } + }, + "dd53a486f7b5403a81e2be89cbbda719": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd993a4a7cdf40448098544c95468a10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "de6718209a7a42b0809e97fcd97e09ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "df8fbdbe9bc341e3a39a7bda99b70be2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e002207d6982491cbef196f25fc891f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1d11cb45c5cb472aa86722e4dbb8c085", + "placeholder": "​", + "style": "IPY_MODEL_34142a8e97594931b316970911679e55", + "value": " 3/3 [00:00<00:00, 2.89ba/s]" + } + }, + "e1769695dffd4ebeb79a63ff4812fa9e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f66e179caa8b4393bed19a0488821c47", + "placeholder": "​", + "style": "IPY_MODEL_cfc7aa04c11d408c9c12cdbd9cff4bb5", + "value": " 2.54k/2.54k [00:00<00:00, 95.8kB/s]" + } + }, + "e1c8e6f843604161bbb6cbd269488469": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e24115bb662c428e89c2c4421915e632": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e293930c8e2c4eadbda53005e21ec450": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e3be963920c84c7fbe7e0bc61b8e778d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_924e6a8308fc47af929aca1987a12f09", + "placeholder": "​", + "style": "IPY_MODEL_c1757a5b684f4496a4b0e3db544bf44b", + "value": "Downloading (…)"pytorch_model.bin";: 100%" + } + }, + "e87b05e685b040f7a99450bfbab72433": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_06cea508d7504b228f6cebc66742d200", + "placeholder": "​", + "style": "IPY_MODEL_9d0500a0f5f74be39e5edfbbcd7a64fc", + "value": " 2.42M/2.42M [00:00<00:00, 4.03MB/s]" + } + }, + "eacf8e9ed6e847faae2b8ecab283ddc4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ebc26228160046c48279d71770c928d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ec73524ed7f14ea0b67f07d72eada173": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ef2fa44d0105457c9aed3812633dd329": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f00b73eb32374c33882c1bfc49822e44": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f061a6deaa73484aa04f219bba6a4329": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f14657da8e1e4298a96e3885eb4eee93": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f2a36b126c1b41848e61b0c581ff8c4b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f2dc5e8a31c348358aca916274899e8b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2bfb7c240e154769a0d58a3ceaa20212", + "IPY_MODEL_8f339c9070f046dab46ebc35c1cc2dba", + "IPY_MODEL_34db70b6e6ec475699fd23a2d6c3a973" + ], + "layout": "IPY_MODEL_e24115bb662c428e89c2c4421915e632" + } + }, + "f3784e85cef34bdba64b611a1f5883e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f48454eadbfb4953b719bdf44555c90e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3c5affff513341b29e6a2c1c90bfe334", + "IPY_MODEL_0bbeca449a814d95bec438a9141b2b6b", + "IPY_MODEL_a10078c15aae4ec6a849f1b58c6b1cc2" + ], + "layout": "IPY_MODEL_06e8fd84d6224e5096088d66aad71961" + } + }, + "f4ff06e2c48d4e58abe64cb7f41dd886": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4f57cfa7cb3b4199babf82dc9d93b074", + "placeholder": "​", + "style": "IPY_MODEL_053de11f995247f6b851909a6a8dfc16", + "value": "Downloading (…)cial_tokens_map.json: 100%" + } + }, + "f62ffbdc24734b999f36058d9edca81f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f66e179caa8b4393bed19a0488821c47": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f742450a607c4ed0bff98ac9b7685d40": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e293930c8e2c4eadbda53005e21ec450", + "max": 2424064, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_945ac449c2e84fd6b5a7805b017343f2", + "value": 2424064 + } + }, + "f79eeece093f4b0e9de6dbc346a3fa19": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f9620e01cd6749f88b722a42ff68c502": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fb6877c376e0430296b2746513f60931": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fd08c4fbe5d84dd893d87a5e2f2d082d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f30253108fb4dce9c3de029457ef6f1", + "placeholder": "​", + "style": "IPY_MODEL_1fa2a7e3ff3c4c99ab95e96a28624846", + "value": " 1/1 [00:00<00:00, 22.88ba/s]" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/Finetune_opt_bnb_peft.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/Finetune_opt_bnb_peft.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..99ab2a30e763d8fe6dce3ce9637bb629a73f10b9 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/Finetune_opt_bnb_peft.ipynb @@ -0,0 +1,9276 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "WE5GJ6s7y0Xo" + }, + "source": [ + "## Fine-tune large models using 🤗 `peft` adapters, `transformers` & `bitsandbytes`\n", + "\n", + "In this tutorial we will cover how we can fine-tune large language models using the very recent `peft` library and `bitsandbytes` for loading large models in 8-bit.\n", + "The fine-tuning method will rely on a recent method called \"Low Rank Adapters\" (LoRA), instead of fine-tuning the entire model you just have to fine-tune these adapters and load them properly inside the model. \n", + "After fine-tuning the model you can also share your adapters on the 🤗 Hub and load them very easily. Let's get started!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TfBzP8gWzkpv" + }, + "source": [ + "### Install requirements\n", + "\n", + "First, run the cells below to install the requirements:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "otj46qRbtpnd", + "outputId": "2aa109f6-3f4e-4887-a16e-336f51e7cc9a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.3/76.3 MB\u001b[0m \u001b[31m10.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m462.8/462.8 KB\u001b[0m \u001b[31m25.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m199.7/199.7 KB\u001b[0m \u001b[31m25.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m190.3/190.3 KB\u001b[0m \u001b[31m23.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m213.0/213.0 KB\u001b[0m \u001b[31m26.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m132.0/132.0 KB\u001b[0m \u001b[31m18.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m140.6/140.6 KB\u001b[0m \u001b[31m20.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.6/7.6 MB\u001b[0m \u001b[31m72.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Building wheel for transformers (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for peft (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n" + ] + } + ], + "source": [ + "!pip install -q datasets==3.6.0 accelerate\n", + "!pip install -q git+https://github.com/bitsandbytes-foundation/bitsandbytes.git\n", + "!pip install -q git+https://github.com/huggingface/transformers.git@main git+https://github.com/huggingface/peft.git" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FOtwYRI3zzXI" + }, + "source": [ + "### Model loading\n", + "\n", + "Here let's load the `opt-6.7b` model, its weights in half-precision (float16) are about 13GB on the Hub! If we load them in 8-bit we would require around 7GB of memory instead." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 408, + "referenced_widgets": [ + "d4de260ffd8a440eb87eb900fc1bb1d3", + "8602b545a9f8474dbb3cc178ac0b8e60", + "b46919912ee54f6f9f2ce9080be1c61a", + "50374e3ab81c4626a182e61fc03b94ce", + "2144bc2897dc40b29f060e30ace12275", + "949ca70002ca4472bbc21fea4d7ac745", + "49943c9dadca43a584b3f354ba45280c", + "6123e53fb26b41f0af9a3a3348ae1afd", + "285ef943d540400ab827c462945a259c", + "95727290446244ccb9626f4594949675", + "61b54aa6c9e94ee1bc45c15a9e3f7917", + "fc2d5ffe254d425b939252ec46ec27cc", + "f65af2e868244edeb0cc9402534874a8", + "e466054f08004bbcabb24e400cb3c7fc", + "6ea40800dfd849e3b106bae71fc53ae3", + "722a01f42b7d4c38836a4546ecb38108", + "1bd5179cdb474b65aa06eca3520ad37b", + "04d367124a3b419ab1fa1dfd4f9004c3", + "4ea667f48b9f4e1f9da7c5a0d3025b85", + "9b96c63630654773acd38b8b88371f28", + "cb69ae47666a4603a07a8778e2ae7d6e", + "8f5e9f2d11d54fd2a08dcbff9f6da05c", + "c6f712eadc4d49019b2bd355968cc155", + "5fd979c05fd34311af877ce1a988ead8", + "179165ff4c0e4586aaf3a40b8502f428", + "cad1d8326e474a4f9ee13db9005121dd", + "b049ac0b3d2e44ba9b1fc1cb2dd3de62", + "921c268ecd724b6a8869dae8f81d558a", + "4cf85a85c0764f15b5134c81b360e910", + "5936d9eb59e147eea6482006decfe0ee", + "fad61c68edc84c8197afeafded84280d", + "451309d8b3ca4cd9b6f538640477039e", + "c7621e14aa16421d9758321e433b92e4", + "5aa74b9b30614172b07f88873cf89471", + "cf39fb025e3d4635a5695135a56d9f64", + "deaf9732f33446a3be015d2ec16aba76", + "bdfd856dd8ee4ae09205ad9d1b9cc806", + "7a49f7a55b054b6d829f290a1a426a7a", + "5b695486a0ac442b8b6a8ef2ebf4e57a", + "03be7cb91cba4afab795aab7aa242ee1", + "8f7890f54d514f80b1eb17905cf0f964", + "ae660d51267544a89f0ad199cc12b6fa", + "d5bb8d7359274c8e9cc79df563175137", + "98d5a80ec50c46c18f9ee991e2982115", + "e73e5388182040a8937ccf1748171a87", + "f797f7b8b13f4b3cb871522d34498631", + "41f47c864e094cacb1c550d37ddfe80e", + "104d982b444947fe8e4fbb2c2f082616", + "2cf8581583c641fb95d1e16aff7d4cd1", + "11808e9097424dd0b22a5af6c77813f3", + "dc08d237860e4788a8ceeff4518c2612", + "7bbf2c40a4ae46fe9e5885db08975263", + "f00cbc4a89f5492787ec489da65ff70b", + "8a7cd2194113493a841b00d034b5f1ba", + "e9673363e85448d494ac9ac5d7ba0efb", + "a994beafbf3f4c20880a7bbe3898db36", + "7769c261781f4f5483c7e9d58c1a5573", + "4a713a8fe16f4e81aa841c69711fa136", + "08d036904ecf47ed88e129ba6e2b285c", + "9f1182fdddab43b59ee98bc701965a17", + "c2302f535b114ad780bfa440445c2e28", + "8fe032f285ba4858b8efd68119c217b0", + "4ca695fca3d140c6ab4e1e1d34df807b", + "b77ceaf55dc04810963cdd01126478f6", + "0ccdefcb25e14d229b2634ffae4a6d3d", + "11d6b952503c4824b36b66e228f87599", + "1e9391f6c89c4d08859ef3413edb19be", + "039bbda2402f469eb21ba7ec7ea589a6", + "5da6eef8fb0048219159f38a68727b64", + "c006e62ee6d04831b2b89273ef04a8ac", + "af0634c2539a43989902daef47776901", + "62fea00ef0364af287e6097b964d00c4", + "9e5ef73f8b244845a6b9002fa5c35d15", + "5cb09c84e1e144e0a92580fb5e1ce2fe", + "0f561c1660744251a8f710b69d434c87", + "9e5f870ef80242f5af09fad70f84ea62", + "6f173ca73dd545deb22b8cd0470d925f", + "4e6d5943bc374b388b93ed115e44b6a5", + "cbe2a6ea41834e95a27d6f02c3c0eeec", + "7beb5f4efefc4593abac253df74d1405", + "370cefbaeebf41f582b7507ad493055f", + "e3df9dda16e244aa9b61d54f9e21ef40", + "23d2ad64a17041b7a006dad1e041e0a1", + "c1fd6a1234274a44b838a09f3f5380c6", + "81bb51d088374394becd9a45ec3b17d4", + "9e762779e5434bb7afcc295b61c2f4e4", + "f539b7a4665449de9eac209a20629969", + "32d528db79ad4f6f836ab2e0df5ac426", + "1ca7684b79c5438fa06b047bd2b3283f", + "a07688185bff4c4b8cbed3af3b4cf802", + "0272f1d9f93f4dd788363a8409cdfd69", + "27b41d23d2c64127ba3ae8464958f855", + "2b54032c0d8e4a2897aed1ac1c79af14", + "ed8fa1048e814f2fa3666899fc42e55a", + "97daf559100c44ac983562fea93c5fac", + "72e511b775604d899ff5b3fa2ebe9fc4", + "da946f86590447d2ab98b9da468fa66b", + "54fe79d5c7254117a2209927a7248dd4", + "1d122e4eaad54e06961288484f31e18b", + "d46b5725c35142a89617e46c0e8d3679", + "c5493c23fd5542738ffd1ff5f09a6a67", + "a1a80d3460984c2496ada5a634875934", + "598c5584ffba4f26815c4e87bb1595c4", + "fe93f25323604447be0bb1d24a0c2c59", + "00c2e2d3ee8b45818ba84da12c6b11e2", + "6ccea64c2e614a9fbdcc2f716cecaea0", + "63fc9a9eebca4f2db2ed8a385fc5e204", + "9a4860dfeac944db85e6e532599bc1cb", + "3b946e1bbab24629b98307275fbe7cbb", + "d9d36f8ff5f747bf90fbc8a7d35a6664" + ] + }, + "id": "cg3fiQOvmI3Q", + "outputId": "135a7675-6a4d-4786-b5dc-34cb867f40c7" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bee2f575b3e64c30b2f3afa137802406", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading checkpoint shards: 0%| | 0/2 [00:00\n", + " \n", + " \n", + " [153/200 26:04 < 08:06, 0.10 it/s, Epoch 0.97/2]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
12.364400
22.200400
32.302300
42.184700
51.878700
62.307200
72.193800
82.446200
92.458900
102.020000
111.941200
121.931000
132.055900
141.975100
152.015100
162.095600
171.768300
182.155700
192.402300
202.124600
212.314900
221.908500
232.078800
241.941900
251.879800
261.927500
271.371400
281.977600
292.055000
301.915800
311.958100
322.195900
332.001000
342.025000
351.576900
361.879800
371.821600
381.727800
391.995700
401.698600
412.129300
422.025800
431.696500
441.984700
452.051100
462.054400
471.765600
482.063100
491.746900
501.873000
512.391300
522.494100
532.072300
541.808000
551.911900
562.168100
572.166100
581.921500
591.856000
601.652800
611.605000
622.032500
631.822100
641.623600
651.923200
662.053200
672.114300
681.807700
691.857800
701.854600
712.023000
721.864900
731.769300
741.837700
751.742200
761.895900
771.922800
782.325300
792.231200
802.309500
811.945700
822.072100
831.917400
842.004600
851.951700
861.450600
871.785600
881.668000
891.903100
901.709800
912.312900
922.092100
932.319600
941.603100
951.740000
961.670500
971.611600
981.728900
992.285200
1001.957800
1011.676700
1021.656300
1031.612400
1041.848900
1051.870000
1061.954000
1072.192200
1081.637600
1091.208700
1102.254200
1111.832100
1122.119600
1132.126400
1141.915700
1151.587500
1161.564800
1171.742700
1181.712600
1191.727900
1202.361500
1212.070300
1221.878500
1231.846600
1242.061700
1252.149700
1261.940600
1272.098300
1281.734100
1292.111700
1301.887600
1311.716300
1322.070000
1331.782200
1341.955200
1351.762900
1361.954700
1371.687100
1381.979100
1391.634600
1401.801200
1411.954100
1421.833900
1432.051400
1441.921200
1451.787500
1461.825400
1471.363400
1481.977400
1491.768300
1502.226700
1511.945500

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import transformers\n", + "from datasets import load_dataset\n", + "\n", + "data = load_dataset(\"Abirate/english_quotes\")\n", + "data = data.map(lambda samples: tokenizer(samples[\"quote\"]), batched=True)\n", + "\n", + "trainer = transformers.Trainer(\n", + " model=model,\n", + " train_dataset=data[\"train\"],\n", + " args=transformers.TrainingArguments(\n", + " per_device_train_batch_size=4,\n", + " gradient_accumulation_steps=4,\n", + " warmup_steps=100,\n", + " max_steps=200,\n", + " learning_rate=2e-4,\n", + " fp16=True,\n", + " logging_steps=1,\n", + " output_dir=\"outputs\",\n", + " ),\n", + " data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),\n", + ")\n", + "model.config.use_cache = False # silence the warnings. Please re-enable for inference!\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Duak7T_B3VpJ" + }, + "source": [ + "## Share adapters on the 🤗 Hub" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 331, + "referenced_widgets": [ + "262f01ffc5824b5faa8a61afac12ff67", + "c1af10b599da43a3a848f3ba816d7acc", + "be673691e713472980fa1132465714b4", + "01f8b90f0f184dfdb92c0c3bffb28b0f", + "9ad2bd0e92174d339a3a91a38253a180", + "bff17ef6aabd4aa681bfd5ad64b808d9", + "55633800b60a4336abea6a4adfcfdec1", + "73d5c6b4034d49b392b103d889bfb3b4", + "a55954b8d7bf4057b0d7aa6a1cb9e91a", + "4da42eb3846f423d88e2a6462a0cfce8", + "dab39ef354a84be3b37b6f151f9d9b9d", + "b88b03326f464c96a5656eef774e36d5", + "4eccb670e98043b3b2702821a3060ece", + "a333501a50df4b9fa9546d8d965e0dc3", + "1f173cb95c5c44f4b32f6cfe10ee3b03", + "52c8a7e673f24276a07042388a13b58f", + "a0f323ccfbc14fc4b7a5e7046b221ce3" + ] + }, + "id": "DpYr24pR8T_0", + "outputId": "20186456-1bd4-4655-b2f2-8f24f9f37fcc" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Token is valid.\n", + "Your token has been saved to /root/.cache/huggingface/token\n", + "Login successful\n" + ] + } + ], + "source": [ + "from huggingface_hub import notebook_login\n", + "\n", + "notebook_login()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 133, + "referenced_widgets": [ + "3dbe077ed0c34e4eb1628418138ccbc6", + "a579cb7804774ca3aa9efd800d1af57e", + "9f44e3175835470aba43e239661037b2", + "549bd12e3af64256a7534903688835a8", + "a18d9beb34b848ff8cc541d2cb290c4c", + "876cb42184f54b749c442163290c2c45", + "43b14e0e1263499dbd592b280cff21b0", + "7164feaf360d4300a5083f95064b144a", + "bd7547126a874a45b608afed7ab2958b", + "26e4b6b94e4540728c59df8e481ce43d", + "9d1b77500f1c45308d4791a9c443e307", + "b2693135b6954d35afb3120f3caf4000", + "aeca2429ee48450a814515cb06acbc3e", + "434c09950be04d728cd7ca8d6c134dc6", + "34f58c132d2e4249b1e62a0b57c85999", + "d148369be26a43949257790cb202728d", + "0ecf58c5cbcd40908595fccddff1c6d4", + "fc2314656a2745eb921f636cc3451381", + "7817f8669b7f449fadf02d7145fa89e2", + "06e012eea9714ed589344a362b7421bb", + "504e9e5ced0348cc87aafae0c1c372eb", + "5b538e8389fb4574a5dfdc554624e3c8" + ] + }, + "id": "VxB6UV5XAvvP", + "outputId": "c3b0133b-f5b1-4283-8367-f06524bea46c" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Uploading the following files to ybelkada/opt-6.7b-lora: adapter_config.json,adapter_model.bin\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3dbe077ed0c34e4eb1628418138ccbc6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Upload 1 LFS files: 0%| | 0/1 [00:00Pro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. " + } + }, + "c006e62ee6d04831b2b89273ef04a8ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9e5f870ef80242f5af09fad70f84ea62", + "placeholder": "​", + "style": "IPY_MODEL_6f173ca73dd545deb22b8cd0470d925f", + "value": " 685/685 [00:00<00:00, 34.4kB/s]" + } + }, + "c1af10b599da43a3a848f3ba816d7acc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_73d5c6b4034d49b392b103d889bfb3b4", + "placeholder": "​", + "style": "IPY_MODEL_a55954b8d7bf4057b0d7aa6a1cb9e91a", + "value": "


Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" + } + }, + "c1fd6a1234274a44b838a09f3f5380c6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c2302f535b114ad780bfa440445c2e28": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c2b42681b8bb47e3895d6105240c5812": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c41a9d785e884ab0a58117d17ac7d228": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c423a3cc0b504828b11077c77268ed92": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c4ab408eb1344da0bb15a9a6760818e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c5493c23fd5542738ffd1ff5f09a6a67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_00c2e2d3ee8b45818ba84da12c6b11e2", + "placeholder": "​", + "style": "IPY_MODEL_6ccea64c2e614a9fbdcc2f716cecaea0", + "value": "Downloading (…)cial_tokens_map.json: 100%" + } + }, + "c57c7cf35bf04f3bb3b2b0d8ce7feb31": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6f712eadc4d49019b2bd355968cc155": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5fd979c05fd34311af877ce1a988ead8", + "IPY_MODEL_179165ff4c0e4586aaf3a40b8502f428", + "IPY_MODEL_cad1d8326e474a4f9ee13db9005121dd" + ], + "layout": "IPY_MODEL_b049ac0b3d2e44ba9b1fc1cb2dd3de62" + } + }, + "c7621e14aa16421d9758321e433b92e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c81d20fe47ce4b7594427830d71504d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a14542c8431c48b48a614cfd0d41f03c", + "IPY_MODEL_856f3dcf949741acb394f252186a1d7e", + "IPY_MODEL_865bae11c917492a9a1ef7286a493bd5" + ], + "layout": "IPY_MODEL_2561b7a7c1694f229d30d2b1eeb14b2f" + } + }, + "c9b718882fec4254bce1f33fa9373921": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4884bf82f5814e049c47cf6d496aab08", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_432fc8277ebc492f91d6b46ed073ccb4", + "value": 1 + } + }, + "cad1d8326e474a4f9ee13db9005121dd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_451309d8b3ca4cd9b6f538640477039e", + "placeholder": "​", + "style": "IPY_MODEL_c7621e14aa16421d9758321e433b92e4", + "value": " 9.96G/9.96G [03:05<00:00, 63.7MB/s]" + } + }, + "cb69ae47666a4603a07a8778e2ae7d6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cbe2a6ea41834e95a27d6f02c3c0eeec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_23d2ad64a17041b7a006dad1e041e0a1", + "placeholder": "​", + "style": "IPY_MODEL_c1fd6a1234274a44b838a09f3f5380c6", + "value": "Downloading (…)olve/main/vocab.json: 100%" + } + }, + "ce6de6f9ddde4a6d8094a2b96eac3a4e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce8d4bac782949579a2e52864455d9de": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf39fb025e3d4635a5695135a56d9f64": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5b695486a0ac442b8b6a8ef2ebf4e57a", + "placeholder": "​", + "style": "IPY_MODEL_03be7cb91cba4afab795aab7aa242ee1", + "value": "Downloading (…)00002-of-00002.bin";: 100%" + } + }, + "d148369be26a43949257790cb202728d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d3511ce1754b41969e5c36a5b33ac466": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d46b5725c35142a89617e46c0e8d3679": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c5493c23fd5542738ffd1ff5f09a6a67", + "IPY_MODEL_a1a80d3460984c2496ada5a634875934", + "IPY_MODEL_598c5584ffba4f26815c4e87bb1595c4" + ], + "layout": "IPY_MODEL_fe93f25323604447be0bb1d24a0c2c59" + } + }, + "d4de260ffd8a440eb87eb900fc1bb1d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8602b545a9f8474dbb3cc178ac0b8e60", + "IPY_MODEL_b46919912ee54f6f9f2ce9080be1c61a", + "IPY_MODEL_50374e3ab81c4626a182e61fc03b94ce" + ], + "layout": "IPY_MODEL_2144bc2897dc40b29f060e30ace12275" + } + }, + "d4f5b19f75e246df9c688f625792e8ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a6ce291698ad460394433a49000c1d25", + "max": 646739, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_aa54b2a9b43848b0902d135beffb806b", + "value": 646739 + } + }, + "d54e8d69575f49eb977da64abc5ceb0c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d5bb8d7359274c8e9cc79df563175137": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d72bd17e161442b0979dceaaef66d82c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4f592d7632fd440aac0bf97ceed2de75", + "max": 33601485, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1b515483e5884479b2101127c16321d4", + "value": 33601485 + } + }, + "d7e33c29d410414eb452d121edd9920e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d9d36f8ff5f747bf90fbc8a7d35a6664": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "da946f86590447d2ab98b9da468fa66b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "dab39ef354a84be3b37b6f151f9d9b9d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dc08d237860e4788a8ceeff4518c2612": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ddc333530c13446a91cf332846bfa22f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d7e33c29d410414eb452d121edd9920e", + "placeholder": "​", + "style": "IPY_MODEL_d3511ce1754b41969e5c36a5b33ac466", + "value": " 0/0 [00:00<?, ? examples/s]" + } + }, + "ddc36fdbdd634dc489f658bead61e7ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "deaf9732f33446a3be015d2ec16aba76": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8f7890f54d514f80b1eb17905cf0f964", + "max": 3356360185, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ae660d51267544a89f0ad199cc12b6fa", + "value": 3356360185 + } + }, + "e1f62cbd805d4b8aa9aba7e345c21c82": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e3df9dda16e244aa9b61d54f9e21ef40": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e466054f08004bbcabb24e400cb3c7fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4ea667f48b9f4e1f9da7c5a0d3025b85", + "max": 41937, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9b96c63630654773acd38b8b88371f28", + "value": 41937 + } + }, + "e73e5388182040a8937ccf1748171a87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f797f7b8b13f4b3cb871522d34498631", + "IPY_MODEL_41f47c864e094cacb1c550d37ddfe80e", + "IPY_MODEL_104d982b444947fe8e4fbb2c2f082616" + ], + "layout": "IPY_MODEL_2cf8581583c641fb95d1e16aff7d4cd1" + } + }, + "e9673363e85448d494ac9ac5d7ba0efb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ed2736d862a94d8f9db9ba6037016071": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "info", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3185bd8ecbde4f26b8ed0f92cf79e14f", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ddc36fdbdd634dc489f658bead61e7ee", + "value": 1 + } + }, + "ed8fa1048e814f2fa3666899fc42e55a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f00cbc4a89f5492787ec489da65ff70b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f27905d0073e493cb9dcd174c0f15e35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c423a3cc0b504828b11077c77268ed92", + "placeholder": "​", + "style": "IPY_MODEL_668dd47eec9942bcad0af209772cf8e6", + "value": " 1/1 [00:00<00:00, 9.58it/s]" + } + }, + "f357166c6e5f43f39d0a287ca6d6f60e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_805a10c2fd794ff692e8ebeefd65f2eb", + "IPY_MODEL_3730f843399d4ba48e98383563283e94", + "IPY_MODEL_f855aced7ca2485ea720604359deaa18" + ], + "layout": "IPY_MODEL_6d728366de1a4bacb1ba1939c5e0146f" + } + }, + "f51c7f18977447e2bca36e1da3e1be4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f539b7a4665449de9eac209a20629969": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f65af2e868244edeb0cc9402534874a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1bd5179cdb474b65aa06eca3520ad37b", + "placeholder": "​", + "style": "IPY_MODEL_04d367124a3b419ab1fa1dfd4f9004c3", + "value": "Downloading (…)model.bin.index.json: 100%" + } + }, + "f797f7b8b13f4b3cb871522d34498631": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_11808e9097424dd0b22a5af6c77813f3", + "placeholder": "​", + "style": "IPY_MODEL_dc08d237860e4788a8ceeff4518c2612", + "value": "Loading checkpoint shards: 100%" + } + }, + "f855aced7ca2485ea720604359deaa18": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_49504531deaf4449938bea751d1ec4e7", + "placeholder": "​", + "style": "IPY_MODEL_7dfe540a75864cf390b3bed20ab1dcd9", + "value": " 5.55k/5.55k [00:00<00:00, 156kB/s]" + } + }, + "fad61c68edc84c8197afeafded84280d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "faf24b3ed994422f8dd806ae0cc30531": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_86dff0987bf040da99c8f2846da26d86", + "placeholder": "​", + "style": "IPY_MODEL_63f8ad255d2147128bdc26f47fdf2528", + "value": " 3/3 [00:02<00:00, 1.18ba/s]" + } + }, + "fc15c6d6eb3049a3b8542b332dd8a3f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fc2314656a2745eb921f636cc3451381": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fc2d5ffe254d425b939252ec46ec27cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f65af2e868244edeb0cc9402534874a8", + "IPY_MODEL_e466054f08004bbcabb24e400cb3c7fc", + "IPY_MODEL_6ea40800dfd849e3b106bae71fc53ae3" + ], + "layout": "IPY_MODEL_722a01f42b7d4c38836a4546ecb38108" + } + }, + "fe93f25323604447be0bb1d24a0c2c59": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ff2454cf69b346fea70070522cf93689": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_87b36eb4ad3b4047a32c7d67a5aabc5e", + "IPY_MODEL_8bf9fd4bd28e4bc1b5895bc9315e727e", + "IPY_MODEL_01845549768a4db580b5555809e83342" + ], + "layout": "IPY_MODEL_a490025901df478f93be1f19c1be4b09" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/config.yaml b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c5d87a578372648e677ce66828e35aec5b49e9e5 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/config.yaml @@ -0,0 +1,19 @@ +compute_environment: LOCAL_MACHINE +debug: false +distributed_type: MULTI_XPU +downcast_bf16: 'no' +enable_cpu_affinity: false +gpu_ids: all +ipex_config: + ipex: false +machine_rank: 0 +main_training_function: main +mixed_precision: 'no' +num_machines: 1 +num_processes: 4 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/fine_tune_blip2_int8.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/fine_tune_blip2_int8.py new file mode 100644 index 0000000000000000000000000000000000000000..1b67013783a0721b2bac5d53d8ba22aec82043c4 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/fine_tune_blip2_int8.py @@ -0,0 +1,104 @@ +# Copyright 2023-present the HuggingFace Inc. team. +# +# 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 torch +from datasets import load_dataset +from torch.utils.data import DataLoader, Dataset +from transformers import AutoModelForVision2Seq, AutoProcessor, BitsAndBytesConfig + +from peft import LoraConfig, get_peft_model + + +# Let's define the LoraConfig +config = LoraConfig( + r=16, + lora_alpha=32, + lora_dropout=0.05, + bias="none", +) + +# We load our model and processor using `transformers` +model = AutoModelForVision2Seq.from_pretrained( + "Salesforce/blip2-opt-2.7b", quantization_config=BitsAndBytesConfig(load_in_8bit=True) +) +processor = AutoProcessor.from_pretrained("Salesforce/blip2-opt-2.7b") + +# Get our peft model and print the number of trainable parameters +model = get_peft_model(model, config) +model.print_trainable_parameters() + +# Let's load the dataset here! +dataset = load_dataset("ybelkada/football-dataset", split="train") + + +class ImageCaptioningDataset(Dataset): + def __init__(self, dataset, processor): + self.dataset = dataset + self.processor = processor + + def __len__(self): + return len(self.dataset) + + def __getitem__(self, idx): + item = self.dataset[idx] + encoding = self.processor(images=item["image"], padding="max_length", return_tensors="pt") + # remove batch dimension + encoding = {k: v.squeeze() for k, v in encoding.items()} + encoding["text"] = item["text"] + return encoding + + +def collator(batch): + # pad the input_ids and attention_mask + processed_batch = {} + for key in batch[0].keys(): + if key != "text": + processed_batch[key] = torch.stack([example[key] for example in batch]) + else: + text_inputs = processor.tokenizer( + [example["text"] for example in batch], padding=True, return_tensors="pt" + ) + processed_batch["input_ids"] = text_inputs["input_ids"] + processed_batch["attention_mask"] = text_inputs["attention_mask"] + return processed_batch + + +train_dataset = ImageCaptioningDataset(dataset, processor) +train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=2, collate_fn=collator) + +optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5) + +device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + +model.train() + +for epoch in range(50): + print("Epoch:", epoch) + for idx, batch in enumerate(train_dataloader): + input_ids = batch.pop("input_ids").to(device) + pixel_values = batch.pop("pixel_values").to(device, torch.float16) + + outputs = model(input_ids=input_ids, pixel_values=pixel_values, labels=input_ids) + + loss = outputs.loss + + print("Loss:", loss.item()) + + loss.backward() + + optimizer.step() + optimizer.zero_grad() + + if idx % 10 == 0: + generated_output = model.generate(pixel_values=pixel_values) + print(processor.batch_decode(generated_output, skip_special_tokens=True)) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/peft_adalora_whisper_large_training.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/peft_adalora_whisper_large_training.py new file mode 100644 index 0000000000000000000000000000000000000000..ff6ec275b2267f82f0f6e3f43d61fb0829dc6dd0 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/peft_adalora_whisper_large_training.py @@ -0,0 +1,817 @@ +import argparse +import gc +import json +import logging +import math +import os +from dataclasses import dataclass +from datetime import datetime, timezone +from pathlib import Path +from random import randint +from typing import Any, Union + +# datasets imports +import datasets + +# metric imports +import evaluate +import numpy as np +import torch +import transformers +import wandb + +# accelerate imports +from accelerate import Accelerator, dispatch_model +from accelerate.logging import get_logger +from datasets import Audio, DatasetDict, IterableDatasetDict, interleave_datasets, load_dataset + +# hf imports +from huggingface_hub import HfApi +from torch.utils.data import DataLoader +from tqdm import tqdm +from transformers import ( + BitsAndBytesConfig, + SchedulerType, + WhisperForConditionalGeneration, + WhisperProcessor, + get_scheduler, + set_seed, +) +from transformers.models.whisper.english_normalizer import BasicTextNormalizer + +# peft imports +from peft import AdaLoraConfig, LoraConfig, PeftModel, get_peft_model + + +logger = get_logger(__name__, log_level="INFO") + + +def parse_args(): + parser = argparse.ArgumentParser(description="Whisper Fine-Tuning with AdaLora") + parser.add_argument( + "--model_name_or_path", + type=str, + help="Path to pretrained model or model identifier from huggingface.co/models.", + required=True, + ) + parser.add_argument("--language", type=str, help="Language to use for training; e.g., 'Hindi' ", required=True) + parser.add_argument("--language_abbr", type=str, help="Language to use for training; e.g., 'hi' ", required=True) + parser.add_argument( + "--task", type=str, default="transcribe", help="Task to use for training; e.g., 'transcribe' ", required=False + ) + parser.add_argument( + "--dataset_name", + type=str, + default="mozilla-foundation/common_voice_11_0", + help="Dataset to use for training; e.g., 'whisper' ", + required=False, + ) + parser.add_argument( + "--dataset_in_streaming_mode", + action="store_true", + help="Whether to use streaming mode for the dataset.", + ) + parser.add_argument( + "--do_lower_case", action="store_true", help="lowercase the transcribed text before tokenizing" + ) + parser.add_argument( + "--do_remove_punctuation", action="store_true", help="remove punctuation from the transcribed text" + ) + parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.") + parser.add_argument( + "--overwrite_cache", type=bool, default=False, help="Overwrite the cached training and evaluation sets" + ) + parser.add_argument("--max_audio_input_length", type=float, default=30.0, help="Maximum audio length in seconds.") + parser.add_argument( + "--preprocessing_num_workers", + type=int, + default=None, + help="The number of processes to use for the preprocessing.", + ) + parser.add_argument( + "--per_device_train_batch_size", + type=int, + default=8, + help="Batch size (per device) for the training dataloader.", + ) + parser.add_argument( + "--per_device_eval_batch_size", + type=int, + default=8, + help="Batch size (per device) for the evaluation dataloader.", + ) + parser.add_argument( + "--buffer_size", + type=int, + default=5000, + help="Number of samples to prefetch in the streaming mode.", + ) + parser.add_argument( + "--dataloader_pin_memory", + action="store_true", + help="Whether or not to pin memory for the DataLoader.", + ) + parser.add_argument( + "--dataloader_num_workers", + type=int, + default=0, + help="Number of subprocesses to use for data loading.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=5e-5, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument("--weight_decay", type=float, default=0.0, help="Weight decay to use.") + parser.add_argument("--num_train_epochs", type=int, default=3, help="Total number of training epochs to perform.") + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--lr_scheduler_type", + type=SchedulerType, + default="linear", + help="The scheduler type to use.", + choices=["linear", "cosine", "cosine_with_restarts", "polynomial", "constant", "constant_with_warmup"], + ) + parser.add_argument( + "--num_warmup_steps", type=int, default=0, help="Number of steps for the warmup in the lr scheduler." + ) + parser.add_argument("--output_dir", type=str, default=None, help="Where to store the final model.") + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--load_best_model", + action="store_true", + help="Whether to load the best model at the end of training", + ) + parser.add_argument( + "--with_tracking", + action="store_true", + help="Whether to enable experiment trackers for logging.", + ) + parser.add_argument( + "--report_to", + type=str, + default="all", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`,' + ' `"wandb"` and `"comet_ml"`. Use `"all"` (default) to report to all integrations.' + "Only applicable when `--with_tracking` is passed." + ), + ) + parser.add_argument("--hub_token", type=str, help="The token to use to push to the Model Hub.") + parser.add_argument( + "--hub_model_id", type=str, help="The name of the repository to keep in sync with the local `output_dir`." + ) + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.", + ) + parser.add_argument( + "--logging_steps", + type=int, + default=100, + help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.", + ) + parser.add_argument( + "--evaluation_steps", + type=int, + default=500, + help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.", + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help="If the training should continue from a checkpoint folder.", + ) + + # lora/adalora specific args + parser.add_argument( + "--use_peft", + action="store_true", + help="Whether to use PEFT", + ) + parser.add_argument( + "--use_adalora", + action="store_true", + help="Whether to use AdaLoRA or LoRA. If set, uses AdaLoRA instead of the default LoRA.", + ) + parser.add_argument( + "--init_r", + type=int, + default=12, + help="Initial AdaLoRA rank", + ) + parser.add_argument( + "--target_r", + type=int, + default=4, + help="Target AdaLoRA rank", + ) + parser.add_argument( + "--tinit", + type=int, + default=200, + help="number of warmup steps for AdaLoRA wherein no pruning is performed", + ) + parser.add_argument( + "--tfinal", + type=int, + default=1000, + help=" fix the resulting budget distribution and fine-tune the model for tfinal steps when using AdaLoRA ", + ) + parser.add_argument( + "--delta_t", + type=int, + default=10, + help="interval of steps for AdaLoRA to update rank", + ) + parser.add_argument( + "--lora_alpha", + type=int, + default=32, + help="LORA alpha", + ) + parser.add_argument( + "--r", + type=int, + default=8, + help="LORA rank", + ) + parser.add_argument( + "--lora_dropout", + type=float, + default=0.1, + help="LORA dropout", + ) + parser.add_argument( + "--orth_reg_weight", + type=float, + default=0.5, + help="Orthogonal regularization weight", + ) + parser.add_argument( + "--debug_mode", + action="store_true", + help="Whether to use debug mode", + ) + + args = parser.parse_args() + + if args.push_to_hub: + assert args.output_dir is not None, "Need an `output_dir` to create a repo when `--push_to_hub` is passed." + + return args + + +def load_streaming_dataset(dataset_name, dataset_config_name, split, **kwargs): + if "+" in split: + # load multiple splits separated by the `+` symbol *with* streaming mode + dataset_splits = [ + load_dataset(dataset_name, dataset_config_name, split=split_name, streaming=True, **kwargs) + for split_name in split.split("+") + ] + # interleave multiple splits to form one dataset + interleaved_dataset = interleave_datasets(dataset_splits) + return interleaved_dataset + else: + # load a single split *with* streaming mode + dataset = load_dataset(dataset_name, dataset_config_name, split=split, streaming=True, **kwargs) + return dataset + + +def prepare_dataset_wrapper(do_lower_case, do_remove_punctuation, processor, normalizer): + def prepare_dataset(batch): + # load and (possibly) resample audio data to 16kHz + audio = batch["audio"] + + # compute log-Mel input features from input audio array + batch["input_features"] = processor.feature_extractor( + audio["array"], sampling_rate=audio["sampling_rate"] + ).input_features[0] + # compute input length of audio sample in seconds + batch["input_length"] = len(audio["array"]) / audio["sampling_rate"] + + # optional pre-processing steps + transcription = batch["sentence"] + if do_lower_case: + transcription = transcription.lower() + if do_remove_punctuation: + transcription = normalizer(transcription).strip() + + # encode target text to label ids + batch["labels"] = processor.tokenizer(transcription).input_ids + return batch + + return prepare_dataset + + +def save_model_hook(models, weights, output_dir): + for model in models: + model.save_pretrained(output_dir) + # make sure to pop weight so that corresponding model is not saved again + weights.pop() + + +def load_model_hook(models, input_dir): + while len(models) > 0: + model = models.pop() + # pop models so that they are not loaded again + PeftModel.from_pretrained(model.base_model.model, input_dir) + + +@dataclass +class DataCollatorSpeechSeq2SeqWithPadding: + processor: Any + + def __call__(self, features: list[dict[str, Union[list[int], torch.Tensor]]]) -> dict[str, torch.Tensor]: + # split inputs and labels since they have to be of different lengths and need different padding methods + # first treat the audio inputs by simply returning torch tensors + input_features = [{"input_features": feature["input_features"]} for feature in features] + batch = self.processor.feature_extractor.pad(input_features, return_tensors="pt") + + # get the tokenized label sequences + label_features = [{"input_ids": feature["labels"]} for feature in features] + # pad the labels to max length + labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt") + + # replace padding with -100 to ignore loss correctly + labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100) + + # if bos token is appended in previous tokenization step, + # cut bos token here as it's append later anyways + if (labels[:, 0] == self.processor.tokenizer.bos_token_id).all().cpu().item(): + labels = labels[:, 1:] + + batch["labels"] = labels + + return batch + + +def get_audio_length_processor(max_input_length): + def is_audio_in_length_range(length): + return length < max_input_length + + return is_audio_in_length_range + + +def evaluation_loop(model, eval_dataloader, processor, normalizer, metric, forced_decoder_ids, accelerator): + model.eval() + predictions = [] + references = [] + normalized_predictions = [] + normalized_references = [] + device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + for _, batch in enumerate(tqdm(eval_dataloader)): + with torch.amp.autocast(device_type=device_type): + with torch.no_grad(): + generated_tokens = ( + model.generate( + input_features=batch["input_features"], + forced_decoder_ids=forced_decoder_ids, + max_new_tokens=255, + ) + .cpu() + .numpy() + ) + labels = batch["labels"].cpu().numpy() + labels = np.where(labels != -100, labels, processor.tokenizer.pad_token_id) + decoded_preds = processor.tokenizer.batch_decode(generated_tokens, skip_special_tokens=True) + decoded_labels = processor.tokenizer.batch_decode(labels, skip_special_tokens=True) + predictions.extend(decoded_preds) + references.extend(decoded_labels) + normalized_predictions.extend([normalizer(pred).strip() for pred in decoded_preds]) + normalized_references.extend([normalizer(label).strip() for label in decoded_labels]) + del generated_tokens, labels, batch + gc.collect() + wer = 100 * metric.compute(predictions=predictions, references=references) + normalized_wer = 100 * metric.compute(predictions=normalized_predictions, references=normalized_references) + eval_metrics = {"eval/wer": wer, "eval/normalized_wer": normalized_wer} + if accelerator.get_tracker("wandb"): + sample_size = min(len(predictions), 256) + ids = [randint(0, len(predictions) - 1) for p in range(sample_size)] + sample_predictions = [predictions[i] for i in ids] + sample_references = [references[i] for i in ids] + sample_normalized_predictions = [normalized_predictions[i] for i in ids] + sample_normalized_references = [normalized_references[i] for i in ids] + table_rows = [ + list(r) + for r in zip( + sample_predictions, sample_references, sample_normalized_predictions, sample_normalized_references + ) + ] + eval_metrics["eval_samples"] = wandb.Table( + columns=["predictions", "references", "normalized_predictions", "normalized_references"], + rows=table_rows, + ) + return eval_metrics + + +def main(): + args = parse_args() + + accelerator_kwargs = {"gradient_accumulation_steps": args.gradient_accumulation_steps} + if args.with_tracking: + accelerator_kwargs["log_with"] = args.report_to + accelerator_kwargs["project_dir"] = args.output_dir + accelerator = Accelerator(**accelerator_kwargs) + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + datasets.utils.logging.set_verbosity_warning() + transformers.utils.logging.set_verbosity_info() + else: + datasets.utils.logging.set_verbosity_error() + transformers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + set_seed(args.seed) + + # Handle the repository creation + if accelerator.is_main_process: + if args.push_to_hub: + api = HfApi(token=args.hub_token) + + # Create repo (repo_name from args or inferred) + repo_name = args.hub_model_id + if repo_name is None: + repo_name = Path(args.output_dir).absolute().name + repo_id = api.create_repo(repo_name, exist_ok=True).repo_id + + with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore: + if "step_*" not in gitignore: + gitignore.write("step_*\n") + if "epoch_*" not in gitignore: + gitignore.write("epoch_*\n") + elif args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + accelerator.wait_for_everyone() + + # load dataset either in streaming mode or not + processor = WhisperProcessor.from_pretrained(args.model_name_or_path, language=args.language, task=args.task) + normalizer = BasicTextNormalizer() + prepare_dataset = prepare_dataset_wrapper(args.do_lower_case, args.do_remove_punctuation, processor, normalizer) + is_audio_in_length_range = get_audio_length_processor(args.max_audio_input_length) + data_collator = DataCollatorSpeechSeq2SeqWithPadding(processor=processor) + + if args.dataset_in_streaming_mode: + raw_datasets = IterableDatasetDict() + loading_method = load_streaming_dataset + else: + raw_datasets = DatasetDict() + loading_method = load_dataset + + if args.debug_mode: + train_split = "train[:100]" + test_split = "test[:10]" + else: + train_split = "train+validation" + test_split = "test" + + raw_datasets["train"] = loading_method(args.dataset_name, args.language_abbr, split=train_split) + raw_datasets["test"] = loading_method(args.dataset_name, args.language_abbr, split=test_split) + raw_datasets = raw_datasets.cast_column("audio", Audio(sampling_rate=16000)) + + logger.info("Dataset loaded: %s", raw_datasets) + logger.info(f"{raw_datasets['train'][0]}") + + vectorized_datasets = raw_datasets.map( + prepare_dataset, + remove_columns=list(next(iter(raw_datasets.values())).features), + num_proc=args.preprocessing_num_workers, + ).with_format("torch") + + if args.dataset_in_streaming_mode: + vectorized_datasets["train"] = vectorized_datasets["train"].shuffle( + buffer_size=args.buffer_size, + seed=args.seed, + ) + + # filter out audio files that are too long from the training set + is_audio_in_length_range = get_audio_length_processor(args.max_audio_input_length) + vectorized_datasets["train"] = vectorized_datasets["train"].filter( + is_audio_in_length_range, input_columns=["input_length"] + ) + + # get dataloaders + train_dataloader = DataLoader( + vectorized_datasets["train"], + batch_size=args.per_device_train_batch_size, + shuffle=True, + collate_fn=data_collator, + num_workers=args.dataloader_num_workers, + pin_memory=args.dataloader_pin_memory, + ) + eval_dataloader = DataLoader( + vectorized_datasets["test"], + batch_size=args.per_device_eval_batch_size, + collate_fn=data_collator, + num_workers=args.dataloader_num_workers, + pin_memory=args.dataloader_pin_memory, + ) + + # metric + metric = evaluate.load("wer") + + # model + model = WhisperForConditionalGeneration.from_pretrained( + args.model_name_or_path, quantization_config=BitsAndBytesConfig(load_in_8bit=True) + ) + model.config.forced_decoder_ids = None + model.config.suppress_tokens = [] + if hasattr(model, "hf_device_map") and len(set(model.hf_device_map.values()).intersection({"cpu", "disk"})) > 0: + raise ValueError("Training on CPU or disk is not supported.") + if hasattr(model, "hf_device_map") and len(set(model.hf_device_map.values())) > 1: + device_map = model.hf_device_map.copy() + # required because `labels` are on main execution device (0) while the output of `proj_out` is on other device. + # So, this leads to device mismatch error when calculation cross-entropy between logits and labels. + # Won't arise during inference as `labels` aren't supplied during that time + # instead of changing device of one of the tied modules, I have to do this for all tied modules + # else the execution device of remaining tied modules isn't changed + device_map["model.decoder.embed_tokens"] = model._hf_hook.execution_device + device_map["model.decoder.embed_positions"] = model._hf_hook.execution_device + device_map["proj_out"] = model._hf_hook.execution_device + dispatch_model(model, device_map=device_map) + + # preparing peft model + if args.use_peft: + from peft import prepare_model_for_kbit_training + + model = prepare_model_for_kbit_training(model) + + # as Whisper model uses Conv layer in encoder, checkpointing disables grad computation + # to avoid this, make the inputs trainable + def make_inputs_require_grad(module, input, output): + output.requires_grad_(True) + + model.model.encoder.conv1.register_forward_hook(make_inputs_require_grad) + + # Calculate total steps first for AdaLoRA + if args.max_train_steps is None: + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + total_steps = args.num_train_epochs * num_update_steps_per_epoch + else: + total_steps = args.max_train_steps + + # wrapping model with adalora tuner + if args.use_adalora: + config = AdaLoraConfig( + init_r=args.init_r, + target_r=args.target_r, + beta1=0.85, + beta2=0.85, + tinit=args.tinit, + tfinal=args.tfinal, + deltaT=args.delta_t, + lora_alpha=args.lora_alpha, + lora_dropout=args.lora_dropout, + target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"], + orth_reg_weight=args.orth_reg_weight, + total_step=total_steps, + ) + else: + config = LoraConfig( + r=args.r, + lora_alpha=args.lora_alpha, + target_modules=["q_proj", "v_proj"], + lora_dropout=args.lora_dropout, + ) + + model = get_peft_model(model, config) + model.print_trainable_parameters() + + # optimizer + optimizer = torch.optim.AdamW(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay) + + if args.max_train_steps is None: + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + else: + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # scheduler + lr_scheduler = get_scheduler( + name=args.lr_scheduler_type, + optimizer=optimizer, + num_warmup_steps=args.num_warmup_steps, + num_training_steps=args.max_train_steps, + ) + + # Prepare everything with our `accelerator`. + model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare( + model, optimizer, train_dataloader, eval_dataloader, lr_scheduler + ) + + accelerator.print(model) + + # Note here that the max steps is adjusted by the accelerator's num_processes + args.max_train_steps = math.ceil(args.max_train_steps / accelerator.num_processes) + if args.use_peft and args.use_adalora: + # Update the total_step in the config to reflect the adjusted max_train_steps + # Handle DDP case where model is wrapped + if hasattr(model, "module"): + # DDP case + model.module.base_model.peft_config["default"].total_step = args.max_train_steps + else: + # Non-DDP case + model.base_model.peft_config["default"].total_step = args.max_train_steps + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if args.with_tracking: + run_name = f"run-{datetime.now(timezone.utc).strftime('%Y-%m-%d_%H-%M-%S')}" + experiment_config = vars(args) + # TensorBoard cannot log Enums, need the raw value + experiment_config["lr_scheduler_type"] = experiment_config["lr_scheduler_type"].value + accelerator.init_trackers( + "Whisper PEFT Fine-Tuning", config=experiment_config, init_kwargs={"wandb": {"name": run_name}} + ) + + # saving and loading checkpoints for resuming training + accelerator.register_save_state_pre_hook(save_model_hook) + accelerator.register_load_state_pre_hook(load_model_hook) + + total_batch_size = args.per_device_train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + logger.info("***** Running training *****") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.per_device_train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {args.max_train_steps}") + # Only show the progress bar once on each machine. + progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process) + global_step = 0 + starting_epoch = 0 + best_metric = None + resume_step = 0 + forced_decoder_ids = processor.get_decoder_prompt_ids(language=args.language, task=args.task) + + # Potentially load in the weights and states from a previous save + if args.resume_from_checkpoint: + accelerator.load_state(args.resume_from_checkpoint) + path = os.path.basename(args.resume_from_checkpoint) + training_difference = os.path.splitext(path)[0] + global_step = resume_step = int(training_difference.replace("step_", "")) + starting_epoch = resume_step // len(train_dataloader) + resume_step -= starting_epoch * len(train_dataloader) + + # We need to adjust the progress bar to the current step + progress_bar.update(resume_step) + for epoch in range(starting_epoch, args.num_train_epochs): + model.train() + if args.with_tracking: + total_loss = 0 + running_loss = 0 + for step, batch in enumerate(accelerator.skip_first_batches(train_dataloader, num_batches=resume_step)): + with accelerator.accumulate(model): + outputs = model(**batch) + loss = outputs.loss + accelerator.backward(loss) + optimizer.step() + lr_scheduler.step() + + # Update the importance of low-rank matrices + # and allocate the budget accordingly. + # This is only needed for AdaLora. + # Note that this requires parameter gradients. + # Hence being called before optimizer.zero_grad(). + if args.use_peft and args.use_adalora: + # Handle DDP case where model is wrapped + if hasattr(model, "module"): + # DDP case + peft_model = model.module + else: + # Non-DDP case + peft_model = model + + # Check if rank_pattern exists before calling update_and_allocate + if ( + hasattr(peft_model, "peft_config") + and peft_model.peft_config["default"].rank_pattern is not None + and global_step >= args.tinit # Only start updating after tinit steps + ): + peft_model.update_and_allocate(global_step) + + optimizer.zero_grad() + global_step += 1 + progress_bar.update(1) + + if args.with_tracking: + step_loss = accelerator.reduce(loss.detach().clone()).item() + total_loss += step_loss + running_loss += step_loss + + if global_step % args.checkpointing_steps == 0: + output_dir = os.path.join(args.output_dir, f"step_{global_step}") + accelerator.save_state(output_dir) + + if global_step % args.logging_steps == 0: + if args.with_tracking: + accelerator.log({"train/running_loss": running_loss / args.logging_steps}, step=global_step) + running_loss = 0 + + if global_step % args.evaluation_steps == 0: + eval_metrics = evaluation_loop( + model, eval_dataloader, processor, normalizer, metric, forced_decoder_ids, accelerator + ) + if args.with_tracking: + logger.info(f"Step {global_step} eval metrics: {eval_metrics}") + accelerator.log(eval_metrics, step=global_step) + if best_metric is None or eval_metrics["eval/wer"] < best_metric: + best_metric = eval_metrics["eval/wer"] + accelerator.save_state(os.path.join(args.output_dir, "best_checkpoint")) + model.train() + + if global_step >= args.max_train_steps: + break + + if args.with_tracking: + train_epoch_loss = total_loss / (step + 1) + logger.info(f"Epoch {epoch} train loss: {train_epoch_loss}") + accelerator.log({"epoch/train_loss": train_epoch_loss}, step=epoch) + + if args.push_to_hub and epoch <= args.num_train_epochs - 1: + accelerator.wait_for_everyone() + unwrapped_model = accelerator.unwrap_model(model) + unwrapped_model.save_pretrained(args.output_dir, is_main_process=accelerator.is_main_process) + # evaluate the model at the end of training + eval_metrics = evaluation_loop( + model, eval_dataloader, processor, normalizer, metric, forced_decoder_ids, accelerator + ) + if args.with_tracking: + logger.info(f"Step {global_step} eval metrics: {eval_metrics}") + accelerator.log(eval_metrics, step=global_step) + if best_metric is None or eval_metrics["eval/wer"] < best_metric: + best_metric = eval_metrics["eval/wer"] + accelerator.save_state(os.path.join(args.output_dir, "best_checkpoint")) + + if accelerator.is_main_process: + processor.tokenizer.save_pretrained(args.output_dir) + api.upload_folder( + repo_id=repo_id, + folder_path=args.output_dir, + commit_message=f"Training in progress epoch {epoch}", + run_as_future=True, + ) + + if args.load_best_model: + # load the best model + accelerator.load_state(os.path.join(args.output_dir, "best_checkpoint")) + # Handle DDP case where model is wrapped + if hasattr(model, "module"): + # DDP case + peft_model = model.module + else: + # Non-DDP case + peft_model = model + + # Only resize if rank_pattern exists + if hasattr(peft_model, "peft_config") and peft_model.peft_config["default"].rank_pattern is not None: + peft_model.resize_modules_by_rank_pattern(peft_model.peft_config["default"].rank_pattern, "default") + + eval_metrics = evaluation_loop( + model, eval_dataloader, processor, normalizer, metric, forced_decoder_ids, accelerator + ) + if args.with_tracking: + best_metrics = {"best_" + k: v for k, v in eval_metrics.items()} + accelerator.log(best_metrics, step=global_step) + + accelerator.wait_for_everyone() + unwrapped_model = accelerator.unwrap_model(model) + unwrapped_model.save_pretrained(args.output_dir, is_main_process=accelerator.is_main_process) + if accelerator.is_main_process: + processor.tokenizer.save_pretrained(args.output_dir) + if args.push_to_hub: + api.upload_folder( + repo_id=repo_id, + folder_path=args.output_dir, + commit_message="End of training", + ) + + with open(os.path.join(args.output_dir, "all_results.json"), "w") as f: + eval_metrics.pop("eval_samples") + json.dump(eval_metrics, f) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/peft_bnb_whisper_large_v2_training.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/peft_bnb_whisper_large_v2_training.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..41c92c6166f9214f687b9a0fe729e262a61f66ae --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/peft_bnb_whisper_large_v2_training.ipynb @@ -0,0 +1,20610 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5cefac89", + "metadata": {}, + "source": [ + "# Finetuning Whisper-large-V2 on Colab using PEFT-Lora + BNB INT8 training" + ] + }, + { + "cell_type": "markdown", + "id": "090fa3ed", + "metadata": {}, + "source": [ + "In this Colab, we present a step-by-step guide on how to fine-tune Whisper for any multilingual ASR dataset using Hugging Face 🤗 Transformers and 🤗 PEFT. Using 🤗 PEFT and `bitsandbytes`, you can train the `whisper-large-v2` seamlessly on a colab with T4 GPU (16 GB VRAM). In this notebook, with most parts from [fine_tune_whisper.ipynb](https://colab.research.google.com/github/sanchit-gandhi/notebooks/blob/main/fine_tune_whisper.ipynb#scrollTo=BRdrdFIeU78w) is adapted to train using PEFT LoRA+BNB INT8.\n", + "\n", + "For more details on model, datasets and metrics, refer blog [Fine-Tune Whisper For Multilingual ASR with 🤗 Transformers](https://huggingface.co/blog/fine-tune-whisper)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "625e47a0", + "metadata": {}, + "source": [ + "## initial Setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eJrPyQM5Xhv5", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "eJrPyQM5Xhv5", + "outputId": "cfd6d8c9-964c-492b-b641-8e80e337f783" + }, + "outputs": [], + "source": [ + "!add-apt-repository -y ppa:jonathonf/ffmpeg-4\n", + "!apt update\n", + "!apt install -y ffmpeg" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "r_Ivl7qlX0dz", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "r_Ivl7qlX0dz", + "outputId": "2caa9eed-f01a-4603-a527-fe3b0b58b6e2" + }, + "outputs": [], + "source": [ + "!pip install datasets==3.6.0\n", + "!pip install git+https://github.com/huggingface/transformers\n", + "!pip install librosa\n", + "!pip install evaluate>=0.30\n", + "!pip install jiwer\n", + "!pip install gradio\n", + "!pip install -q datasets accelerate\n", + "!pip install -q git+https://github.com/bitsandbytes-foundation/bitsandbytes.git\n", + "!pip install -q git+https://github.com/huggingface/transformers.git@main git+https://github.com/huggingface/peft.git@main" + ] + }, + { + "cell_type": "markdown", + "id": "8a528c1a", + "metadata": {}, + "source": [ + "Linking the notebook to the Hub is straightforward - it simply requires entering your Hub authentication token when prompted. Find your Hub authentication token [here](https://huggingface.co/settings/tokens):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed0OpduhX2JF", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 303, + "referenced_widgets": [ + "c60690c2aee74763bf23115553f4e640", + "7d3d6c198e794219ab5db59f0228c8ab", + "5d5ea0207c6148769ad9f15b7b3dd92d", + "642e28d258ca4c30a5df94c5cf7e0471", + "170ee581427d4f30925dc393d124c1be", + "d5d5aa24182a4e04b3fdae1ca7fad52a", + "6dba643113a547ac9b6e121d008791d6", + "cd9bda1053a14890ad9091c63c0a0acf", + "4522666ebbcf4647b06ce81a6316fbbb", + "989b3df296504f34a62d31ca0d6d88bb", + "e8a7a34c6fb146f0b38a40f389a617fa", + "960553d142c446cd8852523887a5cc04", + "441820fb176048109e0f8f7e9519d735", + "0bb38c654e18429a8396466ebab84504", + "1acfc4a2809e41dd995817c3526650dd", + "6d5801774beb4b529b227ef2f098614e", + "dfdf23cde48c421caebb573060641d6a" + ] + }, + "id": "ed0OpduhX2JF", + "outputId": "ecc2048a-b46a-4b20-b94a-5912924feb3d" + }, + "outputs": [], + "source": [ + "from huggingface_hub import notebook_login\n", + "\n", + "notebook_login()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1da5fff", + "metadata": { + "id": "e1da5fff" + }, + "outputs": [], + "source": [ + "# Select CUDA device index\n", + "import os\n", + "\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", + "model_name_or_path = \"openai/whisper-large-v2\"\n", + "language = \"Marathi\"\n", + "language_abbr = \"mr\"\n", + "task = \"transcribe\"\n", + "dataset_name = \"mozilla-foundation/common_voice_11_0\"" + ] + }, + { + "cell_type": "markdown", + "id": "805b1c56", + "metadata": {}, + "source": [ + "## Load Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a2787582-554f-44ce-9f38-4180a5ed6b44", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "020176f5aa0a4d489d022ef5e41ef3f6", + "cbbba08d9e634560a6c0429e32166fe5", + "6d9d1609edc8471dafe653e4da32eeeb", + "435b5708e6cf487ebb1799c7b64a8218", + "931b96b21b39482298f40449424fdd34", + "79da882ea494477a8c94fdac7acd644e", + "f14847261aa247fb9561373e0495f3e5", + "ce8f306e745d4b158c58058d471de037", + "0bd122731d674cdab803a9981eb28237", + "46211764bc6641b4b693c16c90747021", + "f1884e5a392941bfa8c484496d87084c", + "6b1cdae6f5e34d1d9a0b5e7adf5183db", + "4d29aa0885214a2aa79701cc226edaef", + "5411f018d4464e839f2fb21ad3f026aa", + "5fb8e97b25b44e0dae9715eeb97acc5d", + "783d4d18627646648f8c120b728babe1", + "1a721ed289684104b0fbdc8147c2311b", + "4880366554ad4f6687a25b5a17877dcf", + "283f5528547b457698ced126c25c2a44", + "7c90db94a11e4a5aa432e664b2af4e7e", + "7f6a466819bb45e880eb989f388a7523", + "d96245da43944c4b8235e0cd02c1aa4c", + "41187d9a120448fab6c8608f226971fa", + "1d4bd11921d145c7bfd1a8ce0700a666", + "2853a43036244f54b74db99311bc580d", + "d9a85d7c76b54199bbf7646448e3458c", + "b09d153958cf4a28baad268bbda78236", + "003227997471488dae9ae26dcbff89ea", + "deb18822d58b4b60bb75460f0a5fe921", + "e6cf97ef7bc541d0b9c6de206a3a45b0", + "a4b16b5279504dd694090798f5925d65", + "564cd321c06440e9856f10f5c40c20be", + "8a91574c4b6e4745b2b65885323b4d25", + "9202065d8e6f425d88e4514dde70992d", + "f7b4ec74e2ac45bbbf0265d0363f4d9f", + "3a083523ae604362901e4e31c39fe949", + "d1bc2ce48c3e481b9059e882b5102946", + "30c688df949042ce89337643f6178230", + "2bc85a5bde9a454990d3bb7de5e3c7c1", + "2ab45b22ce3f400a81cc451b9d7c9eb8", + "cdd08679c28642a184805912c07b324e", + "90744e5529c04f18b11e00326649abe5", + "11b9c50e720a466aa92c64b254d40778", + "8f856d6bde4041149324e1f53d19c1cb", + "49545bfc91c848b8a465e13d0b45fa34", + "45a85ceb24ea444ab18a6985884be966", + "ac9c1141ca7c453f84a8ab62b2de9158", + "bd4e3eb14252470d9c8ac60a32948a72", + "75dfc66dab48405b85073317c8dff155", + "b16e3a75acd0403f865849f1de6ca654", + "78fb0d05929849ad9aa7a7ded63c7b6b", + "3fd0fd7cbbef4785b360891c12017f48", + "a9c132959dae4303bcf6015106ce3453", + "2ef66808d51d440b9998064e212df420", + "45478f2ce991441c8ceaef9acf745084", + "c1f019686c564cca87c240a75ab71ad3", + "54589117bf244027ba024ea85bd1fd77", + "7b7986ad93f64956b8d198d2cb4acb60", + "dbc1a016a69b4ad7811d2701a9520a2f", + "72f8e7de2a5d4155a9e9146f12e14b19", + "46e44f07b96d4c32bbe75bb89159f093", + "90b53e96b3f04c2993969b17547ae0d5", + "8843f70cfa1f45299a588e96e9c1159a", + "8b2e2c650f4b4bee9e763b7c59525ec8", + "fb9f013a6188463fad6db70702576c37", + "93e2efbb5da747d4b94c916153ee9706", + "c44f472624d84e16a0f380580d36ca61", + "65188c1fdba2421ba85c2cc349709600", + "0683cbffd97a4b75bd5e00a05d541fef", + "4573606592ce4b2a914ed0a70b69f9af", + "efb85d003fb54f55aa4eadf2ab8b1684", + "a235cb3d4d424efeb30901f63fc1dbe5", + "2452ab9f6f974d1d831f7c81e884d00e", + "bd7da2671a22431889fbfa2ae1e0fe2c", + "47ee1eec97cf4af58ed4f50944386a7e", + "a05426c8e5f849b7a972dc0df3cd84ef", + "1e8cdf737c93431e841e129abb541e22", + "91fc5846a32f44d5bc5fa30fdcb3c638", + "daf4005d1d334608846d0fb2fe4f837a", + "ba48d89cab9346ed92dc338779f9f828", + "6b0e0694d895445c9bf7c955a116953f", + "ecb7ffba323743c68961e294e74b337b", + "460be80f176849e0b1241e3a4fc18b74", + "74e2bcef1ce94234bbf6ba0d6488279d", + "73bde731e20d48de8ce66b9d72fb95cb", + "9afdb23ba9ee47709f194e0e92de0edf", + "621f989f46f84d73b96a37c954e92b8d", + "89bb7bbcaa194a23bf3d908a4782ccb8", + "59e79d9132964429a2a2abbdf4bdbf32", + "2e5c1a371742446e8bc416d4735c9ce3", + "e57b15cc74e7474083e87722d6acde47", + "e899060f1edc43b980fe6f3bbe13c609", + "a6963ce72cb3425791804abf1718ba90", + "41a7cc33e0bc4bc5bc04dfc72bab7a81", + "28279812acfb4272a1c28ed70aa1362d", + "451d3851e29e4efabbc2c235dea718da", + "18dfdd09a3af49f5b17cda27872d0ba3", + "aaeec2b7986d493e8d238aa14f2e5937", + "0894264041854eea960707529f3fb8c7", + "3a4965f422f14e1ca2a63e1852235507", + "e590170f306347f3a82b76a25d37b652", + "384f4d9515d1431589a3cc934bcf5ea7", + "edc24ce2510f45f8adde0a187016259f", + "c2c2608dd091493795d975f1a3cc3762", + "1dedb58d31dd43db96ddd7315bb7e2ee", + "308e1ee4593b454a84681bda10921207", + "8f52bab9ebd049d6a57686d621f407ac", + "2958a33cff794de1aa8128327bf405f1", + "1b2780d8137042449bd6779c70bf43ca", + "ddc2a8e8ef4d429f95081c4c5baf1fb3", + "ce06b2a0de6c4fb8bae36bc4d7f63270", + "c4cca1778f314ce582bd09b9b2494f82", + "3bd70d937e924f61b943acb0aaf15619", + "c81c5d3a4dc5409e95a6410e67fa9857", + "dd02d1b31bfd4b19ad626d6691a9b293", + "b1d780c721b840d7a06661a7a5e63236", + "d19402df47464044b36fb5ee4a0c1c4d", + "b1221f4e0a57482682ea4bd6ae245da3", + "64533507b97148008548e55623b6c2a3", + "33888a5cafe6495782309dae44531dd3", + "7d5ff2f1b8794bad8286e90307bd6a61", + "7a2d45b371ba47a994e4372437f51cff", + "dec9f287435e4c6b9fb1d1ead2ded576", + "db5e1bf1871546408f233f0cbc37b136", + "af44aa66372a43beb9812ad9895d8d1f", + "9b427631384c47ab89ee1352c0236afd", + "00071f8cf276478fb2740684552f1275", + "64378b1064dc4036a9a4c8813013e210", + "ed7daa32c94648d5951876229f9835b3", + "eb883a37a9cf4945bd864decb4fc87ea", + "7b190bb2bd234b7997ca041baddd511f", + "7549fd0b38364d8580f8eb1549558a33", + "5cba5542df344d54bb80dcf7be56b2ae", + "8daed385e6564c7897fb6553669a9065", + "25fcd4b584a143058266f7f3a650d69a", + "58a15b8df2d54f89828bcd205d6bf298", + "8b51633b2fe5479db0fc73cd3f0ebaea", + "d2c1704e34c34d12b99c31d64fce88cc", + "6bdce3b33872457ea67a3a3191f438ca", + "c8ba787279ea43aa97b134c134d4f183", + "6efc3be410ef4710a59dea8dbdabcdf3", + "6f9d8dc63c494c76b36074af773330ce", + "64c0bac85ee446e284ed85ec0eb5ad44", + "5162987085ce45d88233f34ca3a41ce0", + "00819c11ea23467689e78a00d89d1b09", + "65dbf3c3a80b468aa8717e97c14db6a2", + "8cb910ad08024c818b99c2e30e30b039", + "0235efbdc6a74cce8050ab1116466427", + "ee1ae17fdf4143ae8125ce5e2a7e9066", + "481ebdff3ccc40fcb7a8d848b01ae8db", + "6117f9e9718c4f4388bd1feec34578b4", + "623d0c6427964291b5c74fb18bfb4ce4", + "14bca5cf764d4464a186961ccc6bdb3d", + "75c793c91b9e4aa994c2d34ebb16f7d4", + "3502b5f8aeab4bfd89c83b99ab308b9e", + "c43169085f2949f1b8259cd0b767d121", + "4903414a865c4813a9371e8b301f1af7", + "ec7e7e3811e34b4a8c8cc31cd021cf20", + "a22db8523d44457bb96448d08129988f", + "9980bca9b1334893bf6583c325122f50", + "931fc769fbeb42bf82df6ef5f914bf48", + "e944fa694d824042845364bdba72d642", + "3785471f614f47c78e3000a303b11ca6", + "dd634585d5e64c97881b132b1d59083e", + "785f3df156b946449c492f1296656a70", + "47a25de2e10d4b55a9e6827b85e49c3a", + "898c7b43a5e94601bc093e0cde28c2ec", + "a03430c0cdcb47bfbd2ffd754074d692", + "cda6af0ca01d4053bcebe06f3c41d887", + "abe561c67f1f42b29c33d4c296221b2f", + "21ca204b93994e8790c9eb7b0722761f", + "f628cb62f5fa446eb608467c1ecea526", + "e20264d19e804f9dba3e3867ef9b31bd", + "43141dcab2324fc6a12f9b8198e10154", + "f773a61b1dba4e3eb0df36162efe9abc", + "bfc9036c9c5f4be7ab191b92d92f1352", + "0f534e081ec64883a5f88d06f93aeb00", + "3a94afa1e03544f68df7752a4f503fbc", + "32ed17ecaf7548d5a80b27eb97cd78af", + "56817cd3b11e46f187dc13e71b7ec97d", + "3d30c20af23e495999646521d39e8e66", + "bafada4a1f29442296c47018dcaedb77", + "6cd3baac550741ba866ce2cd2dcaebdf", + "bc9c3ba4bc6d4623a764d92890536935", + "719f2b2ab9eb4e348ae902d063c27e2d", + "5e09bdca5081429ab82b488a3e016fbf", + "200bc7d8c2bc494399a4560dabd64293", + "91c3b5ddf5fb4c7aa835d992b4c7b4e7", + "52ff6528abdd4a9e9b85f4b355b2391d", + "6bb6737e22bd48d786b02051d077e8cc", + "e97a0201b81446b882ba802a5a3b00e8", + "c1a89a042b044278a8666da306e6a481", + "21ce216193f346c09a04a1d64bc0cd8a", + "23ee9c5c18c64305adc55ee218afd7a9", + "1f632bdc00e84422b64c0a4b8e238f34", + "8d50d82f9d94482c9883f99ea5c7d704", + "6a2dea21e7ce4eda8953995497308327", + "2f3d1d2f1c92402cadc4cfa1b0094238", + "844caba5ebdd48189517a10705543292", + "2d667cd4bc134a44958d17ef75d86321", + "acfb7b6734884939a753fc19047bb9bc", + "73cd51c6c43b40cab25d411e7c0f6ad1", + "19c7ea1e9364437a9c0bf6b4e645f854", + "8675aad817a44ab39b097ec864669833", + "5664e1233a904f4bb4af9c5322517fab", + "0ae5110b687440e89ebebfb847985aa1", + "85509b0aafec47e5ad540abc7ae4ab7d", + "d3d7c15d53c8498e823c84fe609321dd", + "80de3739b91a45478cb6a00dcaeae756", + "7c99e16722cf4fab866732557769b921", + "00834c084ddb4f46ac29f14575a2383d", + "4ce1e695a6ab4906ba0817005cf58d55", + "eb03476353ef4568b94a3071918e72f2", + "1b8307d133bf4280845f7d3a302b3a2b", + "daee15869a92459aabcd9128526183d5", + "5ddd9e1a1fab4531930acaf08cc45c73", + "4081e141986f4abba15477a12a752ca0", + "892e150a80464f8198024587a47186ba", + "9f9e15ff2e394ee7a7776e3e7f4b7d30", + "7e264d54d38e4d02acfd47e4e533b49d", + "746302ee5d21495db5d9a13789c5256c", + "47f7ff7b213e405a822ad6fe2e5de431", + "e4810a798c0f47b6b54f84ff4ffec608", + "8e480fe546f24afebb1ea723bff84456", + "0cf925f582374cd197164625f0ddf27d", + "aa7557fbffc54ed3a9c58c1531fd93f6", + "061c90e4148b43b8ba65848ca4c1ba46", + "f617d181ffdb4b1e8d81fbb393923a6e", + "a26ddb684a07496da4290e3f6031b685", + "f20fc82bcbf245619ad4dec04d0f999d", + "8016eabfc7aa48c2bc0bf3a13919a675", + "83cb83e404a24fba8cf43610cb1696fc", + "7b70db203ee644fe81006f5d48aa426d", + "efd9d5724dbd435991052b4445c6970f", + "41f65340441f419d91e1d3841921f48a", + "58aba8edefa44c60818891a2651137be", + "e5e8f119a91944f296ff821dd7ecfb1b", + "568a85caf800461b8571e3d206854e6b", + "e2a8a379bd0d4cbdb22fbc3bbb4fdc7a", + "2c7d952f958247b681301d1c6bff4fa7", + "27649a0d303643d8985caf506ef66fc3", + "1855ae0388074d08a4763b7ac76c6948", + "7e5252f608d6468f80deb468cb2556fd", + "bce6b62300d942a1ab89a6f0ceb16d30", + "0239f7263d1a4e8b9475ae48379c068d", + "5b527e45d6a946b28047115fa6b5aa3a", + "3c5eb07f0bff43948ff1f283c3c56b0f", + "3545fcc1e9d7453099c4931f658e0bc8", + "2f314258091a430095794c3fe0aea7e3", + "0ebfa123462342e99ad81b7e5ee00eac", + "8af6bd6e8cae4964a2e372be30220bd9", + "4184f160ab6d4f58bc921fb7ba89cf60", + "575c4d8d503244d8a9f2a5709021b5b2", + "ffce35af1ad84a2c838cca55a26dd3c4", + "d21cd4878c6e49d38dd3abb2e3b3f566", + "969e3cf7f3634c3f90b5fea38c5797ca", + "78501c2a5ac84f9ca0d20bbef340fc9f", + "5b4fbd1102a84670a1eed6f3d25c0bcd", + "621880c98245427881dd5b004b480c6a", + "65c2716dd7f14afa93d3bfaebe85c44f", + "2ff541d18f5844408690be00c7259d59", + "679fa9d2a703494dbb10fbfd19879f1a", + "6717b182e5674afb90006b50dea98cae", + "0887c7aabbbe4d4e8fdc64d2e2657cc7" + ] + }, + "id": "a2787582-554f-44ce-9f38-4180a5ed6b44", + "outputId": "b1729004-591e-41c2-c206-9d0e572eb8e5" + }, + "outputs": [], + "source": [ + "from datasets import load_dataset, DatasetDict\n", + "\n", + "common_voice = DatasetDict()\n", + "\n", + "common_voice[\"train\"] = load_dataset(dataset_name, language_abbr, split=\"train+validation\")\n", + "common_voice[\"test\"] = load_dataset(dataset_name, language_abbr, split=\"test\")\n", + "\n", + "print(common_voice)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "20ba635d-518c-47ac-97ee-3cad25f1e0ce", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "20ba635d-518c-47ac-97ee-3cad25f1e0ce", + "outputId": "dd81bced-f544-4d55-9669-5babb901f842" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DatasetDict({\n", + " train: Dataset({\n", + " features: ['audio', 'sentence'],\n", + " num_rows: 3927\n", + " })\n", + " test: Dataset({\n", + " features: ['audio', 'sentence'],\n", + " num_rows: 1816\n", + " })\n", + "})\n" + ] + } + ], + "source": [ + "common_voice = common_voice.remove_columns(\n", + " [\"accent\", \"age\", \"client_id\", \"down_votes\", \"gender\", \"locale\", \"path\", \"segment\", \"up_votes\"]\n", + ")\n", + "\n", + "print(common_voice)" + ] + }, + { + "cell_type": "markdown", + "id": "2d63b2d2-f68a-4d74-b7f1-5127f6d16605", + "metadata": { + "id": "2d63b2d2-f68a-4d74-b7f1-5127f6d16605" + }, + "source": [ + "## Prepare Feature Extractor, Tokenizer and Data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bc77d7bb-f9e2-47f5-b663-30f7a4321ce5", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 49, + "referenced_widgets": [ + "4d25d9919acf44a19f1b6f8fd625f808", + "b041efb27b6149fcaf206590f1c1b961", + "4668602d021a400a8b0ec88599abc85c", + "92d9732acb964601b27695041f9fbb72", + "c3ea17f7dd94462986d30b751664d77b", + "1b1dc31d9a2b4357a71119300c6d899a", + "7a24ae9d13fb4e82b1993b05f8d71d11", + "e1141861d9f44d4c95313fd432795b70", + "6ef55b5db76d4c78854fa0c27165e480", + "91b103ac79e641b190416acdeb55902c", + "e9e10f1e53b74509bfc9c0bf11502c5e" + ] + }, + "id": "bc77d7bb-f9e2-47f5-b663-30f7a4321ce5", + "outputId": "7abb2062-e755-4f1a-e88b-9b7bf2986dbf" + }, + "outputs": [], + "source": [ + "from transformers import WhisperFeatureExtractor\n", + "\n", + "feature_extractor = WhisperFeatureExtractor.from_pretrained(model_name_or_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c7b07f9b-ae0e-4f89-98f0-0c50d432eab6", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 209, + "referenced_widgets": [ + "f436e6a7d3014e2ca44c94455bfeace8", + "f9d6d41ffeba43cf94ec9d7a96af6617", + "bed65245e7234977874d35bf78694e35", + "c28c2fc81e0e467cbc0ded0205d1ee85", + "ea941a078b984f51b66b5f1e8f3d1d82", + "e3f1244dbe2c48bc8102f958c3df6467", + "786d3d34cfd24f81996797c55b10b443", + "3a4bb5b9cf864265af8f1a0b989dff2c", + "ac2e1977ddaf4b948c9cc24d84c08b83", + "dd339bf6baf6433e92665e30dc30b062", + "6a544d6dd5954beab32ce3089d8d2aac", + "f933fbdcc26d41b0bb294dabd0337834", + "950e74921e6042868ab6b7b9070d6f69", + "82dc91c5b065459d827863699a9710e1", + "5b7b6f08765c4c1989f945414f2c3cf4", + "735c3606df924b9297ddc05fae3e92d5", + "d5d632dd16f147e090c62aad38c45d3c", + "24191f38e3654b86a5da3576615e2229", + "4b1f4abe697948d5a1cca9b45b2a6f87", + "8527f474f1a549abafe9519e2b4bd338", + "1031dc4b5d2d45f3b14ab12dbd9bca56", + "ab40616ed9b74f438e74d403f848bed4", + "e6c2dc814c324a0c8cb744ca16707479", + "a615446a48624d0f9a009c1f6d8b1a54", + "383d6e891c5249b4b2fabb60d4900488", + "3c3214f235a54864848902f7e53662db", + "73f6e6860b64491284c9442f0deae8b6", + "6d9826a5adb847e8b4cc4486a31b52ce", + "e8b3093587e44164b0ac043414cea0fa", + "96266c5722f54eeeb682b2707b8025dd", + "f0be69583cd1410da6dbc18302d4439b", + "c24ddbaafa5f4a63b391d981a4f10354", + "629725dfcc684b1db1a57850c3bc7bc3", + "add0f175631742d49dd4695bc004e81a", + "5871a46d60f14da99e4bb8ee74405319", + "64b308019fff4095ab7f1812aab4676a", + "03f62b3f5aa64b6390b157cb3f9d2b9f", + "59657f26f4af490980b1d9bea1526e5e", + "1571fa5d8f494704949c5809f3409fa7", + "5ef218872f2646249888def0abed7149", + "03fcbc61c50c4ddc9c3684e4c085bffb", + "e4234c7c29744fc4be99b8b2ebedc9d1", + "70aa1fc14b09473e911dad3f9030b15b", + "008bead021ea416eb31dd9143d5ae5b9", + "ebd79e22ad4e4256a6d88883af2c1eef", + "c47ba0b11e074f708338863a35a78f7b", + "72b715be2c774235a21602b18d71e75a", + "ff9a0ed54bab49aca6f27bf1be66958e", + "15b5e415b62146ba96215458cf116431", + "8b0dd001d5b04647b1c480aab83d03a2", + "0af935ad4f694fb48094e6a119cbcf82", + "7cfbb542eba34459ba64b881c1040eee", + "fe48e65b2371445bbb01a8d3e9af1f67", + "b8d3539c8a454217a3b6ffab51259054", + "05e96819517e417aaf05f5f38c0c8b76", + "b600ead93bbf44a3a3fe229589c63a61", + "3d4c614fb775434fb0c5b02d46246ee0", + "344d1cc53e28411cae839a4ebba1bf58", + "a1578c0c777f4780a3fdd1635a0909d9", + "41faf55c8878475f8a986b02ad73e8ce", + "b5c8221a09df4dfdb74017d4af544b95", + "65e4b8dae1e4435cb7737a8d5dd13d91", + "6d932eadfd6a448a9a71d741bb64f428", + "dce0d285c7d947dfba9ee5bc1a6ebece", + "bde010029c374a0eb2bb942f380f0e8b", + "a91f37ce798d411ea2a33cfdb1f01251" + ] + }, + "id": "c7b07f9b-ae0e-4f89-98f0-0c50d432eab6", + "outputId": "4c094075-3f95-42db-9f4b-4db0c2fbeb91" + }, + "outputs": [], + "source": [ + "from transformers import WhisperTokenizer\n", + "\n", + "tokenizer = WhisperTokenizer.from_pretrained(model_name_or_path, language=language, task=task)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "77d9f0c5-8607-4642-a8ac-c3ab2e223ea6", + "metadata": { + "id": "77d9f0c5-8607-4642-a8ac-c3ab2e223ea6" + }, + "outputs": [], + "source": [ + "from transformers import WhisperProcessor\n", + "\n", + "processor = WhisperProcessor.from_pretrained(model_name_or_path, language=language, task=task)" + ] + }, + { + "cell_type": "markdown", + "id": "381acd09-0b0f-4d04-9eb3-f028ac0e5f2c", + "metadata": { + "id": "381acd09-0b0f-4d04-9eb3-f028ac0e5f2c" + }, + "source": [ + "### Prepare Data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e6b0ec5-0c94-4e2c-ae24-c791be1b2255", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 72 + }, + "id": "6e6b0ec5-0c94-4e2c-ae24-c791be1b2255", + "outputId": "1f1fe2d1-3ad2-42d4-e6f0-f0929785ae8e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'audio': {'path': '/root/.cache/huggingface/datasets/downloads/extracted/f7e1ef6a2d14f20194999aad5040c5d4bb3ead1377de3e1bbc6e9dba34d18a8a/common_voice_mr_30585613.mp3', 'array': array([-1.3727526e-15, -1.2400461e-13, -1.5159097e-13, ...,\n", + " 4.7928120e-06, 3.5631349e-06, 1.6352631e-06], dtype=float32), 'sampling_rate': 48000}, 'sentence': 'आईचे आजारपण वाढत चालले, तसतशी मथीही नीट खातपीतनाशी झाली.'}\n" + ] + } + ], + "source": [ + "print(common_voice[\"train\"][0])" + ] + }, + { + "cell_type": "markdown", + "id": "5a679f05-063d-41b3-9b58-4fc9c6ccf4fd", + "metadata": { + "id": "5a679f05-063d-41b3-9b58-4fc9c6ccf4fd" + }, + "source": [ + "Since \n", + "our input audio is sampled at 48kHz, we need to _downsample_ it to \n", + "16kHz prior to passing it to the Whisper feature extractor, 16kHz being the sampling rate expected by the Whisper model. \n", + "\n", + "We'll set the audio inputs to the correct sampling rate using dataset's \n", + "[`cast_column`](https://huggingface.co/docs/datasets/package_reference/main_classes.html?highlight=cast_column#datasets.DatasetDict.cast_column)\n", + "method. This operation does not change the audio in-place, \n", + "but rather signals to `datasets` to resample audio samples _on the fly_ the \n", + "first time that they are loaded:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f12e2e57-156f-417b-8cfb-69221cc198e8", + "metadata": { + "id": "f12e2e57-156f-417b-8cfb-69221cc198e8" + }, + "outputs": [], + "source": [ + "from datasets import Audio\n", + "\n", + "common_voice = common_voice.cast_column(\"audio\", Audio(sampling_rate=16000))" + ] + }, + { + "cell_type": "markdown", + "id": "00382a3e-abec-4cdd-a54c-d1aaa3ea4707", + "metadata": { + "id": "00382a3e-abec-4cdd-a54c-d1aaa3ea4707" + }, + "source": [ + "Re-loading the first audio sample in the Common Voice dataset will resample \n", + "it to the desired sampling rate:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "87122d71-289a-466a-afcf-fa354b18946b", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "87122d71-289a-466a-afcf-fa354b18946b", + "outputId": "727a709a-2b21-4c54-807f-efd40ea1719c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'audio': {'path': '/root/.cache/huggingface/datasets/downloads/extracted/f7e1ef6a2d14f20194999aad5040c5d4bb3ead1377de3e1bbc6e9dba34d18a8a/common_voice_mr_30585613.mp3', 'array': array([-4.4097186e-14, -9.4153831e-14, 3.4645775e-13, ...,\n", + " -7.6018655e-06, -1.8617659e-06, 4.4520480e-06], dtype=float32), 'sampling_rate': 16000}, 'sentence': 'आईचे आजारपण वाढत चालले, तसतशी मथीही नीट खातपीतनाशी झाली.'}\n" + ] + } + ], + "source": [ + "print(common_voice[\"train\"][0])" + ] + }, + { + "cell_type": "markdown", + "id": "91edc72d-08f8-4f01-899d-74e65ce441fc", + "metadata": { + "id": "91edc72d-08f8-4f01-899d-74e65ce441fc" + }, + "source": [ + "Now we can write a function to prepare our data ready for the model:\n", + "1. We load and resample the audio data by calling `batch[\"audio\"]`. As explained above, 🤗 Datasets performs any necessary resampling operations on the fly.\n", + "2. We use the feature extractor to compute the log-Mel spectrogram input features from our 1-dimensional audio array.\n", + "3. We encode the transcriptions to label ids through the use of the tokenizer." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6525c478-8962-4394-a1c4-103c54cce170", + "metadata": { + "id": "6525c478-8962-4394-a1c4-103c54cce170" + }, + "outputs": [], + "source": [ + "def prepare_dataset(batch):\n", + " # load and resample audio data from 48 to 16kHz\n", + " audio = batch[\"audio\"]\n", + "\n", + " # compute log-Mel input features from input audio array\n", + " batch[\"input_features\"] = feature_extractor(audio[\"array\"], sampling_rate=audio[\"sampling_rate\"]).input_features[0]\n", + "\n", + " # encode target text to label ids\n", + " batch[\"labels\"] = tokenizer(batch[\"sentence\"]).input_ids\n", + " return batch" + ] + }, + { + "cell_type": "markdown", + "id": "70b319fb-2439-4ef6-a70d-a47bf41c4a13", + "metadata": { + "id": "70b319fb-2439-4ef6-a70d-a47bf41c4a13" + }, + "source": [ + "We can apply the data preparation function to all of our training examples using dataset's `.map` method. The argument `num_proc` specifies how many CPU cores to use. Setting `num_proc` > 1 will enable multiprocessing. If the `.map` method hangs with multiprocessing, set `num_proc=1` and process the dataset sequentially." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7b73ab39-ffaf-4b9e-86e5-782963c6134b", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 197, + "referenced_widgets": [ + "466eeda389c442e487742faff05eeb81", + "664ff40a4e7346869652ba3be663acf2", + "3d8f10b5726b46de934dd0f7ed7244e4", + "b803893882ac4358a4676964dfb3fb31", + "4ff7e3d07f6a48f8935f0f42b86fc20c", + "3e5db1000a6c4871936614e712e769db", + "21dcf39a421847a78ea685eec0983fc6", + "c4119f7ec7464aab90f17d022e674999", + "965ac01b68064dc5a9fc3bb3f244c804", + "f5d7433d15de45e997d12568cac536fc", + "14e284f308844311a9ad40415091d93f", + "58c3766293e64116a131357f6cc66fe5", + "abc8f69eae7b46b1b430cf3b7a231b05", + "979edd227f0840a4be0233082e452b5a", + "12dedd9f089c42f3a8bba9adb01cf9d3", + "3042d874fcf544fabc4701938bca7cf3", + "baa8f739bb7e402bae7ee479e282e813", + "54509d703b7d4416bdee59157f918396", + "ec6017ce2fb3431ab823bde05f977a61", + "1a540a7cba794122abdb1900061479e2", + "d046a46c70ea46ffbb04a3c9f55637d5", + "99b628071c814d88a3cd5d72e4c95f01", + "e213d1c919314315ada180d49e27dfb6", + "0ea1f163e4174684bd6efc2e2433c1d3", + "09511a81a89d4754897a3507a84405be", + "8338339ab8a242c1a485bce8558f9c39", + "8e84abf61e3e45d58efc7ccd0bfe8d37", + "47a5e0cfb3564c16acaedb88613b9020", + "09e357a7187044b0bd2b841893a2601f", + "65e8c45d05be4d41b136439d9785a09c", + "1442a54fad7d44ddbafdacaf7f95279a", + "4bea6b0455ae4019b33d45491dbf4584", + "9c928a14371a4d9aa521953e287fff54", + "b8acdb71c3564972a6c8b27e964ec061", + "688f552e85714fe6a5d3eda82be0106a", + "a8aac44a077040bd9f4638c0c8f7a877", + "89f8ede64593475da4e056e9907f370f", + "851902cb2b0e494998684409d82dafd1", + "328f4d11886d48f49d4578e8e352097f", + "a25ef41450eb42ff9b8b618b40080ac0", + "04144ed3ff5f423f99179702cee5343f", + "8c41e1ee1a2c49b8b3d3d320fbf26262", + "4edf0948ed1346ceba1c0148e9c6fe1c", + "40f2b2ff75ca4562808fc2c7a870901e" + ] + }, + "id": "7b73ab39-ffaf-4b9e-86e5-782963c6134b", + "outputId": "eecac4c8-c5f8-427b-a2ba-0d51fae825ac" + }, + "outputs": [], + "source": [ + "common_voice = common_voice.map(prepare_dataset, remove_columns=common_voice.column_names[\"train\"], num_proc=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4be572c", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "c4be572c", + "outputId": "0383124a-d4b1-4abe-a8a1-868ce6b3884e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Dataset({\n", + " features: ['input_features', 'labels'],\n", + " num_rows: 3927\n", + "})" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "common_voice[\"train\"]" + ] + }, + { + "cell_type": "markdown", + "id": "263a5a58-0239-4a25-b0df-c625fc9c5810", + "metadata": { + "id": "263a5a58-0239-4a25-b0df-c625fc9c5810" + }, + "source": [ + "## Training and Evaluation" + ] + }, + { + "cell_type": "markdown", + "id": "8d230e6d-624c-400a-bbf5-fa660881df25", + "metadata": { + "id": "8d230e6d-624c-400a-bbf5-fa660881df25" + }, + "source": [ + "### Define a Data Collator" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8326221e-ec13-4731-bb4e-51e5fc1486c5", + "metadata": { + "id": "8326221e-ec13-4731-bb4e-51e5fc1486c5" + }, + "outputs": [], + "source": [ + "import torch\n", + "\n", + "from dataclasses import dataclass\n", + "from typing import Any, Dict, List, Union\n", + "\n", + "\n", + "@dataclass\n", + "class DataCollatorSpeechSeq2SeqWithPadding:\n", + " processor: Any\n", + "\n", + " def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:\n", + " # split inputs and labels since they have to be of different lengths and need different padding methods\n", + " # first treat the audio inputs by simply returning torch tensors\n", + " input_features = [{\"input_features\": feature[\"input_features\"]} for feature in features]\n", + " batch = self.processor.feature_extractor.pad(input_features, return_tensors=\"pt\")\n", + "\n", + " # get the tokenized label sequences\n", + " label_features = [{\"input_ids\": feature[\"labels\"]} for feature in features]\n", + " # pad the labels to max length\n", + " labels_batch = self.processor.tokenizer.pad(label_features, return_tensors=\"pt\")\n", + "\n", + " # replace padding with -100 to ignore loss correctly\n", + " labels = labels_batch[\"input_ids\"].masked_fill(labels_batch.attention_mask.ne(1), -100)\n", + "\n", + " # if bos token is appended in previous tokenization step,\n", + " # cut bos token here as it's append later anyways\n", + " if (labels[:, 0] == self.processor.tokenizer.bos_token_id).all().cpu().item():\n", + " labels = labels[:, 1:]\n", + "\n", + " batch[\"labels\"] = labels\n", + "\n", + " return batch" + ] + }, + { + "cell_type": "markdown", + "id": "3cae7dbf-8a50-456e-a3a8-7fd005390f86", + "metadata": { + "id": "3cae7dbf-8a50-456e-a3a8-7fd005390f86" + }, + "source": [ + "Let's initialise the data collator we've just defined:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fc834702-c0d3-4a96-b101-7b87be32bf42", + "metadata": { + "id": "fc834702-c0d3-4a96-b101-7b87be32bf42" + }, + "outputs": [], + "source": [ + "data_collator = DataCollatorSpeechSeq2SeqWithPadding(processor=processor)" + ] + }, + { + "cell_type": "markdown", + "id": "d62bb2ab-750a-45e7-82e9-61d6f4805698", + "metadata": { + "id": "d62bb2ab-750a-45e7-82e9-61d6f4805698" + }, + "source": [ + "### Evaluation Metrics" + ] + }, + { + "cell_type": "markdown", + "id": "66fee1a7-a44c-461e-b047-c3917221572e", + "metadata": { + "id": "66fee1a7-a44c-461e-b047-c3917221572e" + }, + "source": [ + "We'll use the word error rate (WER) metric, the 'de-facto' metric for assessing \n", + "ASR systems. For more information, refer to the WER [docs](https://huggingface.co/metrics/wer). We'll load the WER metric from 🤗 Evaluate:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b22b4011-f31f-4b57-b684-c52332f92890", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 49, + "referenced_widgets": [ + "215c3486e13343e091a26d658e1030d2", + "999382fb9e764a98893bd5269261d70b", + "4e9729771294424f959bbfb6bf8b60f3", + "3d2249516ecd43a08b5fba53fddb32e8", + "681711ebd0c64a63bee6b5337ef401db", + "d37791ea2b6c4152991295ca0edb0fb7", + "730f4d93bbd94452a59de43bf3d0a266", + "048e5c87cea34014a8f8a4538f4126bd", + "fbd27061ff114846aedc99bc2d17f7a7", + "5a306409e9e045b2b936267c520f935c", + "9f0638198f544a3bbb31a3a78b7bd2c2" + ] + }, + "id": "b22b4011-f31f-4b57-b684-c52332f92890", + "outputId": "b0a08086-69b9-4ab4-97ac-dbed295f2e15" + }, + "outputs": [], + "source": [ + "import evaluate\n", + "\n", + "metric = evaluate.load(\"wer\")" + ] + }, + { + "cell_type": "markdown", + "id": "4f32cab6-31f0-4cb9-af4c-40ba0f5fc508", + "metadata": { + "id": "4f32cab6-31f0-4cb9-af4c-40ba0f5fc508" + }, + "source": [ + "We then simply have to define a function that takes our model \n", + "predictions and returns the WER metric. This function, called\n", + "`compute_metrics`, first replaces `-100` with the `pad_token_id`\n", + "in the `label_ids` (undoing the step we applied in the \n", + "data collator to ignore padded tokens correctly in the loss).\n", + "It then decodes the predicted and label ids to strings. Finally,\n", + "it computes the WER between the predictions and reference labels:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23959a70-22d0-4ffe-9fa1-72b61e75bb52", + "metadata": { + "id": "23959a70-22d0-4ffe-9fa1-72b61e75bb52" + }, + "outputs": [], + "source": [ + "def compute_metrics(pred):\n", + " pred_ids = pred.predictions\n", + " label_ids = pred.label_ids\n", + "\n", + " # replace -100 with the pad_token_id\n", + " label_ids[label_ids == -100] = tokenizer.pad_token_id\n", + "\n", + " # we do not want to group tokens when computing the metrics\n", + " pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)\n", + " label_str = tokenizer.batch_decode(label_ids, skip_special_tokens=True)\n", + "\n", + " wer = 100 * metric.compute(predictions=pred_str, references=label_str)\n", + "\n", + " return {\"wer\": wer}" + ] + }, + { + "cell_type": "markdown", + "id": "daf2a825-6d9f-4a23-b145-c37c0039075b", + "metadata": { + "id": "daf2a825-6d9f-4a23-b145-c37c0039075b" + }, + "source": [ + "### Load a Pre-Trained Checkpoint" + ] + }, + { + "cell_type": "markdown", + "id": "437a97fa-4864-476b-8abc-f28b8166cfa5", + "metadata": { + "id": "437a97fa-4864-476b-8abc-f28b8166cfa5" + }, + "source": [ + "Now let's load the pre-trained Whisper `small` checkpoint. Again, this \n", + "is trivial through use of 🤗 Transformers!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a10cc4b-07ec-4ebd-ac1d-7c601023594f", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 220, + "referenced_widgets": [ + "d8c1a66480204f1095ff5f6a7dd2e477", + "9dc736113ef6477d91aaf71c9969ca74", + "79521628c64b4d6f9f22e73749298693", + "c7268972f75e4824893ebe7d893a18e1", + "a87598d464174703b5f5a5eca23543f3", + "e0529b81739144db8912c2d6789e729a", + "13d0a97497274652b081cbcefb3fd17d", + "08b26adf061b48f59078bf0c0b59e643", + "ef056ad59e314089a012acaa73a54e4f", + "7935e298049f4deeaeb278ba3de92291", + "3afca90970fc4925a05a9a1aa5c8d2f2", + "40aba44ef0a74c0d9a385c803c1365a6", + "ae54388d78dc4b7ebd1b21860421ffe4", + "bb4a47c63d254d4aa3220e85f86d37c4", + "cd585c98560b42c8b4a08df5b853b23c", + "a140cd385e5a4c0a88c5562370982d2e", + "fce64f5690024c698701330f0e5d039a", + "abd0e7c414974e51b280a29bf978f776", + "bf7961a79c2f403a89a4fb6d4b1a02e5", + "1d8636d1d1c3442fbbc2fc83cd03fa44", + "313090dc1f034ab19d5ffc573ea1aa5c", + "966c0400dafe4e3ea2c9baebc2e104fa", + "9087be5d992c4198b3ec2c61f4021164", + "6bc07db3471342a6bbc1b86ca734b3e6", + "4f167e9657274d56b8568d48262d1ee6", + "b7fbaa9d4bcd40b5bcf8d1475658c5b1", + "ba21f5ddf2434cc792b70a70c8c1079e", + "21bc84c704874455a57c47239984d28d", + "5b226e580df94448bed54b400c7a9a25", + "b0237154051343adaa076a9cc6dd711d", + "64756452791144859b9c803886c6dc77", + "f027b4358c2c41a8a93c617641135bcd", + "42cb6114956c4a86980c8dafd5a734ae" + ] + }, + "id": "5a10cc4b-07ec-4ebd-ac1d-7c601023594f", + "outputId": "163d4b39-7e5d-4126-8d78-846c5d94dca6" + }, + "outputs": [], + "source": [ + "from transformers import WhisperForConditionalGeneration, BitsAndBytesConfig\n", + "\n", + "model = WhisperForConditionalGeneration.from_pretrained(model_name_or_path, quantization_config=BitsAndBytesConfig(load_in_8bit=True))\n", + "\n", + "# model.hf_device_map - this should be {\" \": 0}" + ] + }, + { + "cell_type": "markdown", + "id": "a15ead5f-2277-4a39-937b-585c2497b2df", + "metadata": { + "id": "a15ead5f-2277-4a39-937b-585c2497b2df" + }, + "source": [ + "Override generation arguments - no tokens are forced as decoder outputs (see [`forced_decoder_ids`](https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.generation_utils.GenerationMixin.generate.forced_decoder_ids)), no tokens are suppressed during generation (see [`suppress_tokens`](https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.generation_utils.GenerationMixin.generate.suppress_tokens)):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62038ba3-88ed-4fce-84db-338f50dcd04f", + "metadata": { + "id": "62038ba3-88ed-4fce-84db-338f50dcd04f" + }, + "outputs": [], + "source": [ + "model.config.forced_decoder_ids = None\n", + "model.config.suppress_tokens = []" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "bR-_yaEOPsfQ", + "metadata": { + "id": "bR-_yaEOPsfQ" + }, + "source": [ + "### Post-processing on the model\n", + "\n", + "Finally, we need to apply some post-processing on the 8-bit model to enable training, let's freeze all our layers, and cast all non `int8` layers in `float32` for stability." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "Cl_ZQualPt9R", + "metadata": { + "id": "Cl_ZQualPt9R" + }, + "outputs": [], + "source": [ + "from peft import prepare_model_for_kbit_training\n", + "\n", + "model = prepare_model_for_kbit_training(model)" + ] + }, + { + "cell_type": "markdown", + "id": "Vjl4j4RJPmPR", + "metadata": { + "id": "Vjl4j4RJPmPR" + }, + "source": [ + "### Apply LoRA\n", + "\n", + "Here comes the magic with `peft`! Let's load a `PeftModel` and specify that we are going to use low-rank adapters (LoRA) using `get_peft_model` utility function from `peft`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "DQtpDPRHPyOL", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DQtpDPRHPyOL", + "outputId": "1effcbde-7acc-4f62-f24b-e6236a43f833" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 15728640 || all params: 1559033600 || trainable%: 1.0088711365810203\n" + ] + } + ], + "source": [ + "from peft import LoraConfig, PeftModel, LoraModel, LoraConfig, get_peft_model\n", + "\n", + "config = LoraConfig(r=32, lora_alpha=64, target_modules=[\"q_proj\", \"v_proj\"], lora_dropout=0.05, bias=\"none\")\n", + "\n", + "model = get_peft_model(model, config)\n", + "model.print_trainable_parameters()" + ] + }, + { + "cell_type": "markdown", + "id": "3906d436", + "metadata": {}, + "source": [ + "We are ONLY using **1%** of the total trainable parameters, thereby performing **Parameter-Efficient Fine-Tuning**" + ] + }, + { + "cell_type": "markdown", + "id": "2178dea4-80ca-47b6-b6ea-ba1915c90c06", + "metadata": { + "id": "2178dea4-80ca-47b6-b6ea-ba1915c90c06" + }, + "source": [ + "### Define the Training Configuration" + ] + }, + { + "cell_type": "markdown", + "id": "c21af1e9-0188-4134-ac82-defc7bdcc436", + "metadata": { + "id": "c21af1e9-0188-4134-ac82-defc7bdcc436" + }, + "source": [ + "In the final step, we define all the parameters related to training. For more detail on the training arguments, refer to the Seq2SeqTrainingArguments [docs](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.Seq2SeqTrainingArguments)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ae3e9af-97b7-4aa0-ae85-20b23b5bcb3a", + "metadata": { + "id": "0ae3e9af-97b7-4aa0-ae85-20b23b5bcb3a" + }, + "outputs": [], + "source": [ + "from transformers import Seq2SeqTrainingArguments\n", + "\n", + "training_args = Seq2SeqTrainingArguments(\n", + " output_dir=\"temp\", # change to a repo name of your choice\n", + " per_device_train_batch_size=8,\n", + " gradient_accumulation_steps=1, # increase by 2x for every 2x decrease in batch size\n", + " learning_rate=1e-3,\n", + " warmup_steps=50,\n", + " num_train_epochs=3,\n", + " eval_strategy=\"epoch\",\n", + " fp16=True,\n", + " per_device_eval_batch_size=8,\n", + " generation_max_length=128,\n", + " logging_steps=25,\n", + " remove_unused_columns=False, # required as the PeftModel forward doesn't have the signature of the wrapped model's forward\n", + " label_names=[\"labels\"], # same reason as above\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "b3a944d8-3112-4552-82a0-be25988b3857", + "metadata": { + "id": "b3a944d8-3112-4552-82a0-be25988b3857" + }, + "source": [ + "**Few Important Notes:**\n", + "1. `remove_unused_columns=False` and `label_names=[\"labels\"]` are required as the PeftModel's forward doesn't have the signature of the base model's forward.\n", + "\n", + "2. INT8 training required autocasting. `predict_with_generate` can't be passed to Trainer because it internally calls transformer's `generate` without autocasting leading to errors. \n", + "\n", + "3. Because of point 2, `compute_metrics` shouldn't be passed to `Seq2SeqTrainer` as seen below. (commented out)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d546d7fe-0543-479a-b708-2ebabec19493", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "d546d7fe-0543-479a-b708-2ebabec19493", + "outputId": "e2fabe64-2c50-42ff-a7ca-7773813e9408" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The model is loaded in 8-bit precision. To train this model you need to add additional modules inside the model such as adapters using `peft` library and freeze the model weights. Please check the examples in https://github.com/huggingface/peft for more details.\n", + "Using cuda_amp half precision backend\n" + ] + } + ], + "source": [ + "from transformers import Seq2SeqTrainer, TrainerCallback, TrainingArguments, TrainerState, TrainerControl\n", + "from transformers.trainer_utils import PREFIX_CHECKPOINT_DIR\n", + "\n", + "\n", + "class SavePeftModelCallback(TrainerCallback):\n", + " def on_save(\n", + " self,\n", + " args: TrainingArguments,\n", + " state: TrainerState,\n", + " control: TrainerControl,\n", + " **kwargs,\n", + " ):\n", + " checkpoint_folder = os.path.join(args.output_dir, f\"{PREFIX_CHECKPOINT_DIR}-{state.global_step}\")\n", + "\n", + " peft_model_path = os.path.join(checkpoint_folder, \"adapter_model\")\n", + " kwargs[\"model\"].save_pretrained(peft_model_path)\n", + "\n", + " pytorch_model_path = os.path.join(checkpoint_folder, \"pytorch_model.bin\")\n", + " if os.path.exists(pytorch_model_path):\n", + " os.remove(pytorch_model_path)\n", + " return control\n", + "\n", + "\n", + "trainer = Seq2SeqTrainer(\n", + " args=training_args,\n", + " model=model,\n", + " train_dataset=common_voice[\"train\"],\n", + " eval_dataset=common_voice[\"test\"],\n", + " data_collator=data_collator,\n", + " # compute_metrics=compute_metrics,\n", + " processing_class=processor.feature_extractor,\n", + " callbacks=[SavePeftModelCallback],\n", + ")\n", + "model.config.use_cache = False # silence the warnings. Please re-enable for inference!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee8b7b8e-1c9a-4d77-9137-1778a629e6de", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "ee8b7b8e-1c9a-4d77-9137-1778a629e6de", + "outputId": "cdea5268-f33a-4d48-ea4a-a9c71576f81d" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/transformers/optimization.py:346: FutureWarning: This implementation of AdamW is deprecated and will be removed in a future version. Use the PyTorch implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this warning\n", + " warnings.warn(\n", + "***** Running training *****\n", + " Num examples = 3927\n", + " Num Epochs = 3\n", + " Instantaneous batch size per device = 8\n", + " Total train batch size (w. parallel, distributed & accumulation) = 8\n", + " Gradient Accumulation steps = 1\n", + " Total optimization steps = 1473\n", + " Number of trainable parameters = 15728640\n", + "/usr/local/lib/python3.8/dist-packages/torch/utils/checkpoint.py:31: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n", + " warnings.warn(\"None of the inputs have requires_grad=True. Gradients will be None\")\n", + "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n", + " warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [1473/1473 3:20:30, Epoch 3/3]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EpochTraining LossValidation Loss
10.2558000.262023
20.1665000.221193

\n", + "

\n", + " \n", + " \n", + " [ 62/227 04:52 < 13:11, 0.21 it/s]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "***** Running Evaluation *****\n", + " Num examples = 1816\n", + " Batch size = 8\n", + "Saving model checkpoint to ./whisper-small-hi/checkpoint-500\n", + "Trainer.model is not a `PreTrainedModel`, only saving its state dict.\n", + "Feature extractor saved in ./whisper-small-hi/checkpoint-500/preprocessor_config.json\n", + "/usr/local/lib/python3.8/dist-packages/torch/utils/checkpoint.py:31: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n", + " warnings.warn(\"None of the inputs have requires_grad=True. Gradients will be None\")\n", + "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n", + " warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n", + "***** Running Evaluation *****\n", + " Num examples = 1816\n", + " Batch size = 8\n", + "Saving model checkpoint to ./whisper-small-hi/checkpoint-1000\n", + "Trainer.model is not a `PreTrainedModel`, only saving its state dict.\n", + "Feature extractor saved in ./whisper-small-hi/checkpoint-1000/preprocessor_config.json\n", + "/usr/local/lib/python3.8/dist-packages/torch/utils/checkpoint.py:31: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n", + " warnings.warn(\"None of the inputs have requires_grad=True. Gradients will be None\")\n", + "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n", + " warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n", + "***** Running Evaluation *****\n", + " Num examples = 1816\n", + " Batch size = 8\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [1473/1473 3:38:43, Epoch 3/3]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EpochTraining LossValidation Loss
10.2558000.262023
20.1665000.221193
30.0839000.215908

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Training completed. Do not forget to share your model on huggingface.co/models =)\n", + "\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=1473, training_loss=0.20080567288382556, metrics={'train_runtime': 13136.6638, 'train_samples_per_second': 0.897, 'train_steps_per_second': 0.112, 'total_flos': 2.52799085113344e+19, 'train_loss': 0.20080567288382556, 'epoch': 3.0})" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trainer.train()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0576aa2a", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 116, + "referenced_widgets": [ + "f309d7a096df4f119e6e6871b56913f1", + "5f283548f34848af90affe55a169b5a9", + "51a4d85c08d745bda70ba0db731dca68", + "eb46a602b3ef484daddbcb847957c3e5", + "8e2e49c6046e4dc0a0a810b4e58f80cc", + "f3f191968f724e9bbb710b86d3657a66", + "d97f77f45e1e400494c2fbf2cd9d69a3", + "10e52425e59d4c2c8d2a1239b24e5a95", + "9ca0667998cb443d9df29fdd09cf90ff", + "f22aa0a93d8b44d0a4c412343ec1f48b", + "6e6a59f8e7454c2d886634eade47a21f", + "92ae14b97e814d51b016e2a14f227a15", + "fb8aca596a1c4ac4a7428248b6c6f8b1", + "31de6bfcde21400ab02af4fb31d409da", + "3c45a19fdf664b92a27be16abf537a03", + "9827e382bf3b49b092969d5656dcad7a", + "168e19229aa5404bb151e4547bb31283", + "d140f5373bf144d1ae5d282e1a65647e", + "fa137c931d2c4e579c27893ca8ee1848", + "93647f2d98a74109bfc5ca7a9cc23eed", + "a478b23c34654615aad4202b8c7089f6", + "4553ba4c0ed645dbb9ddfcc88975ab5f" + ] + }, + "id": "0576aa2a", + "outputId": "6d3fe4aa-f42a-4428-e070-2272f3b87f5c" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Uploading the following files to smangrul/openai-whisper-large-v2-LORA-colab: adapter_model.bin,adapter_config.json\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f309d7a096df4f119e6e6871b56913f1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Upload 1 LFS files: 0%| | 0/1 [00:00
Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. " + } + }, + "7d5ff2f1b8794bad8286e90307bd6a61": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7e2534cfd8564dbd9bddaa2217f2dda4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7e264d54d38e4d02acfd47e4e533b49d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7e5252f608d6468f80deb468cb2556fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bce6b62300d942a1ab89a6f0ceb16d30", + "IPY_MODEL_0239f7263d1a4e8b9475ae48379c068d", + "IPY_MODEL_5b527e45d6a946b28047115fa6b5aa3a" + ], + "layout": "IPY_MODEL_3c5eb07f0bff43948ff1f283c3c56b0f" + } + }, + "7f6a466819bb45e880eb989f388a7523": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7fbb2599863f45f49ad4925d75ef5f77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8016eabfc7aa48c2bc0bf3a13919a675": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "80de3739b91a45478cb6a00dcaeae756": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "812f78ca88234efa9b2ccc001245290c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "82dc91c5b065459d827863699a9710e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4b1f4abe697948d5a1cca9b45b2a6f87", + "max": 1036558, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8527f474f1a549abafe9519e2b4bd338", + "value": 1036558 + } + }, + "830245f63f1947e18b29986d9a091c0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b0efdb97594b4997a8cb148aa03f9a6b", + "placeholder": "​", + "style": "IPY_MODEL_66bdd68e31204abc92fafc0e29860d1c", + "value": " 829/829 [00:00<00:00, 42.4kB/s]" + } + }, + "8338339ab8a242c1a485bce8558f9c39": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4bea6b0455ae4019b33d45491dbf4584", + "placeholder": "​", + "style": "IPY_MODEL_9c928a14371a4d9aa521953e287fff54", + "value": " 908/908 [03:07<00:00, 3.87ex/s]" + } + }, + "83a7cd2ce4074720acc6236aaf24014d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "83cb83e404a24fba8cf43610cb1696fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7b70db203ee644fe81006f5d48aa426d", + "IPY_MODEL_efd9d5724dbd435991052b4445c6970f", + "IPY_MODEL_41f65340441f419d91e1d3841921f48a" + ], + "layout": "IPY_MODEL_58aba8edefa44c60818891a2651137be" + } + }, + "844caba5ebdd48189517a10705543292": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2d667cd4bc134a44958d17ef75d86321", + "IPY_MODEL_acfb7b6734884939a753fc19047bb9bc", + "IPY_MODEL_73cd51c6c43b40cab25d411e7c0f6ad1" + ], + "layout": "IPY_MODEL_19c7ea1e9364437a9c0bf6b4e645f854" + } + }, + "845211300fbd49f480d056bba9de83e1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "851902cb2b0e494998684409d82dafd1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8527f474f1a549abafe9519e2b4bd338": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "85509b0aafec47e5ad540abc7ae4ab7d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "85cdb3ecd88d426a8e517b3c8c8a8307": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "86692318e7584e62b4143c1b2eca5935": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8675aad817a44ab39b097ec864669833": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87d251db4a6e495cb1d59d276e823bf2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8843f70cfa1f45299a588e96e9c1159a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "892e150a80464f8198024587a47186ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "898c7b43a5e94601bc093e0cde28c2ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_21ca204b93994e8790c9eb7b0722761f", + "placeholder": "​", + "style": "IPY_MODEL_f628cb62f5fa446eb608467c1ecea526", + "value": "Downloading data: 100%" + } + }, + "89bb7bbcaa194a23bf3d908a4782ccb8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "89f8ede64593475da4e056e9907f370f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4edf0948ed1346ceba1c0148e9c6fe1c", + "placeholder": "​", + "style": "IPY_MODEL_40f2b2ff75ca4562808fc2c7a870901e", + "value": " 908/908 [03:10<00:00, 4.49ex/s]" + } + }, + "8a91574c4b6e4745b2b65885323b4d25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8af6bd6e8cae4964a2e372be30220bd9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8b0dd001d5b04647b1c480aab83d03a2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b2e2c650f4b4bee9e763b7c59525ec8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8b51633b2fe5479db0fc73cd3f0ebaea": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b9324f5c0e24576a9733f30a8945edd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ad8b6c32caa4493ebadf7691ed1546d4", + "max": 2064, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_85cdb3ecd88d426a8e517b3c8c8a8307", + "value": 2064 + } + }, + "8ba244a082284f6dbac1c8f689c527a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8c010800d6d945fe965fd5b9c6ab2ec4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4568923487c44041ab985ee326842d15", + "max": 358, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_352a2237356846af836779413e584fee", + "value": 358 + } + }, + "8c41e1ee1a2c49b8b3d3d320fbf26262": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8cb910ad08024c818b99c2e30e30b039": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_14bca5cf764d4464a186961ccc6bdb3d", + "placeholder": "​", + "style": "IPY_MODEL_75c793c91b9e4aa994c2d34ebb16f7d4", + "value": " 782k/782k [00:00<00:00, 972kB/s]" + } + }, + "8d50d82f9d94482c9883f99ea5c7d704": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8daed385e6564c7897fb6553669a9065": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d2c1704e34c34d12b99c31d64fce88cc", + "placeholder": "​", + "style": "IPY_MODEL_6bdce3b33872457ea67a3a3191f438ca", + "value": "Downloading data files: 100%" + } + }, + "8e2e49c6046e4dc0a0a810b4e58f80cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8e480fe546f24afebb1ea723bff84456": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f20fc82bcbf245619ad4dec04d0f999d", + "placeholder": "​", + "style": "IPY_MODEL_8016eabfc7aa48c2bc0bf3a13919a675", + "value": " 1682/0 [00:14<00:00, 2245.17 examples/s]" + } + }, + "8e84abf61e3e45d58efc7ccd0bfe8d37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f52bab9ebd049d6a57686d621f407ac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f856d6bde4041149324e1f53d19c1cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "90744e5529c04f18b11e00326649abe5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9087be5d992c4198b3ec2c61f4021164": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6bc07db3471342a6bbc1b86ca734b3e6", + "IPY_MODEL_4f167e9657274d56b8568d48262d1ee6", + "IPY_MODEL_b7fbaa9d4bcd40b5bcf8d1475658c5b1" + ], + "layout": "IPY_MODEL_ba21f5ddf2434cc792b70a70c8c1079e" + } + }, + "90b53e96b3f04c2993969b17547ae0d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "91b103ac79e641b190416acdeb55902c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "91c3b5ddf5fb4c7aa835d992b4c7b4e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_52ff6528abdd4a9e9b85f4b355b2391d", + "IPY_MODEL_6bb6737e22bd48d786b02051d077e8cc", + "IPY_MODEL_e97a0201b81446b882ba802a5a3b00e8" + ], + "layout": "IPY_MODEL_c1a89a042b044278a8666da306e6a481" + } + }, + "91fc5846a32f44d5bc5fa30fdcb3c638": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_daf4005d1d334608846d0fb2fe4f837a", + "IPY_MODEL_ba48d89cab9346ed92dc338779f9f828", + "IPY_MODEL_6b0e0694d895445c9bf7c955a116953f" + ], + "layout": "IPY_MODEL_ecb7ffba323743c68961e294e74b337b" + } + }, + "9202065d8e6f425d88e4514dde70992d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f7b4ec74e2ac45bbbf0265d0363f4d9f", + "IPY_MODEL_3a083523ae604362901e4e31c39fe949", + "IPY_MODEL_d1bc2ce48c3e481b9059e882b5102946" + ], + "layout": "IPY_MODEL_30c688df949042ce89337643f6178230" + } + }, + "921fd273a7254447a93fb997773aedab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "925f7aad24b547cc8071ee9bda713d7c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7e2534cfd8564dbd9bddaa2217f2dda4", + "placeholder": "​", + "style": "IPY_MODEL_a5bd56eb69524729afdfdd14b55b6130", + "value": "Downloading (…)lve/main/config.json: 100%" + } + }, + "92ae14b97e814d51b016e2a14f227a15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_fb8aca596a1c4ac4a7428248b6c6f8b1", + "IPY_MODEL_31de6bfcde21400ab02af4fb31d409da", + "IPY_MODEL_3c45a19fdf664b92a27be16abf537a03" + ], + "layout": "IPY_MODEL_9827e382bf3b49b092969d5656dcad7a" + } + }, + "92d9732acb964601b27695041f9fbb72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_91b103ac79e641b190416acdeb55902c", + "placeholder": "​", + "style": "IPY_MODEL_e9e10f1e53b74509bfc9c0bf11502c5e", + "value": " 185k/185k [00:00<00:00, 656kB/s]" + } + }, + "92debeaea5cc4136bb37703947e825e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7aca78c9768a48a7ab0a8220a3b364b9", + "placeholder": "​", + "style": "IPY_MODEL_7213f79093f74df996f8dbe7fe816ea0", + "value": " 63.1M/63.1M [00:00<00:00, 108MB/s]" + } + }, + "931b96b21b39482298f40449424fdd34": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "931fc769fbeb42bf82df6ef5f914bf48": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "93647f2d98a74109bfc5ca7a9cc23eed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "93e2efbb5da747d4b94c916153ee9706": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "950e74921e6042868ab6b7b9070d6f69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d5d632dd16f147e090c62aad38c45d3c", + "placeholder": "​", + "style": "IPY_MODEL_24191f38e3654b86a5da3576615e2229", + "value": "Downloading (…)olve/main/vocab.json: 100%" + } + }, + "960553d142c446cd8852523887a5cc04": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "96266c5722f54eeeb682b2707b8025dd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "965ac01b68064dc5a9fc3bb3f244c804": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "966c0400dafe4e3ea2c9baebc2e104fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "969e3cf7f3634c3f90b5fea38c5797ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "info", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ff541d18f5844408690be00c7259d59", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_679fa9d2a703494dbb10fbfd19879f1a", + "value": 1 + } + }, + "96c0b77f9a5e473b8b5dc92bde0f4a9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "979edd227f0840a4be0233082e452b5a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ec6017ce2fb3431ab823bde05f977a61", + "max": 1963, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1a540a7cba794122abdb1900061479e2", + "value": 1963 + } + }, + "980e87bb43d54306aba5019964857b89": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9827e382bf3b49b092969d5656dcad7a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "989b3df296504f34a62d31ca0d6d88bb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9980bca9b1334893bf6583c325122f50": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "999382fb9e764a98893bd5269261d70b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d37791ea2b6c4152991295ca0edb0fb7", + "placeholder": "​", + "style": "IPY_MODEL_730f4d93bbd94452a59de43bf3d0a266", + "value": "Downloading builder script: 100%" + } + }, + "99b628071c814d88a3cd5d72e4c95f01": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9abe7ed3e3d347b6bad7d1252bde226f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9afdb23ba9ee47709f194e0e92de0edf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9b427631384c47ab89ee1352c0236afd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9c928a14371a4d9aa521953e287fff54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9ca0667998cb443d9df29fdd09cf90ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9dc736113ef6477d91aaf71c9969ca74": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0529b81739144db8912c2d6789e729a", + "placeholder": "​", + "style": "IPY_MODEL_13d0a97497274652b081cbcefb3fd17d", + "value": "Downloading (…)lve/main/config.json: 100%" + } + }, + "9f0638198f544a3bbb31a3a78b7bd2c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9f9e15ff2e394ee7a7776e3e7f4b7d30": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a03430c0cdcb47bfbd2ffd754074d692": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e20264d19e804f9dba3e3867ef9b31bd", + "max": 615674, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_43141dcab2324fc6a12f9b8198e10154", + "value": 615674 + } + }, + "a05426c8e5f849b7a972dc0df3cd84ef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a140cd385e5a4c0a88c5562370982d2e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a1578c0c777f4780a3fdd1635a0909d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bde010029c374a0eb2bb942f380f0e8b", + "placeholder": "​", + "style": "IPY_MODEL_a91f37ce798d411ea2a33cfdb1f01251", + "value": " 2.06k/2.06k [00:00<00:00, 75.3kB/s]" + } + }, + "a22db8523d44457bb96448d08129988f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a235cb3d4d424efeb30901f63fc1dbe5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a25ef41450eb42ff9b8b618b40080ac0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a26ddb684a07496da4290e3f6031b685": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a478b23c34654615aad4202b8c7089f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4b16b5279504dd694090798f5925d65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a5bd56eb69524729afdfdd14b55b6130": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a615446a48624d0f9a009c1f6d8b1a54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6d9826a5adb847e8b4cc4486a31b52ce", + "placeholder": "​", + "style": "IPY_MODEL_e8b3093587e44164b0ac043414cea0fa", + "value": "Downloading (…)olve/main/merges.txt: 100%" + } + }, + "a6963ce72cb3425791804abf1718ba90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a87598d464174703b5f5a5eca23543f3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a8aac44a077040bd9f4638c0c8f7a877": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_04144ed3ff5f423f99179702cee5343f", + "max": 908, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8c41e1ee1a2c49b8b3d3d320fbf26262", + "value": 908 + } + }, + "a91f37ce798d411ea2a33cfdb1f01251": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a9c132959dae4303bcf6015106ce3453": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "aa7557fbffc54ed3a9c58c1531fd93f6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aaeec2b7986d493e8d238aa14f2e5937": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ab40616ed9b74f438e74d403f848bed4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ab4ae16fa4f448838f677ea60523c905": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "abc8f69eae7b46b1b430cf3b7a231b05": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_baa8f739bb7e402bae7ee479e282e813", + "placeholder": "​", + "style": "IPY_MODEL_54509d703b7d4416bdee59157f918396", + "value": "#1: 100%" + } + }, + "abd0e7c414974e51b280a29bf978f776": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "abe561c67f1f42b29c33d4c296221b2f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ac2e1977ddaf4b948c9cc24d84c08b83": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ac9c1141ca7c453f84a8ab62b2de9158": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3fd0fd7cbbef4785b360891c12017f48", + "max": 12179, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a9c132959dae4303bcf6015106ce3453", + "value": 12179 + } + }, + "acfb7b6734884939a753fc19047bb9bc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0ae5110b687440e89ebebfb847985aa1", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_85509b0aafec47e5ad540abc7ae4ab7d", + "value": 5 + } + }, + "ad8b6c32caa4493ebadf7691ed1546d4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "add0f175631742d49dd4695bc004e81a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5871a46d60f14da99e4bb8ee74405319", + "IPY_MODEL_64b308019fff4095ab7f1812aab4676a", + "IPY_MODEL_03f62b3f5aa64b6390b157cb3f9d2b9f" + ], + "layout": "IPY_MODEL_59657f26f4af490980b1d9bea1526e5e" + } + }, + "ae54388d78dc4b7ebd1b21860421ffe4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fce64f5690024c698701330f0e5d039a", + "placeholder": "​", + "style": "IPY_MODEL_abd0e7c414974e51b280a29bf978f776", + "value": "Downloading (…)"pytorch_model.bin";: 100%" + } + }, + "af44aa66372a43beb9812ad9895d8d1f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b190bb2bd234b7997ca041baddd511f", + "placeholder": "​", + "style": "IPY_MODEL_7549fd0b38364d8580f8eb1549558a33", + "value": " 5/5 [00:03<00:00, 1.15it/s]" + } + }, + "af56501692b84e718fe3e8b1e452b7c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e53d35abac8241bcaf6d3b0f732d1bb9", + "max": 184990, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_87d251db4a6e495cb1d59d276e823bf2", + "value": 184990 + } + }, + "b0237154051343adaa076a9cc6dd711d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b041efb27b6149fcaf206590f1c1b961": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1b1dc31d9a2b4357a71119300c6d899a", + "placeholder": "​", + "style": "IPY_MODEL_7a24ae9d13fb4e82b1993b05f8d71d11", + "value": "Downloading (…)rocessor_config.json: 100%" + } + }, + "b09d153958cf4a28baad268bbda78236": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b0e084a4c551427bb176061df894fdf6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b0efdb97594b4997a8cb148aa03f9a6b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b1183b9042744d3fa7437e2ec55b6cdd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c643b8650c31466a8614510928ab5d2e", + "placeholder": "​", + "style": "IPY_MODEL_58e46e1d355244bcab90b32c163e2877", + "value": " 1.97k/1.97k [00:00<00:00, 31.4kB/s]" + } + }, + "b1221f4e0a57482682ea4bd6ae245da3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b16e3a75acd0403f865849f1de6ca654": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b19431ca425341568c2b3a8556431a8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6072c153de2540bf9e1227db5057fffc", + "placeholder": "​", + "style": "IPY_MODEL_b7d9e1bf1d2e48e59c4dca38a638d4b4", + "value": " 494k/494k [00:00<00:00, 3.65MB/s]" + } + }, + "b1d780c721b840d7a06661a7a5e63236": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b3a59b83acaa4864be23e10d90560139": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b8266519f0a41cd9a065b9e795d7e84", + "max": 2108, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_658361b3d5054f44a5c21df747537bdd", + "value": 2108 + } + }, + "b5c8221a09df4dfdb74017d4af544b95": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b600ead93bbf44a3a3fe229589c63a61": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3d4c614fb775434fb0c5b02d46246ee0", + "IPY_MODEL_344d1cc53e28411cae839a4ebba1bf58", + "IPY_MODEL_a1578c0c777f4780a3fdd1635a0909d9" + ], + "layout": "IPY_MODEL_41faf55c8878475f8a986b02ad73e8ce" + } + }, + "b7d9e1bf1d2e48e59c4dca38a638d4b4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b7fbaa9d4bcd40b5bcf8d1475658c5b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f027b4358c2c41a8a93c617641135bcd", + "placeholder": "​", + "style": "IPY_MODEL_42cb6114956c4a86980c8dafd5a734ae", + "value": " 3.49k/3.49k [00:00<00:00, 142kB/s]" + } + }, + "b803893882ac4358a4676964dfb3fb31": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f5d7433d15de45e997d12568cac536fc", + "placeholder": "​", + "style": "IPY_MODEL_14e284f308844311a9ad40415091d93f", + "value": " 1964/1964 [06:56<00:00, 4.82ex/s]" + } + }, + "b8acdb71c3564972a6c8b27e964ec061": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_688f552e85714fe6a5d3eda82be0106a", + "IPY_MODEL_a8aac44a077040bd9f4638c0c8f7a877", + "IPY_MODEL_89f8ede64593475da4e056e9907f370f" + ], + "layout": "IPY_MODEL_851902cb2b0e494998684409d82dafd1" + } + }, + "b8d3539c8a454217a3b6ffab51259054": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba21f5ddf2434cc792b70a70c8c1079e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ba48d89cab9346ed92dc338779f9f828": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_73bde731e20d48de8ce66b9d72fb95cb", + "max": 65484800, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9afdb23ba9ee47709f194e0e92de0edf", + "value": 65484800 + } + }, + "baa8f739bb7e402bae7ee479e282e813": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bafada4a1f29442296c47018dcaedb77": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb1bcdfd39bb430c8a453d7a4c3a5e3d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb4a47c63d254d4aa3220e85f86d37c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bf7961a79c2f403a89a4fb6d4b1a02e5", + "max": 6173629930, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1d8636d1d1c3442fbbc2fc83cd03fa44", + "value": 6173629930 + } + }, + "bbc5dbbb8b3548d485b878e194683cf2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c0432026ca204c4e89721fb22589c576", + "IPY_MODEL_c5672e82461148e29dc93af865e259ff", + "IPY_MODEL_f8053b94954d401a85ead90319aa4690" + ], + "layout": "IPY_MODEL_cfee6cbc1d15435bad0bc4a193542c10" + } + }, + "bc2b317065ed4b658995663ff202108a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bc9c3ba4bc6d4623a764d92890536935": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bce6b62300d942a1ab89a6f0ceb16d30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3545fcc1e9d7453099c4931f658e0bc8", + "placeholder": "​", + "style": "IPY_MODEL_2f314258091a430095794c3fe0aea7e3", + "value": "Generating other split: " + } + }, + "bd4e3eb14252470d9c8ac60a32948a72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ef66808d51d440b9998064e212df420", + "placeholder": "​", + "style": "IPY_MODEL_45478f2ce991441c8ceaef9acf745084", + "value": " 12.2k/12.2k [00:00<00:00, 142kB/s]" + } + }, + "bd7da2671a22431889fbfa2ae1e0fe2c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bde010029c374a0eb2bb942f380f0e8b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be90fac89e5243fb82389ed06d094c10": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_845211300fbd49f480d056bba9de83e1", + "max": 63056269, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_df4435b0da414c3880adf33a50c465e5", + "value": 63056269 + } + }, + "bed65245e7234977874d35bf78694e35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3a4bb5b9cf864265af8f1a0b989dff2c", + "max": 829, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ac2e1977ddaf4b948c9cc24d84c08b83", + "value": 829 + } + }, + "bf7961a79c2f403a89a4fb6d4b1a02e5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bfc9036c9c5f4be7ab191b92d92f1352": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c0432026ca204c4e89721fb22589c576": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_35e6c9e3c5ea47a89cd0cbebfd197bde", + "placeholder": "​", + "style": "IPY_MODEL_f81bffac74ff4b07a09760a00620610c", + "value": "Downloading (…)olve/main/vocab.json: 100%" + } + }, + "c1a89a042b044278a8666da306e6a481": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c1f019686c564cca87c240a75ab71ad3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_54589117bf244027ba024ea85bd1fd77", + "IPY_MODEL_7b7986ad93f64956b8d198d2cb4acb60", + "IPY_MODEL_dbc1a016a69b4ad7811d2701a9520a2f" + ], + "layout": "IPY_MODEL_72f8e7de2a5d4155a9e9146f12e14b19" + } + }, + "c24ddbaafa5f4a63b391d981a4f10354": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c28c2fc81e0e467cbc0ded0205d1ee85": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dd339bf6baf6433e92665e30dc30b062", + "placeholder": "​", + "style": "IPY_MODEL_6a544d6dd5954beab32ce3089d8d2aac", + "value": " 829/829 [00:00<00:00, 34.3kB/s]" + } + }, + "c2c2608dd091493795d975f1a3cc3762": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c3ea17f7dd94462986d30b751664d77b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c4119f7ec7464aab90f17d022e674999": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c43169085f2949f1b8259cd0b767d121": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9980bca9b1334893bf6583c325122f50", + "placeholder": "​", + "style": "IPY_MODEL_931fc769fbeb42bf82df6ef5f914bf48", + "value": "Downloading data: 100%" + } + }, + "c44f472624d84e16a0f380580d36ca61": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_65188c1fdba2421ba85c2cc349709600", + "IPY_MODEL_0683cbffd97a4b75bd5e00a05d541fef", + "IPY_MODEL_4573606592ce4b2a914ed0a70b69f9af" + ], + "layout": "IPY_MODEL_efb85d003fb54f55aa4eadf2ab8b1684" + } + }, + "c47ba0b11e074f708338863a35a78f7b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8b0dd001d5b04647b1c480aab83d03a2", + "placeholder": "​", + "style": "IPY_MODEL_0af935ad4f694fb48094e6a119cbcf82", + "value": "Downloading (…)in/added_tokens.json: 100%" + } + }, + "c4cca1778f314ce582bd09b9b2494f82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b1d780c721b840d7a06661a7a5e63236", + "placeholder": "​", + "style": "IPY_MODEL_d19402df47464044b36fb5ee4a0c1c4d", + "value": "Downloading data: 100%" + } + }, + "c4e7cf4e42554d61aa055da47ab0ee22": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c5672e82461148e29dc93af865e259ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb55e8ca8bf4477bb323ae45a6c60500", + "max": 1036558, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_3e154f89e56146438bc45030e5254d8d", + "value": 1036558 + } + }, + "c60690c2aee74763bf23115553f4e640": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7d3d6c198e794219ab5db59f0228c8ab", + "IPY_MODEL_5d5ea0207c6148769ad9f15b7b3dd92d", + "IPY_MODEL_642e28d258ca4c30a5df94c5cf7e0471", + "IPY_MODEL_170ee581427d4f30925dc393d124c1be", + "IPY_MODEL_d5d5aa24182a4e04b3fdae1ca7fad52a" + ], + "layout": "IPY_MODEL_6dba643113a547ac9b6e121d008791d6" + } + }, + "c643b8650c31466a8614510928ab5d2e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6c9fa535ff4458ba966183e1489905b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_56e8812fa66e40b0896a19dd3be7330c", + "placeholder": "​", + "style": "IPY_MODEL_116c89bb3a2045f28123e4f36067a7e5", + "value": " 185k/185k [00:00<00:00, 2.18MB/s]" + } + }, + "c7268972f75e4824893ebe7d893a18e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7935e298049f4deeaeb278ba3de92291", + "placeholder": "​", + "style": "IPY_MODEL_3afca90970fc4925a05a9a1aa5c8d2f2", + "value": " 1.97k/1.97k [00:00<00:00, 70.2kB/s]" + } + }, + "c78544f32b564ba6832120b3167a2162": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c80954848a4a499a87708548bed8e7cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c81c5d3a4dc5409e95a6410e67fa9857": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_33888a5cafe6495782309dae44531dd3", + "placeholder": "​", + "style": "IPY_MODEL_7d5ff2f1b8794bad8286e90307bd6a61", + "value": " 91.0M/91.0M [00:02<00:00, 43.0MB/s]" + } + }, + "c89cb73d51dd457d8c17ff97e74b7ca1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c8ba787279ea43aa97b134c134d4f183": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb55e8ca8bf4477bb323ae45a6c60500": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cbbba08d9e634560a6c0429e32166fe5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_79da882ea494477a8c94fdac7acd644e", + "placeholder": "​", + "style": "IPY_MODEL_f14847261aa247fb9561373e0495f3e5", + "value": "Downloading builder script: 100%" + } + }, + "cd585c98560b42c8b4a08df5b853b23c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_313090dc1f034ab19d5ffc573ea1aa5c", + "placeholder": "​", + "style": "IPY_MODEL_966c0400dafe4e3ea2c9baebc2e104fa", + "value": " 6.17G/6.17G [00:31<00:00, 201MB/s]" + } + }, + "cd9bda1053a14890ad9091c63c0a0acf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cda6af0ca01d4053bcebe06f3c41d887": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f773a61b1dba4e3eb0df36162efe9abc", + "placeholder": "​", + "style": "IPY_MODEL_bfc9036c9c5f4be7ab191b92d92f1352", + "value": " 616k/616k [00:00<00:00, 1.31MB/s]" + } + }, + "cdd08679c28642a184805912c07b324e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ce06b2a0de6c4fb8bae36bc4d7f63270": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c4cca1778f314ce582bd09b9b2494f82", + "IPY_MODEL_3bd70d937e924f61b943acb0aaf15619", + "IPY_MODEL_c81c5d3a4dc5409e95a6410e67fa9857" + ], + "layout": "IPY_MODEL_dd02d1b31bfd4b19ad626d6691a9b293" + } + }, + "ce8f306e745d4b158c58058d471de037": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cfee6cbc1d15435bad0bc4a193542c10": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d046a46c70ea46ffbb04a3c9f55637d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d140f5373bf144d1ae5d282e1a65647e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d19402df47464044b36fb5ee4a0c1c4d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d1bc2ce48c3e481b9059e882b5102946": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_11b9c50e720a466aa92c64b254d40778", + "placeholder": "​", + "style": "IPY_MODEL_8f856d6bde4041149324e1f53d19c1cb", + "value": " 60.9k/60.9k [00:00<00:00, 169kB/s]" + } + }, + "d21cd4878c6e49d38dd3abb2e3b3f566": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_621880c98245427881dd5b004b480c6a", + "placeholder": "​", + "style": "IPY_MODEL_65c2716dd7f14afa93d3bfaebe85c44f", + "value": "Generating invalidated split: " + } + }, + "d2c14b2486e24150a8242ca37f4200f4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d2c1704e34c34d12b99c31d64fce88cc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d37791ea2b6c4152991295ca0edb0fb7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d3d7c15d53c8498e823c84fe609321dd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d5d5aa24182a4e04b3fdae1ca7fad52a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6d5801774beb4b529b227ef2f098614e", + "placeholder": "​", + "style": "IPY_MODEL_dfdf23cde48c421caebb573060641d6a", + "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. " + } + }, + "d5d632dd16f147e090c62aad38c45d3c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d65e79ed6a9f4daea04e098959f12c80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c89cb73d51dd457d8c17ff97e74b7ca1", + "max": 3486, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_921fd273a7254447a93fb997773aedab", + "value": 3486 + } + }, + "d8c1a66480204f1095ff5f6a7dd2e477": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9dc736113ef6477d91aaf71c9969ca74", + "IPY_MODEL_79521628c64b4d6f9f22e73749298693", + "IPY_MODEL_c7268972f75e4824893ebe7d893a18e1" + ], + "layout": "IPY_MODEL_a87598d464174703b5f5a5eca23543f3" + } + }, + "d92259acf9704ef9be6eced8a5f25dab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d96245da43944c4b8235e0cd02c1aa4c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d97f77f45e1e400494c2fbf2cd9d69a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d9a85d7c76b54199bbf7646448e3458c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_564cd321c06440e9856f10f5c40c20be", + "placeholder": "​", + "style": "IPY_MODEL_8a91574c4b6e4745b2b65885323b4d25", + "value": " 3.44k/3.44k [00:00<00:00, 71.6kB/s]" + } + }, + "daee15869a92459aabcd9128526183d5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "daf4005d1d334608846d0fb2fe4f837a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_460be80f176849e0b1241e3a4fc18b74", + "placeholder": "​", + "style": "IPY_MODEL_74e2bcef1ce94234bbf6ba0d6488279d", + "value": "Downloading data: 100%" + } + }, + "db5e1bf1871546408f233f0cbc37b136": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ed7daa32c94648d5951876229f9835b3", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_eb883a37a9cf4945bd864decb4fc87ea", + "value": 5 + } + }, + "dbc1a016a69b4ad7811d2701a9520a2f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fb9f013a6188463fad6db70702576c37", + "placeholder": "​", + "style": "IPY_MODEL_93e2efbb5da747d4b94c916153ee9706", + "value": " 5/5 [00:24<00:00, 5.01s/it]" + } + }, + "dbe19b9505884a958e832c0362d547df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6a40bc08e55a4605b478edf01ff088df", + "placeholder": "​", + "style": "IPY_MODEL_fbd304c2564e4acba84809377ba19e25", + "value": "Downloading (…)"pytorch_model.bin";: 100%" + } + }, + "dce0d285c7d947dfba9ee5bc1a6ebece": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "dd02d1b31bfd4b19ad626d6691a9b293": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd339bf6baf6433e92665e30dc30b062": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd634585d5e64c97881b132b1d59083e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ddc2a8e8ef4d429f95081c4c5baf1fb3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "deb18822d58b4b60bb75460f0a5fe921": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dec9f287435e4c6b9fb1d1ead2ded576": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_00071f8cf276478fb2740684552f1275", + "placeholder": "​", + "style": "IPY_MODEL_64378b1064dc4036a9a4c8813013e210", + "value": "Extracting data files: 100%" + } + }, + "df4435b0da414c3880adf33a50c465e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "dfdf23cde48c421caebb573060641d6a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e0529b81739144db8912c2d6789e729a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e1141861d9f44d4c95313fd432795b70": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e166fb45a33c495e9428bcdef8cd8813": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_098e92acdc444f64a031bd0daf070604", + "placeholder": "​", + "style": "IPY_MODEL_6feb1c05469b4bc8ac9c98cdf29fdd57", + "value": " 2.06k/2.06k [00:00<00:00, 70.6kB/s]" + } + }, + "e1fef249d35d482681cd39eefb7e0d7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_54af0365067b498d86d23c453c5e38f1", + "max": 52666, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ab4ae16fa4f448838f677ea60523c905", + "value": 52666 + } + }, + "e20264d19e804f9dba3e3867ef9b31bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e213d1c919314315ada180d49e27dfb6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0ea1f163e4174684bd6efc2e2433c1d3", + "IPY_MODEL_09511a81a89d4754897a3507a84405be", + "IPY_MODEL_8338339ab8a242c1a485bce8558f9c39" + ], + "layout": "IPY_MODEL_8e84abf61e3e45d58efc7ccd0bfe8d37" + } + }, + "e2a8a379bd0d4cbdb22fbc3bbb4fdc7a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "e3f1244dbe2c48bc8102f958c3df6467": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4234c7c29744fc4be99b8b2ebedc9d1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e4810a798c0f47b6b54f84ff4ffec608": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "info", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f617d181ffdb4b1e8d81fbb393923a6e", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a26ddb684a07496da4290e3f6031b685", + "value": 1 + } + }, + "e53d35abac8241bcaf6d3b0f732d1bb9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e57b15cc74e7474083e87722d6acde47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_451d3851e29e4efabbc2c235dea718da", + "max": 69713920, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_18dfdd09a3af49f5b17cda27872d0ba3", + "value": 69713920 + } + }, + "e590170f306347f3a82b76a25d37b652": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1dedb58d31dd43db96ddd7315bb7e2ee", + "placeholder": "​", + "style": "IPY_MODEL_308e1ee4593b454a84681bda10921207", + "value": "Downloading data: 100%" + } + }, + "e5e8f119a91944f296ff821dd7ecfb1b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e6c2dc814c324a0c8cb744ca16707479": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a615446a48624d0f9a009c1f6d8b1a54", + "IPY_MODEL_383d6e891c5249b4b2fabb60d4900488", + "IPY_MODEL_3c3214f235a54864848902f7e53662db" + ], + "layout": "IPY_MODEL_73f6e6860b64491284c9442f0deae8b6" + } + }, + "e6cf97ef7bc541d0b9c6de206a3a45b0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e6dcbcdf41c34e418be0b0b86e44d3f1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e7be6d842a0c4ba485dfa8e58338eed4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e899060f1edc43b980fe6f3bbe13c609": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aaeec2b7986d493e8d238aa14f2e5937", + "placeholder": "​", + "style": "IPY_MODEL_0894264041854eea960707529f3fb8c7", + "value": " 69.7M/69.7M [00:03<00:00, 22.6MB/s]" + } + }, + "e8a7a34c6fb146f0b38a40f389a617fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e8b3093587e44164b0ac043414cea0fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e944fa694d824042845364bdba72d642": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e97a0201b81446b882ba802a5a3b00e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6a2dea21e7ce4eda8953995497308327", + "placeholder": "​", + "style": "IPY_MODEL_2f3d1d2f1c92402cadc4cfa1b0094238", + "value": " 789k/789k [00:00<00:00, 1.10MB/s]" + } + }, + "e9e10f1e53b74509bfc9c0bf11502c5e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ea941a078b984f51b66b5f1e8f3d1d82": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eb03476353ef4568b94a3071918e72f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f9e15ff2e394ee7a7776e3e7f4b7d30", + "placeholder": "​", + "style": "IPY_MODEL_7e264d54d38e4d02acfd47e4e533b49d", + "value": " 2245/0 [00:15<00:00, 2226.90 examples/s]" + } + }, + "eb0d8c3f6de3468fb2b41ddf940de999": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3547b43905c94f479248a29b60e5a1ce", + "placeholder": "​", + "style": "IPY_MODEL_02ec476d0571401eb18332d2af3a13fd", + "value": "Downloading (…)/adapter_config.json: 100%" + } + }, + "eb46a602b3ef484daddbcb847957c3e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f22aa0a93d8b44d0a4c412343ec1f48b", + "placeholder": "​", + "style": "IPY_MODEL_6e6a59f8e7454c2d886634eade47a21f", + "value": " 1/1 [00:03<00:00, 3.39s/it]" + } + }, + "eb883a37a9cf4945bd864decb4fc87ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ebd79e22ad4e4256a6d88883af2c1eef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c47ba0b11e074f708338863a35a78f7b", + "IPY_MODEL_72b715be2c774235a21602b18d71e75a", + "IPY_MODEL_ff9a0ed54bab49aca6f27bf1be66958e" + ], + "layout": "IPY_MODEL_15b5e415b62146ba96215458cf116431" + } + }, + "ec6017ce2fb3431ab823bde05f977a61": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec7e7e3811e34b4a8c8cc31cd021cf20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dd634585d5e64c97881b132b1d59083e", + "placeholder": "​", + "style": "IPY_MODEL_785f3df156b946449c492f1296656a70", + "value": " 581k/581k [00:00<00:00, 1.91MB/s]" + } + }, + "ecb7ffba323743c68961e294e74b337b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ed7daa32c94648d5951876229f9835b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ed80930617a64700a92b3bcff97c2885": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0dc05bee870740ffa72af34ace8c05d9", + "placeholder": "​", + "style": "IPY_MODEL_7a8b8f2a2160441dbdc54a62de83d297", + "value": "Downloading (…)"adapter_model.bin";: 100%" + } + }, + "edc24ce2510f45f8adde0a187016259f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1b2780d8137042449bd6779c70bf43ca", + "placeholder": "​", + "style": "IPY_MODEL_ddc2a8e8ef4d429f95081c4c5baf1fb3", + "value": " 110M/110M [00:04<00:00, 30.6MB/s]" + } + }, + "ee1ae17fdf4143ae8125ce5e2a7e9066": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ef01f9efbfb749a3999c5b89ba0ee370": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ef056ad59e314089a012acaa73a54e4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "efb85d003fb54f55aa4eadf2ab8b1684": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "efd9d5724dbd435991052b4445c6970f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "info", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e2a8a379bd0d4cbdb22fbc3bbb4fdc7a", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2c7d952f958247b681301d1c6bff4fa7", + "value": 1 + } + }, + "f027b4358c2c41a8a93c617641135bcd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f09d5d5e7faf48f5adbaa90cbcf55162": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3ff0c6a4f4fc4b72a5163a7da50af4da", + "IPY_MODEL_e1fef249d35d482681cd39eefb7e0d7e", + "IPY_MODEL_0a8ca977f9db4d7794dcbcaca3c5cb96" + ], + "layout": "IPY_MODEL_e7be6d842a0c4ba485dfa8e58338eed4" + } + }, + "f0be69583cd1410da6dbc18302d4439b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f14847261aa247fb9561373e0495f3e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f1884e5a392941bfa8c484496d87084c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f20fc82bcbf245619ad4dec04d0f999d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f22aa0a93d8b44d0a4c412343ec1f48b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f309d7a096df4f119e6e6871b56913f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5f283548f34848af90affe55a169b5a9", + "IPY_MODEL_51a4d85c08d745bda70ba0db731dca68", + "IPY_MODEL_eb46a602b3ef484daddbcb847957c3e5" + ], + "layout": "IPY_MODEL_8e2e49c6046e4dc0a0a810b4e58f80cc" + } + }, + "f3f191968f724e9bbb710b86d3657a66": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f436e6a7d3014e2ca44c94455bfeace8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f9d6d41ffeba43cf94ec9d7a96af6617", + "IPY_MODEL_bed65245e7234977874d35bf78694e35", + "IPY_MODEL_c28c2fc81e0e467cbc0ded0205d1ee85" + ], + "layout": "IPY_MODEL_ea941a078b984f51b66b5f1e8f3d1d82" + } + }, + "f5d7433d15de45e997d12568cac536fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f5ff1816a56243e4872ddfcd35331ad8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f617d181ffdb4b1e8d81fbb393923a6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "f628cb62f5fa446eb608467c1ecea526": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f773a61b1dba4e3eb0df36162efe9abc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f7b4ec74e2ac45bbbf0265d0363f4d9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2bc85a5bde9a454990d3bb7de5e3c7c1", + "placeholder": "​", + "style": "IPY_MODEL_2ab45b22ce3f400a81cc451b9d7c9eb8", + "value": "Downloading extra modules: 100%" + } + }, + "f8053b94954d401a85ead90319aa4690": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9abe7ed3e3d347b6bad7d1252bde226f", + "placeholder": "​", + "style": "IPY_MODEL_8ba244a082284f6dbac1c8f689c527a8", + "value": " 1.04M/1.04M [00:00<00:00, 5.93MB/s]" + } + }, + "f81bffac74ff4b07a09760a00620610c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f933fbdcc26d41b0bb294dabd0337834": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_950e74921e6042868ab6b7b9070d6f69", + "IPY_MODEL_82dc91c5b065459d827863699a9710e1", + "IPY_MODEL_5b7b6f08765c4c1989f945414f2c3cf4" + ], + "layout": "IPY_MODEL_735c3606df924b9297ddc05fae3e92d5" + } + }, + "f93f87ef211446379963df5bbb2e4ff0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f96c7014b47d4d048ff50d6f1f2da200": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_925f7aad24b547cc8071ee9bda713d7c", + "IPY_MODEL_4043e3ceb27c435d83913b3796bd9927", + "IPY_MODEL_b1183b9042744d3fa7437e2ec55b6cdd" + ], + "layout": "IPY_MODEL_20a0694ee1684ffc8289af9094e812e1" + } + }, + "f9d6d41ffeba43cf94ec9d7a96af6617": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e3f1244dbe2c48bc8102f958c3df6467", + "placeholder": "​", + "style": "IPY_MODEL_786d3d34cfd24f81996797c55b10b443", + "value": "Downloading (…)okenizer_config.json: 100%" + } + }, + "f9e5029c15054f5a9cbcda1ed5878995": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4cc5b0a5c84e43f3bb185c63bc1f9a56", + "IPY_MODEL_af56501692b84e718fe3e8b1e452b7c2", + "IPY_MODEL_c6c9fa535ff4458ba966183e1489905b" + ], + "layout": "IPY_MODEL_b0e084a4c551427bb176061df894fdf6" + } + }, + "fa137c931d2c4e579c27893ca8ee1848": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fab643980982452988a02c14132c73ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_062727d821f248c9958ecc2d79237e5b", + "IPY_MODEL_2c264564d4c642ebb033703b1df02c69", + "IPY_MODEL_b19431ca425341568c2b3a8556431a8f" + ], + "layout": "IPY_MODEL_441e89acb62e47dab61b32b5a97110f3" + } + }, + "fb8aca596a1c4ac4a7428248b6c6f8b1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_168e19229aa5404bb151e4547bb31283", + "placeholder": "​", + "style": "IPY_MODEL_d140f5373bf144d1ae5d282e1a65647e", + "value": "adapter_model.bin: 100%" + } + }, + "fb9f013a6188463fad6db70702576c37": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fbd27061ff114846aedc99bc2d17f7a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fbd304c2564e4acba84809377ba19e25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fce64f5690024c698701330f0e5d039a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe48e65b2371445bbb01a8d3e9af1f67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ff9a0ed54bab49aca6f27bf1be66958e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b8d3539c8a454217a3b6ffab51259054", + "placeholder": "​", + "style": "IPY_MODEL_05e96819517e417aaf05f5f38c0c8b76", + "value": " 2.11k/2.11k [00:00<00:00, 124kB/s]" + } + }, + "ffce35af1ad84a2c838cca55a26dd3c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d21cd4878c6e49d38dd3abb2e3b3f566", + "IPY_MODEL_969e3cf7f3634c3f90b5fea38c5797ca", + "IPY_MODEL_78501c2a5ac84f9ca0d20bbef340fc9f" + ], + "layout": "IPY_MODEL_5b4fbd1102a84670a1eed6f3d25c0bcd" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..9a53bafca0e0ab1d4a7af59c921cd1ca5f5f69aa --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/requirements.txt @@ -0,0 +1,9 @@ +accelerate +git+https://github.com/bitsandbytes-foundation/bitsandbytes.git +datasets==3.6.0 +evaluate +jiwer +librosa +soundfile +transformers==4.52.4 +wandb diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/run_adalora_whisper_int8.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/run_adalora_whisper_int8.sh new file mode 100644 index 0000000000000000000000000000000000000000..39bd69d5f1287401b2bf54bd345b76c8f039d50b --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/int8_training/run_adalora_whisper_int8.sh @@ -0,0 +1,37 @@ +accelerate launch --config_file config.yaml peft_adalora_whisper_large_training.py \ + --model_name_or_path "openai/whisper-large-v2" \ + --language "Marathi" \ + --language_abbr "mr" \ + --task "transcribe" \ + --dataset_name "mozilla-foundation/common_voice_11_0" \ + --push_to_hub \ + --preprocessing_num_workers 2 \ + --per_device_train_batch_size 8 \ + --per_device_eval_batch_size 8 \ + --dataloader_pin_memory \ + --dataloader_num_workers 2 \ + --learning_rate 1e-3 \ + --weight_decay 1e-4 \ + --num_train_epochs 3 \ + --gradient_accumulation_steps 1 \ + --lr_scheduler_type "linear" \ + --num_warmup_steps 50 \ + --output_dir "adalora_whisper_large_marathi_multi_adapter" \ + --seed 42 \ + --load_best_model \ + --with_tracking \ + --report_to "wandb" \ + --hub_token $HUB_TOKEN \ + --checkpointing_steps 2000 \ + --evaluation_steps 2000 \ + --logging_steps 25 \ + --use_peft \ + --use_adalora \ + --init_r 12 \ + --target_r 8 \ + --tinit 100 \ + --tfinal 800 \ + --delta_t 10 \ + --lora_alpha 32 \ + --lora_dropout 0.1 \ + --orth_reg_weight 0.5 \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lily_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lily_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..988b5de954999602454ce91630bc369ea2c22bf3 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lily_finetuning/README.md @@ -0,0 +1,90 @@ +# Lily: Low-Rank Interconnected Adaptation Across Layers + +## Introduction +[**Lily**](https://arxiv.org/abs/2407.09946) is a PEFT method that introduces **cross-layer parameter sharing** to improve parameter efficiency. Unlike LoRA, which assigns independent adapter pairs to each layer, Lily shares adapter components across layers in two ways: + +- **A sharing**: consecutive blocks of `stride_A` layers share the same A adapter, reducing the number of distinct input projections. +- **B sharing**: a small pool of `num_B` B adapters is shared globally across all layers. For each forward pass, a lightweight **router** computes a softmax-weighted combination of all B adapters to produce a layer-specific output projection. + +This design allows Lily to cover more layers with fewer parameters, making it possible to use larger rank for each adapter without increasing parameter count and enabling information sharing across layers. + +## Quick start + +With respect to your standard PEFT training procedure with LoRA, simply swap your `LoraConfig` for a `LilyConfig`. + +```python +import torch +from datasets import load_dataset +from transformers import AutoTokenizer, AutoModelForCausalLM +from trl import SFTTrainer, SFTConfig +from peft import LilyConfig + +model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B") +dataset = load_dataset("timdettmers/openassistant-guanaco", split="train") +lily_config = LilyConfig() + +trainer = SFTTrainer( + model=model, + train_dataset=dataset, + processing_class=tokenizer, + peft_config=lily_config, + args=SFTConfig( + max_length=2048, + dataset_text_field="text", + per_device_train_batch_size=2, + ), +) +trainer.train() +trainer.model.save_pretrained("lily-llama-3.2-3b") +``` + +Run the finetuning script simply by running: +```sh +python examples/lily_finetuning/lily_finetuning.py --base_model meta-llama/Llama-3.2-3B --data_path timdettmers/openassistant-guanaco +``` + +## Use the model on 🤗 +You can load and use the model as any other 🤗 models. +```python +import torch +from peft import PeftModel +from transformers import AutoModelForCausalLM + +model = AutoModelForCausalLM.from_pretrained( + "meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto" +) +peft_model = PeftModel.from_pretrained(model, "lily-llama-3.2-3b") +``` + +## Additional Notes + +- `r` controls the rank (inner hidden dimension). Since Lily typically uses fewer adapter instances than LoRA, it is recommended to use a **larger `r`** — typically `2x`–`4x` the rank you would use in LoRA. +- `stride_A` controls how many consecutive layers share one A adapter. Larger `stride_A` means fewer distinct A adapters and fewer trainable parameters. Suggested values: `2`, `3`, or `4`. Make sure that `total_layers` is divisible by `stride_A` to ensure even sharing. +- `num_B` controls the size of the shared B adapter pool. It is recommended to set `num_B` to roughly `total_layers / stride_A`. Note that `num_B >= 2` is required. +- `scaling` is a direct scalar multiplier on the adapter output (analogous to `alpha / r` in LoRA). It is recommended to start with `2.0` and treat it as a hyperparameter. +- The general rule of thumb: **prefer larger `r` with larger `stride_A` and smaller `num_B`** over smaller `r` with smaller `stride_A` and larger `num_B`. + +## Citation +``` +@inproceedings{zhong-etal-2025-low, + title = "Low-Rank Interconnected Adaptation across Layers", + author = "Zhong, Yibo and + Zhao, Jinman and + Zhou, Yao", + editor = "Che, Wanxiang and + Nabende, Joyce and + Shutova, Ekaterina and + Pilehvar, Mohammad Taher", + booktitle = "Findings of the Association for Computational Linguistics: ACL 2025", + month = jul, + year = "2025", + address = "Vienna, Austria", + publisher = "Association for Computational Linguistics", + url = "https://aclanthology.org/2025.findings-acl.874/", + doi = "10.18653/v1/2025.findings-acl.874", + pages = "17005--17029", + ISBN = "979-8-89176-256-5", + abstract = "Low-rank adaptation (LoRA) is a widely used parameter-efficient fine-tuning (PEFT) method that learns weight updates $\Delta W = AB$ for pretrained weights $W$ through low-rank adapters $A$ and $B$. While LoRA ensures hardware efficiency, its low-rank weight updates limit adaptation performance. In this paper, we propose low-rank interconnected adaptation across layers (Lily), a novel PEFT method that introduces an interconnected framework with locally shared $A$ and globally shared $B$ experts. This structure eliminates redundant per-layer $AB$ pairs, enabling higher-rank $\Delta W$ with equal or fewer parameters. To enhance expressiveness, we use data-dependent routers to determine $A$-$B$ interconnections, preventing $B$ experts from converging to the same behavior and improving representational power across domains. Experiments across modalities, architectures, and model sizes demonstrate Lily{'}s superior performance and efficiency." +} +``` \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lily_finetuning/lily_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lily_finetuning/lily_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..4e09c2bffc5db44355c38a28427a21320e6a33d1 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lily_finetuning/lily_finetuning.py @@ -0,0 +1,190 @@ +# This script is based on examples/gralora_finetuning/gralora_finetuning.py +import os + +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + DataCollatorForLanguageModeling, + Trainer, + TrainingArguments, +) + +from peft import LilyConfig, get_peft_model + + +def train_model( + base_model: str, + data_path: str, + output_dir: str, + batch_size: int, + num_epochs: int, + learning_rate: float, + cutoff_len: int, + val_set_size: int, + eval_step: int, + save_step: int, + device: str, + lily_r: int, + lily_scaling: float, + lily_stride_A: int, + lily_num_B: int, + lily_target_modules: str, + hub_model_id: str, + push_to_hub: bool, +): + os.environ["TOKENIZERS_PARALLELISM"] = "false" + hf_token = os.getenv("HF_TOKEN") + + # Setup device + if device == "auto": + device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + else: + device = torch.device(device) + print(f"Using device: {device}") + + # load tokenizer + tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token) + + model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token) + + # Lily config for the PEFT model + lily_config = LilyConfig( + r=lily_r, + scaling=lily_scaling, + stride_A=lily_stride_A, + num_B=lily_num_B, + target_modules=( + lily_target_modules.split(",") + if lily_target_modules + else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] + ), + ) + + # get the peft model with Lily config + model = get_peft_model(model, lily_config) + model.print_trainable_parameters() + + model.to(device) + tokenizer.pad_token = tokenizer.eos_token + + # Load the dataset + dataset = load_dataset(data_path) + + def tokenize_function(examples): + inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len) + inputs["labels"] = inputs["input_ids"].copy() # setting labels for a language modeling task + return inputs + + # Tokenize the dataset and prepare for training + tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names) + + # Data collator to dynamically pad the batched examples + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + + # Define training arguments + training_args = TrainingArguments( + output_dir=output_dir, + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + per_device_eval_batch_size=batch_size, + warmup_steps=100, + weight_decay=0.01, + logging_steps=eval_step, + save_steps=save_step, + save_total_limit=2, + push_to_hub=push_to_hub, + hub_model_id=hub_model_id, + gradient_accumulation_steps=16, + fp16=True, + learning_rate=learning_rate, + hub_token=hf_token, + ) + + # Clear device cache to free memory + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + # Initialize the Trainer + trainer = Trainer( + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["test"], + data_collator=data_collator, + ) + + # Start model training + trainer.train() + + # Save and push the trained model and tokenizer + if push_to_hub: + trainer.push_to_hub(commit_message="Fine-tuned model with Lily") + + # Save the model and tokenizer locally + model.save_pretrained(output_dir) + tokenizer.save_pretrained(output_dir) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Fine-tune LLaMA with Lily and PEFT") + parser.add_argument("--base_model", type=str, default="meta-llama/Llama-3.2-3B", help="Base model path or name") + parser.add_argument( + "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name" + ) + parser.add_argument( + "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model" + ) + parser.add_argument("--batch_size", type=int, default=1, help="Batch size") + parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs") + parser.add_argument("--learning_rate", type=float, default=1e-4, help="Learning rate") + parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization") + parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size") + parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval") + parser.add_argument("--save_step", type=int, default=100, help="Save step interval") + parser.add_argument("--device", type=str, default="auto", help="Device to use for training") + parser.add_argument("--lily_r", type=int, default=32, help="Lily rank") + parser.add_argument( + "--lily_scaling", type=float, default=2.0, help="Lily scaling factor applied to adapter output" + ) + parser.add_argument( + "--lily_stride_A", type=int, default=4, help="Number of consecutive layers sharing one A adapter" + ) + parser.add_argument("--lily_num_B", type=int, default=7, help="Number of shared B adapters (must be >= 2)") + parser.add_argument( + "--lily_target_modules", type=str, default=None, help="Comma-separated list of target modules for Lily" + ) + parser.add_argument( + "--hub_model_id", + type=str, + default="path/to/repo", + help="Repository name to push the model on the Hugging Face Hub", + ) + parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub") + args = parser.parse_args() + + train_model( + base_model=args.base_model, + data_path=args.data_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + val_set_size=args.val_set_size, + eval_step=args.eval_step, + save_step=args.save_step, + device=args.device, + lily_r=args.lily_r, + lily_scaling=args.lily_scaling, + lily_stride_A=args.lily_stride_A, + lily_num_B=args.lily_num_B, + lily_target_modules=args.lily_target_modules, + hub_model_id=args.hub_model_id, + push_to_hub=args.push_to_hub, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/LoftQ_weight_replacement.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/LoftQ_weight_replacement.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..b03d8524cc73b04c4296f55fd2a26a5e14774323 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/LoftQ_weight_replacement.ipynb @@ -0,0 +1,801 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "546b6c6d-f949-4387-9c41-6989223911f8", + "metadata": {}, + "source": [ + "# Initializing weights with LoftQ by replacing LoRA weights in-place" + ] + }, + { + "cell_type": "markdown", + "id": "d041ecb4-6957-467e-8f3e-d4a12c674e9f", + "metadata": {}, + "source": [ + "This notebook shows how to apply [LoftQ](https://huggingface.co/papers/2310.08659) initialization on our QLoRA model.\n", + "\n", + "In short, the idea behind LoftQ is the following. When we use QLoRA, i.e. we quantize the base model with bitsandbytes to save memory, and then train LoRA weights on top of this base model, we expect a certain performance gap. This is partly due to the fact that quantization is onyl an approximation of the \"real\" weights and thus introduces a quantization error. By default, LoRA weights are initialized such that they are a no-op at the start of the training. However, we can instead initialize them so that they minimize the quantization error. This is the idea behind LoftQ.\n", + "\n", + "Note that this only influences the initialization of the model. Everything that follows stays the same as always." + ] + }, + { + "cell_type": "markdown", + "id": "90d5420f-de32-42fa-8792-247f60e3647d", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a2c69b7c-c922-405f-aae1-ccc4f6911155", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "22be0432-8798-44a2-9014-d929525e3059", + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f087ce0f-71b4-45ec-b2f9-197677bbc1ee", + "metadata": {}, + "outputs": [], + "source": [ + "from peft import get_peft_model, LoraConfig, replace_lora_weights_loftq" + ] + }, + { + "cell_type": "markdown", + "id": "63fdf18e-4ac4-409e-8475-88147cf85067", + "metadata": {}, + "source": [ + "## Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "af14bd0a-597e-446c-800b-619fc0599ee0", + "metadata": {}, + "outputs": [], + "source": [ + "def get_mae(x, y):\n", + " return (x - y).abs().mean()\n", + "\n", + "\n", + "def get_mse(x, y):\n", + " return torch.pow(x - y, 2).mean()\n", + "\n", + "\n", + "def error_report(x, y):\n", + " mae = get_mae(x, y)\n", + " mse = get_mse(x, y)\n", + " print(\n", + " f\"Mean absolute error: {mae:>8.5f}\\n\"\n", + " f\"Mean squared error: {mse:>8.5f}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "1bc01a5f-7ee8-400f-8e80-3f2b7df29882", + "metadata": {}, + "source": [ + "## Base model" + ] + }, + { + "cell_type": "markdown", + "id": "fdc447d9-2f4f-4d0f-afdb-1cf5c4237321", + "metadata": {}, + "source": [ + "First, let's load a base model and calculate some logits. These logits are the baseline, i.e. we try to match their values as best as possible. We only need these logits for demonstration purposes. In practice, it is not necessary to load the non-quantized weights to apply LoftQ initialization.\n", + "\n", + "**Note**: We have to choose a model with a `model.safetensors` file. As PyTorch checkpoints (pickle) cannot be loaded lazily, we have to use [safetensors](https://huggingface.co/docs/safetensors/index). If those don't exist for your model, save the pretrained model as a safetensors file using `safe_pretrained` and pass the model path to `replace_lora_weights_loftq`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0cb29074-d180-4fdc-8a47-27d2b9857264", + "metadata": {}, + "outputs": [], + "source": [ + "model_id = \"bigscience/bloomz-560m\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e7ddd6a2-04dd-42ec-9f48-100a3946ae04", + "metadata": {}, + "outputs": [], + "source": [ + "tokenizer = AutoTokenizer.from_pretrained(model_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1f5b27db-51cc-41da-a21d-049ff747a149", + "metadata": {}, + "outputs": [], + "source": [ + "model = AutoModelForCausalLM.from_pretrained(model_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "51548b6a-945c-4797-b02a-0e3fc77d1242", + "metadata": {}, + "outputs": [], + "source": [ + "s = \"\"\"Beautiful is better than ugly.\n", + "Explicit is better than implicit.\n", + "Simple is better than complex.\n", + "Complex is better than complicated.\n", + "Flat is better than nested.\n", + "Sparse is better than dense.\n", + "Readability counts.\n", + "Special cases aren't special enough to break the rules.\n", + "Although practicality beats purity.\n", + "Errors should never pass silently.\n", + "Unless explicitly silenced.\n", + "In the face of ambiguity, refuse the temptation to guess.\n", + "There should be one-- and preferably only one --obvious way to do it.\n", + "Although that way may not be obvious at first unless you're Dutch.\n", + "Now is better than never.\n", + "Although never is often better than *right* now.\n", + "If the implementation is hard to explain, it's a bad idea.\n", + "If the implementation is easy to explain, it may be a good idea.\n", + "Namespaces are one honking great idea -- let's do more of those!\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ce72d923-5283-48ba-96ef-7f859309ad84", + "metadata": {}, + "outputs": [], + "source": [ + "inputs = tokenizer(s.splitlines(), return_tensors=\"pt\", padding=True)" + ] + }, + { + "cell_type": "markdown", + "id": "3bfe54cb-76ef-4981-ba25-3e544d264c62", + "metadata": {}, + "source": [ + "Our baseline logits:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "04bebcaa-3a05-4621-9a03-e25de72fa27c", + "metadata": {}, + "outputs": [], + "source": [ + "logits_base = model(**inputs).logits" + ] + }, + { + "cell_type": "markdown", + "id": "fa9c9001-8ade-422d-92f8-bcafa50917c7", + "metadata": {}, + "source": [ + "## Normal LoRA model" + ] + }, + { + "cell_type": "markdown", + "id": "8024390b-736a-4b21-848b-aa4f30951d51", + "metadata": {}, + "source": [ + "Now we load the model quantized with bitsandbytes. For now, only 4bit is supported." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "01d1912a-646e-42d2-8292-6702b77d1948", + "metadata": {}, + "outputs": [], + "source": [ + "bnb_config = BitsAndBytesConfig(\n", + " load_in_4bit=True,\n", + " bnb_4bit_use_double_quant=True,\n", + " bnb_4bit_compute_dtype=torch.float16,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b1218717-4db4-48ce-978d-c05dc190fa91", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`low_cpu_mem_usage` was None, now set to True since model is quantized.\n" + ] + } + ], + "source": [ + "model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config)" + ] + }, + { + "cell_type": "markdown", + "id": "a0b4e4c5-3932-4d9a-9457-41a05f24d556", + "metadata": {}, + "source": [ + "Next we create a LoRA model using PEFT and compute the logits of that model." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4741bce0-cd2b-4f05-a50c-4f9e56b43e72", + "metadata": {}, + "outputs": [], + "source": [ + "lora_config = LoraConfig(task_type=\"CAUSAL_LM\", target_modules=\"all-linear\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "cf55cc48-b55d-4806-b6ab-e9b8035ed526", + "metadata": {}, + "outputs": [], + "source": [ + "peft_model = get_peft_model(model, lora_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f2f11e25-4a1e-485b-be4c-65aec62ac207", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + ".../bitsandbytes/nn/modules.py:391: UserWarning: Input type into Linear4bit is torch.float16, but bnb_4bit_compute_dtype=torch.float32 (default). This will lead to slow inference or training speed.\n", + " warnings.warn('Input type into Linear4bit is torch.float16, but bnb_4bit_compute_dtype=torch.float32 (default). This will lead to slow inference or training speed.')\n" + ] + } + ], + "source": [ + "logits_lora = peft_model(**inputs).logits" + ] + }, + { + "cell_type": "markdown", + "id": "5bc0cde7-0b9f-4305-ac0e-e3a6d2cfa401", + "metadata": {}, + "source": [ + "Let's check the influence of the quantization error on our logits:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "6f404c0d-f428-4923-9122-7b830410f089", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean absolute error: 3.61113\n", + "Mean squared error: 36.53259\n" + ] + } + ], + "source": [ + "error_report(logits_base, logits_lora)" + ] + }, + { + "cell_type": "markdown", + "id": "58c437e1-4fae-4a2f-9c42-ada6bedb9a4d", + "metadata": {}, + "source": [ + "## LoftQ" + ] + }, + { + "cell_type": "markdown", + "id": "1af05376-c8b0-48ec-8d80-7d7f4d32bbd7", + "metadata": {}, + "source": [ + "Next, let's use LoftQ initialization and see if it helps reduce the error." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "890e6108-3f02-469c-9e7d-f2144448227c", + "metadata": {}, + "outputs": [], + "source": [ + "replace_lora_weights_loftq(peft_model)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b452db0e-a510-42d3-bef5-f567186e26c2", + "metadata": {}, + "outputs": [], + "source": [ + "logits_loftq = peft_model(**inputs).logits" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "456dc564-f268-4cf3-9d59-a6942d3733ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean absolute error: 3.24111\n", + "Mean squared error: 31.13725\n" + ] + } + ], + "source": [ + "error_report(logits_base, logits_loftq)" + ] + }, + { + "cell_type": "markdown", + "id": "1ddf9e0f-3f78-426c-be59-77c6481674ec", + "metadata": {}, + "source": [ + "We can see that LoftQ initialization helped a little bit, but the difference is not huge." + ] + }, + { + "cell_type": "markdown", + "id": "0dd344f2-249c-4fe9-8357-7fe3bcd1e82f", + "metadata": {}, + "source": [ + "## LoftQ with callback" + ] + }, + { + "cell_type": "markdown", + "id": "e2fd7dd5-88b3-40b8-95c2-3f3895d8093d", + "metadata": {}, + "source": [ + "To help with this, let's write a small callback function and pass it to `replace_lora_weights_loftq`. What this function does is that each time one weight is being replaced with LoftQ-initialized weights, we perform a test if the quantization error is actually reduced. If it it is not, we roll back the replacement. This way, we keep only those replacements that improve the results." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "1f882802-22b7-4969-919e-120b1f2893d2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`low_cpu_mem_usage` was None, now set to True since model is quantized.\n" + ] + } + ], + "source": [ + "# Since PEFT has modified the base model, we should reload it\n", + "model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "c6438363-b66e-4507-8667-5a6df379a03f", + "metadata": {}, + "outputs": [], + "source": [ + "peft_model = get_peft_model(model, lora_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "7b93d082-0fcb-4b20-982e-c1aaf0c71d13", + "metadata": {}, + "outputs": [], + "source": [ + "current_mse = float(\"inf\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "e22eb18d-b06e-47fe-91ba-ff34cbf62f60", + "metadata": {}, + "outputs": [], + "source": [ + "def my_callback(model, module_name):\n", + " \"\"\"Callable to replace weights with LoFTQ if the mse is lower than the current best one.\"\"\"\n", + " global current_mse\n", + "\n", + " logits = model(**inputs).logits\n", + " mse = get_mse(logits_base, logits)\n", + " if mse < current_mse:\n", + " current_mse = mse\n", + " print(f\"MSE improved for module {module_name}\")\n", + " return True\n", + " print(f\"MSE did not improve for module {module_name}\")\n", + " return False" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "44ee90d1-e15a-4740-a39d-ebf9e7adb79c", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE improved for module transformer.h.0.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.0.self_attention.dense\n", + "MSE improved for module transformer.h.0.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.0.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.1.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.1.self_attention.dense\n", + "MSE did not improve for module transformer.h.1.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.1.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.2.self_attention.query_key_value\n", + "MSE improved for module transformer.h.2.self_attention.dense\n", + "MSE improved for module transformer.h.2.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.2.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.3.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.3.self_attention.dense\n", + "MSE improved for module transformer.h.3.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.3.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.4.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.4.self_attention.dense\n", + "MSE improved for module transformer.h.4.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.4.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.5.self_attention.query_key_value\n", + "MSE improved for module transformer.h.5.self_attention.dense\n", + "MSE improved for module transformer.h.5.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.5.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.6.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.6.self_attention.dense\n", + "MSE improved for module transformer.h.6.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.6.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.7.self_attention.query_key_value\n", + "MSE improved for module transformer.h.7.self_attention.dense\n", + "MSE did not improve for module transformer.h.7.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.7.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.8.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.8.self_attention.dense\n", + "MSE improved for module transformer.h.8.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.8.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.9.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.9.self_attention.dense\n", + "MSE did not improve for module transformer.h.9.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.9.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.10.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.10.self_attention.dense\n", + "MSE did not improve for module transformer.h.10.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.10.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.11.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.11.self_attention.dense\n", + "MSE did not improve for module transformer.h.11.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.11.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.12.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.12.self_attention.dense\n", + "MSE improved for module transformer.h.12.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.12.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.13.self_attention.query_key_value\n", + "MSE improved for module transformer.h.13.self_attention.dense\n", + "MSE did not improve for module transformer.h.13.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.13.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.14.self_attention.query_key_value\n", + "MSE improved for module transformer.h.14.self_attention.dense\n", + "MSE did not improve for module transformer.h.14.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.14.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.15.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.15.self_attention.dense\n", + "MSE did not improve for module transformer.h.15.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.15.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.16.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.16.self_attention.dense\n", + "MSE improved for module transformer.h.16.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.16.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.17.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.17.self_attention.dense\n", + "MSE improved for module transformer.h.17.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.17.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.18.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.18.self_attention.dense\n", + "MSE did not improve for module transformer.h.18.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.18.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.19.self_attention.query_key_value\n", + "MSE improved for module transformer.h.19.self_attention.dense\n", + "MSE improved for module transformer.h.19.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.19.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.20.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.20.self_attention.dense\n", + "MSE did not improve for module transformer.h.20.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.20.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.21.self_attention.query_key_value\n", + "MSE improved for module transformer.h.21.self_attention.dense\n", + "MSE did not improve for module transformer.h.21.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.21.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.22.self_attention.query_key_value\n", + "MSE improved for module transformer.h.22.self_attention.dense\n", + "MSE improved for module transformer.h.22.mlp.dense_h_to_4h\n", + "MSE improved for module transformer.h.22.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.23.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.23.self_attention.dense\n", + "MSE improved for module transformer.h.23.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.23.mlp.dense_4h_to_h\n" + ] + } + ], + "source": [ + "replace_lora_weights_loftq(peft_model, callback=my_callback)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e31adc81-a090-49b2-90f6-9906743c76ae", + "metadata": {}, + "outputs": [], + "source": [ + "logits_loftq_callback = peft_model(**inputs).logits" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "7c640092-1f26-48be-bea4-487511205440", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean absolute error: 1.79576\n", + "Mean squared error: 8.47075\n" + ] + } + ], + "source": [ + "error_report(logits_base, logits_loftq_callback)" + ] + }, + { + "cell_type": "markdown", + "id": "1896857e-3d87-44a9-887f-90c765bc8d91", + "metadata": {}, + "source": [ + "We can see that applying LoftQ with the help of the callback reduced the error quite significantly." + ] + }, + { + "cell_type": "markdown", + "id": "8eaf86cf-4fb4-455d-ab07-892591564303", + "metadata": {}, + "source": [ + "## Applying LoftQ multiple times" + ] + }, + { + "cell_type": "markdown", + "id": "70836a75-5c6d-4b7b-9175-f395aef8383b", + "metadata": {}, + "source": [ + "It is possible to run `replace_lora_weights_loftq` multiple times on the same model when using the callback." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "8e5ee38c-007c-4c75-9248-005d94b19445", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE did not improve for module transformer.h.0.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.0.self_attention.dense\n", + "MSE did not improve for module transformer.h.0.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.0.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.1.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.1.self_attention.dense\n", + "MSE did not improve for module transformer.h.1.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.1.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.2.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.2.self_attention.dense\n", + "MSE did not improve for module transformer.h.2.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.2.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.3.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.3.self_attention.dense\n", + "MSE did not improve for module transformer.h.3.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.3.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.4.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.4.self_attention.dense\n", + "MSE did not improve for module transformer.h.4.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.4.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.5.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.5.self_attention.dense\n", + "MSE did not improve for module transformer.h.5.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.5.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.6.self_attention.query_key_value\n", + "MSE improved for module transformer.h.6.self_attention.dense\n", + "MSE did not improve for module transformer.h.6.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.6.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.7.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.7.self_attention.dense\n", + "MSE did not improve for module transformer.h.7.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.7.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.8.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.8.self_attention.dense\n", + "MSE did not improve for module transformer.h.8.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.8.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.9.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.9.self_attention.dense\n", + "MSE did not improve for module transformer.h.9.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.9.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.10.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.10.self_attention.dense\n", + "MSE improved for module transformer.h.10.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.10.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.11.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.11.self_attention.dense\n", + "MSE did not improve for module transformer.h.11.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.11.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.12.self_attention.query_key_value\n", + "MSE improved for module transformer.h.12.self_attention.dense\n", + "MSE did not improve for module transformer.h.12.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.12.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.13.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.13.self_attention.dense\n", + "MSE did not improve for module transformer.h.13.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.13.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.14.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.14.self_attention.dense\n", + "MSE did not improve for module transformer.h.14.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.14.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.15.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.15.self_attention.dense\n", + "MSE did not improve for module transformer.h.15.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.15.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.16.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.16.self_attention.dense\n", + "MSE did not improve for module transformer.h.16.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.16.mlp.dense_4h_to_h\n", + "MSE improved for module transformer.h.17.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.17.self_attention.dense\n", + "MSE did not improve for module transformer.h.17.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.17.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.18.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.18.self_attention.dense\n", + "MSE did not improve for module transformer.h.18.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.18.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.19.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.19.self_attention.dense\n", + "MSE did not improve for module transformer.h.19.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.19.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.20.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.20.self_attention.dense\n", + "MSE did not improve for module transformer.h.20.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.20.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.21.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.21.self_attention.dense\n", + "MSE did not improve for module transformer.h.21.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.21.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.22.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.22.self_attention.dense\n", + "MSE did not improve for module transformer.h.22.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.22.mlp.dense_4h_to_h\n", + "MSE did not improve for module transformer.h.23.self_attention.query_key_value\n", + "MSE did not improve for module transformer.h.23.self_attention.dense\n", + "MSE did not improve for module transformer.h.23.mlp.dense_h_to_4h\n", + "MSE did not improve for module transformer.h.23.mlp.dense_4h_to_h\n" + ] + } + ], + "source": [ + "replace_lora_weights_loftq(peft_model, callback=my_callback)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "2abe2702-9510-4814-b5f2-63140a102c17", + "metadata": {}, + "outputs": [], + "source": [ + "logits_loftq_callback_twice = peft_model(**inputs).logits" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "e908de14-01f9-4fdc-91b5-61118a3ce6cb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean absolute error: 1.76357\n", + "Mean squared error: 8.33938\n" + ] + } + ], + "source": [ + "error_report(logits_base, logits_loftq_callback_twice)" + ] + }, + { + "cell_type": "markdown", + "id": "5b8b09fe-d369-4444-b6e2-cd514e775637", + "metadata": {}, + "source": [ + "There are further gains, but they are not very big." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..73decc96b69c9883427dfe8beb6d9da5ef636c71 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/README.md @@ -0,0 +1,144 @@ +# LoftQ: LoRA-fine-tuning-aware Quantization + +## Introduction + +LoftQ finds quantized LoRA initialization: quantized backbone Q and LoRA adapters A and B, given a pre-trained weight W. + +## Quick Start +Steps: + +1. Apply LoftQ to a full-precision pre-trained weight and save. +2. Load LoftQ initialization and train. + +For step 1, we have provided off-the-shelf LoftQ initializations (see [supported model list](#appendix-off-the-shelf-model-list)) +in [Huggingface Hub LoftQ](https://huggingface.co/LoftQ). +If you want to do it yourself, jump to [LoftQ DIY](#loftq-diy). + +For step 2, below is an example of loading 4bit Mistral-7B with 64rank LoRA adapters from Huggingface Hub. +```python +import torch +from transformers import AutoModelForCausalLM, BitsAndBytesConfig +from peft import PeftModel + +MODEL_ID = "LoftQ/Mistral-7B-v0.1-4bit-64rank" + +base_model = AutoModelForCausalLM.from_pretrained( + MODEL_ID, + dtype=torch.bfloat16, # you may change it with different models + quantization_config=BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=torch.bfloat16, # bfloat16 is recommended + bnb_4bit_use_double_quant=False, + bnb_4bit_quant_type='nf4', + ), +) +peft_model = PeftModel.from_pretrained( + base_model, + MODEL_ID, + subfolder="loftq_init", + is_trainable=True, +) + +# Do training with peft_model ... +``` + +## LoftQ DIY + +### Apply LoftQ and save +We provide [quantize_save_load.py](quantize_save_load.py) as an example to apply LoftQ with +different bits(`--bits`), ranks(`--rank`), and alternating steps (`--iter`, a hyper-parameter in LoftQ, see Algorithm 1 in [LoftQ paper](https://huggingface.co/papers/2310.08659)). Currently, this example supports +`llama-2`, `falcon`, `mistral`, `bart`, `t5`, `deberta`, `bert`, `roberta`. + +Below is an example of obtaining 4bit LLAMA-2-7b with 16-rank LoRA adapters by 5 alternating steps. +```sh +SAVE_DIR="model_zoo/loftq/" +python quantize_save_load.py \ + --model_name_or_path meta-llama/Llama-2-7b-hf \ # high-precision model id in HF + --token HF_TOKEN \ # your HF token if the model is private, e.g., llama-2 + --bits 4 \ + --iter 5 \ + --rank 16 \ + --save_dir $SAVE_DIR +``` + +The above commands end up with creating the model directory under `$SAVE_DIR`. +Specifically, the model directory is named as + +`MODEL_DIR = SAVE_DIR + f"{args.model_name_or_path.split('/')[-1]}-{args.bits}bits-{args.rank}rank"` + +In this example, `MODEL_DIR="model_zoo/loftq/Llama-2-7b-hf-4bit-16rank"`, where the backbone is stored in `$MODEL_DIR` +and the LoRA adapters are at the sub-folder `$MODEL_DIR/loftq_init`. + +### Load and train +Similar to loading from Huggingface Hub, we only need to change the `MODEL_ID` to the `MODEL_DIR`. + +```python +import torch +from transformers import AutoModelForCausalLM, BitsAndBytesConfig +from peft import PeftModel + +MODEL_DIR = "model_zoo/loftq/Llama-2-7b-hf-4bit-16rank" + +base_model = AutoModelForCausalLM.from_pretrained( + MODEL_DIR, + dtype=torch.bfloat16, + quantization_config=BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=torch.bfloat16, + bnb_4bit_use_double_quant=False, + bnb_4bit_quant_type='nf4', + ), +) +peft_model = PeftModel.from_pretrained( + base_model, + MODEL_DIR, + subfolder="loftq_init", + is_trainable=True, +) +# Do training with peft_model ... +``` + +## LoftQ Fine-tuning + +We also provide an example to fine-tune LoftQ on GSM8K. +We load the quantized backbone and LoRA adapters from the [LoftQ Huggingface hub](https://huggingface.co/LoftQ). + +```sh +python train_gsm8k_llama.py \ + --model_name_or_path LoftQ/Llama-2-13b-hf-4bit-64rank \ + --output_dir exp_results/gsm8k/llama-2-13b/bit4-rank64/lr1e-4 \ + --learning_rate 1e-4 \ + --weight_decay 0.1 \ + --lr_scheduler_type cosine \ + --num_warmup_steps 100 \ + --seed 202 \ + --dataset_name gsm8k \ + --dataset_config main \ + --pad_to_max_length \ + --max_source_length 128 \ + --max_target_length 256 \ + --num_train_epochs 5 \ + --per_device_train_batch_size 4 \ + --per_device_eval_batch_size 4 \ + --gradient_accumulation_steps 4 \ + --with_tracking \ + --report_to tensorboard +``` + + +## Appendix: Off-the-shelf Model List +| Model Name | Bits | Ranks | +| ----------- | ---- | ----- | +| LLAMA-2-7b | 4 | 64 | +| LLAMA-2-13b | 4 | 64 | +| LLAMA-2-70b | 4 | 64 | +| Mistral | 4 | 64 | +| Mistral | 4 | 32 | +| BART-large | 4 | 8 | +| BART-large | 4 | 16 | +| BART-large | 4 | 32 | +| BART-large | 2 | 8 | + +## In-place application of LoftQ initialization + +PEFT provides a convenience function `replace_lora_weights_loftq` to apply LoftQ initialization in-place to the quantized model. Check out [this notebook](https://github.com/huggingface/peft/blob/main/examples/loftq_finetuning/LoftQ_weight_replacement.ipynb) for an example. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/int8_correction.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/int8_correction.py new file mode 100644 index 0000000000000000000000000000000000000000..b2c2d4203ead6480f891fdd5d94eff01997209cc --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/int8_correction.py @@ -0,0 +1,279 @@ +#!/usr/bin/env python +""" +Script to show-case how to offset quantization error with LoRA / LoftQ +when dealing with quantizations that both quantize weights and activations. +This is the case for bnb int8, for example, but also other quantizations +such as BitNet do this. + +The math for how this works is explained in MyLinear8bitLt.forward and +can be seen quickly when defining W_q = W + E_W (quantized weight is the +sum of the original weights plus an error term) and the same for +x_q = x + e_x. + +To demonstrate the effectiveness, we load a unquantized model, generate +logits for reference inputs and then do the same for a quantized model +and a quantized model with LoftQ and our mitigations applied. The +error between reference model logits and LoftQ logits is significantly +smaller compared to the logits produced by the quantized model without +mitigation. + +Note: set llm_int8_threshold=0 in your BitsAndBytesConfig. The thresholding +enables dynamic fp16 quantization (for x values above that threshold). +The quantization error for the affected values is much lower and not +static anymore, LoftQ is not able to deal with this. While technically +possible, this script doesn't filter out these masked values and it +is probably not worth the effort. + +Note: Some rudimentary testing showed that the LoftQ mitigation is still +more effective than tuning threshold values but YMMV. + +Note: LoftQ is not doing the heavy lifting in this script's case. The error +between LoftQ and zeroed LoRA is only about two percent points (check this +yourself by using the `--no-loftq` flag). This effect is probably dependent +on the quantization strength. + +Examples of experiments you can do: + +- check the difference between applying no-op LoRA and LoftQ initialized + LoRA by running the following two commands: + * ./int8_correction.py --no-mitigation + * ./int8_correction.py --no-mitigation --no-loftq + +- check the effect of the mitigation vs. the static compenstation by LoftQ: + * ./int8_correction.py + * ./int8_correction.py --no-loftq + +- check the rank contribution for LoftQ: + * for r in 8 16 32 64 128; do ./int8_correction.py --rank $i --no-mitigation; done + +""" + +import argparse +from pathlib import Path +from tempfile import TemporaryDirectory + +import bitsandbytes as bnb +import torch +from transformers import AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig + +import peft.tuners.lora.bnb +from peft import LoftQConfig, LoraConfig, PeftModel, TaskType, get_peft_model + + +torch.backends.cudnn.deterministic = True +torch.backends.cudnn.benchmark = False + + +class MyLinear8bitLt(peft.tuners.lora.bnb.Linear8bitLt): + def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor: + self._check_forward_args(x, *args, **kwargs) + adapter_names = kwargs.pop("adapter_names", None) + + if self.disable_adapters: + if self.merged: + self.unmerge() + result = self.base_layer(x, *args, **kwargs) + elif adapter_names is not None: + result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs) + elif self.merged: + result = self.base_layer(x, *args, **kwargs) + else: + result = self.base_layer(x, *args, **kwargs) + for active_adapter in self.active_adapters: + if active_adapter not in self.lora_A.keys(): + continue + lora_A = self.lora_A[active_adapter] + lora_B = self.lora_B[active_adapter] + dropout = self.lora_dropout[active_adapter] + scaling = self.scaling[active_adapter] + + requires_conversion = not torch.is_autocast_enabled() + if requires_conversion: + expected_dtype = result.dtype + x = self._cast_input_dtype(x, lora_A.weight.dtype) + + # The premise of this is that when we quantize, we introduce an + # error. This means that quantizing x to xq we can state that + # x = x_q + e_x or x_q = x - e_x. The same goes for W: W = W_q + E_W + # or W_q = W - E_W. + # + # LoftQ computes E_W, applies SVD and initializes LoRA's B and A with + # self.r ranks of E_W, giving us ~E_W. For our forward this means: + # y = W_q x + BAx = (W_q + BA) x = (W_q + ~E_W) x = W x + # if ~E_W is close enough to E_W. + # + # This breaks down if x is also quantized (as is the case for bnb int8): + # y = W_q x_q + BA x_q = (W_q + ~E_W) x_q = W x_q = W (x - e_x) = Wx - W e_x + # + # Since e_x is non-zero and W is relatively large, it is a non-negligible + # error term. But we can offset this, since we can compute e_x and we can + # approximate W with W_q - or - in the case of LoftQ with ~E_W. Both work. + # I didn't see a difference empirically but with other quantizations this + # might change. In any case, we can compute ex_mitigation = W_q e_x and + # add it along with the LoRA to remove the W e_x term and be left with + # y = Wx. + # + # This is the term yielding the most error correction gain. There's a + # smaller gain to be had by passing x_q to the LoRA's layers. Let's + # revisit the quantized base layer definition: + # y = W_q x_q = (W - E_W) (x - e_x) = Wx - W e_x - E_W x + E_W e_x + # + # (W e_x) we handled before, (- E_W x) is what we approximate with (~E_W x) + # and is subsequently removed as well but this leaves us (E_W e_x). + # It turns out, if you pass x_q into the LoRA modules, you will end up + # with (~E_W x - ~E_W e_x) - which removes this term as well. + + # Compute x_q (int8 quantized x) to pass it into the LoRA's forward. + CB, SCB, _ = bnb.functional.int8_vectorwise_quant(x.half()) + CB = CB.reshape(-1, CB.shape[-1]) + x_q = bnb.functional.int8_vectorwise_dequant(CB, SCB).to(lora_A.weight.dtype) + x_q = x_q.reshape(*x.shape) + + e_x = x - x_q + W_dq = bnb.functional.int8_vectorwise_dequant(self.base_layer.state.CB, self.base_layer.state.SCB).to( + e_x.dtype + ) + e_x_mitigation = e_x @ W_dq.T + # e_x_mitigation = e_x @ (W_dq.T + (lora_B.weight @ lora_A.weight * scaling).T) + + output = lora_B(lora_A(dropout(x_q))) * scaling + output += e_x_mitigation + if requires_conversion: + output = output.to(expected_dtype) + result = result + output + + return result + + +parser = argparse.ArgumentParser() +parser.add_argument( + "--no-loftq", action="store_true", default=False, help="Disable LoftQ initialization (LoRA no-op init instead)" +) +parser.add_argument( + "--no-mitigation", action="store_true", default=False, help="Disable activation quantization mitigiation" +) +parser.add_argument( + "--model", + choices=["t5-small", "t5-base", "t5-large", "facebook/opt-125m"], + default="t5-base", + help="What model to test.", +) +parser.add_argument("--rank", type=int, default=64) +parser.add_argument("--device", type=str, default="cuda") +parser.add_argument( + "--int8-threshold", type=float, default=0.0, help="To demonstrate that int8 threshold > 0 doesn't work" +) + +args = parser.parse_args() + +device = args.device +qconf = BitsAndBytesConfig( + load_in_8bit=True, + llm_int8_threshold=args.int8_threshold, +) +input_texts = [ + "All I need", + "All I want is", + "Forever yours truly: ", + "Translate French to German: Tu l'as lu?", + "Translate German to French: Last du es?", + ( + "Beautiful is better than ugly.\n" + "Explicit is better than implicit.\n" + "Simple is better than complex.\n" + "Complex is better than complicated.\n" + ), +] +bits = 8 +loftq_iter = 1 +rank = args.rank + +model_id = args.model + +if "t5" in args.model: + target_modules = ["o", "k", "wi", "q", "v"] + task_type = TaskType.SEQ_2_SEQ_LM +else: + target_modules = "all-linear" + task_type = TaskType.CAUSAL_LM + +# ---- + + +def get_logits(model, inputs): + torch.manual_seed(0) + if task_type == TaskType.CAUSAL_LM: + return model(**inputs).logits + + with torch.inference_mode(): + return model(**inputs, labels=inputs["input_ids"]).logits + + +def mse(a, b, attention_mask=None): + squared_error = torch.pow(a - b, 2) + if attention_mask is not None: + # attention_mask shape: [batch_size, seq_len] + # squared_error shape: [batch_size, seq_len, vocab_size] + # apply the mask (zeros out the squared error for padding tokens) + mask = attention_mask.unsqueeze(-1).expand_as(squared_error) + masked_squared_error = squared_error * mask + return (masked_squared_error.sum() / mask.sum()).item() + return squared_error.mean().item() + + +def get_model(*args, **kwargs): + if task_type == TaskType.CAUSAL_LM: + return AutoModelForCausalLM.from_pretrained(*args, **kwargs) + return AutoModelForSeq2SeqLM.from_pretrained(*args, **kwargs) + + +tokenizer = AutoTokenizer.from_pretrained(model_id) +inputs = tokenizer(input_texts, padding=True, return_tensors="pt").to(device) + +ref_model = get_model(model_id, dtype=torch.float32, device_map=device) +qref_model = get_model(model_id, quantization_config=qconf, dtype=torch.float32, device_map=device) + +loftq_config = LoftQConfig(loftq_bits=bits, loftq_iter=loftq_iter) +lora_config = LoraConfig( + task_type=task_type, + r=rank, + init_lora_weights=True if args.no_loftq else "loftq", + loftq_config=loftq_config, + target_modules=target_modules, +) + +base_model = get_model(model_id, dtype=torch.float32, device_map=device) +loftq_model = get_peft_model(base_model, lora_config) + +print("APPLYING SAVED ADAPTER TO QUANTIZED MODEL") +with TemporaryDirectory() as tmp_path: + tmp_path = Path(tmp_path) + loftq_model.base_model.peft_config["default"].init_lora_weights = True + loftq_model.save_pretrained(tmp_path / "loftq_model") + + lora_config = LoraConfig.from_pretrained(tmp_path / "loftq_model") + model_id = args.model + + if not args.no_mitigation: + custom_module_mapping = {bnb.nn.Linear8bitLt: MyLinear8bitLt} + lora_config._register_custom_module(custom_module_mapping) + + base_model = get_model(model_id, quantization_config=qconf, dtype=torch.float32, device_map=device) + loftq_model = PeftModel.from_pretrained( + base_model, tmp_path / "loftq_model", is_trainable=True, config=lora_config + ) + + +ref_logits = get_logits(ref_model, inputs) + +qref_logits = get_logits(qref_model, inputs) +loftq_logits = get_logits(loftq_model, inputs) + +mse_loftq = mse(ref_logits, loftq_logits, attention_mask=inputs["attention_mask"]) +mse_qref = mse(ref_logits, qref_logits, attention_mask=inputs["attention_mask"]) + + +print(f"{model_id=}{device=}") +print(f"{mse_qref=}, {mse_loftq=}") +assert mse_loftq < (mse_qref / 1.05), f"{mse_loftq} >= {mse_qref / 1.05}" +print(f"relative reduction of error: {(mse_qref - mse_loftq) / mse_qref * 100:.2f}%") diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/quantize_save_load.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/quantize_save_load.py new file mode 100644 index 0000000000000000000000000000000000000000..48fba6cc06af4c2a6cbf8bf5d63215efa244a4b5 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/quantize_save_load.py @@ -0,0 +1,193 @@ +# Copyright 2023-present the HuggingFace Inc. team. +# +# 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 argparse +import os + +import torch +from torch import nn +from transformers import ( + AutoModelForCausalLM, + AutoModelForSeq2SeqLM, + AutoModelForSequenceClassification, + AutoTokenizer, +) + +from peft import LoftQConfig, LoraConfig, TaskType, get_peft_model + + +class Shell(nn.Module): + def __init__(self, weight, bias=None): + super().__init__() + self.weight = nn.Parameter(weight, requires_grad=False) + if bias is not None: + self.bias = nn.Parameter(bias, requires_grad=False) + + +def unwrap_model(model, sub_module_name=".base_layer"): + sub_module_name_list = [k.split(sub_module_name)[0] for k in model.state_dict().keys() if sub_module_name in k] + sub_module_name_set = set(sub_module_name_list) + for name in sub_module_name_set: + # get the parent of the submodule + name_parent = ".".join(name.split(".")[:-1]) + name_child = name.split(".")[-1] + sub_module = model.get_submodule(name_parent) + print(sub_module) + + # replace with shell + child = getattr(sub_module, name_child) + weight = getattr(child.base_layer, "weight", None) + bias = getattr(child.base_layer, "bias", None) + shell = Shell(weight, bias) + + setattr(sub_module, name_child, shell) + + print("You have unwrapped the model. Use it on your own risk.") + + +def print_model(model, name): + print("=" * 10 + name + "=" * 10) + print(model) + for param_name, param in model.named_parameters(): + if torch.is_tensor(param): + if param.dtype in [torch.float32, torch.float16]: + print( + param_name, + param.shape, + param.device, + param.dtype, + param.requires_grad, + param.mean().item(), + param.max().item(), + ) + else: + print(name, param.shape, param.device, param.dtype, param.requires_grad) + + +def arg_parse(): + parser = argparse.ArgumentParser(description="Quantize a model with LoftQ.") + parser.add_argument( + "--model_name_or_path", + type=str, + default=None, + required=True, + help="The name or path of the fp32/16 model.", + ) + parser.add_argument( + "--token", + type=str, + default=None, + help="The access token to download model from HuggingFace Hub.", + ) + parser.add_argument( + "--bits", + type=int, + default=4, + help="The quantized bits", + ) + parser.add_argument( + "--iter", + type=int, + default=1, + help="The alternating steps in LoftQ", + ) + parser.add_argument( + "--rank", + type=int, + default=16, + help="The rank of the LoRA adapter", + ) + parser.add_argument( + "--save_dir", + type=str, + default="./model_zoo/loftq/", + help="The rank of the LoRA adapter", + ) + args = parser.parse_args() + return args + + +def quantize_and_save(): + args = arg_parse() + + # Download weights and configure LoRA + tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, token=args.token, trust_remote_code=True) + if any(name in args.model_name_or_path.lower() for name in ["llama", "mistral", "falcon"]): + model = AutoModelForCausalLM.from_pretrained(args.model_name_or_path, token=args.token, trust_remote_code=True) + task_type = TaskType.CAUSAL_LM + target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "up_proj", "down_proj", "gate_proj"] + + elif any(name in args.model_name_or_path.lower() for name in ["bart", "t5"]): + model = AutoModelForSeq2SeqLM.from_pretrained(args.model_name_or_path, token=args.token) + task_type = TaskType.SEQ_2_SEQ_LM + target_modules = ["q_proj", "k_proj", "v_proj", "fc1", "fc2", "out_proj"] + + elif any(name in args.model_name_or_path.lower() for name in ["deberta", "roberta", "bert"]): + model = AutoModelForSequenceClassification.from_pretrained(args.model_name_or_path, token=args.token) + task_type = TaskType.SEQ_CLS + target_modules = ["query_proj", "key_proj", "value_proj", "dense"] # embeddings not supported by peft + else: + raise NotImplementedError("Other models not supported yet.") + + # Config of LoftQ + loftq_config = LoftQConfig(loftq_bits=args.bits, loftq_iter=args.iter) + + lora_config = LoraConfig( + task_type=task_type, + inference_mode=True, + r=args.rank, + lora_alpha=16 if task_type is TaskType.CAUSAL_LM else args.rank, + lora_dropout=0.1, + target_modules=target_modules, + init_lora_weights="loftq", + loftq_config=loftq_config, + ) + + # Obtain LoftQ model + lora_model = get_peft_model(model, lora_config) + base_model = lora_model.get_base_model() + + # Save LoftQ model + model_name = args.model_name_or_path.split("/")[-1] + f"-{args.bits}bit" + f"-{args.rank}rank" + base_model_dir = os.path.join(args.save_dir, model_name) + lora_model_dir = os.path.join(args.save_dir, model_name, "loft_init") + + # save lora adapters first + lora_model.base_model.peft_config[ + "default" + ].base_model_name_or_path = base_model_dir # This can be a local path or Hub model id + lora_model.base_model.peft_config["default"].init_lora_weights = True # Don't apply LoftQ when loading again + + lora_model.save_pretrained(lora_model_dir) + print_model(lora_model, "lora_model") + + # remove lora adapters and save the backbone + unwrap_model(base_model) + base_model.save_pretrained(base_model_dir) + tokenizer.save_pretrained(base_model_dir) + + print_model(base_model, "base_model") + + return base_model_dir, lora_model_dir + + +if __name__ == "__main__": + base_dir, lora_dir = quantize_and_save() + +# example command: +# python quantize_save_load.py \ +# --model_name_or_path meta-llama/Llama-2-7b-hf \ +# --token XXX \ +# --bits 4 --iter 5 --rank 16 \ +# --save_dir ./model_zoo/loftq/ diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/train_gsm8k_llama.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/train_gsm8k_llama.py new file mode 100644 index 0000000000000000000000000000000000000000..63491a6036d7ddb05f50aa424cd0d4af0a7454f6 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/loftq_finetuning/train_gsm8k_llama.py @@ -0,0 +1,851 @@ +# Copyright 2023-present the HuggingFace Inc. team. +# +# 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 argparse +import copy +import logging +import math +import os +import random +import re +from pathlib import Path + +import datasets +import torch +import transformers +from accelerate import Accelerator, DistributedType +from accelerate.logging import get_logger +from accelerate.utils import set_seed +from datasets import load_dataset +from huggingface_hub import HfApi +from torch.utils.data import DataLoader +from tqdm.auto import tqdm +from transformers import ( + CONFIG_MAPPING, + MODEL_MAPPING, + AutoConfig, + AutoModelForCausalLM, + AutoTokenizer, + BitsAndBytesConfig, + SchedulerType, + default_data_collator, + get_scheduler, +) +from transformers.utils import send_example_telemetry +from transformers.utils.versions import require_version + +from peft import PeftModel + + +# Will error if the minimal version of Transformers is not installed. Remove at your own risks. +# check_min_version("4.32.0.dev0") + +logger = get_logger(__name__) + +require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/language-modeling/requirements.txt") + +MODEL_CONFIG_CLASSES = list(MODEL_MAPPING.keys()) +MODEL_TYPES = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES) + + +def parse_args(): + parser = argparse.ArgumentParser(description="Finetune a transformers model on a causal language modeling task") + parser.add_argument( + "--dataset_name", + type=str, + default=None, + help="The name of the dataset to use (via the datasets library).", + ) + parser.add_argument( + "--dataset_config_name", + type=str, + default=None, + help="The configuration name of the dataset to use (via the datasets library).", + ) + parser.add_argument( + "--train_file", type=str, default=None, help="A csv, txt or a json file containing the training data." + ) + parser.add_argument( + "--validation_file", type=str, default=None, help="A csv, txt or a json file containing the validation data." + ) + parser.add_argument( + "--validation_split_percentage", + default=5, + help="The percentage of the train set used as validation set in case there's no validation split", + ) + parser.add_argument( + "--model_name_or_path", + type=str, + help="Path to pretrained model or model identifier from huggingface.co/models.", + required=False, + ) + parser.add_argument( + "--config_name", + type=str, + default=None, + help="Pretrained config name or path if not the same as model_name", + ) + parser.add_argument( + "--tokenizer_name", + type=str, + default=None, + help="Pretrained tokenizer name or path if not the same as model_name", + ) + parser.add_argument( + "--use_slow_tokenizer", + action="store_true", + help="If passed, will use a slow tokenizer (not backed by the 🤗 Tokenizers library).", + ) + parser.add_argument( + "--per_device_train_batch_size", + type=int, + default=8, + help="Batch size (per device) for the training dataloader.", + ) + parser.add_argument( + "--per_device_eval_batch_size", + type=int, + default=8, + help="Batch size (per device) for the evaluation dataloader.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=5e-5, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument("--weight_decay", type=float, default=0.0, help="Weight decay to use.") + parser.add_argument("--num_train_epochs", type=int, default=3, help="Total number of training epochs to perform.") + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--lr_scheduler_type", + type=SchedulerType, + default="linear", + help="The scheduler type to use.", + choices=["linear", "cosine", "cosine_with_restarts", "polynomial", "constant", "constant_with_warmup"], + ) + parser.add_argument( + "--num_warmup_steps", type=int, default=0, help="Number of steps for the warmup in the lr scheduler." + ) + parser.add_argument("--output_dir", type=str, default=None, help="Where to store the final model.") + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--model_type", + type=str, + default=None, + help="Model type to use if training from scratch.", + choices=MODEL_TYPES, + ) + parser.add_argument( + "--ignore_pad_token_for_loss", + type=bool, + default=True, + help="Whether to ignore the tokens corresponding to padded labels in the loss computation or not.", + ) + parser.add_argument( + "--max_source_length", + type=int, + default=128, + help=( + "The maximum total input sequence length after " + "tokenization.Sequences longer than this will be truncated, sequences shorter will be padded." + ), + ) + parser.add_argument( + "--max_target_length", + type=int, + default=128, + help=( + "The maximum total sequence length for target text after " + "tokenization. Sequences longer than this will be truncated, sequences shorter will be padded." + "during ``evaluate`` and ``predict``." + ), + ) + parser.add_argument( + "--pad_to_max_length", + action="store_true", + help="If passed, pad all samples to `max_length`. Otherwise, dynamic padding is used.", + ) + parser.add_argument( + "--preprocessing_num_workers", + type=int, + default=None, + help="The number of processes to use for the preprocessing.", + ) + parser.add_argument( + "--overwrite_cache", action="store_true", help="Overwrite the cached training and evaluation sets" + ) + parser.add_argument( + "--no_keep_linebreaks", action="store_true", help="Do not keep line breaks when using TXT files." + ) + parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.") + parser.add_argument( + "--hub_model_id", type=str, help="The name of the repository to keep in sync with the local `output_dir`." + ) + parser.add_argument("--hub_token", type=str, help="The token to use to push to the Model Hub.") + parser.add_argument( + "--trust_remote_code", + type=bool, + default=False, + help=( + "Whether or not to allow for custom models defined on the Hub in their own modeling files. This option" + "should only be set to `True` for repositories you trust and in which you have read the code, as it will" + "execute code present on the Hub on your local machine." + ), + ) + parser.add_argument( + "--checkpointing_steps", + type=str, + default=None, + help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.", + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help="If the training should continue from a checkpoint folder.", + ) + parser.add_argument( + "--with_tracking", + action="store_true", + help="Whether to enable experiment trackers for logging.", + ) + parser.add_argument( + "--report_to", + type=str, + default="tensorboard", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`,' + ' `"wandb"`, `"comet_ml"` and `"clearml"`. Use `"all"` (default) to report to all integrations.' + "Only applicable when `--with_tracking` is passed." + ), + ) + parser.add_argument( + "--low_cpu_mem_usage", + action="store_true", + help=( + "It is an option to create the model as an empty shell, then only materialize its parameters when the pretrained weights are loaded." + "If passed, LLM loading time and RAM consumption will be benefited." + ), + ) + ########################## + # Generation Config # + ########################## + parser.add_argument( + "--temperature", + type=float, + default=0.8, + help="temperature of 1.0 has no effect, lower tend toward greedy sampling", + ) + parser.add_argument("--k", type=int, default=40, help="Choose k candidate words") + parser.add_argument("--p", type=float, default=0.95, help="The sum of probability of candidate words is 0.9 ") + + ########################## + # Exp Args # + ########################## + parser.add_argument( + "--adapter_name_or_path", + type=str, + default=None, + help=( + "The LoRA adapter checkpoint. Set None if you want to fine-tune from LoftQ." + "Specify a path if you want to evaluate." + ), + ) + + args = parser.parse_args() + + # Sanity checks + if args.dataset_name is None and args.train_file is None and args.validation_file is None: + raise ValueError("Need either a dataset name or a training/validation file.") + else: + if args.train_file is not None: + extension = args.train_file.split(".")[-1] + assert extension in ["csv", "json", "txt"], "`train_file` should be a csv, json or txt file." + if args.validation_file is not None: + extension = args.validation_file.split(".")[-1] + assert extension in ["csv", "json", "txt"], "`validation_file` should be a csv, json or txt file." + + if args.push_to_hub: + assert args.output_dir is not None, "Need an `output_dir` to create a repo when `--push_to_hub` is passed." + + return args + + +def main(): + args = parse_args() + + # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The + # information sent is the one passed as arguments along with your Python/PyTorch versions. + send_example_telemetry("run_clm_no_trainer", args) + + # Initialize the accelerator. We will let the accelerator handle device placement for us in this example. + # If we're using tracking, we also need to initialize it here and it will by default pick up all supported trackers + # in the environment + accelerator_log_kwargs = {} + + if args.with_tracking: + accelerator_log_kwargs["log_with"] = args.report_to + accelerator_log_kwargs["project_dir"] = args.output_dir + + accelerator = Accelerator(gradient_accumulation_steps=args.gradient_accumulation_steps, **accelerator_log_kwargs) + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + datasets.utils.logging.set_verbosity_warning() + transformers.utils.logging.set_verbosity_info() + else: + datasets.utils.logging.set_verbosity_error() + transformers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + set_seed(args.seed) + + # Handle the repository creation + if accelerator.is_main_process: + if args.push_to_hub: + api = HfApi(token=args.hub_token) + + # Create repo (repo_name from args or inferred) + repo_name = args.hub_model_id + if repo_name is None: + repo_name = Path(args.output_dir).absolute().name + repo_id = api.create_repo(repo_name, exist_ok=True).repo_id + + with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore: + if "step_*" not in gitignore: + gitignore.write("step_*\n") + if "epoch_*" not in gitignore: + gitignore.write("epoch_*\n") + elif args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + accelerator.wait_for_everyone() + + # Get the datasets: you can either provide your own CSV/JSON/TXT training and evaluation files (see below) + # or just provide the name of one of the public datasets available on the hub at https://huggingface.co/datasets/ + # (the dataset will be downloaded automatically from the datasets Hub). + # + # For CSV/JSON files, this script will use the column called 'text' or the first column if no column called + # 'text' is found. You can easily tweak this behavior (see below). + # + # In distributed training, the load_dataset function guarantee that only one local process can concurrently + # download the dataset. + if args.dataset_name is not None: + # Downloading and loading a dataset from the hub. + raw_datasets = load_dataset(args.dataset_name, args.dataset_config_name) + if "validation" not in raw_datasets.keys(): + raw_datasets["validation"] = load_dataset( + args.dataset_name, + args.dataset_config_name, + split=f"train[:{args.validation_split_percentage}%]", + ) + raw_datasets["train"] = load_dataset( + args.dataset_name, + args.dataset_config_name, + split=f"train[{args.validation_split_percentage}%:]", + ) + else: + data_files = {} + dataset_args = {} + if args.train_file is not None: + data_files["train"] = args.train_file + if args.validation_file is not None: + data_files["validation"] = args.validation_file + extension = args.train_file.split(".")[-1] + if extension == "txt": + extension = "text" + dataset_args["keep_linebreaks"] = not args.no_keep_linebreaks + raw_datasets = load_dataset(extension, data_files=data_files, **dataset_args) + # If no validation data is there, validation_split_percentage will be used to divide the dataset. + if "validation" not in raw_datasets.keys(): + raw_datasets["validation"] = load_dataset( + extension, + data_files=data_files, + split=f"train[:{args.validation_split_percentage}%]", + **dataset_args, + ) + raw_datasets["train"] = load_dataset( + extension, + data_files=data_files, + split=f"train[{args.validation_split_percentage}%:]", + **dataset_args, + ) + + # See more about loading any type of standard or custom dataset (from files, python dict, pandas DataFrame, etc) at + # https://huggingface.co/docs/datasets/loading_datasets.html. + + # Load pretrained model and tokenizer + # + # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently + # download model & vocab. + if args.config_name: + config = AutoConfig.from_pretrained( + args.config_name, + trust_remote_code=args.trust_remote_code, + ) + elif args.model_name_or_path: + config = AutoConfig.from_pretrained( + args.model_name_or_path, + trust_remote_code=args.trust_remote_code, + ) + else: + config = CONFIG_MAPPING[args.model_type]() + logger.warning("You are instantiating a new config instance from scratch.") + + if args.tokenizer_name: + tokenizer = AutoTokenizer.from_pretrained( + args.tokenizer_name, use_fast=not args.use_slow_tokenizer, trust_remote_code=args.trust_remote_code + ) + elif args.model_name_or_path: + tokenizer = AutoTokenizer.from_pretrained( + args.model_name_or_path, + use_fast=not args.use_slow_tokenizer, + trust_remote_code=args.trust_remote_code, + ) + else: + raise ValueError( + "You are instantiating a new tokenizer from scratch. This is not supported by this script." + "You can do it from another script, save it, and load it from here, using --tokenizer_name." + ) + + ########################## + # Tokenizer # + ########################## + tokenizer.pad_token_id = 0 # unk. we want this to be different from the eos token + tokenizer.padding_side = "left" # Allow batched inference + tokenizer.truncation_side = "left" + + if args.model_name_or_path: + model = AutoModelForCausalLM.from_pretrained( + args.model_name_or_path, + from_tf=bool(".ckpt" in args.model_name_or_path), + config=config, + low_cpu_mem_usage=True, + quantization_config=BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_use_double_quant=False, + bnb_4bit_quant_type="nf4", + bnb_4bit_compute_dtype=config.dtype, + ), + ) + else: + logger.info("Training new model from scratch") + model = AutoModelForCausalLM.from_config(config, trust_remote_code=args.trust_remote_code) + + ########################## + # Peft Model # + ########################## + if args.adapter_name_or_path is None: + model = PeftModel.from_pretrained(model, args.model_name_or_path, subfolder="loftq_init", is_trainable=True) + else: + model = PeftModel.from_pretrained(model, args.adapter_name_or_path, is_trainable=True) + model.print_trainable_parameters() + + # We resize the embeddings only when necessary to avoid index errors. If you are creating a model from scratch + # on a small vocab and want a smaller embedding size, remove this test. + embedding_size = model.get_input_embeddings().weight.shape[0] + if len(tokenizer) > embedding_size: + model.resize_token_embeddings(len(tokenizer)) + + # Preprocessing the datasets. + # First we tokenize all the texts. + ########################## + # GSM8K dataset # + ########################## + + # Preprocessing the datasets. + # First we tokenize all the texts. + column_names = raw_datasets["train"].column_names + + # Get the column names for source/target. + source_column, target_column = "question", "answer" + + # Temporarily set max_target_length for training. + padding = "max_length" if args.pad_to_max_length else False + task_prompt = "\nAnswer the above question. First think step by step and then answer the final number.\n" + + def prompt_process(sent_1, sent_2, prompt_1="", prompt_2="", prompt_3=""): + sent_2 = sent_2.replace("####", "The final answer is") + return prompt_1 + sent_1 + prompt_2 + sent_2 + prompt_3 + + def preprocess_function_train(examples): + sources = examples[source_column] + targets = examples[target_column] + + inputs = [prompt_process(source, target, prompt_2=task_prompt) for (source, target) in zip(sources, targets)] + + model_inputs = tokenizer( + inputs, + max_length=args.max_source_length + args.max_target_length, + padding=padding, + truncation=True, + return_tensors="pt", + ) + + labels = copy.deepcopy(model_inputs) + + # If we are padding here, replace all tokenizer.pad_token_id in the labels by -100 when we want to ignore + # padding in the loss. + if padding == "max_length" and args.ignore_pad_token_for_loss: + # get the length of the target tokens. -1 to kick out the token + target_tokens = tokenizer(targets, padding=False) + target_len = [len(label) - 1 for label in target_tokens["input_ids"]] + + # don't calculate the loss from source and padding (left padding) + for i in range(len(labels["input_ids"])): + labels["input_ids"][i, : -target_len[i]] = -100 + + model_inputs["labels"] = labels["input_ids"] + return model_inputs + + def preprocess_function_test(examples): + sources = examples[source_column] + labels = examples[target_column] + + inputs = [source + task_prompt for source in sources] + + model_inputs = tokenizer(inputs, max_length=args.max_source_length, padding=padding, truncation=True) + labels = tokenizer(labels, max_length=args.max_target_length, padding=padding, truncation=True) + + model_inputs["labels"] = labels["input_ids"] + + return model_inputs + + with accelerator.main_process_first(): + train_dataset = raw_datasets["train"].map( + preprocess_function_train, + batched=True, + num_proc=args.preprocessing_num_workers, + remove_columns=column_names, + load_from_cache_file=not args.overwrite_cache, + desc="Running tokenizer on training dataset", + ) + + eval_dataset = raw_datasets["test"].map( + preprocess_function_test, + batched=True, + num_proc=args.preprocessing_num_workers, + remove_columns=column_names, + load_from_cache_file=not args.overwrite_cache, + desc="Running tokenizer on test dataset", + ) + + # Log a few random samples from the set: + for index in random.sample(range(len(train_dataset)), 2): + logger.info(f"Sample {index} of the training set: {train_dataset[index]}.") + for index in random.sample(range(len(eval_dataset)), 2): + logger.info(f"Sample {index} of the validation set: {eval_dataset[index]}.") + + # DataLoaders creation: + train_dataloader = DataLoader( + train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=args.per_device_train_batch_size + ) + eval_dataloader = DataLoader( + eval_dataset, collate_fn=default_data_collator, batch_size=args.per_device_eval_batch_size + ) + + # Optimizer + # Split weights in two groups, one with weight decay and the other not. + no_decay = ["bias", "layer_norm.weight"] + optimizer_grouped_parameters = [ + { + "params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay) and "lora" in n], + "weight_decay": args.weight_decay, + }, + { + "params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], + "weight_decay": 0.0, + }, + ] + optimizer = torch.optim.AdamW(optimizer_grouped_parameters, lr=args.learning_rate) + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + name=args.lr_scheduler_type, + optimizer=optimizer, + num_warmup_steps=args.num_warmup_steps * args.gradient_accumulation_steps, + num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, + ) + + # Prepare everything with our `accelerator`. + model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare( + model, optimizer, train_dataloader, eval_dataloader, lr_scheduler + ) + + # On TPU, the tie weights in our model have been disconnected, so we need to restore the ties. + if accelerator.distributed_type == DistributedType.TPU: + model.tie_weights() + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # Figure out how many steps we should save the Accelerator states + checkpointing_steps = args.checkpointing_steps + if checkpointing_steps is not None and checkpointing_steps.isdigit(): + checkpointing_steps = int(checkpointing_steps) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if args.with_tracking: + experiment_config = vars(args) + # TensorBoard cannot log Enums, need the raw value + experiment_config["lr_scheduler_type"] = experiment_config["lr_scheduler_type"].value + accelerator.init_trackers("clm_no_trainer", experiment_config) + + # Train! + total_batch_size = args.per_device_train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + + logger.info("***** Running training *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.per_device_train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {args.max_train_steps}") + # Only show the progress bar once on each machine. + progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process) + completed_steps = 0 + starting_epoch = 0 + + # Potentially load in the weights and states from a previous save + if args.resume_from_checkpoint: + if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "": + checkpoint_path = args.resume_from_checkpoint + path = os.path.basename(args.resume_from_checkpoint) + else: + # Get the most recent checkpoint + dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()] + dirs.sort(key=os.path.getctime) + path = dirs[-1] # Sorts folders by date modified, most recent checkpoint is the last + checkpoint_path = path + path = os.path.basename(checkpoint_path) + + accelerator.print(f"Resumed from checkpoint: {checkpoint_path}") + accelerator.load_state(path) + # Extract `epoch_{i}` or `step_{i}` + training_difference = os.path.splitext(path)[0] + + if "epoch" in training_difference: + starting_epoch = int(training_difference.replace("epoch_", "")) + 1 + resume_step = None + completed_steps = starting_epoch * num_update_steps_per_epoch + else: + # need to multiply `gradient_accumulation_steps` to reflect real steps + resume_step = int(training_difference.replace("step_", "")) * args.gradient_accumulation_steps + starting_epoch = resume_step // len(train_dataloader) + resume_step -= starting_epoch * len(train_dataloader) + completed_steps = resume_step // args.gradient_accumulation_steps + + # update the progress_bar if load from checkpoint + progress_bar.update(completed_steps) + + for epoch in range(starting_epoch, args.num_train_epochs): + model.train() + if args.with_tracking: + total_loss = 0 + if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None: + # We skip the first `n` batches in the dataloader when resuming from a checkpoint + active_dataloader = accelerator.skip_first_batches(train_dataloader, resume_step) + else: + active_dataloader = train_dataloader + for step, batch in enumerate(active_dataloader): + with accelerator.accumulate(model): + outputs = model(**batch) + loss = outputs.loss + # We keep track of the loss at each epoch + if args.with_tracking: + total_loss += loss.detach().float() + accelerator.backward(loss) + if completed_steps % 50: + accelerator.print(f"Epoch: {epoch} | Step: {completed_steps} | Loss: {loss}") + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + completed_steps += 1 + + if isinstance(checkpointing_steps, int): + if completed_steps % checkpointing_steps == 0: + output_dir = f"step_{completed_steps}" + if args.output_dir is not None: + output_dir = os.path.join(args.output_dir, output_dir) + accelerator.save_state(output_dir) + if completed_steps >= args.max_train_steps: + break + + model.eval() + gen_kwargs = { + "max_new_tokens": args.max_target_length, + "temperature": args.temperature, + "top_k": args.k, + "top_p": args.p, + "do_sample": True, + } + ans_pred_list = [] + ans_gold_list = [] + for step, batch in enumerate(eval_dataloader): + with torch.no_grad(): + gen_kwargs["input_ids"] = batch["input_ids"] + gen_kwargs["attention_mask"] = batch["attention_mask"] + generated_tokens = accelerator.unwrap_model(model).generate(**gen_kwargs) + + pred_tokens = generated_tokens[:, args.max_source_length :] + pred_tokens = accelerator.pad_across_processes(pred_tokens, dim=1, pad_index=tokenizer.pad_token_id) + gold_tokens = batch["labels"] + + if not args.pad_to_max_length: + # If we did not pad to max length, we need to pad the labels too + gold_tokens = accelerator.pad_across_processes( + batch["labels"], dim=1, pad_index=tokenizer.pad_token_id + ) + + pred_tokens, gold_tokens = accelerator.gather_for_metrics((pred_tokens, gold_tokens)) + pred_tokens, gold_tokens = pred_tokens.cpu().numpy(), gold_tokens.cpu().numpy() + + if isinstance(pred_tokens, tuple): + pred_tokens = pred_tokens[0] + decoded_pred = tokenizer.batch_decode(pred_tokens, skip_special_tokens=True) + decoded_gold = tokenizer.batch_decode(gold_tokens, skip_special_tokens=True) + + # Extract the numbers in sentences + accelerator.print(decoded_pred) + ans_pred_list += [extract_answer_number(sentence_pred) for sentence_pred in decoded_pred] + ans_gold_list += [extract_answer_number(sentence_gold) for sentence_gold in decoded_gold] + + accelerator.print(ans_pred_list) + accelerator.print(ans_gold_list) + accuracy = compute_accuracy(ans_gold_list, ans_pred_list) + + logger.info(f"epoch {epoch}: accuracy: {accuracy}") + + if args.with_tracking: + accelerator.log( + { + "accuracy": accuracy, + "train_loss": total_loss.item() / len(train_dataloader), + "epoch": epoch, + "step": completed_steps, + }, + step=completed_steps, + ) + + if args.push_to_hub and epoch < args.num_train_epochs - 1: + accelerator.wait_for_everyone() + unwrapped_model = accelerator.unwrap_model(model) + unwrapped_model.save_pretrained( + args.output_dir, is_main_process=accelerator.is_main_process, save_function=accelerator.save + ) + if accelerator.is_main_process: + tokenizer.save_pretrained(args.output_dir) + api.upload_folder( + repo_id=repo_id, + folder_path=args.output_dir, + commit_message=f"Training in progress epoch {epoch}", + run_as_future=True, + ) + + if args.checkpointing_steps == "epoch": + output_dir = f"epoch_{epoch}" + if args.output_dir is not None: + output_dir = os.path.join(args.output_dir, output_dir) + accelerator.save_state(output_dir) + + if args.with_tracking: + accelerator.end_training() + + if args.output_dir is not None: + accelerator.wait_for_everyone() + unwrapped_model = accelerator.unwrap_model(model) + unwrapped_model.save_pretrained( + args.output_dir, is_main_process=accelerator.is_main_process, save_function=accelerator.save + ) + if accelerator.is_main_process: + tokenizer.save_pretrained(args.output_dir) + if args.push_to_hub: + api.upload_folder( + repo_id=repo_id, + folder_path=args.output_dir, + commit_message="End of training", + ) + + +PATTERN_NUMBER = re.compile(r"-?\d+\.?\d*") + + +def extract_answer_number(sentence: str) -> float: + sentence = sentence.replace(",", "") + pred = PATTERN_NUMBER.findall(sentence) + if not pred: + return float("inf") + segment = sentence.split("The final answer is ") + if len(segment) > 1: + pred_answer = segment[1] + pred_answer = PATTERN_NUMBER.findall(pred_answer) + if len(pred_answer) > 0: + pred_answer = pred_answer[0] + else: + pred_answer = float(pred[-1]) + else: + pred_answer = float(pred[-1]) + + if isinstance(pred_answer, str): + try: + pred_answer = float(pred_answer) + except ValueError: + pred_answer = float("inf") + return pred_answer + + +def compute_accuracy(pred: list, gold: list): + acc = 0.0 + for p, g in zip(pred, gold): + if p == g: + acc += 1 + + return acc / len(pred) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/colab_notebook.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/colab_notebook.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..91ac558aaf6728e2b9d0e501d99cbed0f053c3a5 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/colab_notebook.ipynb @@ -0,0 +1,54 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "kdOhtpergLCQ" + }, + "outputs": [], + "source": [ + "!git clone https://huggingface.co/spaces/smangrul/peft-lora-sd-dreambooth" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_LuGk9mihPx7" + }, + "outputs": [], + "source": [ + "%cd \"peft-lora-sd-dreambooth\"\n", + "!pip install -r requirements.txt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BYKO8e5ElJOX" + }, + "outputs": [], + "source": [ + "!python colab.py" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [] + }, + "gpuClass": "premium", + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/convert_kohya_ss_sd_lora_to_peft.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/convert_kohya_ss_sd_lora_to_peft.py new file mode 100644 index 0000000000000000000000000000000000000000..a691ba7d053d83f64611db2763c5717d29abe7d3 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/convert_kohya_ss_sd_lora_to_peft.py @@ -0,0 +1,175 @@ +import argparse +import os +from collections import Counter +from dataclasses import dataclass +from typing import Optional + +import safetensors +import torch +from diffusers import UNet2DConditionModel +from transformers import CLIPTextModel + +from peft import LoraConfig, get_peft_model, get_peft_model_state_dict, set_peft_model_state_dict + + +# Default kohya_ss LoRA replacement modules +# https://github.com/kohya-ss/sd-scripts/blob/c924c47f374ac1b6e33e71f82948eb1853e2243f/networks/lora.py#L661 +UNET_TARGET_REPLACE_MODULE = ["Transformer2DModel", "Attention"] +UNET_TARGET_REPLACE_MODULE_CONV2D_3X3 = ["ResnetBlock2D", "Downsample2D", "Upsample2D"] +TEXT_ENCODER_TARGET_REPLACE_MODULE = ["CLIPAttention", "CLIPMLP"] +LORA_PREFIX_UNET = "lora_unet" +LORA_PREFIX_TEXT_ENCODER = "lora_te" + + +@dataclass +class LoRAInfo: + kohya_key: str + peft_key: str + alpha: Optional[float] = None + rank: Optional[int] = None + lora_A: Optional[torch.Tensor] = None + lora_B: Optional[torch.Tensor] = None + + def peft_state_dict(self) -> dict[str, torch.Tensor]: + if self.lora_A is None or self.lora_B is None: + raise ValueError("At least one of lora_A or lora_B is None, they must both be provided") + return {f"{peft_key}.lora_A.weight": self.lora_A, f"{peft_key}.lora_B.weight": self.lora_A} + + +def construct_peft_loraconfig(info: dict[str, LoRAInfo]) -> LoraConfig: + """Constructs LoraConfig from data extracted from kohya checkpoint + + Args: + info (Dict[str, LoRAInfo]): Information extracted from kohya checkpoint + + Returns: + LoraConfig: config for constructing LoRA + """ + + # Unpack all ranks and alphas + ranks = {x[0]: x[1].rank for x in info.items()} + alphas = {x[0]: x[1].alpha or x[1].rank for x in info.items()} + + # Determine which modules needs to be transformed + target_modules = list(info.keys()) + + # Determine most common rank and alpha + r = Counter(ranks.values()).most_common(1)[0] + lora_alpha = Counter(alphas.values()).most_common(1)[0] + + # Determine which modules have different rank and alpha + rank_pattern = dict(filter(lambda x: x[1] != r, ranks.items())) + alpha_pattern = dict(filter(lambda x: x[1] != lora_alpha, alphas.items())) + + config = LoraConfig( + r=r, + lora_alpha=lora_alpha, + target_modules=target_modules, + lora_dropout=0.0, + bias="none", + init_lora_weights=False, + rank_pattern=rank_pattern, + alpha_pattern=alpha_pattern, + ) + + return config + + +def combine_peft_state_dict(info: dict[str, LoRAInfo]) -> dict[str, torch.Tensor]: + result = {} + for key_name, key_info in info.items(): + result[f"base_model.model.{key_name}.lora_A.weight"] = key_info.lora_A + result[f"base_model.model.{key_name}.lora_B.weight"] = key_info.lora_B + return result + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + parser.add_argument("--sd_checkpoint", default=None, type=str, required=True, help="SD checkpoint to use") + + parser.add_argument( + "--kohya_lora_path", default=None, type=str, required=True, help="Path to kohya_ss trained LoRA" + ) + + parser.add_argument("--dump_path", default=None, type=str, required=True, help="Path to the output model.") + + parser.add_argument("--half", action="store_true", help="Save weights in half precision.") + args = parser.parse_args() + + # Load all models that we need to add adapter to + text_encoder = CLIPTextModel.from_pretrained(args.sd_checkpoint, subfolder="text_encoder") + unet = UNet2DConditionModel.from_pretrained(args.sd_checkpoint, subfolder="unet") + + # Construct possible mapping from kohya keys to peft keys + models_keys = {} + for model, model_key, model_name in [ + (text_encoder, LORA_PREFIX_TEXT_ENCODER, "text_encoder"), + (unet, LORA_PREFIX_UNET, "unet"), + ]: + models_keys.update( + { + f"{model_key}.{peft_key}".replace(".", "_"): peft_key + for peft_key in (x[0] for x in model.named_modules()) + } + ) + + # Store conversion info (model_type -> peft_key -> LoRAInfo) + lora_info: dict[str, dict[str, LoRAInfo]] = { + "text_encoder": {}, + "unet": {}, + } + + # Open kohya_ss checkpoint + with safetensors.safe_open(args.kohya_lora_path, framework="pt", device="cpu") as f: + # Extract information about LoRA structure + metadata = f.metadata() + + # Iterate through available info and unpack all the values + for key in f.keys(): + kohya_key, kohya_type = key.split(".")[:2] + + # Find which model this key belongs to + if kohya_key.startswith(LORA_PREFIX_TEXT_ENCODER): + model_type = "text_encoder" + elif kohya_key.startswith(LORA_PREFIX_UNET): + model_type = "unet" + else: + raise ValueError(f"Cannot determine model for key: {key}") + + # Find corresponding peft key + if kohya_key not in models_keys: + raise ValueError(f"Cannot find corresponding key for diffusers/transformers model: {kohya_key}") + peft_key = models_keys[kohya_key] + + if peft_key not in lora_info[model_type]: + lora_info[model_type][peft_key] = LoRAInfo(kohya_key=kohya_key, peft_key=peft_key) + + if kohya_type == "alpha": + lora_info[model_type][peft_key].alpha = f.get_tensor(key).item() + elif kohya_type == "lora_down": + tensor = f.get_tensor(key) + lora_info[model_type][peft_key].lora_A = tensor + lora_info[model_type][peft_key].rank = tensor.shape[0] + elif kohya_type == "lora_up": + tensor = f.get_tensor(key) + lora_info[model_type][peft_key].lora_B = f.get_tensor(key) + lora_info[model_type][peft_key].rank = tensor.shape[1] + else: + raise ValueError(f"Unknown weight name in key: {key} - {kohya_type}") + + # Process each model + for model, model_name in [(text_encoder, "text_encoder"), (unet, "unet")]: + config = construct_peft_loraconfig(lora_info[model_name]) + model = get_peft_model(model, config) + + keys_peft = list(get_peft_model_state_dict(model).keys()) + keys_new = list(combine_peft_state_dict(lora_info[model_name]).keys()) + + set_peft_model_state_dict(model, combine_peft_state_dict(lora_info[model_name])) + + if args.half: + model.to(torch.float16) + + # Save model to disk + model.save_pretrained(os.path.join(args.dump_path, model_name)) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/convert_peft_sd_lora_to_kohya_ss.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/convert_peft_sd_lora_to_kohya_ss.py new file mode 100644 index 0000000000000000000000000000000000000000..97f964844ebb79546cbe5fa8dc5d15e48dd11a74 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/convert_peft_sd_lora_to_kohya_ss.py @@ -0,0 +1,100 @@ +import argparse +import os + +import torch +from diffusers import UNet2DConditionModel +from safetensors.torch import save_file +from transformers import CLIPTextModel + +from peft import PeftModel, get_peft_model_state_dict + + +# Default kohya_ss LoRA replacement modules +# https://github.com/kohya-ss/sd-scripts/blob/c924c47f374ac1b6e33e71f82948eb1853e2243f/networks/lora.py#L664 +LORA_PREFIX_UNET = "lora_unet" +LORA_PREFIX_TEXT_ENCODER = "lora_te" +LORA_ADAPTER_NAME = "default" + + +def get_module_kohya_state_dict( + module: PeftModel, prefix: str, dtype: torch.dtype, adapter_name: str = LORA_ADAPTER_NAME +) -> dict[str, torch.Tensor]: + kohya_ss_state_dict = {} + for peft_key, weight in get_peft_model_state_dict(module, adapter_name=adapter_name).items(): + kohya_key = peft_key.replace("base_model.model", prefix) + kohya_key = kohya_key.replace("lora_A", "lora_down") + kohya_key = kohya_key.replace("lora_B", "lora_up") + kohya_key = kohya_key.replace(".", "_", kohya_key.count(".") - 2) + kohya_ss_state_dict[kohya_key] = weight.to(dtype) + + # Set alpha parameter + if "lora_down" in kohya_key: + alpha_key = f"{kohya_key.split('.')[0]}.alpha" + kohya_ss_state_dict[alpha_key] = torch.tensor(module.peft_config[adapter_name].lora_alpha).to(dtype) + + return kohya_ss_state_dict + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + parser.add_argument( + "--sd_checkpoint", + default=None, + type=str, + required=True, + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + + parser.add_argument( + "--sd_checkpoint_revision", + type=str, + default=None, + required=False, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + + parser.add_argument("--peft_lora_path", default=None, type=str, required=True, help="Path to peft trained LoRA") + + parser.add_argument( + "--dump_path", + default=None, + type=str, + required=True, + help="Path to the output safetensors file for use with webui.", + ) + + parser.add_argument("--half", action="store_true", help="Save weights in half precision.") + args = parser.parse_args() + + # Store kohya_ss state dict + kohya_ss_state_dict = {} + dtype = torch.float16 if args.half else torch.float32 + + # Load Text Encoder LoRA model + text_encoder_peft_lora_path = os.path.join(args.peft_lora_path, "text_encoder") + if os.path.exists(text_encoder_peft_lora_path): + text_encoder = CLIPTextModel.from_pretrained( + args.sd_checkpoint, subfolder="text_encoder", revision=args.sd_checkpoint_revision + ) + text_encoder = PeftModel.from_pretrained( + text_encoder, text_encoder_peft_lora_path, adapter_name=LORA_ADAPTER_NAME + ) + kohya_ss_state_dict.update( + get_module_kohya_state_dict(text_encoder, LORA_PREFIX_TEXT_ENCODER, dtype, LORA_ADAPTER_NAME) + ) + + # Load UNet LoRA model + unet_peft_lora_path = os.path.join(args.peft_lora_path, "unet") + if os.path.exists(unet_peft_lora_path): + unet = UNet2DConditionModel.from_pretrained( + args.sd_checkpoint, subfolder="unet", revision=args.sd_checkpoint_revision + ) + unet = PeftModel.from_pretrained(unet, unet_peft_lora_path, adapter_name=LORA_ADAPTER_NAME) + kohya_ss_state_dict.update(get_module_kohya_state_dict(unet, LORA_PREFIX_UNET, dtype, LORA_ADAPTER_NAME)) + + # Save state dict + save_file( + kohya_ss_state_dict, + args.dump_path, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/lora_dreambooth_inference.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/lora_dreambooth_inference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..a94358c6f11927f8f3006e8e8f8cdd4a0791535d --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/lora_dreambooth_inference.ipynb @@ -0,0 +1,497 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "acab479f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "===================================BUG REPORT===================================\n", + "Welcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n", + "================================================================================\n" + ] + } + ], + "source": [ + "import argparse\n", + "import gc\n", + "import hashlib\n", + "import itertools\n", + "import logging\n", + "import math\n", + "import os\n", + "import threading\n", + "import warnings\n", + "from pathlib import Path\n", + "from typing import Optional\n", + "import psutil\n", + "import json\n", + "\n", + "import torch\n", + "import torch.nn.functional as F\n", + "import torch.utils.checkpoint\n", + "from torch.utils.data import Dataset\n", + "\n", + "import datasets\n", + "import diffusers\n", + "import transformers\n", + "from accelerate import Accelerator\n", + "from accelerate.logging import get_logger\n", + "from accelerate.utils import set_seed\n", + "from diffusers import AutoencoderKL, DDPMScheduler, DiffusionPipeline, UNet2DConditionModel\n", + "from diffusers import DDPMScheduler, PNDMScheduler, StableDiffusionPipeline\n", + "from diffusers.pipelines.stable_diffusion import StableDiffusionSafetyChecker\n", + "from diffusers.optimization import get_scheduler\n", + "from diffusers.utils import check_min_version\n", + "from diffusers.utils.import_utils import is_xformers_available\n", + "from huggingface_hub import HfFolder, Repository, whoami\n", + "from PIL import Image\n", + "from torchvision import transforms\n", + "from tqdm.auto import tqdm\n", + "from transformers import AutoTokenizer, PretrainedConfig, CLIPFeatureExtractor\n", + "from peft import PeftModel, LoraConfig, get_peft_model_state_dict, set_peft_model_state_dict\n", + "\n", + "# Will error if the minimal version of diffusers is not installed. Remove at your own risks.\n", + "check_min_version(\"0.10.0.dev0\")\n", + "\n", + "logger = get_logger(__name__)\n", + "\n", + "\n", + "MODEL_NAME = \"CompVis/stable-diffusion-v1-4\" # \"stabilityai/stable-diffusion-2-1-base\"\n", + "INSTANCE_PROMPT = \"a photo of sks dog\"\n", + "base_path = \"/home/sourab/temp/\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06cfd506", + "metadata": {}, + "outputs": [], + "source": [ + "def get_lora_sd_pipeline(\n", + " ckpt_dir, base_model_name_or_path=None, dtype=torch.float16, device=\"auto\", adapter_name=\"default\"\n", + "):\n", + " if device == \"auto\":\n", + " device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "\n", + " unet_sub_dir = os.path.join(ckpt_dir, \"unet\")\n", + " text_encoder_sub_dir = os.path.join(ckpt_dir, \"text_encoder\")\n", + " if os.path.exists(text_encoder_sub_dir) and base_model_name_or_path is None:\n", + " config = LoraConfig.from_pretrained(text_encoder_sub_dir)\n", + " base_model_name_or_path = config.base_model_name_or_path\n", + "\n", + " if base_model_name_or_path is None:\n", + " raise ValueError(\"Please specify the base model name or path\")\n", + "\n", + " pipe = StableDiffusionPipeline.from_pretrained(\n", + " base_model_name_or_path, torch_dtype=dtype, requires_safety_checker=False\n", + " ).to(device)\n", + " pipe.unet = PeftModel.from_pretrained(pipe.unet, unet_sub_dir, adapter_name=adapter_name)\n", + "\n", + " if os.path.exists(text_encoder_sub_dir):\n", + " pipe.text_encoder = PeftModel.from_pretrained(\n", + " pipe.text_encoder, text_encoder_sub_dir, adapter_name=adapter_name\n", + " )\n", + "\n", + " if dtype in (torch.float16, torch.bfloat16):\n", + " pipe.unet.half()\n", + " pipe.text_encoder.half()\n", + "\n", + " pipe.to(device)\n", + " return pipe\n", + "\n", + "\n", + "def load_adapter(pipe, ckpt_dir, adapter_name):\n", + " unet_sub_dir = os.path.join(ckpt_dir, \"unet\")\n", + " text_encoder_sub_dir = os.path.join(ckpt_dir, \"text_encoder\")\n", + " pipe.unet.load_adapter(unet_sub_dir, adapter_name=adapter_name)\n", + " if os.path.exists(text_encoder_sub_dir):\n", + " pipe.text_encoder.load_adapter(text_encoder_sub_dir, adapter_name=adapter_name)\n", + "\n", + "\n", + "def set_adapter(pipe, adapter_name):\n", + " pipe.unet.set_adapter(adapter_name)\n", + " if isinstance(pipe.text_encoder, PeftModel):\n", + " pipe.text_encoder.set_adapter(adapter_name)\n", + "\n", + "\n", + "def merging_lora_with_base(pipe, ckpt_dir, adapter_name=\"default\"):\n", + " unet_sub_dir = os.path.join(ckpt_dir, \"unet\")\n", + " text_encoder_sub_dir = os.path.join(ckpt_dir, \"text_encoder\")\n", + " if isinstance(pipe.unet, PeftModel):\n", + " pipe.unet.set_adapter(adapter_name)\n", + " else:\n", + " pipe.unet = PeftModel.from_pretrained(pipe.unet, unet_sub_dir, adapter_name=adapter_name)\n", + " pipe.unet = pipe.unet.merge_and_unload()\n", + "\n", + " if os.path.exists(text_encoder_sub_dir):\n", + " if isinstance(pipe.text_encoder, PeftModel):\n", + " pipe.text_encoder.set_adapter(adapter_name)\n", + " else:\n", + " pipe.text_encoder = PeftModel.from_pretrained(\n", + " pipe.text_encoder, text_encoder_sub_dir, adapter_name=adapter_name\n", + " )\n", + " pipe.text_encoder = pipe.text_encoder.merge_and_unload()\n", + "\n", + " return pipe\n", + "\n", + "\n", + "def create_weighted_lora_adapter(pipe, adapters, weights, adapter_name=\"default\"):\n", + " pipe.unet.add_weighted_adapter(adapters, weights, adapter_name)\n", + " if isinstance(pipe.text_encoder, PeftModel):\n", + " pipe.text_encoder.add_weighted_adapter(adapters, weights, adapter_name)\n", + "\n", + " return pipe" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d4e888d2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9f12b2cca0784cba9dc14ec48de929d5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 19 files: 0%| | 0/19 [00:00" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prompt = \"sks dog playing fetch in the park\"\n", + "negative_prompt = \"low quality, blurry, unfinished\"\n", + "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1e1d1f30", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 7.74 ms, sys: 0 ns, total: 7.74 ms\n", + "Wall time: 7.31 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "set_adapter(pipe, adapter_name=\"toy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0c50c03d", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4f978437709b44b391744cf972415027", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prompt = \"narendra modi rendered in the style of <1>\"\n", + "negative_prompt = \"low quality, blurry, unfinished\"\n", + "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e3b9a681", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8871731127904802ba6123128ba22ecf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "set_adapter(pipe, adapter_name=\"dog\")\n", + "prompt = \"sks dog in a big red bucket\"\n", + "negative_prompt = \"low quality, blurry, unfinished\"\n", + "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a659ca6e", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b701336557e4417d8d39d500699c298b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "set_adapter(pipe, adapter_name=\"toy\")\n", + "prompt = \"superman rendered in the style of <1>, close up potrait\"\n", + "negative_prompt = \"low quality, blurry, unfinished\"\n", + "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "1f0ecb40", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b47385e953b14c768d82bea776129904", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "set_adapter(pipe, adapter_name=\"toy_dog\")\n", + "prompt = \"sks dog rendered in the style of <1>, close up potrait, 4K HD\"\n", + "negative_prompt = \"low quality, blurry, unfinished\"\n", + "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29720cdb", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..ec1a3dcd9922d0a01cb636f5cd0c57f6aac5b3d3 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/requirements.txt @@ -0,0 +1,11 @@ +transformers +accelerate +evaluate +tqdm +datasets +diffusers +Pillow +torchvision +huggingface_hub +safetensors +wandb \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/train_dreambooth.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/train_dreambooth.py new file mode 100644 index 0000000000000000000000000000000000000000..a5648f2e5aa82f31caf6eb703125ac4aef87b4b7 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_dreambooth/train_dreambooth.py @@ -0,0 +1,1107 @@ +import argparse +import gc +import hashlib +import itertools +import logging +import math +import os +import threading +import warnings +from contextlib import nullcontext +from pathlib import Path + +import datasets +import diffusers +import numpy as np +import psutil +import torch +import torch.nn.functional as F +import torch.utils.checkpoint +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import set_seed +from diffusers import ( + AutoencoderKL, + DDPMScheduler, + DiffusionPipeline, + DPMSolverMultistepScheduler, + UNet2DConditionModel, +) +from diffusers.optimization import get_scheduler +from diffusers.utils import check_min_version +from diffusers.utils.import_utils import is_xformers_available +from huggingface_hub import HfApi +from PIL import Image +from torch.utils.data import Dataset +from torchvision import transforms +from tqdm.auto import tqdm +from transformers import AutoTokenizer, PretrainedConfig + +from peft import LoraConfig, get_peft_model + + +# Will error if the minimal version of diffusers is not installed. Remove at your own risks. +check_min_version("0.10.0.dev0") + +logger = get_logger(__name__) + +UNET_TARGET_MODULES = ["to_q", "to_v", "query", "value"] # , "ff.net.0.proj"] +TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"] + + +def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str): + text_encoder_config = PretrainedConfig.from_pretrained( + pretrained_model_name_or_path, + subfolder="text_encoder", + revision=revision, + ) + model_class = text_encoder_config.architectures[0] + + if model_class == "CLIPTextModel": + from transformers import CLIPTextModel + + return CLIPTextModel + elif model_class == "RobertaSeriesModelWithTransformation": + from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation + + return RobertaSeriesModelWithTransformation + else: + raise ValueError(f"{model_class} is not supported.") + + +def parse_args(input_args=None): + parser = argparse.ArgumentParser(description="Simple example of a training script.") + parser.add_argument( + "--pretrained_model_name_or_path", + type=str, + default=None, + required=True, + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--tokenizer_name", + type=str, + default=None, + help="Pretrained tokenizer name or path if not the same as model_name", + ) + parser.add_argument( + "--instance_data_dir", + type=str, + default=None, + required=True, + help="A folder containing the training data of instance images.", + ) + parser.add_argument( + "--class_data_dir", + type=str, + default=None, + required=False, + help="A folder containing the training data of class images.", + ) + parser.add_argument( + "--instance_prompt", + type=str, + default=None, + required=True, + help="The prompt with identifier specifying the instance", + ) + parser.add_argument( + "--class_prompt", + type=str, + default=None, + help="The prompt to specify images in the same class as provided instance images.", + ) + parser.add_argument( + "--with_prior_preservation", + default=False, + action="store_true", + help="Flag to add prior preservation loss.", + ) + parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.") + parser.add_argument( + "--num_class_images", + type=int, + default=100, + help=( + "Minimal class images for prior preservation loss. If there are not enough images already present in" + " class_data_dir, additional images will be sampled with class_prompt." + ), + ) + parser.add_argument( + "--validation_prompt", + type=str, + default=None, + help="A prompt that is used during validation to verify that the model is learning.", + ) + parser.add_argument( + "--num_validation_images", + type=int, + default=4, + help="Number of images that should be generated during validation with `validation_prompt`.", + ) + parser.add_argument( + "--validation_steps", + type=int, + default=100, + help=( + "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt" + " `args.validation_prompt` multiple times: `args.num_validation_images`." + ), + ) + parser.add_argument( + "--output_dir", + type=str, + default="text-inversion-model", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution" + ) + parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder") + + # lora args + parser.add_argument("--use_lora", action="store_true", help="Whether to use Lora for parameter efficient tuning") + parser.add_argument("--lora_r", type=int, default=8, help="Lora rank, only used if use_lora is True") + parser.add_argument("--lora_alpha", type=int, default=32, help="Lora alpha, only used if use_lora is True") + parser.add_argument("--lora_dropout", type=float, default=0.0, help="Lora dropout, only used if use_lora is True") + parser.add_argument( + "--lora_bias", + type=str, + default="none", + help="Bias type for Lora. Can be 'none', 'all' or 'lora_only', only used if use_lora is True", + ) + parser.add_argument( + "--lora_text_encoder_r", + type=int, + default=8, + help="Lora rank for text encoder, only used if `use_lora` and `train_text_encoder` are True", + ) + parser.add_argument( + "--lora_text_encoder_alpha", + type=int, + default=32, + help="Lora alpha for text encoder, only used if `use_lora` and `train_text_encoder` are True", + ) + parser.add_argument( + "--lora_text_encoder_dropout", + type=float, + default=0.0, + help="Lora dropout for text encoder, only used if `use_lora` and `train_text_encoder` are True", + ) + parser.add_argument( + "--lora_text_encoder_bias", + type=str, + default="none", + help="Bias type for Lora. Can be 'none', 'all' or 'lora_only', only used if use_lora and `train_text_encoder` are True", + ) + + parser.add_argument( + "--num_dataloader_workers", type=int, default=1, help="Num of workers for the training dataloader." + ) + + parser.add_argument( + "--no_tracemalloc", + default=False, + action="store_true", + help="Flag to stop memory allocation tracing during training. This could speed up training on Windows.", + ) + + parser.add_argument( + "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader." + ) + parser.add_argument( + "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images." + ) + parser.add_argument("--num_train_epochs", type=int, default=1) + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help=( + "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final" + " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming" + " training using `--resume_from_checkpoint`." + ), + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help=( + "Whether training should be resumed from a previous checkpoint. Use a path saved by" + ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.' + ), + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=5e-6, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of accelerators, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler." + ) + parser.add_argument( + "--lr_num_cycles", + type=int, + default=1, + help="Number of hard resets of the lr in cosine_with_restarts scheduler.", + ) + parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.") + parser.add_argument( + "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes." + ) + parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.") + parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.") + parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.") + parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer") + parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.") + parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.") + parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.") + parser.add_argument( + "--hub_model_id", + type=str, + default=None, + help="The name of the repository to keep in sync with the local `output_dir`.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument( + "--report_to", + type=str, + default="tensorboard", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`' + ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument( + "--wandb_key", + type=str, + default=None, + help=("If report to option is set to wandb, api-key for wandb used for login to wandb "), + ) + parser.add_argument( + "--wandb_project_name", + type=str, + default=None, + help=("If report to option is set to wandb, project name in wandb for log tracking "), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default=None, + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU or Intel XPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--prior_generation_precision", + type=str, + default=None, + choices=["no", "fp32", "fp16", "bf16"], + help=( + "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU or Intel XPU. Default to fp16 if a GPU is available else fp32." + ), + ) + parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank") + parser.add_argument( + "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers." + ) + + if input_args is not None: + args = parser.parse_args(input_args) + else: + args = parser.parse_args() + + env_local_rank = int(os.environ.get("LOCAL_RANK", "-1")) + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + if args.with_prior_preservation: + if args.class_data_dir is None: + raise ValueError("You must specify a data directory for class images.") + if args.class_prompt is None: + raise ValueError("You must specify prompt for class images.") + else: + # logger is not available yet + if args.class_data_dir is not None: + warnings.warn("You need not use --class_data_dir without --with_prior_preservation.") + if args.class_prompt is not None: + warnings.warn("You need not use --class_prompt without --with_prior_preservation.") + + return args + + +# Converting Bytes to Megabytes +def b2mb(x): + return int(x / 2**20) + + +# This context manager is used to track the peak memory usage of the process +class TorchTracemalloc: + def __enter__(self): + gc.collect() + self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + self.device_module = getattr(torch, self.device_type, torch.cuda) + self.device_module.empty_cache() + self.device_module.reset_peak_memory_stats() # reset the peak gauge to zero + self.begin = self.device_module.memory_allocated() + self.process = psutil.Process() + + self.cpu_begin = self.cpu_mem_used() + self.peak_monitoring = True + peak_monitor_thread = threading.Thread(target=self.peak_monitor_func) + peak_monitor_thread.daemon = True + peak_monitor_thread.start() + return self + + def cpu_mem_used(self): + """get resident set size memory for the current process""" + return self.process.memory_info().rss + + def peak_monitor_func(self): + self.cpu_peak = -1 + + while True: + self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak) + + # can't sleep or will not catch the peak right (this comment is here on purpose) + # time.sleep(0.001) # 1msec + + if not self.peak_monitoring: + break + + def __exit__(self, *exc): + self.peak_monitoring = False + + gc.collect() + self.device_module.empty_cache() + self.end = self.device_module.memory_allocated() + self.peak = self.device_module.max_memory_allocated() + self.used = b2mb(self.end - self.begin) + self.peaked = b2mb(self.peak - self.begin) + + self.cpu_end = self.cpu_mem_used() + self.cpu_used = b2mb(self.cpu_end - self.cpu_begin) + self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin) + # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}") + + +class DreamBoothDataset(Dataset): + """ + A dataset to prepare the instance and class images with the prompts for fine-tuning the model. + It pre-processes the images and the tokenizes prompts. + """ + + def __init__( + self, + instance_data_root, + instance_prompt, + tokenizer, + class_data_root=None, + class_prompt=None, + size=512, + center_crop=False, + ): + self.size = size + self.center_crop = center_crop + self.tokenizer = tokenizer + + self.instance_data_root = Path(instance_data_root) + if not self.instance_data_root.exists(): + raise ValueError("Instance images root doesn't exists.") + + self.instance_images_path = list(Path(instance_data_root).iterdir()) + self.num_instance_images = len(self.instance_images_path) + self.instance_prompt = instance_prompt + self._length = self.num_instance_images + + if class_data_root is not None: + self.class_data_root = Path(class_data_root) + self.class_data_root.mkdir(parents=True, exist_ok=True) + self.class_images_path = list(self.class_data_root.iterdir()) + self.num_class_images = len(self.class_images_path) + self._length = max(self.num_class_images, self.num_instance_images) + self.class_prompt = class_prompt + else: + self.class_data_root = None + + self.image_transforms = transforms.Compose( + [ + transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR), + transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + + def __len__(self): + return self._length + + def __getitem__(self, index): + example = {} + instance_image = Image.open(self.instance_images_path[index % self.num_instance_images]) + if instance_image.mode != "RGB": + instance_image = instance_image.convert("RGB") + example["instance_images"] = self.image_transforms(instance_image) + example["instance_prompt_ids"] = self.tokenizer( + self.instance_prompt, + truncation=True, + padding="max_length", + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + if self.class_data_root: + class_image = Image.open(self.class_images_path[index % self.num_class_images]) + if class_image.mode != "RGB": + class_image = class_image.convert("RGB") + example["class_images"] = self.image_transforms(class_image) + example["class_prompt_ids"] = self.tokenizer( + self.class_prompt, + truncation=True, + padding="max_length", + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + return example + + +def collate_fn(examples, with_prior_preservation=False): + input_ids = [example["instance_prompt_ids"] for example in examples] + pixel_values = [example["instance_images"] for example in examples] + + # Concat class and instance examples for prior preservation. + # We do this to avoid doing two forward passes. + if with_prior_preservation: + input_ids += [example["class_prompt_ids"] for example in examples] + pixel_values += [example["class_images"] for example in examples] + + pixel_values = torch.stack(pixel_values) + pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float() + + input_ids = torch.cat(input_ids, dim=0) + + batch = { + "input_ids": input_ids, + "pixel_values": pixel_values, + } + return batch + + +class PromptDataset(Dataset): + "A simple dataset to prepare the prompts to generate class images on multiple accelerators." + + def __init__(self, prompt, num_samples): + self.prompt = prompt + self.num_samples = num_samples + + def __len__(self): + return self.num_samples + + def __getitem__(self, index): + example = {} + example["prompt"] = self.prompt + example["index"] = index + return example + + +def main(args): + logging_dir = Path(args.output_dir, args.logging_dir) + + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_dir=logging_dir, + ) + if args.report_to == "wandb": + import wandb + + wandb.login(key=args.wandb_key) + wandb.init(project=args.wandb_project_name) + # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate + # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models. + # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate. + if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1: + raise ValueError( + "Gradient accumulation is not supported when training the text encoder in distributed training. " + "Please set gradient_accumulation_steps to 1. This feature will be supported in the future." + ) + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + datasets.utils.logging.set_verbosity_warning() + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + datasets.utils.logging.set_verbosity_error() + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + set_seed(args.seed) + + # Generate class images if prior preservation is enabled. + if args.with_prior_preservation: + class_images_dir = Path(args.class_data_dir) + if not class_images_dir.exists(): + class_images_dir.mkdir(parents=True) + cur_class_images = len(list(class_images_dir.iterdir())) + + if cur_class_images < args.num_class_images: + dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32 + if args.prior_generation_precision == "fp32": + dtype = torch.float32 + elif args.prior_generation_precision == "fp16": + dtype = torch.float16 + elif args.prior_generation_precision == "bf16": + dtype = torch.bfloat16 + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + dtype=dtype, + safety_checker=None, + revision=args.revision, + ) + pipeline.set_progress_bar_config(disable=True) + + num_new_images = args.num_class_images - cur_class_images + logger.info(f"Number of class images to sample: {num_new_images}.") + + sample_dataset = PromptDataset(args.class_prompt, num_new_images) + sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size) + + sample_dataloader = accelerator.prepare(sample_dataloader) + pipeline.to(accelerator.device) + + for example in tqdm( + sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process + ): + images = pipeline(example["prompt"]).images + + for i, image in enumerate(images): + hash_image = hashlib.sha1(image.tobytes()).hexdigest() + image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg" + image.save(image_filename) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + # Handle the repository creation + if accelerator.is_main_process: + if args.push_to_hub: + api = HfApi(token=args.hub_token) + + # Create repo (repo_name from args or inferred) + repo_name = args.hub_model_id + if repo_name is None: + repo_name = Path(args.output_dir).absolute().name + repo_id = api.create_repo(repo_name, exist_ok=True).repo_id + + with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore: + if "step_*" not in gitignore: + gitignore.write("step_*\n") + if "epoch_*" not in gitignore: + gitignore.write("epoch_*\n") + elif args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + # Load the tokenizer + if args.tokenizer_name: + tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False) + elif args.pretrained_model_name_or_path: + tokenizer = AutoTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.revision, + use_fast=False, + ) + + # import correct text encoder class + text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision) + + # Load scheduler and models + noise_scheduler = DDPMScheduler( + beta_start=0.00085, + beta_end=0.012, + beta_schedule="scaled_linear", + num_train_timesteps=1000, + ) # DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler") + text_encoder = text_encoder_cls.from_pretrained( + args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision + ) + vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision) + unet = UNet2DConditionModel.from_pretrained( + args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision + ) + + if args.use_lora: + config = LoraConfig( + r=args.lora_r, + lora_alpha=args.lora_alpha, + target_modules=UNET_TARGET_MODULES, + lora_dropout=args.lora_dropout, + bias=args.lora_bias, + ) + unet = get_peft_model(unet, config) + unet.print_trainable_parameters() + print(unet) + + vae.requires_grad_(False) + if not args.train_text_encoder: + text_encoder.requires_grad_(False) + elif args.train_text_encoder and args.use_lora: + config = LoraConfig( + r=args.lora_text_encoder_r, + lora_alpha=args.lora_text_encoder_alpha, + target_modules=TEXT_ENCODER_TARGET_MODULES, + lora_dropout=args.lora_text_encoder_dropout, + bias=args.lora_text_encoder_bias, + ) + text_encoder = get_peft_model(text_encoder, config) + text_encoder.print_trainable_parameters() + print(text_encoder) + + if args.enable_xformers_memory_efficient_attention: + if accelerator.device.type == "xpu": + logger.warning("XPU hasn't support xformers yet, ignore it.") + elif is_xformers_available(): + unet.enable_xformers_memory_efficient_attention() + else: + raise ValueError("xformers is not available. Make sure it is installed correctly") + + if args.gradient_checkpointing: + unet.enable_gradient_checkpointing() + # below fails when using lora so commenting it out + if args.train_text_encoder and not args.use_lora: + text_encoder.gradient_checkpointing_enable() + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.allow_tf32 and torch.cuda.is_available(): + torch.backends.cuda.matmul.allow_tf32 = True + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes + ) + + # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB accelerators + if args.use_8bit_adam: + try: + import bitsandbytes as bnb + except ImportError: + raise ImportError( + "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`." + ) + + optimizer_class = bnb.optim.AdamW8bit + else: + optimizer_class = torch.optim.AdamW + + # Optimizer creation + params_to_optimize = ( + itertools.chain(unet.parameters(), text_encoder.parameters()) if args.train_text_encoder else unet.parameters() + ) + optimizer = optimizer_class( + params_to_optimize, + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + # Dataset and DataLoaders creation: + train_dataset = DreamBoothDataset( + instance_data_root=args.instance_data_dir, + instance_prompt=args.instance_prompt, + class_data_root=args.class_data_dir if args.with_prior_preservation else None, + class_prompt=args.class_prompt, + tokenizer=tokenizer, + size=args.resolution, + center_crop=args.center_crop, + ) + + train_dataloader = torch.utils.data.DataLoader( + train_dataset, + batch_size=args.train_batch_size, + shuffle=True, + collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation), + num_workers=args.num_dataloader_workers, + ) + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, + num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, + num_cycles=args.lr_num_cycles, + power=args.lr_power, + ) + + # Prepare everything with our `accelerator`. + if args.train_text_encoder: + unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, text_encoder, optimizer, train_dataloader, lr_scheduler + ) + else: + unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, optimizer, train_dataloader, lr_scheduler + ) + + # For mixed precision training we cast the text_encoder and vae weights to half-precision + # as these models are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + # Move vae and text_encoder to device and cast to weight_dtype + vae.to(accelerator.device, dtype=weight_dtype) + if not args.train_text_encoder: + text_encoder.to(accelerator.device, dtype=weight_dtype) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + accelerator.init_trackers("dreambooth", config=vars(args)) + + # Train! + total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + + logger.info("***** Running training *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num batches each epoch = {len(train_dataloader)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {args.max_train_steps}") + global_step = 0 + first_epoch = 0 + + # Potentially load in the weights and states from a previous save + if args.resume_from_checkpoint: + if args.resume_from_checkpoint != "latest": + path = os.path.basename(args.resume_from_checkpoint) + else: + # Get the mos recent checkpoint + dirs = os.listdir(args.output_dir) + dirs = [d for d in dirs if d.startswith("checkpoint")] + dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) + path = dirs[-1] + accelerator.print(f"Resuming from checkpoint {path}") + accelerator.load_state(os.path.join(args.output_dir, path)) + global_step = int(path.split("-")[1]) + + resume_global_step = global_step * args.gradient_accumulation_steps + first_epoch = resume_global_step // num_update_steps_per_epoch + resume_step = resume_global_step % num_update_steps_per_epoch + + # Only show the progress bar once on each machine. + progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process) + progress_bar.set_description("Steps") + + for epoch in range(first_epoch, args.num_train_epochs): + unet.train() + if args.train_text_encoder: + text_encoder.train() + with TorchTracemalloc() if not args.no_tracemalloc else nullcontext() as tracemalloc: + for step, batch in enumerate(train_dataloader): + # Skip steps until we reach the resumed step + if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step: + if step % args.gradient_accumulation_steps == 0: + progress_bar.update(1) + if args.report_to == "wandb": + accelerator.print(progress_bar) + continue + + with accelerator.accumulate(unet): + # Convert images to latent space + latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample() + latents = latents * 0.18215 + + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + bsz = latents.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint( + 0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device + ) + timesteps = timesteps.long() + + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + # Get the text embedding for conditioning + encoder_hidden_states = text_encoder(batch["input_ids"])[0] + + # Predict the noise residual + model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample + + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + if args.with_prior_preservation: + # Chunk the noise and model_pred into two parts and compute the loss on each part separately. + model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0) + target, target_prior = torch.chunk(target, 2, dim=0) + + # Compute instance loss + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + # Compute prior loss + prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean") + + # Add the prior loss to the instance loss. + loss = loss + args.prior_loss_weight * prior_loss + else: + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + accelerator.backward(loss) + if accelerator.sync_gradients: + params_to_clip = ( + itertools.chain(unet.parameters(), text_encoder.parameters()) + if args.train_text_encoder + else unet.parameters() + ) + accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm) + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + if args.report_to == "wandb": + accelerator.print(progress_bar) + global_step += 1 + + # if global_step % args.checkpointing_steps == 0: + # if accelerator.is_main_process: + # save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}") + # accelerator.save_state(save_path) + # logger.info(f"Saved state to {save_path}") + + logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + accelerator.log(logs, step=global_step) + + if ( + args.validation_prompt is not None + and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0 + ): + logger.info( + f"Running validation... \n Generating {args.num_validation_images} images with prompt:" + f" {args.validation_prompt}." + ) + # create pipeline + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + safety_checker=None, + revision=args.revision, + ) + # set `keep_fp32_wrapper` to True because we do not want to remove + # mixed precision hooks while we are still training + pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True) + pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True) + pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config) + pipeline = pipeline.to(accelerator.device) + pipeline.set_progress_bar_config(disable=True) + + # run inference + if args.seed is not None: + generator = torch.Generator(device=accelerator.device).manual_seed(args.seed) + else: + generator = None + images = [] + for _ in range(args.num_validation_images): + image = pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0] + images.append(image) + + for tracker in accelerator.trackers: + if tracker.name == "tensorboard": + np_images = np.stack([np.asarray(img) for img in images]) + tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC") + if tracker.name == "wandb": + import wandb + + tracker.log( + { + "validation": [ + wandb.Image(image, caption=f"{i}: {args.validation_prompt}") + for i, image in enumerate(images) + ] + } + ) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + if global_step >= args.max_train_steps: + break + + # Printing the accelerator memory usage details such as allocated memory, peak memory, and total memory usage + if not args.no_tracemalloc: + accelerator.print( + f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}" + ) + + accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}") + accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}") + accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}") + accelerator.print( + f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}" + ) + + # Create the pipeline using using the trained modules and save it. + accelerator.wait_for_everyone() + if accelerator.is_main_process: + if args.use_lora: + unwarpped_unet = accelerator.unwrap_model(unet) + unwarpped_unet.save_pretrained( + os.path.join(args.output_dir, "unet"), state_dict=accelerator.get_state_dict(unet) + ) + if args.train_text_encoder: + unwarpped_text_encoder = accelerator.unwrap_model(text_encoder) + unwarpped_text_encoder.save_pretrained( + os.path.join(args.output_dir, "text_encoder"), + state_dict=accelerator.get_state_dict(text_encoder), + ) + else: + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + unet=accelerator.unwrap_model(unet), + text_encoder=accelerator.unwrap_model(text_encoder), + revision=args.revision, + ) + pipeline.save_pretrained(args.output_dir) + + if args.push_to_hub: + api.upload_folder( + repo_id=repo_id, + folder_path=args.output_dir, + commit_message="End of training", + run_as_future=True, + ) + + accelerator.end_training() + + +if __name__ == "__main__": + args = parse_args() + main(args) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/Dockerfile b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..013964358109829537d53e85cdce086bcc66a9fe --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/Dockerfile @@ -0,0 +1,8 @@ +FROM nvcr.io/nvidia/pytorch:26.01-py3 + +WORKDIR /workspace/lora_finetuning + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY lora_finetuning_te.py . diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b58595c3d3bbc8fe3ab6bcfe5ba4b69f61345d8e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/README.md @@ -0,0 +1,119 @@ +# Transformer Engine ESM2 LoRA Fine-Tuning + +This example demonstrates LoRA fine-tuning for Transformer Engine ESM2 token classification. + +## Setup + +Choose one of the two options below. + +### Option A: Docker (recommended) + +Build a self-contained image based on the publicly available NVIDIA PyTorch container +(`nvcr.io/nvidia/pytorch:26.01-py3`), which already ships CUDA, cuDNN, and Transformer Engine: + +```bash +docker build -t lora-te examples/lora_finetuning_transformer_engine +``` + +Run the training inside the container: + +```bash +docker run --gpus all --rm lora-te \ + python lora_finetuning_te.py \ + --base_model nvidia/esm2_t6_8M_UR50D \ + --output_dir ./esm2_lora_output \ + --num_train_samples 256 \ + --num_eval_samples 64 \ + --num_epochs 1 +``` + +Or start an interactive session to experiment: + +```bash +docker run --gpus all --rm -it lora-te bash +``` + +### Option B: Virtual environment + +Create and activate a virtual environment, then install the Python dependencies: + +```bash +python -m venv .venv +source .venv/bin/activate +pip install -r examples/lora_finetuning_transformer_engine/requirements.txt +``` + +**Transformer Engine** must be installed separately and must match the system CUDA toolkit version. +See the [TE installation guide](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/installation.html) +for details. + +## What this example does + +- Loads a Transformer Engine ESM2 model for token classification +- Applies LoRA adapters via PEFT +- Generates random protein-like sequences +- Assigns randomly generated secondary structure labels (`H`, `E`, `C`) +- Trains/evaluates with `Trainer` + +## Run + +```bash +python examples/lora_finetuning_transformer_engine/lora_finetuning_te.py \ + --base_model nvidia/esm2_t6_8M_UR50D \ + --output_dir ./esm2_lora_output \ + --num_train_samples 256 \ + --num_eval_samples 64 \ + --num_epochs 1 +``` + +> **Note:** The default ESM2 models on Hugging Face Hub ship custom modeling code. +> You must pass `--trust_remote_code` to allow loading that code. + +## Customize + +```bash +python examples/lora_finetuning_transformer_engine/lora_finetuning_te.py \ + --base_model nvidia/esm2_t6_8M_UR50D \ + --trust_remote_code \ + --output_dir ./esm2_lora_output \ + --max_length 256 \ + --batch_size 4 \ + --learning_rate 3e-4 \ + --lora_r 16 \ + --lora_alpha 32 \ + --lora_dropout 0.1 +``` + +## Dataset + +By default the script generates a **synthetic dataset** at runtime — random protein-like sequences +with randomly generated secondary structure labels (`H`, `E`, `C`). This is useful for quick sanity checks and testing. + +For a more realistic evaluation, you can use the **Porter6** secondary-structure dataset. +A download-and-convert script is available in the BioNeMo repository: + +[prepare_porter6_dataset.py](https://github.com/NVIDIA/bionemo-framework/blob/bd72d882bca458d9438e05661c41163949713d1f/bionemo-recipes/recipes/esm2_peft_te/data/prepare_porter6_dataset.py) + +Run it to produce train and validation parquet files, then pass them to the training script +with `--train_parquet` and `--val_parquet`: + +```bash +python examples/lora_finetuning_transformer_engine/lora_finetuning_te.py \ + --base_model nvidia/esm2_t6_8M_UR50D \ + --train_parquet porter6_train_dataset_55k.parquet \ + --val_parquet porter6_val_dataset_2024_692.parquet \ + --output_dir ./esm2_lora_output \ + --num_epochs 3 +``` + +## Outputs + +After training, the script saves: + +- PEFT adapter weights/config in `--output_dir` +- Tokenizer files in `--output_dir` + +## More examples + +For additional examples of TransformerEngine-accelerated transformers, visit +`https://github.com/NVIDIA/bionemo-framework/bionemo-recipes`. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/lora_finetuning_te.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/lora_finetuning_te.py new file mode 100644 index 0000000000000000000000000000000000000000..dc952a4f8c9d703f35116768c3c4e91e76b0f058 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/lora_finetuning_te.py @@ -0,0 +1,329 @@ +""" +Transformer Engine ESM2 LoRA fine-tuning example using Hugging Face Trainer. + +This script demonstrates: +1. Loading a Transformer Engine-based ESM2 token classification model +2. Applying LoRA adapters with PEFT +3. Building a synthetic protein token-classification dataset in code +4. Training with the Hugging Face Trainer (no DDP setup required) +""" + +import os + + +# TE-backed models are incompatible with Trainer's DataParallel wrapping. +# Pin to a single GPU before torch is imported so torch.cuda.device_count() == 1. +os.environ.setdefault("CUDA_VISIBLE_DEVICES", "0") + +import argparse +import random + +import numpy as np +import pandas as pd +import torch +from datasets import Dataset +from transformers import ( + AutoConfig, + AutoModelForTokenClassification, + AutoTokenizer, + DataCollatorForTokenClassification, + Trainer, + TrainingArguments, +) + +from peft import LoraConfig, TaskType, get_peft_model + + +SS3_ID2LABEL = {0: "H", 1: "E", 2: "C"} +SS3_LABEL2ID = {label: idx for idx, label in SS3_ID2LABEL.items()} + +AMINO_ACIDS = "ACDEFGHIKLMNPQRSTVWY" +HELIX_AA = set("AELMQKRH") +BETA_AA = set("VIFYWT") + + +def parse_args(): + """Parse command-line arguments.""" + parser = argparse.ArgumentParser(description="Transformer Engine ESM2 LoRA fine-tuning with Hugging Face Trainer") + + parser.add_argument( + "--base_model", + type=str, + default="nvidia/esm2_t6_8M_UR50D", + help="Transformer Engine ESM2 model name or path", + ) + parser.add_argument("--output_dir", type=str, default="./esm2_lora_output", help="Output directory") + parser.add_argument("--max_length", type=int, default=128, help="Maximum sequence length") + parser.add_argument("--num_train_samples", type=int, default=256, help="Number of synthetic training samples") + parser.add_argument("--num_eval_samples", type=int, default=64, help="Number of synthetic evaluation samples") + parser.add_argument("--min_seq_len", type=int, default=32, help="Minimum sequence length") + parser.add_argument("--max_seq_len", type=int, default=96, help="Maximum sequence length") + parser.add_argument("--batch_size", type=int, default=8, help="Per-device batch size") + parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs") + parser.add_argument("--learning_rate", type=float, default=5e-4, help="Learning rate") + parser.add_argument("--weight_decay", type=float, default=0.01, help="Weight decay") + parser.add_argument("--logging_steps", type=int, default=10, help="Logging frequency (steps)") + parser.add_argument("--eval_steps", type=int, default=25, help="Evaluation frequency (steps)") + parser.add_argument("--save_steps", type=int, default=25, help="Save frequency (steps)") + parser.add_argument("--seed", type=int, default=42, help="Random seed") + parser.add_argument("--lora_r", type=int, default=8, help="LoRA rank") + parser.add_argument("--lora_alpha", type=int, default=16, help="LoRA alpha") + parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout") + parser.add_argument( + "--trust_remote_code", + action="store_true", + default=False, + help="Allow loading model code from the Hub. Required for models like nvidia/esm2_*.", + ) + parser.add_argument( + "--train_parquet", + type=str, + default=None, + help="Path to a training parquet file with Sequence and Secondary_structure columns. " + "When provided, the synthetic dataset is not generated.", + ) + parser.add_argument( + "--val_parquet", + type=str, + default=None, + help="Path to a validation parquet file with the same schema as --train_parquet.", + ) + + args = parser.parse_args() + + if bool(args.train_parquet) != bool(args.val_parquet): + parser.error("--train_parquet and --val_parquet must both be provided or both omitted.") + + return args + + +def set_seed(seed: int): + """Set random seeds for reproducibility.""" + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + if torch.cuda.is_available(): + torch.cuda.manual_seed_all(seed) + + +def build_synthetic_sequences(num_samples: int, min_len: int, max_len: int): + """Generate random amino-acid sequences.""" + sequences = [] + for _ in range(num_samples): + length = random.randint(min_len, max_len) + sequences.append("".join(random.choices(AMINO_ACIDS, k=length))) + return sequences + + +def ss_char_to_label(char: str) -> int: + """Map a single secondary structure character to a label id (H/E/C).""" + return SS3_LABEL2ID.get(char, SS3_LABEL2ID["C"]) + + +def tokenize_and_align_labels(sequences, label_strings, tokenizer, max_length: int): + """Tokenize protein sequences and align per-residue label strings to token positions.""" + batch_input_ids = [] + batch_attention_mask = [] + batch_labels = [] + + for sequence, label_str in zip(sequences, label_strings): + encoded = tokenizer( + sequence, + truncation=True, + max_length=max_length, + add_special_tokens=True, + ) + input_ids = encoded["input_ids"] + attention_mask = encoded["attention_mask"] + + labels = [-100] * len(input_ids) + usable_len = min(len(sequence), len(label_str), len(input_ids) - 2) + for idx in range(usable_len): + labels[idx + 1] = ss_char_to_label(label_str[idx]) + + batch_input_ids.append(input_ids) + batch_attention_mask.append(attention_mask) + batch_labels.append(labels) + + return { + "input_ids": batch_input_ids, + "attention_mask": batch_attention_mask, + "labels": batch_labels, + } + + +def load_parquet_dataset(train_path: str, val_path: str, tokenizer, max_length: int): + """Load train/val parquet files and return tokenized Datasets.""" + train_df = pd.read_parquet(train_path) + val_df = pd.read_parquet(val_path) + + train_dataset = Dataset.from_pandas(train_df).map( + lambda ex: tokenize_and_align_labels(ex["Sequence"], ex["Secondary_structure"], tokenizer, max_length), + batched=True, + remove_columns=train_df.columns.tolist(), + ) + val_dataset = Dataset.from_pandas(val_df).map( + lambda ex: tokenize_and_align_labels(ex["Sequence"], ex["Secondary_structure"], tokenizer, max_length), + batched=True, + remove_columns=val_df.columns.tolist(), + ) + return train_dataset, val_dataset + + +def compute_metrics(eval_pred): + """Compute token accuracy while ignoring -100 labels.""" + logits, labels = eval_pred + predictions = np.argmax(logits, axis=-1) + mask = labels != -100 + correct = (predictions == labels) & mask + total_tokens = mask.sum() + accuracy = float(correct.sum() / total_tokens) if total_tokens > 0 else 0.0 + return {"token_accuracy": accuracy} + + +def residue_to_ss_char(aa: str) -> str: + """Map an amino acid to a synthetic secondary structure character (H/E/C).""" + if aa in HELIX_AA: + return "H" + if aa in BETA_AA: + return "E" + return "C" + + +def sequence_to_synthetic_labels(sequence: str) -> str: + """Derive a synthetic per-residue label string from an amino acid sequence.""" + return "".join(residue_to_ss_char(aa) for aa in sequence) + + +def make_synthetic_dataset( + tokenizer, + num_train_samples: int, + num_eval_samples: int, + min_seq_len: int, + max_seq_len: int, + max_length: int, +): + """Create a synthetic train/eval dataset for token classification.""" + train_sequences = build_synthetic_sequences(num_train_samples, min_seq_len, max_seq_len) + eval_sequences = build_synthetic_sequences(num_eval_samples, min_seq_len, max_seq_len) + + train_labels = [sequence_to_synthetic_labels(s) for s in train_sequences] + eval_labels = [sequence_to_synthetic_labels(s) for s in eval_sequences] + + train_dataset = Dataset.from_dict({"sequence": train_sequences, "labels_str": train_labels}).map( + lambda ex: tokenize_and_align_labels(ex["sequence"], ex["labels_str"], tokenizer, max_length), + batched=True, + remove_columns=["sequence", "labels_str"], + ) + eval_dataset = Dataset.from_dict({"sequence": eval_sequences, "labels_str": eval_labels}).map( + lambda ex: tokenize_and_align_labels(ex["sequence"], ex["labels_str"], tokenizer, max_length), + batched=True, + remove_columns=["sequence", "labels_str"], + ) + return train_dataset, eval_dataset + + +def main(): + args = parse_args() + set_seed(args.seed) + + if not args.trust_remote_code and "esm2" in args.base_model.lower(): + raise ValueError( + f"Model '{args.base_model}' requires remote code execution. " + "Re-run with --trust_remote_code to confirm you trust this model's code." + ) + + os.makedirs(args.output_dir, exist_ok=True) + use_bf16 = torch.cuda.is_available() and torch.cuda.is_bf16_supported() + model_dtype = torch.bfloat16 if use_bf16 else torch.float32 + + print(f"Loading tokenizer and model from: {args.base_model}") + tokenizer = AutoTokenizer.from_pretrained(args.base_model, trust_remote_code=args.trust_remote_code) + + config = AutoConfig.from_pretrained(args.base_model, trust_remote_code=args.trust_remote_code) + config.num_labels = 3 + config.id2label = SS3_ID2LABEL + config.label2id = SS3_LABEL2ID + + model = AutoModelForTokenClassification.from_pretrained( + args.base_model, + config=config, + trust_remote_code=args.trust_remote_code, + dtype=model_dtype, + ) + + lora_config = LoraConfig( + task_type=TaskType.TOKEN_CLS, + r=args.lora_r, + lora_alpha=args.lora_alpha, + lora_dropout=args.lora_dropout, + target_modules=["layernorm_qkv"], + bias="none", + inference_mode=False, + ) + model = get_peft_model(model, lora_config) + model.print_trainable_parameters() + + if args.train_parquet and args.val_parquet: + print(f"Loading parquet datasets: train={args.train_parquet}, val={args.val_parquet}") + train_dataset, eval_dataset = load_parquet_dataset( + train_path=args.train_parquet, + val_path=args.val_parquet, + tokenizer=tokenizer, + max_length=args.max_length, + ) + else: + print("Building synthetic dataset...") + train_dataset, eval_dataset = make_synthetic_dataset( + tokenizer=tokenizer, + num_train_samples=args.num_train_samples, + num_eval_samples=args.num_eval_samples, + min_seq_len=args.min_seq_len, + max_seq_len=args.max_seq_len, + max_length=args.max_length, + ) + + data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer) + + training_args = TrainingArguments( + output_dir=args.output_dir, + num_train_epochs=args.num_epochs, + per_device_train_batch_size=args.batch_size, + per_device_eval_batch_size=args.batch_size, + learning_rate=args.learning_rate, + weight_decay=args.weight_decay, + logging_steps=args.logging_steps, + eval_steps=args.eval_steps, + save_steps=args.save_steps, + eval_strategy="steps", + save_strategy="steps", + save_total_limit=2, + load_best_model_at_end=True, + metric_for_best_model="token_accuracy", + greater_is_better=True, + report_to="none", + remove_unused_columns=False, + bf16=use_bf16, + seed=args.seed, + ) + + trainer = Trainer( + model=model, + args=training_args, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + data_collator=data_collator, + compute_metrics=compute_metrics, + ) + + trainer.train() + final_metrics = trainer.evaluate() + print(f"Final evaluation metrics: {final_metrics}") + + model.save_pretrained(args.output_dir) + tokenizer.save_pretrained(args.output_dir) + print(f"Saved LoRA adapter and tokenizer to: {args.output_dir}") + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..5beaf1648b090fc9dd2f650e03c268799606014f --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_finetuning_transformer_engine/requirements.txt @@ -0,0 +1,12 @@ +torch +transformers +datasets +peft +accelerate +numpy +pandas +pyarrow +safetensors +# transformer-engine must match the system CUDA toolkit version. +# Install it separately or use the system-provided package. +# See: https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/installation.html diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_ga_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_ga_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..dd422ba11d0e5bdc1441e14feb34a6811c6fd5c6 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_ga_finetuning/README.md @@ -0,0 +1,295 @@ +# LoRA-GA: Low-Rank Adaptation with Gradient Approximation + +## Introduction + +[LoRA-GA](https://huggingface.co/papers/2407.05000) improves upon standard LoRA by using gradient information during initialization instead of random initialization. By performing SVD on estimated gradients, LoRA-GA initializes adapter weights in a direction that aligns with full fine-tuning, achieving 2-4x faster convergence while maintaining the same final performance. The method is orthogonal to existing LoRA variants and can be easily integrated with techniques like DoRA and LoRA+. + +## Quick start + +This example script demonstrates how to fine-tune a language model using LoRA-GA on the WikiText-2 dataset. The script performs gradient estimation on a small number of batches, uses those gradients to initialize LoRA adapters, and then trains the model with the Hugging Face Trainer. + +```python +import torch +from datasets import load_dataset +from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer, TrainingArguments +from torch.utils.data import DataLoader +from peft import LoraConfig, get_peft_model +from peft.tuners.lora import LoraGAConfig, preprocess_loraga + +# Load model and tokenizer +model = AutoModelForCausalLM.from_pretrained("gpt2") +tokenizer = AutoTokenizer.from_pretrained("gpt2") +dataset = load_dataset("wikitext", "wikitext-2-raw-v1") + +# Prepare dataloader for gradient estimation +train_dataloader = DataLoader(dataset["train"], batch_size=2, shuffle=True) + +# Define train_step callback for gradient estimation +def train_step(): + """Run forward and backward passes for gradient estimation.""" + data_iter = iter(train_dataloader) + for _ in range(64): # 64 iterations + batch = next(data_iter) + + outputs = model(**batch) + loss = outputs.loss + loss.backward() + +# Step 1: Create LoRA-GA config +lora_ga_config = LoraGAConfig( + direction="ArB2r", + scale="stable", + stable_gamma=16, +) + +lora_config = LoraConfig( + r=8, + lora_alpha=16, + target_modules=["c_attn"], + init_lora_weights="lora_ga", + lora_ga_config=lora_ga_config, + task_type="CAUSAL_LM", +) + +# Step 2: Preprocess with LoRA-GA to estimate gradients +preprocess_loraga(model, lora_config, train_step) + +# Step 3: Create PEFT model with LoRA-GA initialization +peft_model = get_peft_model(model, lora_config) + +# Step 4: Train normally +trainer = Trainer( + model=peft_model, + train_dataset=dataset["train"], + args=TrainingArguments(output_dir="./output", num_train_epochs=3), +) +trainer.train() + +# Step 5: Save the trained adapter +peft_model.save_pretrained("./output") +``` + +## Saving with Modified Base Weights + +**Important**: LoRA-GA modifies the base model weights during initialization (unlike standard LoRA). This means you need to handle saving carefully if you want to restore the original base weights. + +### Option 1: Save adapter only (default) + +The standard `save_pretrained()` saves the adapter with the modified base weights embedded: + +```python +# This saves the adapter - base weights remain modified +peft_model.save_pretrained("./output") +``` + +### Option 2: Restore original base weights + +If you need to restore the original base weights (e.g., for model merging or sharing), use `path_initial_model_for_weight_conversion`: + +```python +# Save the original model BEFORE LoRA-GA preprocessing +model.save_pretrained("./original_model") + +# ... do preprocessing and training ... + +# Save adapter and convert back to original base weights +peft_model.save_pretrained( + "./output", + path_initial_model_for_weight_conversion="./original_model" +) +``` + +This is useful when: +- You want to merge the adapter with the original base weights later +- You're sharing the adapter and want users to apply it to the unmodified base model +- You need the base model weights in their original state for other purposes + +## Run the finetuning script + +Simply run: + +```bash +python examples/lora_ga_finetuning/lora_ga_finetuning.py \ + --base_model gpt2 \ + --dataset_name wikitext \ + --dataset_config wikitext-2-raw-v1 \ + --output_dir ./lora_ga_output +``` + +### Customize LoRA-GA parameters + +You can customize the direction and scaling strategies: + +```bash +python examples/lora_ga_finetuning/lora_ga_finetuning.py \ + --base_model gpt2 \ + --direction ArB2r \ + --scale stable \ + --stable_gamma 16 \ + --grad_estimate_iters 64 +``` + +### Full example with all parameters + +```bash +python lora_ga_finetuning.py \ + --base_model "gpt2" \ + --dataset_name "wikitext" \ + --dataset_config "wikitext-2-raw-v1" \ + --output_dir "./lora_ga_output" \ + --r 8 \ + --lora_alpha 16 \ + --lora_dropout 0.1 \ + --direction "ArB2r" \ + --scale "stable" \ + --stable_gamma 16 \ + --grad_estimate_iters 64 \ + --grad_estimate_batch_size 2 \ + --num_epochs 3 \ + --batch_size 8 \ + --learning_rate 3e-5 +``` + +## Configuration Options + +### Direction Strategies + +Controls how SVD components are distributed to lora_A and lora_B: + +- `ArBr`: Alternating distribution - A takes odd indices, B takes even indices +- `A2rBr`: A takes second half, B takes first half +- `ArB2r` (default): A takes first half, B takes second half - typically performs best +- `random`: Random selection of singular vectors + +### Scaling Strategies + +Controls initialization magnitude: + +- `stable` (default): Conservative scaling using stable_gamma parameter for stable training +- `weight_svd`: Scales based on SVD of original weights for better alignment +- `gd_scale`: Scales based on gradient descent step size +- `unit`: Unit scaling (no adjustment) + +## Use the model on 🤗 + +You can load and use the model as any other 🤗 models: + +```python +from transformers import AutoModelForCausalLM +from peft import PeftModel + +model = AutoModelForCausalLM.from_pretrained("gpt2") +model = PeftModel.from_pretrained(model, "path/to/lora_ga_output") +``` + +## LoRA-GA vs. LoRA + +Key differences and advantages: + +1. **Faster Convergence**: LoRA-GA achieves 2-4x faster convergence compared to standard LoRA due to gradient-aligned initialization. + +2. **Same Final Performance**: LoRA-GA maintains the same or better final performance as standard LoRA. + +3. **Initialization Overhead**: LoRA-GA requires a gradient estimation phase (typically 1-2 minutes for 64 iterations), but this is quickly amortized during training. + +4. **Orthogonal to Other Methods**: LoRA-GA can be combined with DoRA, LoRA+, quantization, and other LoRA enhancements. + +## API Design + +LoRA-GA follows the same pattern as PiSSA, OLoRA, and CorDA: + +1. **Preprocessing**: Use `preprocess_loraga(model, lora_config, train_step)` to estimate gradients and attach them to model layers +2. **Configuration**: Use `LoraGAConfig` as a sub-config within `LoraConfig` with `init_lora_weights="lora_ga"` +3. **Initialization**: Call `get_peft_model()` after preprocessing to create the PEFT model with LoRA-GA initialization +4. **Training**: Train normally using Hugging Face Trainer or your own training loop +5. **Saving**: Use standard `save_pretrained()` to save the trained adapter + +## Using LoRA-GA with Quantized Models + +LoRA-GA requires full-precision gradients during preprocessing. For quantized models (e.g., BitsAndBytes 4-bit/8-bit), use a two-stage workflow: + +### Step 1: Estimate gradients with full-precision model + +```python +import torch +from transformers import AutoModelForCausalLM, BitsAndBytesConfig +from peft import LoraConfig, get_peft_model +from peft.tuners.lora import LoraGAConfig, preprocess_loraga + +# Load model in full precision for gradient estimation +model = AutoModelForCausalLM.from_pretrained( + "meta-llama/Llama-2-7b-hf", + torch_dtype=torch.bfloat16, + device_map="auto" +) + +# Configure LoRA-GA +lora_config = LoraConfig( + r=8, + target_modules=["q_proj", "v_proj"], + init_lora_weights="lora_ga", + lora_ga_config=LoraGAConfig(direction="ArB2r", scale="stable"), +) + +# Define your train_step (same as before) +def train_step(): + for _ in range(64): + # Your training logic here + outputs = model(**batch) + loss = outputs.loss + loss.backward() + +# Estimate and cache gradients +preprocess_loraga(model, lora_config, train_step, cache_file="loraga_gradients.pt") + +# Clean up full-precision model +del model +torch.cuda.empty_cache() +``` + +### Step 2: Load quantized model and apply LoRA-GA + +```python +# Load model with quantization +quantization_config = BitsAndBytesConfig(load_in_4bit=True) +model = AutoModelForCausalLM.from_pretrained( + "meta-llama/Llama-2-7b-hf", + quantization_config=quantization_config, + device_map="auto" +) + +# Apply LoRA-GA - gradients will be loaded from cache automatically +peft_model = get_peft_model(model, lora_config) + +# Train normally +trainer.train() +``` + +**Key points:** +- Gradient estimation must use a non-quantized model (full precision or bfloat16/float16) +- Cache gradients with `cache_file` parameter to avoid re-computation +- Cached gradients are automatically loaded when applying LoRA to the quantized model +- This workflow allows memory-efficient training with quantized models while benefiting from LoRA-GA's faster convergence + +## Tips + +- **Gradient Estimation**: 64-128 iterations is typically sufficient. More iterations provide more accurate estimation but increase initialization time. + +- **Batch Size**: Use smaller batch sizes (2-4) for gradient estimation to maximize gradient diversity. + +- **Direction and Scale**: The default `direction="ArB2r"` and `scale="stable"` work well in most cases. + +- **User-Defined Callback**: The `train_step` callback gives you full control over the gradient estimation process. You can customize batching, loss functions, and more. + +- **Gradient Accumulation**: Do NOT call `model.zero_grad()` or `optimizer.zero_grad()` inside your `train_step` callback. LoRA-GA relies on PyTorch's natural gradient accumulation across iterations. + +## Citation + +```bibtex +@article{wang2024loraga, + title={LoRA-GA: Low-Rank Adaptation with Gradient Approximation}, + author={Wang, Shaowen and Zhu, Linxi and Ding, Hengyuan and Liu, Jiaqi and Chen, Jiaming and Zhu, Kaikai and Pang, Wei and Zhu, Jun and You, Yang}, + journal={arXiv preprint arXiv:2407.05000}, + year={2024} +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_ga_finetuning/lora_ga_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_ga_finetuning/lora_ga_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..afafb89dfbff4af66da4b900f047e5fea42f115f --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lora_ga_finetuning/lora_ga_finetuning.py @@ -0,0 +1,279 @@ +#!/usr/bin/env python3 +""" +Example script demonstrating LoRA-GA (Low-Rank Adaptation with Gradient Approximation) fine-tuning. + +LoRA-GA improves upon standard LoRA by using gradient information during initialization, +achieving 2-4x faster convergence while maintaining the same final performance. + +This example shows: +1. How to define a train_step callback for gradient estimation +2. How to use preprocess_loraga for LoRA-GA initialization +3. Training with standard Hugging Face Trainer +4. Saving the trained adapter +""" + +import argparse +import os + +import torch +from datasets import load_dataset +from torch.utils.data import DataLoader +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + DataCollatorForLanguageModeling, + Trainer, + TrainingArguments, + default_data_collator, +) + +from peft import LoraConfig, get_peft_model +from peft.tuners.lora import LoraGAConfig, preprocess_loraga + + +def parse_args(): + parser = argparse.ArgumentParser(description="LoRA-GA fine-tuning example") + + # Model arguments + parser.add_argument("--base_model", type=str, default="gpt2", help="Base model name or path") + parser.add_argument("--output_dir", type=str, default="./lora_ga_output", help="Output directory") + + # Dataset arguments + parser.add_argument("--dataset_name", type=str, default="wikitext", help="Dataset name") + parser.add_argument("--dataset_config", type=str, default="wikitext-2-raw-v1", help="Dataset configuration") + parser.add_argument("--max_length", type=int, default=512, help="Maximum sequence length") + + # LoRA-GA configuration + parser.add_argument("--r", type=int, default=8, help="LoRA rank") + parser.add_argument("--lora_alpha", type=int, default=16, help="LoRA alpha") + parser.add_argument("--lora_dropout", type=float, default=0.1, help="LoRA dropout") + parser.add_argument( + "--target_modules", + type=str, + nargs="+", + default=["c_attn"], + help="Target modules for LoRA (e.g., c_attn for GPT-2)", + ) + parser.add_argument( + "--direction", + type=str, + default="ArB2r", + choices=["ArBr", "A2rBr", "ArB2r", "random"], + help="Direction strategy for LoRA-GA initialization", + ) + parser.add_argument( + "--scale", + type=str, + default="stable", + choices=["stable", "weight_svd", "gd_scale", "unit"], + help="Scaling strategy for LoRA-GA initialization", + ) + parser.add_argument("--stable_gamma", type=int, default=16, help="Gamma for stable scaling") + + # Gradient estimation arguments + parser.add_argument( + "--grad_estimate_iters", type=int, default=64, help="Number of iterations for gradient estimation" + ) + parser.add_argument("--grad_estimate_batch_size", type=int, default=2, help="Batch size for gradient estimation") + + # Training arguments + parser.add_argument("--num_epochs", type=int, default=3, help="Number of training epochs") + parser.add_argument("--batch_size", type=int, default=8, help="Training batch size") + parser.add_argument("--learning_rate", type=float, default=3e-5, help="Learning rate") + parser.add_argument("--warmup_steps", type=int, default=100, help="Warmup steps") + parser.add_argument("--logging_steps", type=int, default=10, help="Logging steps") + parser.add_argument("--save_steps", type=int, default=500, help="Save checkpoint steps") + parser.add_argument("--eval_steps", type=int, default=500, help="Evaluation steps") + + # Other arguments + parser.add_argument("--seed", type=int, default=42, help="Random seed") + + return parser.parse_args() + + +def prepare_dataset(dataset_name, dataset_config, tokenizer, max_length): + """Load and prepare the dataset.""" + print(f"\nLoading dataset: {dataset_name}/{dataset_config}") + dataset = load_dataset(dataset_name, dataset_config) + + def tokenize_function(examples): + # For causal language modeling, we tokenize and set labels = input_ids + result = tokenizer( + examples["text"], padding="max_length", truncation=True, max_length=max_length, return_tensors="pt" + ) + result["labels"] = result["input_ids"].clone() + return result + + # Tokenize the dataset + print("Tokenizing dataset...") + tokenized_datasets = dataset.map( + tokenize_function, batched=True, remove_columns=dataset["train"].column_names, desc="Tokenizing" + ) + + return tokenized_datasets + + +def main(): + args = parse_args() + + # Set random seed + torch.manual_seed(args.seed) + + # Create output directory + os.makedirs(args.output_dir, exist_ok=True) + + # Load tokenizer and model + print(f"\nLoading model: {args.base_model}") + tokenizer = AutoTokenizer.from_pretrained(args.base_model) + tokenizer.pad_token = tokenizer.eos_token + + model = AutoModelForCausalLM.from_pretrained(args.base_model) + + # Prepare dataset + tokenized_datasets = prepare_dataset(args.dataset_name, args.dataset_config, tokenizer, args.max_length) + + # Create LoRA-GA configuration + print("\nCreating LoRA-GA configuration...") + lora_ga_config = LoraGAConfig( + direction=args.direction, + scale=args.scale, + stable_gamma=args.stable_gamma, + ) + + lora_config = LoraConfig( + r=args.r, + lora_alpha=args.lora_alpha, + lora_dropout=args.lora_dropout, + target_modules=args.target_modules, + bias="none", + task_type="CAUSAL_LM", + init_lora_weights="lora_ga", + lora_ga_config=lora_ga_config, + ) + print(f" Direction: {args.direction}") + print(f" Scale: {args.scale}") + print(f" Rank: {args.r}, Alpha: {args.lora_alpha}") + + # ===== GRADIENT ESTIMATION PHASE ===== + print("\n" + "=" * 70) + print("GRADIENT ESTIMATION PHASE") + print("=" * 70) + print(f"Estimating gradients over {args.grad_estimate_iters} iterations...") + print("This allows LoRA-GA to initialize adapters aligned with full fine-tuning.") + + # Prepare gradient estimation dataloader + train_dataset = tokenized_datasets["train"] + + # Create a simple DataLoader for gradient estimation + grad_dataloader = DataLoader( + train_dataset, + batch_size=args.grad_estimate_batch_size, + shuffle=True, + collate_fn=default_data_collator, + ) + + # Move model to GPU if available + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + model = model.to(device) + model.train() + + # Define train_step callback + def train_step(): + """Run forward and backward passes for gradient estimation.""" + grad_iter = iter(grad_dataloader) + for _ in range(args.grad_estimate_iters): + batch = next(grad_iter) + + # Move batch to device + batch = {k: v.to(device) for k, v in batch.items()} + + # Forward pass + outputs = model(**batch) + loss = outputs.loss + + # Backward pass + loss.backward() + + # Preprocess with LoRA-GA + print("Running gradient estimation...") + preprocess_loraga(model, lora_config, train_step) + print("✓ Gradient estimation complete!") + + # ===== MODEL INITIALIZATION PHASE ===== + print("\n" + "=" * 70) + print("LORA-GA INITIALIZATION PHASE") + print("=" * 70) + print("Initializing LoRA adapters with gradient information...") + + # Create PEFT model with LoRA-GA initialization + peft_model = get_peft_model(model, lora_config) + + # Print trainable parameters + peft_model.print_trainable_parameters() + + # ===== TRAINING PHASE ===== + print("\n" + "=" * 70) + print("TRAINING PHASE") + print("=" * 70) + print("Starting training with LoRA-GA initialized adapters...") + print("LoRA-GA achieves 2-4x faster convergence compared to random initialization!\n") + + # Setup training arguments + training_args = TrainingArguments( + output_dir=args.output_dir, + num_train_epochs=args.num_epochs, + per_device_train_batch_size=args.batch_size, + per_device_eval_batch_size=args.batch_size, + learning_rate=args.learning_rate, + warmup_steps=args.warmup_steps, + logging_steps=args.logging_steps, + save_steps=args.save_steps, + eval_steps=args.eval_steps, + eval_strategy="steps", + save_total_limit=2, + load_best_model_at_end=True, + report_to="none", + seed=args.seed, + ) + + # Data collator + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + + # Create Trainer + trainer = Trainer( + model=peft_model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["validation"], + data_collator=data_collator, + ) + + # Train the model + trainer.train() + + # ===== SAVING PHASE ===== + print("\n" + "=" * 70) + print("SAVING PHASE") + print("=" * 70) + print("Saving trained adapter...") + + # Save the trained adapter + peft_model.save_pretrained(args.output_dir) + + print(f"\n✓ Training complete! Model saved to: {args.output_dir}") + print("\nSaved files:") + print(" - adapter_model.safetensors: Trained adapter weights") + print(" - adapter_config.json: Configuration file") + + print("\n" + "=" * 70) + print("DONE!") + print("=" * 70) + print("\nYou can now use the trained adapter with:") + print(" from peft import PeftModel") + print(" from transformers import AutoModelForCausalLM") + print(f" model = AutoModelForCausalLM.from_pretrained('{args.base_model}')") + print(f" model = PeftModel.from_pretrained(model, '{args.output_dir}')") + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lorafa_finetune/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lorafa_finetune/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1c1314dbd60e1d98cd68b1aaa32c0613b5ea36b3 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lorafa_finetune/README.md @@ -0,0 +1,121 @@ +# LoRA-FA: Memory-efficient Low-rank Adaptation for Large Language Models Fine-tuning + +## Introduction + +[LoRA-FA](https://huggingface.co/papers/2308.03303) is a noval Parameter-efficient Fine-tuning method, which freezes the projection down layer (matrix A) during LoRA training process and thus lead to less accelerator memory consumption by eliminating the need for storing the activations of input tensors (X). Furthermore, LoRA-FA narrows the gap between the update amount of pre-trained weights when using the low-rank fine-tuning method and the full fine-tuning method. In conclusion, LoRA-FA reduces the memory consumption and leads to superior performance compared to vanilla LoRA. + +## Quick start + +```python +import torch +from peft import LoraConfig, get_peft_model +from peft.optimizers import create_lorafa_optimizer +from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer +from datasets import load_dataset + +model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct") +tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct") +dataset = load_dataset("timdettmers/openassistant-guanaco", split="train") + +lora_rank = 16 +lora_alpha = 32 + +lora_config = LoraConfig( + r=lora_rank, + lora_alpha=lora_alpha, + bias="none", +) +peft_model = get_peft_model(model, lora_config) +optimizer = create_lorafa_optimizer( + model=peft_model, + r=lora_rank, + lora_alpha=lora_alpha, + lr=7e-5, +) +# you can also use scheduler, we recommend get_cosine_schedule_with_warmup from transformers +# for better model performance +scheduler = None + +trainer = transformers.Trainer( + model=peft_model, + train_dataset=dataset, + dataset_text_field="text", + max_length=2048, + processing_class=tokenizer, + optimizers=(optimizer, None), +) +trainer.train() +peft_model.save_pretrained("lorafa-llama-3-8b-inst") +``` + +The only change in your code is to pass the LoRA-FA optimizer to the trainer (if training with trainer). Do not forget `from peft.optimizers import create_lorafa_optimizer`! + +## Example + +In this dir, we also provide you a simple example for fine-tuning with LoRA-FA optimizer. + +### Run on CPU, single-accelerator or multi-accelerator + +This 👇 by default will load the model in peft set up with LoRA config, and train the model with LoRA-FA optimizer. + +0. CPU + +You can simply run LoRA-FA as below: + +```bash +python lorafa_finetuning.py --base_model_name_or_path meta-llama/Meta-Llama-3-8B --dataset_name_or_path meta-math/MetaMathQA-40K --output_dir path/to/output --lorafa +``` + +1. Single-accelerator + +Run the finetuning script on 1 accelerator: + +```bash +export CUDA_VISIBLE_DEVICES=0 # force to use CUDA GPU 0 +export ZE_AFFINITY_MASK=0 # force to use Intel XPU 0 + +python lorafa_finetuning.py --base_model_name_or_path meta-llama/Meta-Llama-3-8B --dataset_name_or_path meta-math/MetaMathQA-40K --output_dir path/to/output --lorafa +``` + +2. Multi-accelerator + +LoRA-FA can also be run on multi-accelerator, with 🤗 Accelerate: + +```bash +export CUDA_VISIBLE_DEVICES=0,1,2,3 # force to use CUDA GPU 0,1,2,3 +export ZE_AFFINITY_MASK=0,1,2,3 # force to use Intel XPU 0,1,2,3 + +accelerate launch lorafa_finetuning.py --base_model_name_or_path meta-llama/Meta-Llama-3-8B --dataset_name_or_path meta-math/MetaMathQA-40K --output_dir path/to/output --lorafa +``` + +The `accelerate launch` will automatically configure multi-accelerator for you. You can also utilize `accelerate launch` in single-accelerator scenario. + +### Use the model from 🤗 +You can load and use the model as any other 🤗 models. +```python +from transformers import AutoModel +model = AutoModel.from_pretrained("meta-llama/Llama-2-7b-chat-hf") +``` + +## Best practice in fine-tuning Llama using LoRA-FA: the hyper-params + +Sometimes, achieving optimal LoRA fine-tuning can be challenging due to the larger number of hyperparameters to consider compared to full fine-tuning. For instance, not only do we need to adjust the commonly used learning rate, but the ideal LoRA rank may also vary depending on the specific model and task. Additionally, there are other factors to consider, such as LoRA alpha and sequence length. To assist with this, we have created a repository of reproducible best practices in the [LoRA-FA examples](https://github.com/AaronZLT/lorafa) for reference. This resource showcases the optimal LoRA-FA fine-tuning hyperparameters for different models across various datasets. By doing so, we significantly reduce the time and effort spent on hyperparameter tuning, and it may also provide insights for tuning other training hyperparameters. We encourage you to experiment and fine-tune on your own downstream tasks as well. + +## LoRA-FA's advantages and limitations + +By eliminating the activation of adapter A, LoRA-FA uses less memory for fine-tuning compared to LoRA. For instance, when fine-tuning Llama-2-7b-chat-hf with a batch size of 8 and a sequence length of 1024, LoRA-FA requires 36GB of memory to store activations. This allows it to run successfully on an 80GB accelerator. In contrast, LoRA requires at least 60GB of memory for activations, leading to an Out of Memory (OOM) error. Additionally, the memory consumption of LoRA-FA is not sensitive to the rank, allowing for performance improvements by increasing the LoRA rank without additional memory usage. LoRA-FA further narrows the performance gap with Full-FT by minimizing the discrepancy between the low-rank gradient and the full gradient, enabling it to achieve performance that is on par with or even superior to vanilla LoRA. + +Despite its advantages, LoRA-FA is inherently limited by its low-rank approximation nature and potential issues with catastrophic forgetting. The gradient approximation can impact training throughput. Addressing these limitations, especially in terms of approximation accuracy and forgetting phenomena, presents a promising direction for future research. + +## Citation +``` +@misc{zhang2023lorafamemoryefficientlowrankadaptation, + title={LoRA-FA: Memory-efficient Low-rank Adaptation for Large Language Models Fine-tuning}, + author={Longteng Zhang and Lin Zhang and Shaohuai Shi and Xiaowen Chu and Bo Li}, + year={2023}, + eprint={2308.03303}, + archivePrefix={arXiv}, + primaryClass={cs.CL}, + url={https://huggingface.co/papers/2308.03303}, +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/lorafa_finetune/lorafa_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lorafa_finetune/lorafa_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..3c96c0c99efa227d660c4eee3eef66c0434e1c4b --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/lorafa_finetune/lorafa_finetuning.py @@ -0,0 +1,221 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from typing import Optional + +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + BitsAndBytesConfig, + DataCollatorForLanguageModeling, + Trainer, + TrainingArguments, +) + +from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training +from peft.optimizers import create_lorafa_optimizer + + +def train_model( + base_model_name_or_path: str, + dataset_name_or_path: str, + output_dir: str, + batch_size: int, + num_epochs: int, + lr: float, + cutoff_len: int, + quantize: bool, + eval_step: int, + save_step: int, + lora_rank: int, + lora_alpha: int, + lora_dropout: float, + lora_target_modules: Optional[str], + lorafa: bool, +): + os.environ["TOKENIZERS_PARALLELISM"] = "false" + + is_bf16_supported = False + device_map = "cpu" + if torch.cuda.is_available(): + is_bf16_supported = torch.cuda.is_bf16_supported() + device_map = "cuda" + elif torch.xpu.is_available(): + is_bf16_supported = torch.xpu.is_bf16_supported() + device_map = "xpu" + compute_dtype = torch.bfloat16 if is_bf16_supported else torch.float16 + + # load tokenizer + tokenizer = AutoTokenizer.from_pretrained(base_model_name_or_path) + + # load model + if quantize: + model = AutoModelForCausalLM.from_pretrained( + base_model_name_or_path, + quantization_config=BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=compute_dtype, + bnb_4bit_use_double_quant=False, + bnb_4bit_quant_type="nf4", + ), + dtype=compute_dtype, + device_map=device_map, + ) + # setup for quantized training + model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True) + else: + model = AutoModelForCausalLM.from_pretrained( + base_model_name_or_path, dtype=compute_dtype, device_map=device_map + ) + + # LoRA config for the PEFT model + if lora_target_modules is not None: + if lora_target_modules == "all-linear": + target_modules = "all-linear" + else: + target_modules = lora_target_modules.split(",") + else: + target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] + + lora_config = LoraConfig( + r=lora_rank, + lora_alpha=lora_alpha, + target_modules=target_modules, + lora_dropout=lora_dropout, + bias="none", + ) + + # get the peft model with LoRA config + model = get_peft_model(model, lora_config) + + tokenizer.pad_token = tokenizer.eos_token + + # Load the dataset + dataset = load_dataset(dataset_name_or_path) + + def tokenize_function(examples): + inputs = tokenizer(examples["query"], padding="max_length", truncation=True, max_length=cutoff_len) + outputs = tokenizer(examples["response"], padding="max_length", truncation=True, max_length=cutoff_len) + inputs["labels"] = outputs["input_ids"].copy() + return inputs + + # Tokenize the dataset and prepare for training + tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names) + dataset = tokenized_datasets["train"].train_test_split(test_size=0.1, shuffle=True, seed=42) + train_dataset = dataset["train"] + eval_dataset = dataset["test"] + + # Data collator to dynamically pad the batched examples + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + + # Define training arguments + training_args = TrainingArguments( + output_dir=output_dir, + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + per_device_eval_batch_size=batch_size, + warmup_steps=100, + weight_decay=0.01, + logging_dir="./logs", + logging_steps=eval_step, + save_steps=save_step, + save_total_limit=2, + gradient_accumulation_steps=1, + bf16=compute_dtype == torch.bfloat16, + fp16=compute_dtype == torch.float16, + learning_rate=lr, + ) + + # Here we initialize the LoRA-FA Optimizer + # After this, all adapter A will be fixed, only adapter B will be trainable + if lorafa: + optimizer = create_lorafa_optimizer( + model=model, r=lora_rank, lora_alpha=lora_alpha, lr=lr, weight_decay=training_args.weight_decay + ) + trainer = Trainer( + model=model, + args=training_args, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + data_collator=data_collator, + optimizers=(optimizer, None), + ) + else: + trainer = Trainer( + model=model, + args=training_args, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + data_collator=data_collator, + ) + + # Start model training + trainer.train() + + # Save the model and tokenizer locally + model.save_pretrained(output_dir) + tokenizer.save_pretrained(output_dir) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Fine-tune Meta-Llama-3-8B-Instruct with LoRA-FA and PEFT") + parser.add_argument( + "--base_model_name_or_path", + type=str, + default="meta-llama/Meta-Llama-3-8B-Instruct", + help="Base model name or path", + ) + parser.add_argument( + "--dataset_name_or_path", type=str, default="meta-math/MetaMathQA-40K", help="Dataset name or path" + ) + parser.add_argument("--output_dir", type=str, help="Output directory for the fine-tuned model") + parser.add_argument("--batch_size", type=int, default=1, help="Batch size") + parser.add_argument("--num_epochs", type=int, default=3, help="Number of training epochs") + parser.add_argument("--lr", type=float, default=7e-5, help="Learning rate") + parser.add_argument("--cutoff_len", type=int, default=1024, help="Cutoff length for tokenization") + parser.add_argument("--quantize", action="store_true", help="Use quantization") + parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval") + parser.add_argument("--save_step", type=int, default=100, help="Save step interval") + parser.add_argument("--lora_rank", type=int, default=16, help="LoRA rank") + parser.add_argument("--lora_alpha", type=int, default=32, help="LoRA alpha") + parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout rate") + parser.add_argument( + "--lora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA" + ) + parser.add_argument("--lorafa", action="store_true", help="Use LoRA-FA Optimizer") + + args = parser.parse_args() + + train_model( + base_model_name_or_path=args.base_model_name_or_path, + dataset_name_or_path=args.dataset_name_or_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + lr=args.lr, + cutoff_len=args.cutoff_len, + quantize=args.quantize, + eval_step=args.eval_step, + save_step=args.save_step, + lora_rank=args.lora_rank, + lora_alpha=args.lora_alpha, + lora_dropout=args.lora_dropout, + lora_target_modules=args.lora_target_modules, + lorafa=args.lorafa, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/miss_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/miss_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..72e149468f1fdfe7d0528c4f54d8a53dac49d9a3 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/miss_finetuning/README.md @@ -0,0 +1,106 @@ +# MiSS: Balancing LoRA Performance and Efficiency with Simple Shard Sharing +## Introduction ([Paper](https://huggingface.co/papers/2409.15371), [code](https://github.com/JL-er/MiSS)) +MiSS (Matrix Shard Sharing) is a novel PEFT method that adopts a low-rank structure, requires only a single trainable matrix, and introduces a new update mechanism distinct from LoRA, achieving an excellent balance between performance and efficiency. + + +## Quick Start +```python +import torch +from peft import MissConfig, get_peft_model +from transformers import AutoTokenizer, AutoModelForCausalLM +from trl import SFTConfig, SFTTrainer +from datasets import load_dataset + +model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf") +tokenizer.pad_token_id = tokenizer.eos_token_id + +miss_config = MissConfig( + r = 64, + miss_dropout = 0.01 +) +#bat: In this mode, you can enable nonlinear updates across different shards. +# miss_config = MissConfig( +# r = 64, +# init_weights="bat" +# ) + +# mini: In this mode, you can set a smaller rank to use fewer trainable parameters, but it is recommended to keep `out_features % mini_r == 0`. +# miss_config = MissConfig( +# r = 64, +# init_weights="mini", +# mini_r = 8 +# ) +peft_model = get_peft_model(model, miss_config) + +peft_model.print_trainable_parameters() + +dataset = load_dataset("imdb", split="train[:1%]") + +training_args = SFTConfig(dataset_text_field="text", max_length=128) +trainer = SFTTrainer( + model=peft_model, + args=training_args, + train_dataset=dataset, + processing_class=tokenizer, +) +trainer.train() +peft_model.save_pretrained("miss-llama-2-7b") +``` + + +To utilize the fine-tuned MiSS modules, simply run the following command: +```python +import torch +from peft import PeftModel +from transformers import AutoModelForCausalLM + +model = AutoModelForCausalLM.from_pretrained( + "meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto" +) +peft_model = PeftModel.from_pretrained(model, "miss-llama-2-7b") +``` + +## Advanced Usage + +### Fine-tune +```shell +#Bat performs better than MiSS, but it uses more memory and is twice as slow. If you want to use the Bat method, you only need to add the parameter init_weights="bat". +python miss_finetuning.py \ + --base_model_name_or_path meta-llama/Llama-2-7b-hf \ + --output_dir output/miss-llama-2-7b-metamath-10k \ + --miss_r 64 \ + --miss_dropout 0.01 \ + --init_weights True \ + --bits bf16 \ + --data_path meta-math/MetaMathQA \ + --dataset_split train[:100000] \ + --dataset_field query response \ + --bf16 True \ + --num_train_epochs 1 \ + --per_device_train_batch_size 2 \ + --gradient_accumulation_steps 8 \ + --save_strategy "steps" \ + --save_steps 1000 \ + --save_total_limit 1 \ + --logging_steps 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_steps 0.03 \ + --tf32 True \ + --report_to none +``` + + + +# Citation +```bib +@misc{kang2025missrevisitingtradeofflora, + title={MiSS: Revisiting the Trade-off in LoRA with an Efficient Shard-Sharing Structure}, + author={Jiale Kang and Qingyu Yin}, + year={2025}, + eprint={2409.15371}, + archivePrefix={arXiv}, + primaryClass={cs.CL}, + url={https://arxiv.org/abs/2409.15371}, +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/miss_finetuning/miss_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/miss_finetuning/miss_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..c3dfe66c6cd3ca1007f1ca048632f0df0831cecb --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/miss_finetuning/miss_finetuning.py @@ -0,0 +1,109 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from dataclasses import dataclass, field +from typing import Literal, Optional + +import torch +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser +from trl import SFTConfig, SFTTrainer + +from peft import MissConfig, get_peft_model + + +@dataclass +class ScriptArguments(SFTConfig): + # model configs + base_model_name_or_path: Optional[str] = field( + default=None, metadata={"help": "The name or path of the fp32/16 base model."} + ) + bits: str = field(default="bf16", metadata={"help": "(`['bf16', 'fp16', fp32]`)"}) + init_weights: Literal[True, "bat"] = field( + default=True, + metadata={ + "help": ( + "True -> MiSS efficience and balance; `bat` -> Bat, `mini` -> smaller MiSS efficience and balance" + ), + }, + ) + miss_r: int = field(default=16) + miss_dropout: float = field(default=0.0) + merge_and_save: bool = field(default=False) + # dataset configs + data_path: str = field(default="imdb", metadata={"help": "Path to the training data."}) + dataset_split: str = field(default="train[:1%]", metadata={"help": "(`['train', 'test', 'eval']`):"}) + dataset_field: list[str] = field(default=None, metadata={"help": "Fields of dataset input and output."}) + + +parser = HfArgumentParser(ScriptArguments) +script_args = parser.parse_args_into_dataclasses()[0] +print(script_args) + +print(f"Load pre-processed residual model in {script_args.bits} bits.") +if script_args.bits in ["nf4", "fp4", "int8"]: + print("MiSS currently does not support quantization.") + +elif script_args.base_model_name_or_path is not None: + print(f"No available pre-processed model, manually initialize a MiSS using {script_args.base_model_name_or_path}.") + model = AutoModelForCausalLM.from_pretrained( + script_args.base_model_name_or_path, + dtype=( + torch.float16 + if script_args.bits == "fp16" + else (torch.bfloat16 if script_args.bits == "bf16" else torch.float32) + ), + device_map="auto", + ) + tokenizer = AutoTokenizer.from_pretrained(script_args.base_model_name_or_path) + tokenizer.pad_token_id = tokenizer.eos_token_id + miss_config = MissConfig( + r=script_args.miss_r, + miss_dropout=script_args.miss_dropout, + target_modules=["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"], + bias="none", + task_type="CAUSAL_LM", + init_weights=script_args.init_weights, + ) + peft_model = get_peft_model(model, miss_config) + +print(peft_model) +peft_model.print_trainable_parameters() + +print(f"Training MiSS with trl on the {script_args.data_path}[{script_args.dataset_split}] dataset.") +dataset = load_dataset(script_args.data_path, split=script_args.dataset_split) +dataset = dataset.map( + lambda example: { + "text": f"### USER: {example[script_args.dataset_field[0]]}\n### ASSISTANT: {example[script_args.dataset_field[1]]}" + } +) + +trainer = SFTTrainer( + model=peft_model, + args=script_args, + train_dataset=dataset, + processing_class=tokenizer, +) +trainer.train() +trainer.save_state() + +peft_model.save_pretrained( + os.path.join(script_args.output_dir, "miss_ft"), +) + +if script_args.merge_and_save: + model = peft_model.merge_and_unload() + model.save_pretrained(os.path.join(script_args.output_dir, "miss_merged")) + tokenizer.save_pretrained(os.path.join(script_args.output_dir, "miss_merged")) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/monteclora_finetuning/sequence_classification_finetune_monteclora.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/monteclora_finetuning/sequence_classification_finetune_monteclora.py new file mode 100644 index 0000000000000000000000000000000000000000..c43d37cf23a1c1cb969695303d90736203802195 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/monteclora_finetuning/sequence_classification_finetune_monteclora.py @@ -0,0 +1,203 @@ +import argparse +import os + +import evaluate +import numpy as np +from datasets import load_dataset +from transformers import ( + AutoModelForSequenceClassification, + AutoTokenizer, + DataCollatorWithPadding, + Trainer, + TrainingArguments, +) + +# Assuming MonteCLoRA is available in your local installed PEFT version +from peft import LoraConfig, MontecloraConfig, TaskType, get_peft_model +from peft.helpers import MontecloraTrainerMixin as MonteCLoRATrainerMixin +from peft.utils import infer_device + + +# ---------------------------------------------------------------------------- +# 1. Trainer Definition +# ---------------------------------------------------------------------------- +# Reuse the helper mixin so variational loss handling stays centralized. +class MonteCLoRATrainer(MonteCLoRATrainerMixin, Trainer): + pass + + +# ---------------------------------------------------------------------------- +# 2. Metrics Helper +# ---------------------------------------------------------------------------- +# GLUE/MRPC uses Accuracy and F1 score +metric = evaluate.load("glue", "mrpc") + + +def compute_metrics(eval_pred): + predictions, labels = eval_pred + predictions = np.argmax(predictions, axis=1) + return metric.compute(predictions=predictions, references=labels) + + +# ---------------------------------------------------------------------------- +# 3. Main Training Function +# ---------------------------------------------------------------------------- +def train_model( + base_model: str, + output_dir: str, + batch_size: int, + num_epochs: int, + learning_rate: float, + max_length: int, + device: str, + rank: int, + lora_alpha: int, + target_modules: str, + n_samples: int, + push_to_hub: bool, + hub_model_id: str, +): + hf_token = os.getenv("HF_TOKEN") or None + + # --- Device Setup --- + device = infer_device() + print(f"Using device: {device}") + + # --- Load Tokenizer --- + tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token) + + # --- Load Dataset (GLUE MRPC) --- + # MRPC is a classification task (Is sentence B a paraphrase of sentence A?) + dataset = load_dataset("glue", "mrpc") + + def tokenize_function(examples): + return tokenizer( + examples["sentence1"], examples["sentence2"], padding="max_length", truncation=True, max_length=max_length + ) + + tokenized_datasets = dataset.map(tokenize_function, batched=True) + + # Remove raw text columns to avoid Trainer warnings + tokenized_datasets = tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"]) + tokenized_datasets = tokenized_datasets.rename_column("label", "labels") + tokenized_datasets.set_format("torch") + + # --- Load Base Model --- + # num_labels=2 because MRPC is binary classification + model = AutoModelForSequenceClassification.from_pretrained(base_model, num_labels=2, token=hf_token) + + # --- PEFT Configuration (MonteCLoRA) --- + # Note: Using n_samples to control Monte Carlo iterations + monte_clora_config = MontecloraConfig(num_samples=n_samples) + peft_config = LoraConfig( + task_type=TaskType.SEQ_CLS, + inference_mode=False, + r=rank, + lora_alpha=lora_alpha, + target_modules=target_modules.split(",") if target_modules else ["query", "value"], + bias="none", + monteclora_config=monte_clora_config, + ) + + # {'loss': 0.6984, 'grad_norm': 1.1652556657791138, 'learning_rate': 0.00019843478260869567, 'epoch': 0.04} + # {'loss': 0.6794, 'grad_norm': 1.619783878326416, 'learning_rate': 0.00019669565217391306, 'epoch': 0.09} + # {'loss': 0.7077, 'grad_norm': 0.7201359272003174, 'learning_rate': 0.00019495652173913045, 'epoch': 0.13} + # {'loss': 0.6822, 'grad_norm': 2.9292023181915283, 'learning_rate': 0.00019321739130434784, 'epoch': 0.17} + # {'loss': 0.6673, 'grad_norm': 0.6151084899902344, 'learning_rate': 0.0001914782608695652, 'epoch': 0.22} + # {'loss': 0.6674, 'grad_norm': 0.7056446671485901, 'learning_rate': 0.00018973913043478262, 'epoch': 0.26} + # Wrap model with PEFT + model = get_peft_model(model, peft_config) + model.print_trainable_parameters() + print(model) + model.to(device) + + # --- Training Setup --- + data_collator = DataCollatorWithPadding(tokenizer=tokenizer) + + training_args = TrainingArguments( + output_dir=output_dir, + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + per_device_eval_batch_size=batch_size, + learning_rate=learning_rate, + weight_decay=0.01, + eval_strategy="epoch", # Evaluate at end of every epoch + save_strategy="epoch", + load_best_model_at_end=True, + metric_for_best_model="f1", # Optimize for F1 score + logging_steps=10, + push_to_hub=push_to_hub, + hub_model_id=hub_model_id, + hub_token=hf_token, + remove_unused_columns=False, # Important for PEFT sometimes + ) + + # Trainer mixes in MonteCLoRA variational regularization support. + trainer = MonteCLoRATrainer( + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["validation"], # MRPC standard validation split + tokenizer=tokenizer, + data_collator=data_collator, + compute_metrics=compute_metrics, + ) + + print("Starting Training...") + trainer.train() + + # --- Evaluation --- + print("Evaluating...") + eval_results = trainer.evaluate() + print(f"Evaluation Results: {eval_results}") + + # --- Save & Push --- + if push_to_hub: + trainer.push_to_hub() + + trainer.save_model(output_dir) + print(f"Model saved to {output_dir}") + + +# ---------------------------------------------------------------------------- +# 4. Entry Point +# ---------------------------------------------------------------------------- +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Fine-tune RoBERTa on MRPC with MonteCLoRA") + + parser.add_argument("--base_model", type=str, default="roberta-base", help="Base model name") + parser.add_argument("--output_dir", type=str, default="./monteclora-roberta-mrpc", help="Output directory") + parser.add_argument("--batch_size", type=int, default=16, help="Batch size (per device)") + parser.add_argument("--num_epochs", type=int, default=5, help="Training epochs") + parser.add_argument( + "--learning_rate", type=float, default=2e-4, help="Learning rate" + ) # Higher LR for PEFT is common + parser.add_argument("--max_length", type=int, default=128, help="Max sequence length") + parser.add_argument("--device", type=str, default="auto", help="Device (cuda/cpu/auto)") + + # MonteCLoRA specific args + parser.add_argument("--rank", type=int, default=8, help="LoRA Rank") + parser.add_argument("--lora_alpha", type=int, default=16, help="LoRA Alpha") + parser.add_argument("--target_modules", type=str, default="query,value", help="Modules to apply adapter to") + parser.add_argument("--n_samples", type=int, default=10, help="Number of MC samples") + + parser.add_argument("--push_to_hub", action="store_true", help="Push to HF Hub") + parser.add_argument("--hub_model_id", type=str, default=None, help="Hub Repo ID") + + args = parser.parse_args() + + train_model( + base_model=args.base_model, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + max_length=args.max_length, + device=args.device, + rank=args.rank, + lora_alpha=args.lora_alpha, + target_modules=args.target_modules, + n_samples=args.n_samples, + push_to_hub=args.push_to_hub, + hub_model_id=args.hub_model_id, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/multi_adapter_examples/Lora_Merging.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/multi_adapter_examples/Lora_Merging.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..7778c1a21a6ec1ab4e7f4aa0a029eb591728054d --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/multi_adapter_examples/Lora_Merging.ipynb @@ -0,0 +1,194 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "id": "db4208b9-5da4-46df-b77a-0f1836c9e4ec", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\" # force using CUDA device 1\n", + "os.environ[\"ZE_AFFINITY_MASK\"] = \"1\" # force using Intel XPU device 1\n", + "from peft import PeftConfig, PeftModel\n", + "from peft import PeftModel, PeftConfig\n", + "from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n", + "from datasets import load_dataset\n", + "import torch\n", + "import random\n", + "\n", + "peft_model_id = \"smangrul/tinyllama_lora_norobots\"\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "config = PeftConfig.from_pretrained(peft_model_id)\n", + "model_kwargs = {\"device_map\": \"auto\"}\n", + "model_kwargs[\"quantization_config\"] = BitsAndBytesConfig(load_in_4bit=True)\n", + "model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, **model_kwargs)\n", + "tokenizer = AutoTokenizer.from_pretrained(peft_model_id)\n", + "model.resize_token_embeddings(len(tokenizer))\n", + "model = PeftModel.from_pretrained(model, peft_model_id, adapter_name=\"norobots\")\n", + "_ = model.load_adapter(\"smangrul/tinyllama_lora_sql\", adapter_name=\"sql\")\n", + "_ = model.load_adapter(\"smangrul/tinyllama_lora_adcopy\", adapter_name=\"adcopy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "541dab43-9675-42a2-8d90-7437df9f0fa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 17.1 s, sys: 458 ms, total: 17.5 s\n", + "Wall time: 1.94 s\n" + ] + } + ], + "source": [ + "%%time\n", + "# [0.8, 0.1, 0.1] linear #[1.0, 0.2] 0.7 density dare_linear #[1.5, 0.3] 0.5 density ties #[0.8, 0.5] cat\n", + "adapters = [\"norobots\", \"adcopy\", \"sql\"]\n", + "weights = [2.0, 0.3, 0.7]\n", + "adapter_name = \"merge\"\n", + "density = 0.2\n", + "combination_type = \"ties\"\n", + "if adapter_name in model.peft_config:\n", + " model.delete_adapter(adapter_name)\n", + "model.add_weighted_adapter(adapters, weights, adapter_name, combination_type=combination_type, density=density)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "76596671-3677-47f0-9d66-81f40bc4d726", + "metadata": {}, + "outputs": [], + "source": [ + "model.eval()\n", + "model.set_adapter(\"merge\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d59f9f3-6313-43d8-be36-4ca2bbb105b2", + "metadata": {}, + "outputs": [], + "source": [ + "messages = [\n", + " {\"role\": \"user\", \"content\": \"Write an essay about Generative AI.\"},\n", + "]\n", + "text = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)\n", + "inputs = tokenizer(text, return_tensors=\"pt\") # , add_special_tokens=False)\n", + "inputs = {k: v.to(device) for k, v in inputs.items()}\n", + "outputs = model.generate(\n", + " **inputs,\n", + " max_new_tokens=256,\n", + " do_sample=True,\n", + " top_p=0.95,\n", + " temperature=0.2,\n", + " repetition_penalty=1.2,\n", + " eos_token_id=tokenizer.eos_token_id,\n", + ")\n", + "print(tokenizer.decode(outputs[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e5c1daeb-59c8-41d7-bebb-7abd052ab917", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "<|im_start|>system \n", + "Create a text ad given the following product and description.<|im_end|> \n", + "<|im_start|>user \n", + "Product: Sony PS5 PlayStation Console\n", + "Description: The PS5™ console unleashes new gaming possibilities that you never anticipated.<|im_end|> \n", + "<|im_start|>assistant \n", + "Ad Text: Experience the next-gen power of the all-new Sony PS5 with its stunning visuals, innovative gameplay features, and more! Get ready to play in style as you experience the future of gaming on your own terms.<|im_end|>\n" + ] + } + ], + "source": [ + "messages = [\n", + " {\"role\": \"system\", \"content\": \"Create a text ad given the following product and description.\"},\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": \"Product: Sony PS5 PlayStation Console\\nDescription: The PS5™ console unleashes new gaming possibilities that you never anticipated.\",\n", + " },\n", + "]\n", + "text = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)\n", + "inputs = tokenizer(text, return_tensors=\"pt\") # , add_special_tokens=False)\n", + "inputs = {k: v.to(device) for k, v in inputs.items()}\n", + "outputs = model.generate(\n", + " **inputs,\n", + " max_new_tokens=128,\n", + " do_sample=True,\n", + " top_p=0.95,\n", + " temperature=0.2,\n", + " repetition_penalty=1.2,\n", + " eos_token_id=tokenizer.eos_token_id,\n", + ")\n", + "print(tokenizer.decode(outputs[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5bb08b46-90ae-48a8-8783-ca74b3e26e42", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Table: 2-11365528-2\n", + "Columns: ['Team', 'Head Coach', 'President', 'Home Ground', 'Location']\n", + "Natural Query: Who is the Head Coach of the team whose President is Mario Volarevic?\n", + "SQL Query: SELECT Head Coach FROM 2-11365528-2 WHERE President = Mario Volarevic\n" + ] + } + ], + "source": [ + "text = \"\"\"Table: 2-11365528-2\n", + "Columns: ['Team', 'Head Coach', 'President', 'Home Ground', 'Location']\n", + "Natural Query: Who is the Head Coach of the team whose President is Mario Volarevic?\n", + "SQL Query:\"\"\"\n", + "\n", + "inputs = tokenizer(text, return_tensors=\"pt\") # , add_special_tokens=False)\n", + "inputs = {k: v.to(device) for k, v in inputs.items()}\n", + "outputs = model.generate(\n", + " **inputs, max_new_tokens=64, repetition_penalty=1.1, eos_token_id=tokenizer(\"\").input_ids[-1]\n", + ")\n", + "print(tokenizer.decode(outputs[0]))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/multi_adapter_examples/PEFT_Multi_LoRA_Inference.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/multi_adapter_examples/PEFT_Multi_LoRA_Inference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..3815a360a779206c18c810197c193523c0f8dcab --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/multi_adapter_examples/PEFT_Multi_LoRA_Inference.ipynb @@ -0,0 +1,367 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "jONLwzXgLg-I", + "metadata": { + "id": "jONLwzXgLg-I" + }, + "outputs": [], + "source": [ + "!pip install -q git+https://github.com/huggingface/transformers.git\n", + "!pip install -q git+https://github.com/huggingface/peft.git\n", + "!pip install -q git+https://github.com/huggingface/accelerate.git@main\n", + "!pip install huggingface_hub\n", + "!pip install bitsandbytes\n", + "!pip install SentencePiece" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "36460935", + "metadata": { + "id": "36460935" + }, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\" # force using CUDA device 0\n", + "os.environ[\"ZE_AFFINITY_MASK\"] = \"0\" # force using Intel XPU device 0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1351e04c", + "metadata": { + "id": "1351e04c" + }, + "outputs": [], + "source": [ + "from huggingface_hub import notebook_login\n", + "\n", + "\n", + "notebook_login()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d85af699", + "metadata": { + "id": "d85af699" + }, + "outputs": [], + "source": [ + "from peft import PeftModel\n", + "from transformers import LlamaTokenizer, LlamaForCausalLM, GenerationConfig, BitsAndBytesConfig\n", + "\n", + "model_name = \"meta-llama/Llama-2-7b-hf\"\n", + "tokenizer = LlamaTokenizer.from_pretrained(model_name)\n", + "model = LlamaForCausalLM.from_pretrained(model_name, quantization_config=BitsAndBytesConfig(load_in_8bit=True), device_map=\"auto\", use_auth_token=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f0f515ed", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f0f515ed", + "outputId": "312488a5-f4f8-48a4-8c63-7b4a59e80418" + }, + "outputs": [], + "source": [ + "%%time\n", + "model = PeftModel.from_pretrained(model, \"tloen/alpaca-lora-7b\", adapter_name=\"eng_alpaca\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "67a0c121", + "metadata": { + "id": "67a0c121" + }, + "outputs": [], + "source": [ + "%%time\n", + "model.load_adapter(\"22h/cabrita-lora-v0-1\", adapter_name=\"portuguese_alpaca\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b655fca", + "metadata": { + "id": "4b655fca" + }, + "outputs": [], + "source": [ + "model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e9ebd572", + "metadata": { + "id": "e9ebd572" + }, + "outputs": [], + "source": [ + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "\n", + "model.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "138805b3", + "metadata": { + "id": "138805b3" + }, + "outputs": [], + "source": [ + "def generate_prompt(instruction, input=None):\n", + " if input:\n", + " return f\"\"\"Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.\n", + "### Instruction:\n", + "{instruction}\n", + "### Input:\n", + "{input}\n", + "### Response:\"\"\"\n", + " else:\n", + " return f\"\"\"Below is an instruction that describes a task. Write a response that appropriately completes the request.\n", + "### Instruction:\n", + "{instruction}\n", + "### Response:\"\"\"\n", + "\n", + "\n", + "def evaluate(\n", + " instruction,\n", + " input=None,\n", + " temperature=0.1,\n", + " top_p=0.75,\n", + " top_k=40,\n", + " num_beams=4,\n", + " max_new_tokens=256,\n", + " **kwargs,\n", + "):\n", + " prompt = generate_prompt(instruction, input)\n", + " inputs = tokenizer(prompt, return_tensors=\"pt\")\n", + " input_ids = inputs[\"input_ids\"].to(device)\n", + " generation_config = GenerationConfig(\n", + " temperature=temperature,\n", + " top_p=top_p,\n", + " top_k=top_k,\n", + " num_beams=num_beams,\n", + " no_repeat_ngram_size=3,\n", + " **kwargs,\n", + " )\n", + "\n", + " with torch.no_grad():\n", + " generation_output = model.generate(\n", + " input_ids=input_ids,\n", + " generation_config=generation_config,\n", + " return_dict_in_generate=True,\n", + " output_scores=True,\n", + " max_new_tokens=max_new_tokens,\n", + " )\n", + " s = generation_output.sequences[0]\n", + " output = tokenizer.decode(s)\n", + " return output.split(\"### Response:\")[1].strip()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "fd5e6b3b", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fd5e6b3b", + "outputId": "ec72241b-c427-4258-b02f-2101df0d171a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 5.16 ms, sys: 443 μs, total: 5.6 ms\n", + "Wall time: 5.58 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "model.set_adapter(\"eng_alpaca\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "33650851", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "33650851", + "outputId": "aae24052-0f09-4812-88c3-6fb53dec656c" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n", + "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The alpaca (Vicugna pacos) is a domesticated species of South American camelid. It resembles a small llama in appearance. It is kept in herds that graze on the level heights of the Andes of southern Peru, southern Bolivia, Ecuador, and northern Chile, at an altitude of about 3,800 m (12,500 ft) to 5,000 meters (16,404 ft). It is bred for its fiber, which is similar to sheep's wool but finer, silkier, and more durable. Alpaca fiber is used for making knitted and woven items, such as sweaters, hats, gloves, scarves, a variety of textiles, rugs, and blankets. The wool can be dyed, and is used to make ponchos, blankets, and sweaters in Peru and other Andean countries. The animals are also raised for meat and as a source of dairy products, including milk, butter, and cheese.\n", + "Alpaca fleece comes in 22 natural colors, the most\n" + ] + } + ], + "source": [ + "instruction = \"Tell me about alpacas.\"\n", + "\n", + "print(evaluate(instruction))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "fdc7196e", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fdc7196e", + "outputId": "44cb6742-066b-470e-f507-cbf21e5ae030" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 6 ms, sys: 0 ns, total: 6 ms\n", + "Wall time: 5.86 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "model.set_adapter(\"portuguese_alpaca\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "31997da3", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "31997da3", + "outputId": "8071de75-dc9d-4e89-e85f-674f1de22658" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n", + "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I'm sorry, but I can't make it to the party. I'm not feeling well. I have a headache and I don't think it's a good idea for me to go out tonight. I hope you understand and that you have a great time at the party!\n" + ] + } + ], + "source": [ + "instruction = \"Invente uma desculpa criativa pra dizer que não preciso ir à festa.\"\n", + "\n", + "print(evaluate(instruction))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8b8e4e9a", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8b8e4e9a", + "outputId": "84226223-e018-4feb-e189-969c344fd940" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n", + "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Eu não posso ir porque tenho que fazer uma tarefa para o meu professor.\n", + "\n" + ] + } + ], + "source": [ + "with model.disable_adapter():\n", + " instruction = \"Invente uma desculpa criativa pra dizer que não preciso ir à festa.\"\n", + "\n", + " print(evaluate(instruction))" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [] + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/multi_adapter_examples/multi_adapter_weighted_inference_diffusers.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/multi_adapter_examples/multi_adapter_weighted_inference_diffusers.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..595242f91035344aa661ae46a20c17f71a39963e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/multi_adapter_examples/multi_adapter_weighted_inference_diffusers.ipynb @@ -0,0 +1,12881 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook shows how to use the adapter merging methods from `peft` and apply them image generation models using `diffusers`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QaEZ3dPgGtza" + }, + "source": [ + "## Turn `diffusers` LoRA checkpoints into `PeftModel`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KwvBjN-e62ts", + "outputId": "19c58dc7-95db-49c6-beb8-3ade1a8fe284" + }, + "outputs": [], + "source": [ + "!pip install diffusers accelerate transformers -U -q\n", + "!pip install git+https://github.com/huggingface/peft -q" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "5S64sUQhJqB3" + }, + "outputs": [], + "source": [ + "from google.colab import userdata\n", + "TOKEN = userdata.get(\"HF_TOKEN\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 150, + "referenced_widgets": [ + "c9f764b5036042af9f1505e3729cbc32", + "b999b3e3af3744a79c0c90657ef37d4e", + "f3baef4fbf4b4ec08480522be921f841", + "bd2740e191a74558a77a965b4f2d7f28", + "6f6a6cfd50404f1ea09f83e95b04550a", + "713dec1904ce46f6b2d5a9b7e3e0373a", + "a6bb8206de044c74a03d1a64c801e742", + "f2c67c29e1224df3b2def5a87eb8d368", + "486282a4ead148868005c592d74a4ed4", + "48f51c96b7574946bf9542633eb39135", + "35c810f4bfe741f091f172cede413950", + "67567eea233b423c8acd62773a4adb30", + "5161248cd0384d5887ed231ecd48c82e", + "6f72ea2c284e4e40899375c7b07c517f", + "d99a364420454ba5bfd510d1226b94af", + "d33c90e8ea0945d397659f6a90cf51b6", + "097fa44254ea4ecda7c8db995f370afc", + "9fb982789fbc4582bceb356e351db438", + "0204153b17ca4bb0b21fc033393ce9bd", + "f02041b1d5e1485bb2ba02b00fc2c242", + "4d327c9e91b34c7b84cedd8f9660e9fd", + "b44f7154c55146a3bf5f4bd9e438086f", + "b27ac2aaff694dd5999ab2cba91195da", + "556730e12d5d4e0ea51a0dd1b5aac331", + "584dd148b2344bdc92f1d0850399aed7", + "ccc5bdc185a84901994577ff7f1bc962", + "2c75632d8fdc4458814055172d1d72c3", + "2f016774e7854ef589442734d0bb2f08", + "a15c3a32bfd347a98c2a50d27cd5b9f9", + "67ef71b6521b47dd90e3dc0fd03016f2", + "989c54778eb7469fb91e4337d6f49b0b", + "439cf6c6f9e845cea4008e3219454ff4", + "460c3c96d1724713b78bddcfc1f3eb97" + ] + }, + "id": "1YH9xWDcyhaa", + "outputId": "8b7b32f4-4b77-411e-f499-7b2cf7650613" + }, + "outputs": [], + "source": [ + "from diffusers import UNet2DConditionModel\n", + "import torch\n", + "\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "\n", + "model_id = \"stabilityai/stable-diffusion-xl-base-1.0\"\n", + "unet = UNet2DConditionModel.from_pretrained(\n", + " model_id, subfolder=\"unet\", torch_dtype=torch.float16, use_safetensors=True, variant=\"fp16\"\n", + ").to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "-kfTBaLR1Mp-" + }, + "outputs": [], + "source": [ + "# So that we can populate it later.\n", + "import copy\n", + "\n", + "sdxl_unet = copy.deepcopy(unet)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 593, + "referenced_widgets": [ + "0b7ffee735044ece90f010c6771d2d69", + "27671f87d0f3400b89e34bc428daa53c", + "33a018bf2ed547caa69f8ca91dcbb112", + "a91df5ceea8647d98f4d49701bb00969", + "c8555cb30ade40b9bd9a3435d6deeb67", + "b28a2b59aab9478e9ac3ab24a1de6f9a", + "c08fca70486040069d4f8f1df46a1074", + "bab2458ba3f54b229828ad9c8706aba4", + "2a0f746d6eab4680b6c44ec5cdbd8fd9", + "5269d405725946b3a657d3a8d7b25885", + "b4a697d8335c435ab21219716a1da022", + "85f22e78d47641d19efb6e6d62f6a014", + "d8bbb7402f3e44b2899fc98f02cee87e", + "8b41763280a048d485f06682ddc12ca2", + "05791b70a24a42138755141602399c47", + "753f64d9069640d985f399a058fc9b5b", + "19679186751b42e3ad2c44ea46c82a9c", + "d4baf7891f854c9c9898314633f97356", + "9c6ab017f5fb46eda8e3c22e9dd2b838", + "10bc970e474a46249e2a5e9e43fec7be", + "5c838962c7854541b61877c6d42481c4", + "4d54c07dd8e94557b82521772c1a2825", + "efd33121bdfc4ce195a07c9ef523a477", + "d2cd2572973249baa8e130b5777f4147", + "4e77d8b6cdb94fc68974d27b24cfb3fd", + "c292a598350d4dd4bb9b70aab1320c29", + "c68a5ad3bb664e8785e724085d208e96", + "b27c74f0c7bf493fa8bcb4c5b9c9c100", + "09638c8da74f4dddaf1d5d94dd8ad885", + "6a8a634cd3844fa081a4622d224ec940", + "2460b9e05b58481e898b139b94532c14", + "cdd8f9b1592842b48e1ffa80f8ec8246", + "ba9b002888b448738ba4b127e1046f5d", + "54ab158c643540abb8b3a96c1ae3ecab", + "55130e37444844f88286a87c8d153eba", + "7e3048e0fac94dfdaca1bc862ecfce15", + "643ba607008547ba9572fa4880a7d0f2", + "5738e5d103254c5485856f97d82954ab", + "beedc3b275c24432a2e959dcf9dd418d", + "10690b309908402289e9891203714199", + "0c68c6c65fb94650b15069a25d9e1699", + "ad233dfd52034b9e8c6c2c5b86995717", + "2ef25bd6dd644347baac12366d7002fd", + "0918b23f41e0404e82fccd08cadc6ccf", + "b25e822b3f77431fb72b4780067c90d9", + "55177afb435f44898df300143703e4d8", + "b79d3f5bd8024451bc7148ba2a5029bd", + "eacd646e2b984e60ab603bfc6d631de8", + "d158a80f4186411a8a9c335a8d5a888e", + "7049676db714446b98bba16b5f1b049e", + "09172ff4be4e433483d27b576464d1df", + "ea257c1c73524141b87ab3c1ef85c908", + "c474ed5e340146baae6c38f62013afe3", + "2ece04bc10934b3cb9d383abfc5ccd6e", + "67a03631ebc54f99928f0feb18ab38af", + "40ff502d2d5c40378c25cf84dd3323c8", + "230bd59922e84b90b0a141b3ac1e681b", + "6d0f946764444df28cb0da0fd0a408eb", + "c995197e66e04874a9f5d34db98b8890", + "f2596717405c40e1a39b721386e7a972", + "f8e6babf4fdd4c8e80d6dd24ff22d464", + "5e030e8a026b4513aa954203169f0a27", + "f9ca5d4810b34938b6f997ff66a8d541", + "b418ff1733db4efbab1b00b632b894e2", + "83f2d1dfaba54da38f0421b69930c3c1", + "577cc4b4f27941189c62951046db24ec", + "a16016987b6145b69caaac6712d72835", + "c82cf8cf90ed4e93bccffcf75881a56d", + "5a4c6dc09a1049c0adfca9834b045a25", + "c4d83c2b37504473afe63209a178b4cd", + "fae9d16daace412492b048b012b8d6dc", + "421b59f4021d4c4d930c51b6b4c7071f", + "60cc7415644d4e16b88f8fc5896b4b3b", + "fd13a58d6b444a0f955832647f64df12", + "8d492d53eb7f4225b516a65ef80f24e5", + "70849993c0c94ecf87c56e430f06181d", + "e820c557697648378966ed0a073826c8", + "a9ac3b2188594c19885bcdb9a659ecde", + "a708db5805424449afa269b714ebb3b3", + "6d492ddabcbe4d65b5d311834865ab92", + "e17e3253c16743a29f09b82d23c3b26d", + "e67a69c294334b01974f8bef36f133a0", + "24cbd9338ad94801aa11f4dcb2a867cb", + "c88fcf0d20154b1fb9b7e8a00116b5e6", + "ee8407365f5d42d9b98536152c9efe92", + "5ceb5c369f974b84ba850c9e81730a0e", + "a7767d5a440f4c819cdb87414f2187ff", + "f0bc6b14a299445ca705b888b3047064", + "fd0ff16b68b2488d8c31ebe700dee9c9", + "0e49d820da754da785bec2e5940eb9f6", + "0b53b908088648e3b2beadaeba0f5da1", + "804e7ee768794bba88aec3137f418868", + "0d786d8386ba49d0b53a5452d52e722d", + "33d459c0fbfe45389abe7eb43d2710a1", + "dd42a2ff90854b74ba5fde1de26b4e15", + "a3ce5829f8a640e79a19d737663b8474", + "62afb52a01924566b52f6c2d9ffb76f4", + "7a52c380a91c4f49bbfde658550248d3", + "3e418e46c47841ac9d717a6981807f68", + "8840288388ae4162884feef9c8e776f7", + "67b7783351d340d99c44149635b9be84", + "0f60c0f123954744ad13b670ca6dce77", + "dfabe7aa70024d1aa868ef5e6650dc6d", + "7d282fda276343c3aff99b001253ecc1", + "4cae160456c74a5fa761f026d64b2e35", + "819a26acd18f443882feb129f2c576d6", + "d2ed1988cf8c4bcdb1793b3d5068efed", + "6f113303101b4f448380a878d8900bf6", + "60e8e9f8e6ce40dd910ce1a9410b5e24", + "6703a0417c474db5bf261fe8679051e9", + "cb89ecd5a8c14051985495da1797a202", + "61db57127c5845759360bdf8b29dac2d", + "ab9c869439a94bddbbc0c6098f4c5b2a", + "587bd0b90afa450ba82e49cf86ee135d", + "955ec2551f8b400dbbdba68d7449de76", + "f46df85f441e4ada831f0e2b142f296a", + "d4f1dbe4ce244abc987b1089876e080f", + "13ac509e0d5f42e9bbb6deda62f77923", + "4a4a50a17c014f189b52119901104d79", + "cf42fc299989442f94f4a9df63005ab4", + "90b9300ba00e41e58170ec5634622985", + "4fa4f545258b4d6ca014a4c84ec4b24a", + "993e5303f107468f83dbf51026e64301", + "1e6c1c848e364ce4841ddcaa1383cfba", + "d432098a941c463599648b156abea24b", + "917139ad07a64e0cae89f2beeffae956", + "83afce4becac4f37ba916bf1901346ff", + "071e40d45ad14fc19b1480927d15d2ae", + "fe19dcea6d9a44d28f077e065f1671c4", + "08fddacdff4b4ae09adb5440fd86ae86", + "d62465d39d7e4265832901e9b9707993", + "4f56214f69034077bafdfdabc1c2aebf", + "29b67774c6944bc7ab93e7ba0eaf867f", + "0805d34df44f451d9b9910dbe5999245", + "2f2c0ea0fc914e7981e34d01751f74d8", + "5f52ae61812544f29f774f80fcb7a09c", + "ca5dc8342ef946a49d9e67a21f1a67c8", + "babce0e85baf4279ae1d22d64006667f", + "5cf6cd09cda64d688f4a0f7c511533d0", + "f668dd13af6f41d8be358f7db5261c54", + "8a8ef60b3b72452fb9ccc31052ab3b4f", + "7d29b20296aa4e33837b8ad53fc4adba", + "6a94d1d176b844db96de0c0e3cd67701", + "c80901426c87439481078b9da2e0c772", + "416f31db79fd431fb8dc06e994421b70", + "1971fcd35a564c449b4f437dac46058f", + "76a474e4aab14a5987cf25d1391d578c", + "ff3bf3f1873c4b01b0a547dfe02923ce", + "a6295c7e7630444c9b7425b884ad9707", + "3ede828a0374453e9aac9a6695befae3", + "dc4391fe30694a788134fffdd2a23d1a", + "cfc6ec59d45d42d187f42061902abbfb", + "68822f8f861a48859df630fad63f51c1", + "2671327d35e64f0da670a3a611fd0886", + "aae194e7f71f4eba80ffd18f91f083a8", + "9ad4192f6f244264aede1b3c8ac3c57a", + "90558769855c4bb08ff2fe4af940c45b", + "75384779c5d540d28afb53a0e318b674", + "a287f197e4fe4f908e3ee0a0e6cb35cf", + "fdb799739700447d8a5198f1f4f9b17f", + "683db0ff105a47038c350cfc74b88345", + "b79d32186443469d94836b663bf156b5", + "86cb336c1f684867bd13dae0370b4d36", + "7f63b3d80ecb4c3eb837bd0e616e1623", + "4f6e7b21ba0747f19b9d63468861c988", + "766567be45eb4db6b8d7a3364566c1dc", + "3c222a56d4404863a1dac60f1d03835b", + "db862ffbb44d450db514173df4c7f301", + "ddbeb13bb8174fc0b7d5543108d1c4f5", + "5b3bbc663d504fb99318ba186e6b8499", + "30bfac68f4224152b048d6ccf6013c5c", + "971f59d5f3e04697b3ab3c39ec0fc667", + "fe958df746be4dc1871bd58628697c3c", + "54417d8b9c5249d0a028d9e831dd8be6", + "9a37ffb9810f482b80f245f64947c371", + "bdfe4e4109a14a41bcd2e1e4242d82bb", + "22e894ba852e4072a1f63a83b3a98b16", + "95e24bbc8397455fabb724ed3c330511", + "d35b3848508c4b6390c243866649439d", + "c7cf10df8d7944aeb93947d5f4156c92", + "8e3b0b9f26a34ab8a932756b32834fd0", + "b1d427082b9f452eb6546c7d55016b36", + "061fcc6e5f3c44c48cde212c1ba515e5", + "d70508c304794bc79e80aab136eaf65a", + "01b20535e40b47068723073ac6c819ee", + "de0b54a59d9f47408d92915ad746cd5e", + "eb9a5f255fa0447eba6a33e1c30ba166", + "d1e4d2fd70e644f986104c998db7e53b", + "f786a0f386f6486083c15e576f6eb3e7", + "6715d91c6b62426aa49c344b65bcd8a2", + "0b0a85e1133c4ca3ba716e2403511703", + "017dc44dbe1c4de491e003a1e279a218", + "e3a1a5e9f29d4d28b0b9496493dafa21", + "c008577d922e436aabb8680ca0d13117", + "bd176c410a4e48a382a1b688e77aafcb", + "6b586ad7a3054c83b14243d69484127f", + "34fcd527a59748cf832c9efdb954fc0e", + "fd672cd5ba0c4695be4240707dcf4bf3" + ] + }, + "id": "EMTVH9cLEZYi", + "outputId": "7a24b4b0-71f6-4c65-a242-fb3d502da6a8" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading pipeline components...: 100%|██████████| 7/7 [00:00<00:00, 10.25it/s]\n" + ] + } + ], + "source": [ + "# Load the pipeline too.\n", + "from diffusers import DiffusionPipeline\n", + "\n", + "pipe = DiffusionPipeline.from_pretrained(\n", + " model_id, variant=\"fp16\", torch_dtype=torch.float16, unet=unet\n", + ").to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 49, + "referenced_widgets": [ + "5e677518051c43768dbf06243701c817", + "d727913663634e368ade4a7dc64fe74b", + "eb73095c804a4272856fe348fa3cb1e9", + "7e9b46b10fa24dfea489dfbc150d2a2e", + "c8156b0cc68e4b3693dcabc530a4ea9a", + "d987907f09084d44b452f939aadff65e", + "e976b994189343f5ba7d762ef92c79e2", + "9810873713024e79ae6d338dfeae5876", + "2e18ce21c01a4a3ca992622957e7d297", + "2db944a049a04426bba181fddb2801b1", + "683863a313034025ab99fab5810f39c7" + ] + }, + "id": "D5hL5156zPis", + "outputId": "2510b8e7-c030-40f8-dcd2-ef76fc8529c6" + }, + "outputs": [], + "source": [ + "# Only UNet\n", + "pipe.load_lora_weights(\"CiroN2022/toy-face\", weight_name=\"toy_face_sdxl.safetensors\", adapter_name=\"toy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "p-7YWoOs02La" + }, + "outputs": [], + "source": [ + "from peft import get_peft_model, LoraConfig\n", + "\n", + "toy_peft_model = get_peft_model(\n", + " sdxl_unet,\n", + " pipe.unet.peft_config[\"toy\"],\n", + " adapter_name=\"toy\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 101, + "referenced_widgets": [ + "c6bdeef396174d51af9eee277752bec7", + "685797f8907c47ffab4fe7a81ca22e63", + "414f8301f76043758f69bbfb6960072d", + "23c0492f021a4b60b1d84b0b82d15378", + "550b3ad10fcb422eb66f71ad95988616", + "222da37b5af14d60814c65cdd1ea20be", + "6a2b5bbd4afe4e0cabe39e95ccf528be", + "7ba112dcece64386bdbac6837004891b", + "2ffbf400ff1f4cc9b358bb10c6b9d99f", + "5405d8a1aa1d411b895b0523fb8e4ce7", + "04846af1def142ffad328d434ba228fe" + ] + }, + "id": "a_2n4Odz2a0c", + "outputId": "4b3b801b-649f-4c69-b75c-f800ac75c17f" + }, + "outputs": [], + "source": [ + "original_state_dict = {f\"base_model.model.{k}\": v for k, v in pipe.unet.state_dict().items()}\n", + "\n", + "toy_peft_model.load_state_dict(original_state_dict, strict=True)\n", + "toy_peft_model.push_to_hub(\"toy_peft_model-new\", token=TOKEN)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "z1DWL0X12rxD" + }, + "outputs": [], + "source": [ + "pipe.delete_adapters(\"toy\")\n", + "sdxl_unet.delete_adapters(\"toy\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 49, + "referenced_widgets": [ + "d18c97fe685e4be080125ae770526255", + "e44c018bc76c48cd8738fee5966767ce", + "57b491647f1e49cea7ce34774a963936", + "484f694f734b4a92a14ecc4d048db0af", + "bcb3ec98d25b4c138c5e8f84c1e937c6", + "b0abce2d8a2046dba320e788e33e9d66", + "aef81ec1a7e844f883beba8c5754a8af", + "c040aa1f65514be28f0ca8ecdd1f69e4", + "eec76868d92f45d7a6db2e232a45e0c2", + "157c0c1e85ef40fb99e6cfe0e176be38", + "99717def9b6b4afe8a411a3bb83320c9" + ] + }, + "id": "9PW-SfwH5L7e", + "outputId": "90721ffa-faa5-4628-994a-7b719a4ef02c" + }, + "outputs": [], + "source": [ + "pipe.load_lora_weights(\"nerijs/pixel-art-xl\", weight_name=\"pixel-art-xl.safetensors\", adapter_name=\"pixel\")\n", + "pipe.set_adapters(adapter_names=\"pixel\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 101, + "referenced_widgets": [ + "adb2daf9d62f49f8ab1f0144b717d41e", + "bba38c266ceb4f30bb4bc1eaf5e3aa96", + "6926c8dd4e4e46d089bb387333691df7", + "abf2248c725b4837b5c2babef7f4ff3e", + "39e4bdf8d621451f984f6e7302fd6961", + "4abac6a83641414499f9b6b1514d1695", + "bf6e103b43844f17968eadf223a42acb", + "adf53d97af214cceaae895c8abfbd909", + "9d74948f7bcb498c9295e41e690a0a8d", + "d872c3900b8b4275b2224c9ec5e7d78f", + "4fbaa1bd51bf4b1e90337a435604d2bd" + ] + }, + "id": "jHSb-iIf7IEb", + "outputId": "29124d4c-b58f-4f0e-c59b-d79b44cb162f" + }, + "outputs": [], + "source": [ + "pixel_peft_model = get_peft_model(\n", + " sdxl_unet,\n", + " pipe.unet.peft_config[\"pixel\"],\n", + " adapter_name=\"pixel\"\n", + ")\n", + "\n", + "original_state_dict = {f\"base_model.model.{k}\": v for k, v in pipe.unet.state_dict().items()}\n", + "pixel_peft_model.load_state_dict(original_state_dict, strict=True)\n", + "pixel_peft_model.push_to_hub(\"pixel_peft_model-new\", token=TOKEN)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "yoPzMtyqG2ZO" + }, + "outputs": [], + "source": [ + "del pipe, sdxl_unet, toy_peft_model, pixel_peft_model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Zis3zKZpGy8w" + }, + "source": [ + "## Weighted adapter inference" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 145, + "referenced_widgets": [ + "d74b1c667d42472b865ee1cbefc33a60", + "1074a274530e46c5b5a3e43653da43d0", + "dfde3984062442869bc8091bb94f2c36", + "a6f2ce8830734be4b8efe5ca0e14e990", + "07da49088e8d480fad03a2e828357872", + "5dd09616ba6544c499271054e8d8d2c5", + "fdb1fd279a0241429e5721ae2e92d217", + "7c6c4dff0a814bc6a7ac677980b45add", + "9a9da0d0e3d84a19b5d188c9bd6a83bb", + "de31002ed7fc475c915b4a29253108af", + "fbf3d268f30344b7864ce691d5bcb1f3", + "153a93d930df4ee396e03f1aaa6f04f1", + "c8e40d44aeac47a78f6502771f1471b7", + "270ddad8d7704f929a28c9fbbdabfa26", + "e57d317b3dda43bba13ecd4514f776d3", + "22b55b5ee1af4ea7b1acfe511b194cd8", + "a48d3ad24e9744f7898d1f2c5a696ea2", + "f29673e57d174839a0bde70bfa165715", + "13f5160dd981465890ada8a2cef22d5e", + "cc06ed7338b74ae6a1c563212aeb9f94", + "3a017f1d0ebf4a4aab57ac3eb0788774", + "48643ea67f2f4762bcd27de1d4cf0fd2", + "5c3d142907404cef8fd624839a166530", + "abaecfe7f39a43bb8fbd655d1a3009f4", + "d488374da5e74ec3a5973003590a7d69", + "5d8ae9661dce4a1aac8d418d84f3a209", + "32132ecbe71a4c2c903932513c2a1aa0", + "05700817adac4fdda6c95dd00eaeae38", + "5a7d87338ddc45df84080e0096a31631", + "cb9a536bc56f4d0ebf285e7f73d4730e", + "49bb475a11104e9496f2623e3d5caebd", + "887c5eae5b154eccb4a1caa3deef6e94", + "e87dffe17f1948e9ba794eddb605a908", + "2c352a90375443da835eef55b3e63303", + "db8fd6b2687c449fa0600d3e87c96999", + "17691a346ca5407a99a5e385450c97eb", + "0bca833a6aa74ebaa8f69feb738806bf", + "6bdb9b0b68c24b84a748c18ed927a8d3", + "355efc45ddaf42498d72d6134a28c87b", + "8b6464ce614c4aa29ac66ecce29b6cbf", + "bc07cdaad5b64fb3b0e1f8c214bba813", + "9e2e87c131a140a2a37dfdf483d27ced", + "47468a75637d436f849283c295a74ab6", + "af5003cf40ae4dfaa0660f247598856e" + ] + }, + "id": "gEqT1vFtG0_e", + "outputId": "282ce865-c653-4912-e497-ff825c896ae7" + }, + "outputs": [], + "source": [ + "from peft import PeftModel\n", + "\n", + "base_unet = UNet2DConditionModel.from_pretrained(\n", + " model_id, subfolder=\"unet\", torch_dtype=torch.float16, use_safetensors=True, variant=\"fp16\"\n", + ").to(device)\n", + "\n", + "toy_id = \"sayakpaul/toy_peft_model-new\"\n", + "model = PeftModel.from_pretrained(base_unet, toy_id, use_safetensors=True, subfolder=\"toy\", adapter_name=\"toy\")\n", + "model.load_adapter(\"sayakpaul/pixel_peft_model-new\", use_safetensors=True, subfolder=\"pixel\", adapter_name=\"pixel\")\n", + "\n", + "# https://huggingface.co/docs/peft/main/en/package_reference/lora#peft.LoraModel.add_weighted_adapter\n", + "model.add_weighted_adapter(\n", + " adapters=[\"toy\", \"pixel\"],\n", + " weights=[0.7, 0.3],\n", + " combination_type=\"linear\",\n", + " adapter_name=\"toy-pixel\"\n", + ")\n", + "model.set_adapters(\"toy-pixel\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 186 + }, + "id": "QStyurhKsP_g", + "outputId": "5e3a2627-27a2-4771-e62f-1b81ded2b87e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "diffusers.models.unets.unet_2d_condition.UNet2DConditionModel" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(model.base_model.model)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "28a5059a2cc445d783e94ad5d83a0748", + "faddc146c69545cdaeb81edc8a0cda70", + "cd08b99de03c483a965248ff4df752ba", + "d37c6ac25fd34a65bf307896443a5063", + "66da596ae59d474f8a82a600174adff6", + "b600178b161d4a87a0b832a169d7caf2", + "b3eaa188cc2e48d081488eea4ed2971f", + "c05842ed12c848c68c4a69de9aa742a8", + "18e3ba4a61784f04b3238cf273c90c3e", + "42a623abc5d84c0eb7de4e5323bb6546", + "a65484354d254516936fcb425917a4b7", + "64029a1e70e040b49e38d38bd36823fd", + "3e1ec3a51e9b4fbbab489d34640cda90", + "ea0910fc31e44597968b2129272cc94d", + "3a0e9adc345f409cbcd79d1bd19219e6", + "3fe7e7f00ca746cc8cc762da6f365fde", + "6466eff2786241eeb142f17758894bb2", + "c181408b9b2b437ca11d584e3d1e94e7", + "0371aa5607604c06a868deb2a413cb31", + "c212598c5a8747f783a6efc18816e868", + "89ed71090d5c4366b21d25ad102e7da7", + "4ab21d7b956e46348ad6f6542fd92c2d" + ] + }, + "id": "iHwVV8f6s1EC", + "outputId": "47cb80da-266e-40c2-cfc1-3f3e5421b50b" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading pipeline components...: 100%|██████████| 7/7 [00:00<00:00, 21.14it/s]\n", + "Expected types for unet: (,), got .\n", + "100%|██████████| 30/30 [00:09<00:00, 3.19it/s]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = model.to(torch_dtype=torch.float16, device=device)\n", + "\n", + "pipe = DiffusionPipeline.from_pretrained(\n", + " model_id, unet=model, variant=\"fp16\", torch_dtype=torch.float16,\n", + ").to(device)\n", + "\n", + "prompt = \"toy_face of a hacker with a hoodie, pixel art\"\n", + "image = pipe(prompt, num_inference_steps=30, generator=torch.manual_seed(0)).images[0]\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "id": "adLnc7sMRZlq" + }, + "outputs": [], + "source": [ + "del pipe" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "nIwIQK5zRX25" + }, + "outputs": [], + "source": [ + "base_unet = UNet2DConditionModel.from_pretrained(\n", + " model_id, subfolder=\"unet\", torch_dtype=torch.float16, use_safetensors=True, variant=\"fp16\"\n", + ").to(device)\n", + "\n", + "toy_id = \"sayakpaul/toy_peft_model-new\"\n", + "model = PeftModel.from_pretrained(base_unet, toy_id, use_safetensors=True, subfolder=\"toy\", adapter_name=\"toy\")\n", + "model.load_adapter(\"sayakpaul/pixel_peft_model-new\", use_safetensors=True, subfolder=\"pixel\", adapter_name=\"pixel\")\n", + "\n", + "# https://huggingface.co/docs/peft/main/en/package_reference/lora#peft.LoraModel.add_weighted_adapter\n", + "model.add_weighted_adapter(\n", + " adapters=[\"toy\", \"pixel\"],\n", + " weights=[0.5, 0.5],\n", + " combination_type=\"cat\",\n", + " adapter_name=\"toy-pixel\"\n", + ")\n", + "model.set_adapters(\"toy-pixel\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "65bf3df199b44763aa223fee96889e17", + "a32666723b0e4b9883a78f56295c4356", + "c08373a044204308ac882dd8cf9cdd3e", + "fa7876ade8e240fc89a35a1f8c7c7d3c", + "de583920d3b54774a486aef4c052e50d", + "979c68bd2e224a40b939c27f32c25dac", + "0027f3aa006d4276983691ad985ce91b", + "a0f8a1a3512443ac84799b95da70ca26", + "e08d739f59874064994212363a307f6e", + "52c7e22284b0468c8bc0c3b1cad047fb", + "17c29bbcbc0c437c9c8bc83e0b085f1a", + "65b15618abfd4e6f9fafd64813e86ace", + "1e8747251a1f4cca970857911d1c4a98", + "caa46820018f47abab4a962afe51cc34", + "22a2ea45880f4b0da47f1b213882dcb0", + "0cf822f588244e54b5264176f9611164", + "dd9666d76af04b72b08f59023eb04ee3", + "2702528a2ca049fc800ad44c492690ae", + "aed53b6480de4dd4bc7463af04840952", + "447d29db05384c55a57c5fb1bd121af4", + "2d7e7e816a63428b8f30471a12b57bc4", + "e15aab8dd01f4d5582db80e6ad9931fc" + ] + }, + "id": "29iGITdnRhFG", + "outputId": "dc6a1e54-3f76-457e-da1b-e8677be5c31f" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading pipeline components...: 100%|██████████| 7/7 [00:00<00:00, 19.85it/s]\n", + "Expected types for unet: (,), got .\n", + "100%|██████████| 30/30 [00:05<00:00, 5.35it/s]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = model.to(torch_dtype=torch.float16, device=device)\n", + "\n", + "pipe = DiffusionPipeline.from_pretrained(\n", + " model_id, unet=model, variant=\"fp16\", torch_dtype=torch.float16,\n", + ").to(device)\n", + "\n", + "prompt = \"toy_face of a hacker with a hoodie, pixel art\"\n", + "image = pipe(prompt, num_inference_steps=30, generator=torch.manual_seed(0)).images[0]\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "8b88a1a63cf242de8a68962f50498c72", + "777c5583820248838f0c39e82362d9e3", + "491da86a94c44b7c87366b4bb72a3bd1", + "31c3a375a2964a06a2473925fe9b197b", + "0ba0a0fca31c482bb628a6739d341601", + "734e9a834ff74b64b17453013208a116", + "9784d9210d6e4214b78ab5f8c33e8044", + "490be826ebc14d5ab4e9f0e10ec79d5f", + "64ea3c5cc12841f59d1acba12deb6a88", + "fc1391aaeaad4eecad967e800a669ec1", + "272fceb4e9484b389067080872b1abf9", + "5ab5097f19cf4474945f96741c444d71", + "6d8fdd0303774305ae20dd39e2a1706c", + "031a326124f1496abe1f3bf8de720029", + "b9feee6f48bd49209e72e5c5e3136f67", + "a2d497a2ddb04d8fac8a4c0f8aa7f5dc", + "7bb3f4cda33947138c61aac74d952289", + "d3b73a841e68425994632d0f05cf4f16", + "71ad1e3dbe44437d8df985cfae207dcd", + "598fa824f517445394d08c37393f9f3d", + "daad0d12aff8470d990fbbbbe19d5891", + "16e18e872ab64b3f8bfb32f580c3371b" + ] + }, + "id": "sQOnSrteuS-S", + "outputId": "44c5e61a-370b-44bf-a5e5-80b7787088e5" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading pipeline components...: 100%|██████████| 7/7 [00:00<00:00, 14.10it/s]\n", + "100%|██████████| 30/30 [00:03<00:00, 9.26it/s]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "del pipe\n", + "\n", + "pipe = DiffusionPipeline.from_pretrained(\n", + " model_id, variant=\"fp16\", dtype=torch.float16,\n", + ").to(device)\n", + "\n", + "prompt = \"toy_face of a hacker with a hoodie, pixel art\"\n", + "image = pipe(prompt, num_inference_steps=30, generator=torch.manual_seed(0)).images[0]\n", + "image" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "0027f3aa006d4276983691ad985ce91b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "017dc44dbe1c4de491e003a1e279a218": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "01b20535e40b47068723073ac6c819ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "0204153b17ca4bb0b21fc033393ce9bd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "031a326124f1496abe1f3bf8de720029": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_71ad1e3dbe44437d8df985cfae207dcd", + "max": 30, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_598fa824f517445394d08c37393f9f3d", + "value": 30 + } + }, + "0371aa5607604c06a868deb2a413cb31": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04846af1def142ffad328d434ba228fe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "05700817adac4fdda6c95dd00eaeae38": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "05791b70a24a42138755141602399c47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5c838962c7854541b61877c6d42481c4", + "placeholder": "​", + "style": "IPY_MODEL_4d54c07dd8e94557b82521772c1a2825", + "value": " 17/17 [01:04<00:00, 14.56s/it]" + } + }, + "061fcc6e5f3c44c48cde212c1ba515e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "071e40d45ad14fc19b1480927d15d2ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "07da49088e8d480fad03a2e828357872": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0805d34df44f451d9b9910dbe5999245": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_babce0e85baf4279ae1d22d64006667f", + "placeholder": "​", + "style": "IPY_MODEL_5cf6cd09cda64d688f4a0f7c511533d0", + "value": "vae/config.json: 100%" + } + }, + "08fddacdff4b4ae09adb5440fd86ae86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "09172ff4be4e433483d27b576464d1df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0918b23f41e0404e82fccd08cadc6ccf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "09638c8da74f4dddaf1d5d94dd8ad885": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "097fa44254ea4ecda7c8db995f370afc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b0a85e1133c4ca3ba716e2403511703": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_34fcd527a59748cf832c9efdb954fc0e", + "placeholder": "​", + "style": "IPY_MODEL_fd672cd5ba0c4695be4240707dcf4bf3", + "value": " 7/7 [00:01<00:00,  9.61it/s]" + } + }, + "0b53b908088648e3b2beadaeba0f5da1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a3ce5829f8a640e79a19d737663b8474", + "max": 565, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_62afb52a01924566b52f6c2d9ffb76f4", + "value": 565 + } + }, + "0b7ffee735044ece90f010c6771d2d69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_27671f87d0f3400b89e34bc428daa53c", + "IPY_MODEL_33a018bf2ed547caa69f8ca91dcbb112", + "IPY_MODEL_a91df5ceea8647d98f4d49701bb00969" + ], + "layout": "IPY_MODEL_c8555cb30ade40b9bd9a3435d6deeb67" + } + }, + "0ba0a0fca31c482bb628a6739d341601": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0bca833a6aa74ebaa8f69feb738806bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_47468a75637d436f849283c295a74ab6", + "placeholder": "​", + "style": "IPY_MODEL_af5003cf40ae4dfaa0660f247598856e", + "value": " 170M/170M [00:07<00:00, 22.4MB/s]" + } + }, + "0c68c6c65fb94650b15069a25d9e1699": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0cf822f588244e54b5264176f9611164": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d786d8386ba49d0b53a5452d52e722d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0e49d820da754da785bec2e5940eb9f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_33d459c0fbfe45389abe7eb43d2710a1", + "placeholder": "​", + "style": "IPY_MODEL_dd42a2ff90854b74ba5fde1de26b4e15", + "value": "text_encoder/config.json: 100%" + } + }, + "0f60c0f123954744ad13b670ca6dce77": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d2ed1988cf8c4bcdb1793b3d5068efed", + "max": 1059962, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6f113303101b4f448380a878d8900bf6", + "value": 1059962 + } + }, + "10690b309908402289e9891203714199": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1074a274530e46c5b5a3e43653da43d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5dd09616ba6544c499271054e8d8d2c5", + "placeholder": "​", + "style": "IPY_MODEL_fdb1fd279a0241429e5721ae2e92d217", + "value": "toy/adapter_config.json: 100%" + } + }, + "10bc970e474a46249e2a5e9e43fec7be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "13ac509e0d5f42e9bbb6deda62f77923": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "13f5160dd981465890ada8a2cef22d5e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "153a93d930df4ee396e03f1aaa6f04f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c8e40d44aeac47a78f6502771f1471b7", + "IPY_MODEL_270ddad8d7704f929a28c9fbbdabfa26", + "IPY_MODEL_e57d317b3dda43bba13ecd4514f776d3" + ], + "layout": "IPY_MODEL_22b55b5ee1af4ea7b1acfe511b194cd8" + } + }, + "157c0c1e85ef40fb99e6cfe0e176be38": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "16e18e872ab64b3f8bfb32f580c3371b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "17691a346ca5407a99a5e385450c97eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bc07cdaad5b64fb3b0e1f8c214bba813", + "max": 170461008, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9e2e87c131a140a2a37dfdf483d27ced", + "value": 170461008 + } + }, + "17c29bbcbc0c437c9c8bc83e0b085f1a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "18e3ba4a61784f04b3238cf273c90c3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "19679186751b42e3ad2c44ea46c82a9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1971fcd35a564c449b4f437dac46058f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dc4391fe30694a788134fffdd2a23d1a", + "max": 1389382176, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_cfc6ec59d45d42d187f42061902abbfb", + "value": 1389382176 + } + }, + "1e6c1c848e364ce4841ddcaa1383cfba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fe19dcea6d9a44d28f077e065f1671c4", + "max": 460, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_08fddacdff4b4ae09adb5440fd86ae86", + "value": 460 + } + }, + "1e8747251a1f4cca970857911d1c4a98": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dd9666d76af04b72b08f59023eb04ee3", + "placeholder": "​", + "style": "IPY_MODEL_2702528a2ca049fc800ad44c492690ae", + "value": "100%" + } + }, + "222da37b5af14d60814c65cdd1ea20be": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "22a2ea45880f4b0da47f1b213882dcb0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2d7e7e816a63428b8f30471a12b57bc4", + "placeholder": "​", + "style": "IPY_MODEL_e15aab8dd01f4d5582db80e6ad9931fc", + "value": " 30/30 [00:07<00:00,  4.07it/s]" + } + }, + "22b55b5ee1af4ea7b1acfe511b194cd8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "22e894ba852e4072a1f63a83b3a98b16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_95e24bbc8397455fabb724ed3c330511", + "IPY_MODEL_d35b3848508c4b6390c243866649439d", + "IPY_MODEL_c7cf10df8d7944aeb93947d5f4156c92" + ], + "layout": "IPY_MODEL_8e3b0b9f26a34ab8a932756b32834fd0" + } + }, + "230bd59922e84b90b0a141b3ac1e681b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f8e6babf4fdd4c8e80d6dd24ff22d464", + "placeholder": "​", + "style": "IPY_MODEL_5e030e8a026b4513aa954203169f0a27", + "value": "text_encoder_2/config.json: 100%" + } + }, + "23c0492f021a4b60b1d84b0b82d15378": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5405d8a1aa1d411b895b0523fb8e4ce7", + "placeholder": "​", + "style": "IPY_MODEL_04846af1def142ffad328d434ba228fe", + "value": " 5.12k/5.12k [00:00<00:00, 358kB/s]" + } + }, + "2460b9e05b58481e898b139b94532c14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "24cbd9338ad94801aa11f4dcb2a867cb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2671327d35e64f0da670a3a611fd0886": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2702528a2ca049fc800ad44c492690ae": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "270ddad8d7704f929a28c9fbbdabfa26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_13f5160dd981465890ada8a2cef22d5e", + "max": 170461008, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_cc06ed7338b74ae6a1c563212aeb9f94", + "value": 170461008 + } + }, + "272fceb4e9484b389067080872b1abf9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "27671f87d0f3400b89e34bc428daa53c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b28a2b59aab9478e9ac3ab24a1de6f9a", + "placeholder": "​", + "style": "IPY_MODEL_c08fca70486040069d4f8f1df46a1074", + "value": "model_index.json: 100%" + } + }, + "28a5059a2cc445d783e94ad5d83a0748": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_faddc146c69545cdaeb81edc8a0cda70", + "IPY_MODEL_cd08b99de03c483a965248ff4df752ba", + "IPY_MODEL_d37c6ac25fd34a65bf307896443a5063" + ], + "layout": "IPY_MODEL_66da596ae59d474f8a82a600174adff6" + } + }, + "29b67774c6944bc7ab93e7ba0eaf867f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0805d34df44f451d9b9910dbe5999245", + "IPY_MODEL_2f2c0ea0fc914e7981e34d01751f74d8", + "IPY_MODEL_5f52ae61812544f29f774f80fcb7a09c" + ], + "layout": "IPY_MODEL_ca5dc8342ef946a49d9e67a21f1a67c8" + } + }, + "2a0f746d6eab4680b6c44ec5cdbd8fd9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2c352a90375443da835eef55b3e63303": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_db8fd6b2687c449fa0600d3e87c96999", + "IPY_MODEL_17691a346ca5407a99a5e385450c97eb", + "IPY_MODEL_0bca833a6aa74ebaa8f69feb738806bf" + ], + "layout": "IPY_MODEL_6bdb9b0b68c24b84a748c18ed927a8d3" + } + }, + "2c75632d8fdc4458814055172d1d72c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d7e7e816a63428b8f30471a12b57bc4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2db944a049a04426bba181fddb2801b1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e18ce21c01a4a3ca992622957e7d297": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2ece04bc10934b3cb9d383abfc5ccd6e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ef25bd6dd644347baac12366d7002fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f016774e7854ef589442734d0bb2f08": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f2c0ea0fc914e7981e34d01751f74d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f668dd13af6f41d8be358f7db5261c54", + "max": 642, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8a8ef60b3b72452fb9ccc31052ab3b4f", + "value": 642 + } + }, + "2ffbf400ff1f4cc9b358bb10c6b9d99f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "30bfac68f4224152b048d6ccf6013c5c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "31c3a375a2964a06a2473925fe9b197b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fc1391aaeaad4eecad967e800a669ec1", + "placeholder": "​", + "style": "IPY_MODEL_272fceb4e9484b389067080872b1abf9", + "value": " 7/7 [00:01<00:00,  4.28it/s]" + } + }, + "32132ecbe71a4c2c903932513c2a1aa0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "33a018bf2ed547caa69f8ca91dcbb112": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bab2458ba3f54b229828ad9c8706aba4", + "max": 609, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2a0f746d6eab4680b6c44ec5cdbd8fd9", + "value": 609 + } + }, + "33d459c0fbfe45389abe7eb43d2710a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34fcd527a59748cf832c9efdb954fc0e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "355efc45ddaf42498d72d6134a28c87b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35c810f4bfe741f091f172cede413950": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "39e4bdf8d621451f984f6e7302fd6961": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a017f1d0ebf4a4aab57ac3eb0788774": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3a0e9adc345f409cbcd79d1bd19219e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_89ed71090d5c4366b21d25ad102e7da7", + "placeholder": "​", + "style": "IPY_MODEL_4ab21d7b956e46348ad6f6542fd92c2d", + "value": " 30/30 [00:08<00:00,  4.13it/s]" + } + }, + "3c222a56d4404863a1dac60f1d03835b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_30bfac68f4224152b048d6ccf6013c5c", + "placeholder": "​", + "style": "IPY_MODEL_971f59d5f3e04697b3ab3c39ec0fc667", + "value": "tokenizer_2/vocab.json: 100%" + } + }, + "3e1ec3a51e9b4fbbab489d34640cda90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6466eff2786241eeb142f17758894bb2", + "placeholder": "​", + "style": "IPY_MODEL_c181408b9b2b437ca11d584e3d1e94e7", + "value": "100%" + } + }, + "3e418e46c47841ac9d717a6981807f68": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3ede828a0374453e9aac9a6695befae3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3fe7e7f00ca746cc8cc762da6f365fde": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "40ff502d2d5c40378c25cf84dd3323c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_230bd59922e84b90b0a141b3ac1e681b", + "IPY_MODEL_6d0f946764444df28cb0da0fd0a408eb", + "IPY_MODEL_c995197e66e04874a9f5d34db98b8890" + ], + "layout": "IPY_MODEL_f2596717405c40e1a39b721386e7a972" + } + }, + "414f8301f76043758f69bbfb6960072d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7ba112dcece64386bdbac6837004891b", + "max": 5116, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2ffbf400ff1f4cc9b358bb10c6b9d99f", + "value": 5116 + } + }, + "416f31db79fd431fb8dc06e994421b70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a6295c7e7630444c9b7425b884ad9707", + "placeholder": "​", + "style": "IPY_MODEL_3ede828a0374453e9aac9a6695befae3", + "value": "model.fp16.safetensors: 100%" + } + }, + "421b59f4021d4c4d930c51b6b4c7071f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42a623abc5d84c0eb7de4e5323bb6546": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "439cf6c6f9e845cea4008e3219454ff4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "447d29db05384c55a57c5fb1bd121af4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "460c3c96d1724713b78bddcfc1f3eb97": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "47468a75637d436f849283c295a74ab6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "484f694f734b4a92a14ecc4d048db0af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_157c0c1e85ef40fb99e6cfe0e176be38", + "placeholder": "​", + "style": "IPY_MODEL_99717def9b6b4afe8a411a3bb83320c9", + "value": " 171M/171M [00:00<00:00, 331MB/s]" + } + }, + "486282a4ead148868005c592d74a4ed4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "48643ea67f2f4762bcd27de1d4cf0fd2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "48f51c96b7574946bf9542633eb39135": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "490be826ebc14d5ab4e9f0e10ec79d5f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "491da86a94c44b7c87366b4bb72a3bd1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_490be826ebc14d5ab4e9f0e10ec79d5f", + "max": 7, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_64ea3c5cc12841f59d1acba12deb6a88", + "value": 7 + } + }, + "49bb475a11104e9496f2623e3d5caebd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4a4a50a17c014f189b52119901104d79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4ab21d7b956e46348ad6f6542fd92c2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4abac6a83641414499f9b6b1514d1695": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4cae160456c74a5fa761f026d64b2e35": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4d327c9e91b34c7b84cedd8f9660e9fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4d54c07dd8e94557b82521772c1a2825": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4e77d8b6cdb94fc68974d27b24cfb3fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6a8a634cd3844fa081a4622d224ec940", + "max": 246144152, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2460b9e05b58481e898b139b94532c14", + "value": 246144152 + } + }, + "4f56214f69034077bafdfdabc1c2aebf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4f6e7b21ba0747f19b9d63468861c988": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4fa4f545258b4d6ca014a4c84ec4b24a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_993e5303f107468f83dbf51026e64301", + "IPY_MODEL_1e6c1c848e364ce4841ddcaa1383cfba", + "IPY_MODEL_d432098a941c463599648b156abea24b" + ], + "layout": "IPY_MODEL_917139ad07a64e0cae89f2beeffae956" + } + }, + "4fbaa1bd51bf4b1e90337a435604d2bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5161248cd0384d5887ed231ecd48c82e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_097fa44254ea4ecda7c8db995f370afc", + "placeholder": "​", + "style": "IPY_MODEL_9fb982789fbc4582bceb356e351db438", + "value": "unet/config.json: 100%" + } + }, + "5269d405725946b3a657d3a8d7b25885": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "52c7e22284b0468c8bc0c3b1cad047fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5405d8a1aa1d411b895b0523fb8e4ce7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "54417d8b9c5249d0a028d9e831dd8be6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "54ab158c643540abb8b3a96c1ae3ecab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_55130e37444844f88286a87c8d153eba", + "IPY_MODEL_7e3048e0fac94dfdaca1bc862ecfce15", + "IPY_MODEL_643ba607008547ba9572fa4880a7d0f2" + ], + "layout": "IPY_MODEL_5738e5d103254c5485856f97d82954ab" + } + }, + "550b3ad10fcb422eb66f71ad95988616": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "55130e37444844f88286a87c8d153eba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_beedc3b275c24432a2e959dcf9dd418d", + "placeholder": "​", + "style": "IPY_MODEL_10690b309908402289e9891203714199", + "value": "scheduler/scheduler_config.json: 100%" + } + }, + "55177afb435f44898df300143703e4d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7049676db714446b98bba16b5f1b049e", + "placeholder": "​", + "style": "IPY_MODEL_09172ff4be4e433483d27b576464d1df", + "value": "tokenizer/tokenizer_config.json: 100%" + } + }, + "556730e12d5d4e0ea51a0dd1b5aac331": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2f016774e7854ef589442734d0bb2f08", + "placeholder": "​", + "style": "IPY_MODEL_a15c3a32bfd347a98c2a50d27cd5b9f9", + "value": "diffusion_pytorch_model.fp16.safetensors: 100%" + } + }, + "5738e5d103254c5485856f97d82954ab": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "577cc4b4f27941189c62951046db24ec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "57b491647f1e49cea7ce34774a963936": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c040aa1f65514be28f0ca8ecdd1f69e4", + "max": 170543052, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_eec76868d92f45d7a6db2e232a45e0c2", + "value": 170543052 + } + }, + "584dd148b2344bdc92f1d0850399aed7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_67ef71b6521b47dd90e3dc0fd03016f2", + "max": 5135149760, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_989c54778eb7469fb91e4337d6f49b0b", + "value": 5135149760 + } + }, + "587bd0b90afa450ba82e49cf86ee135d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cf42fc299989442f94f4a9df63005ab4", + "placeholder": "​", + "style": "IPY_MODEL_90b9300ba00e41e58170ec5634622985", + "value": " 725/725 [00:00<00:00, 55.6kB/s]" + } + }, + "598fa824f517445394d08c37393f9f3d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5a4c6dc09a1049c0adfca9834b045a25": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fd13a58d6b444a0f955832647f64df12", + "max": 472, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_8d492d53eb7f4225b516a65ef80f24e5", + "value": 472 + } + }, + "5a7d87338ddc45df84080e0096a31631": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5ab5097f19cf4474945f96741c444d71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6d8fdd0303774305ae20dd39e2a1706c", + "IPY_MODEL_031a326124f1496abe1f3bf8de720029", + "IPY_MODEL_b9feee6f48bd49209e72e5c5e3136f67" + ], + "layout": "IPY_MODEL_a2d497a2ddb04d8fac8a4c0f8aa7f5dc" + } + }, + "5b3bbc663d504fb99318ba186e6b8499": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c3d142907404cef8fd624839a166530": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_abaecfe7f39a43bb8fbd655d1a3009f4", + "IPY_MODEL_d488374da5e74ec3a5973003590a7d69", + "IPY_MODEL_5d8ae9661dce4a1aac8d418d84f3a209" + ], + "layout": "IPY_MODEL_32132ecbe71a4c2c903932513c2a1aa0" + } + }, + "5c838962c7854541b61877c6d42481c4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5ceb5c369f974b84ba850c9e81730a0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5cf6cd09cda64d688f4a0f7c511533d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5d8ae9661dce4a1aac8d418d84f3a209": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_887c5eae5b154eccb4a1caa3deef6e94", + "placeholder": "​", + "style": "IPY_MODEL_e87dffe17f1948e9ba794eddb605a908", + "value": " 47.3k/47.3k [00:00<00:00, 3.39MB/s]" + } + }, + "5dd09616ba6544c499271054e8d8d2c5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e030e8a026b4513aa954203169f0a27": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5e677518051c43768dbf06243701c817": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d727913663634e368ade4a7dc64fe74b", + "IPY_MODEL_eb73095c804a4272856fe348fa3cb1e9", + "IPY_MODEL_7e9b46b10fa24dfea489dfbc150d2a2e" + ], + "layout": "IPY_MODEL_c8156b0cc68e4b3693dcabc530a4ea9a" + } + }, + "5f52ae61812544f29f774f80fcb7a09c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7d29b20296aa4e33837b8ad53fc4adba", + "placeholder": "​", + "style": "IPY_MODEL_6a94d1d176b844db96de0c0e3cd67701", + "value": " 642/642 [00:00<00:00, 35.8kB/s]" + } + }, + "60cc7415644d4e16b88f8fc5896b4b3b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "60e8e9f8e6ce40dd910ce1a9410b5e24": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "61db57127c5845759360bdf8b29dac2d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f46df85f441e4ada831f0e2b142f296a", + "placeholder": "​", + "style": "IPY_MODEL_d4f1dbe4ce244abc987b1089876e080f", + "value": "tokenizer_2/tokenizer_config.json: 100%" + } + }, + "62afb52a01924566b52f6c2d9ffb76f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "64029a1e70e040b49e38d38bd36823fd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3e1ec3a51e9b4fbbab489d34640cda90", + "IPY_MODEL_ea0910fc31e44597968b2129272cc94d", + "IPY_MODEL_3a0e9adc345f409cbcd79d1bd19219e6" + ], + "layout": "IPY_MODEL_3fe7e7f00ca746cc8cc762da6f365fde" + } + }, + "643ba607008547ba9572fa4880a7d0f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ef25bd6dd644347baac12366d7002fd", + "placeholder": "​", + "style": "IPY_MODEL_0918b23f41e0404e82fccd08cadc6ccf", + "value": " 479/479 [00:00<00:00, 40.5kB/s]" + } + }, + "6466eff2786241eeb142f17758894bb2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "64ea3c5cc12841f59d1acba12deb6a88": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "65b15618abfd4e6f9fafd64813e86ace": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1e8747251a1f4cca970857911d1c4a98", + "IPY_MODEL_caa46820018f47abab4a962afe51cc34", + "IPY_MODEL_22a2ea45880f4b0da47f1b213882dcb0" + ], + "layout": "IPY_MODEL_0cf822f588244e54b5264176f9611164" + } + }, + "65bf3df199b44763aa223fee96889e17": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a32666723b0e4b9883a78f56295c4356", + "IPY_MODEL_c08373a044204308ac882dd8cf9cdd3e", + "IPY_MODEL_fa7876ade8e240fc89a35a1f8c7c7d3c" + ], + "layout": "IPY_MODEL_de583920d3b54774a486aef4c052e50d" + } + }, + "66da596ae59d474f8a82a600174adff6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6703a0417c474db5bf261fe8679051e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6715d91c6b62426aa49c344b65bcd8a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bd176c410a4e48a382a1b688e77aafcb", + "max": 7, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6b586ad7a3054c83b14243d69484127f", + "value": 7 + } + }, + "67567eea233b423c8acd62773a4adb30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5161248cd0384d5887ed231ecd48c82e", + "IPY_MODEL_6f72ea2c284e4e40899375c7b07c517f", + "IPY_MODEL_d99a364420454ba5bfd510d1226b94af" + ], + "layout": "IPY_MODEL_d33c90e8ea0945d397659f6a90cf51b6" + } + }, + "67a03631ebc54f99928f0feb18ab38af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "67b7783351d340d99c44149635b9be84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4cae160456c74a5fa761f026d64b2e35", + "placeholder": "​", + "style": "IPY_MODEL_819a26acd18f443882feb129f2c576d6", + "value": "tokenizer/vocab.json: 100%" + } + }, + "67ef71b6521b47dd90e3dc0fd03016f2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "683863a313034025ab99fab5810f39c7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "683db0ff105a47038c350cfc74b88345": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "685797f8907c47ffab4fe7a81ca22e63": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_222da37b5af14d60814c65cdd1ea20be", + "placeholder": "​", + "style": "IPY_MODEL_6a2b5bbd4afe4e0cabe39e95ccf528be", + "value": "README.md: 100%" + } + }, + "68822f8f861a48859df630fad63f51c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6926c8dd4e4e46d089bb387333691df7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_adf53d97af214cceaae895c8abfbd909", + "max": 170461008, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9d74948f7bcb498c9295e41e690a0a8d", + "value": 170461008 + } + }, + "6a2b5bbd4afe4e0cabe39e95ccf528be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6a8a634cd3844fa081a4622d224ec940": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6a94d1d176b844db96de0c0e3cd67701": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6b586ad7a3054c83b14243d69484127f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6bdb9b0b68c24b84a748c18ed927a8d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6d0f946764444df28cb0da0fd0a408eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f9ca5d4810b34938b6f997ff66a8d541", + "max": 575, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b418ff1733db4efbab1b00b632b894e2", + "value": 575 + } + }, + "6d492ddabcbe4d65b5d311834865ab92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ee8407365f5d42d9b98536152c9efe92", + "max": 524619, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_5ceb5c369f974b84ba850c9e81730a0e", + "value": 524619 + } + }, + "6d8fdd0303774305ae20dd39e2a1706c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7bb3f4cda33947138c61aac74d952289", + "placeholder": "​", + "style": "IPY_MODEL_d3b73a841e68425994632d0f05cf4f16", + "value": "100%" + } + }, + "6f113303101b4f448380a878d8900bf6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6f6a6cfd50404f1ea09f83e95b04550a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f72ea2c284e4e40899375c7b07c517f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0204153b17ca4bb0b21fc033393ce9bd", + "max": 1680, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f02041b1d5e1485bb2ba02b00fc2c242", + "value": 1680 + } + }, + "7049676db714446b98bba16b5f1b049e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "70849993c0c94ecf87c56e430f06181d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "713dec1904ce46f6b2d5a9b7e3e0373a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "71ad1e3dbe44437d8df985cfae207dcd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "734e9a834ff74b64b17453013208a116": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "75384779c5d540d28afb53a0e318b674": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7f63b3d80ecb4c3eb837bd0e616e1623", + "placeholder": "​", + "style": "IPY_MODEL_4f6e7b21ba0747f19b9d63468861c988", + "value": " 167M/167M [00:07<00:00, 24.0MB/s]" + } + }, + "753f64d9069640d985f399a058fc9b5b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "766567be45eb4db6b8d7a3364566c1dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3c222a56d4404863a1dac60f1d03835b", + "IPY_MODEL_db862ffbb44d450db514173df4c7f301", + "IPY_MODEL_ddbeb13bb8174fc0b7d5543108d1c4f5" + ], + "layout": "IPY_MODEL_5b3bbc663d504fb99318ba186e6b8499" + } + }, + "76a474e4aab14a5987cf25d1391d578c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_68822f8f861a48859df630fad63f51c1", + "placeholder": "​", + "style": "IPY_MODEL_2671327d35e64f0da670a3a611fd0886", + "value": " 1.39G/1.39G [01:02<00:00, 24.3MB/s]" + } + }, + "777c5583820248838f0c39e82362d9e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_734e9a834ff74b64b17453013208a116", + "placeholder": "​", + "style": "IPY_MODEL_9784d9210d6e4214b78ab5f8c33e8044", + "value": "Loading pipeline components...: 100%" + } + }, + "7a52c380a91c4f49bbfde658550248d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7ba112dcece64386bdbac6837004891b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7bb3f4cda33947138c61aac74d952289": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7c6c4dff0a814bc6a7ac677980b45add": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7d282fda276343c3aff99b001253ecc1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7d29b20296aa4e33837b8ad53fc4adba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7e3048e0fac94dfdaca1bc862ecfce15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0c68c6c65fb94650b15069a25d9e1699", + "max": 479, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ad233dfd52034b9e8c6c2c5b86995717", + "value": 479 + } + }, + "7e9b46b10fa24dfea489dfbc150d2a2e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2db944a049a04426bba181fddb2801b1", + "placeholder": "​", + "style": "IPY_MODEL_683863a313034025ab99fab5810f39c7", + "value": " 171M/171M [00:00<00:00, 302MB/s]" + } + }, + "7f63b3d80ecb4c3eb837bd0e616e1623": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "804e7ee768794bba88aec3137f418868": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a52c380a91c4f49bbfde658550248d3", + "placeholder": "​", + "style": "IPY_MODEL_3e418e46c47841ac9d717a6981807f68", + "value": " 565/565 [00:00<00:00, 16.6kB/s]" + } + }, + "819a26acd18f443882feb129f2c576d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "83afce4becac4f37ba916bf1901346ff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "83f2d1dfaba54da38f0421b69930c3c1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "85f22e78d47641d19efb6e6d62f6a014": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d8bbb7402f3e44b2899fc98f02cee87e", + "IPY_MODEL_8b41763280a048d485f06682ddc12ca2", + "IPY_MODEL_05791b70a24a42138755141602399c47" + ], + "layout": "IPY_MODEL_753f64d9069640d985f399a058fc9b5b" + } + }, + "86cb336c1f684867bd13dae0370b4d36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8840288388ae4162884feef9c8e776f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_67b7783351d340d99c44149635b9be84", + "IPY_MODEL_0f60c0f123954744ad13b670ca6dce77", + "IPY_MODEL_dfabe7aa70024d1aa868ef5e6650dc6d" + ], + "layout": "IPY_MODEL_7d282fda276343c3aff99b001253ecc1" + } + }, + "887c5eae5b154eccb4a1caa3deef6e94": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "89ed71090d5c4366b21d25ad102e7da7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a8ef60b3b72452fb9ccc31052ab3b4f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8b41763280a048d485f06682ddc12ca2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9c6ab017f5fb46eda8e3c22e9dd2b838", + "max": 17, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_10bc970e474a46249e2a5e9e43fec7be", + "value": 17 + } + }, + "8b6464ce614c4aa29ac66ecce29b6cbf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8b88a1a63cf242de8a68962f50498c72": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_777c5583820248838f0c39e82362d9e3", + "IPY_MODEL_491da86a94c44b7c87366b4bb72a3bd1", + "IPY_MODEL_31c3a375a2964a06a2473925fe9b197b" + ], + "layout": "IPY_MODEL_0ba0a0fca31c482bb628a6739d341601" + } + }, + "8d492d53eb7f4225b516a65ef80f24e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8e3b0b9f26a34ab8a932756b32834fd0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "90558769855c4bb08ff2fe4af940c45b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b79d32186443469d94836b663bf156b5", + "max": 167335342, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_86cb336c1f684867bd13dae0370b4d36", + "value": 167335342 + } + }, + "90b9300ba00e41e58170ec5634622985": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "917139ad07a64e0cae89f2beeffae956": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "955ec2551f8b400dbbdba68d7449de76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95e24bbc8397455fabb724ed3c330511": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b1d427082b9f452eb6546c7d55016b36", + "placeholder": "​", + "style": "IPY_MODEL_061fcc6e5f3c44c48cde212c1ba515e5", + "value": "diffusion_pytorch_model.fp16.safetensors: 100%" + } + }, + "971f59d5f3e04697b3ab3c39ec0fc667": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9784d9210d6e4214b78ab5f8c33e8044": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "979c68bd2e224a40b939c27f32c25dac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9810873713024e79ae6d338dfeae5876": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "989c54778eb7469fb91e4337d6f49b0b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "993e5303f107468f83dbf51026e64301": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_83afce4becac4f37ba916bf1901346ff", + "placeholder": "​", + "style": "IPY_MODEL_071e40d45ad14fc19b1480927d15d2ae", + "value": "tokenizer_2/special_tokens_map.json: 100%" + } + }, + "99717def9b6b4afe8a411a3bb83320c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9a37ffb9810f482b80f245f64947c371": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9a9da0d0e3d84a19b5d188c9bd6a83bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9ad4192f6f244264aede1b3c8ac3c57a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fdb799739700447d8a5198f1f4f9b17f", + "placeholder": "​", + "style": "IPY_MODEL_683db0ff105a47038c350cfc74b88345", + "value": "diffusion_pytorch_model.fp16.safetensors: 100%" + } + }, + "9c6ab017f5fb46eda8e3c22e9dd2b838": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d74948f7bcb498c9295e41e690a0a8d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9e2e87c131a140a2a37dfdf483d27ced": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9fb982789fbc4582bceb356e351db438": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a0f8a1a3512443ac84799b95da70ca26": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a15c3a32bfd347a98c2a50d27cd5b9f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a16016987b6145b69caaac6712d72835": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c82cf8cf90ed4e93bccffcf75881a56d", + "IPY_MODEL_5a4c6dc09a1049c0adfca9834b045a25", + "IPY_MODEL_c4d83c2b37504473afe63209a178b4cd" + ], + "layout": "IPY_MODEL_fae9d16daace412492b048b012b8d6dc" + } + }, + "a287f197e4fe4f908e3ee0a0e6cb35cf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a2d497a2ddb04d8fac8a4c0f8aa7f5dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a32666723b0e4b9883a78f56295c4356": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_979c68bd2e224a40b939c27f32c25dac", + "placeholder": "​", + "style": "IPY_MODEL_0027f3aa006d4276983691ad985ce91b", + "value": "Loading pipeline components...: 100%" + } + }, + "a3ce5829f8a640e79a19d737663b8474": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a48d3ad24e9744f7898d1f2c5a696ea2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a6295c7e7630444c9b7425b884ad9707": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a65484354d254516936fcb425917a4b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a6bb8206de044c74a03d1a64c801e742": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a6f2ce8830734be4b8efe5ca0e14e990": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_de31002ed7fc475c915b4a29253108af", + "placeholder": "​", + "style": "IPY_MODEL_fbf3d268f30344b7864ce691d5bcb1f3", + "value": " 47.3k/47.3k [00:00<00:00, 3.74MB/s]" + } + }, + "a708db5805424449afa269b714ebb3b3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_24cbd9338ad94801aa11f4dcb2a867cb", + "placeholder": "​", + "style": "IPY_MODEL_c88fcf0d20154b1fb9b7e8a00116b5e6", + "value": "tokenizer/merges.txt: 100%" + } + }, + "a7767d5a440f4c819cdb87414f2187ff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a91df5ceea8647d98f4d49701bb00969": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5269d405725946b3a657d3a8d7b25885", + "placeholder": "​", + "style": "IPY_MODEL_b4a697d8335c435ab21219716a1da022", + "value": " 609/609 [00:00<00:00, 49.0kB/s]" + } + }, + "a9ac3b2188594c19885bcdb9a659ecde": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a708db5805424449afa269b714ebb3b3", + "IPY_MODEL_6d492ddabcbe4d65b5d311834865ab92", + "IPY_MODEL_e17e3253c16743a29f09b82d23c3b26d" + ], + "layout": "IPY_MODEL_e67a69c294334b01974f8bef36f133a0" + } + }, + "aae194e7f71f4eba80ffd18f91f083a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9ad4192f6f244264aede1b3c8ac3c57a", + "IPY_MODEL_90558769855c4bb08ff2fe4af940c45b", + "IPY_MODEL_75384779c5d540d28afb53a0e318b674" + ], + "layout": "IPY_MODEL_a287f197e4fe4f908e3ee0a0e6cb35cf" + } + }, + "ab9c869439a94bddbbc0c6098f4c5b2a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_13ac509e0d5f42e9bbb6deda62f77923", + "max": 725, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4a4a50a17c014f189b52119901104d79", + "value": 725 + } + }, + "abaecfe7f39a43bb8fbd655d1a3009f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_05700817adac4fdda6c95dd00eaeae38", + "placeholder": "​", + "style": "IPY_MODEL_5a7d87338ddc45df84080e0096a31631", + "value": "pixel/adapter_config.json: 100%" + } + }, + "abf2248c725b4837b5c2babef7f4ff3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d872c3900b8b4275b2224c9ec5e7d78f", + "placeholder": "​", + "style": "IPY_MODEL_4fbaa1bd51bf4b1e90337a435604d2bd", + "value": " 170M/170M [00:12<00:00, 18.9MB/s]" + } + }, + "ad233dfd52034b9e8c6c2c5b86995717": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "adb2daf9d62f49f8ab1f0144b717d41e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bba38c266ceb4f30bb4bc1eaf5e3aa96", + "IPY_MODEL_6926c8dd4e4e46d089bb387333691df7", + "IPY_MODEL_abf2248c725b4837b5c2babef7f4ff3e" + ], + "layout": "IPY_MODEL_39e4bdf8d621451f984f6e7302fd6961" + } + }, + "adf53d97af214cceaae895c8abfbd909": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aed53b6480de4dd4bc7463af04840952": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aef81ec1a7e844f883beba8c5754a8af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "af5003cf40ae4dfaa0660f247598856e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b0abce2d8a2046dba320e788e33e9d66": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b1d427082b9f452eb6546c7d55016b36": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b25e822b3f77431fb72b4780067c90d9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_55177afb435f44898df300143703e4d8", + "IPY_MODEL_b79d3f5bd8024451bc7148ba2a5029bd", + "IPY_MODEL_eacd646e2b984e60ab603bfc6d631de8" + ], + "layout": "IPY_MODEL_d158a80f4186411a8a9c335a8d5a888e" + } + }, + "b27ac2aaff694dd5999ab2cba91195da": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_556730e12d5d4e0ea51a0dd1b5aac331", + "IPY_MODEL_584dd148b2344bdc92f1d0850399aed7", + "IPY_MODEL_ccc5bdc185a84901994577ff7f1bc962" + ], + "layout": "IPY_MODEL_2c75632d8fdc4458814055172d1d72c3" + } + }, + "b27c74f0c7bf493fa8bcb4c5b9c9c100": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b28a2b59aab9478e9ac3ab24a1de6f9a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b3eaa188cc2e48d081488eea4ed2971f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b418ff1733db4efbab1b00b632b894e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b44f7154c55146a3bf5f4bd9e438086f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b4a697d8335c435ab21219716a1da022": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b600178b161d4a87a0b832a169d7caf2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b79d32186443469d94836b663bf156b5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b79d3f5bd8024451bc7148ba2a5029bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ea257c1c73524141b87ab3c1ef85c908", + "max": 737, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c474ed5e340146baae6c38f62013afe3", + "value": 737 + } + }, + "b999b3e3af3744a79c0c90657ef37d4e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_713dec1904ce46f6b2d5a9b7e3e0373a", + "placeholder": "​", + "style": "IPY_MODEL_a6bb8206de044c74a03d1a64c801e742", + "value": "" + } + }, + "b9feee6f48bd49209e72e5c5e3136f67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_daad0d12aff8470d990fbbbbe19d5891", + "placeholder": "​", + "style": "IPY_MODEL_16e18e872ab64b3f8bfb32f580c3371b", + "value": " 30/30 [00:03<00:00,  8.40it/s]" + } + }, + "ba9b002888b448738ba4b127e1046f5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bab2458ba3f54b229828ad9c8706aba4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "babce0e85baf4279ae1d22d64006667f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bba38c266ceb4f30bb4bc1eaf5e3aa96": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4abac6a83641414499f9b6b1514d1695", + "placeholder": "​", + "style": "IPY_MODEL_bf6e103b43844f17968eadf223a42acb", + "value": "adapter_model.safetensors: 100%" + } + }, + "bc07cdaad5b64fb3b0e1f8c214bba813": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bcb3ec98d25b4c138c5e8f84c1e937c6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bd176c410a4e48a382a1b688e77aafcb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bd2740e191a74558a77a965b4f2d7f28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_48f51c96b7574946bf9542633eb39135", + "placeholder": "​", + "style": "IPY_MODEL_35c810f4bfe741f091f172cede413950", + "value": " 0/0 [00:00<?, ?it/s]" + } + }, + "bdfe4e4109a14a41bcd2e1e4242d82bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "beedc3b275c24432a2e959dcf9dd418d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bf6e103b43844f17968eadf223a42acb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c008577d922e436aabb8680ca0d13117": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c040aa1f65514be28f0ca8ecdd1f69e4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c05842ed12c848c68c4a69de9aa742a8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c08373a044204308ac882dd8cf9cdd3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a0f8a1a3512443ac84799b95da70ca26", + "max": 7, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e08d739f59874064994212363a307f6e", + "value": 7 + } + }, + "c08fca70486040069d4f8f1df46a1074": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c181408b9b2b437ca11d584e3d1e94e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c212598c5a8747f783a6efc18816e868": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c292a598350d4dd4bb9b70aab1320c29": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cdd8f9b1592842b48e1ffa80f8ec8246", + "placeholder": "​", + "style": "IPY_MODEL_ba9b002888b448738ba4b127e1046f5d", + "value": " 246M/246M [00:00<00:00, 345MB/s]" + } + }, + "c474ed5e340146baae6c38f62013afe3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c4d83c2b37504473afe63209a178b4cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_70849993c0c94ecf87c56e430f06181d", + "placeholder": "​", + "style": "IPY_MODEL_e820c557697648378966ed0a073826c8", + "value": " 472/472 [00:00<00:00, 10.4kB/s]" + } + }, + "c68a5ad3bb664e8785e724085d208e96": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c6bdeef396174d51af9eee277752bec7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_685797f8907c47ffab4fe7a81ca22e63", + "IPY_MODEL_414f8301f76043758f69bbfb6960072d", + "IPY_MODEL_23c0492f021a4b60b1d84b0b82d15378" + ], + "layout": "IPY_MODEL_550b3ad10fcb422eb66f71ad95988616" + } + }, + "c7cf10df8d7944aeb93947d5f4156c92": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_de0b54a59d9f47408d92915ad746cd5e", + "placeholder": "​", + "style": "IPY_MODEL_eb9a5f255fa0447eba6a33e1c30ba166", + "value": " 167M/167M [00:08<00:00, 18.9MB/s]" + } + }, + "c80901426c87439481078b9da2e0c772": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_416f31db79fd431fb8dc06e994421b70", + "IPY_MODEL_1971fcd35a564c449b4f437dac46058f", + "IPY_MODEL_76a474e4aab14a5987cf25d1391d578c" + ], + "layout": "IPY_MODEL_ff3bf3f1873c4b01b0a547dfe02923ce" + } + }, + "c8156b0cc68e4b3693dcabc530a4ea9a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c82cf8cf90ed4e93bccffcf75881a56d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_421b59f4021d4c4d930c51b6b4c7071f", + "placeholder": "​", + "style": "IPY_MODEL_60cc7415644d4e16b88f8fc5896b4b3b", + "value": "tokenizer/special_tokens_map.json: 100%" + } + }, + "c8555cb30ade40b9bd9a3435d6deeb67": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c88fcf0d20154b1fb9b7e8a00116b5e6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c8e40d44aeac47a78f6502771f1471b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a48d3ad24e9744f7898d1f2c5a696ea2", + "placeholder": "​", + "style": "IPY_MODEL_f29673e57d174839a0bde70bfa165715", + "value": "adapter_model.safetensors: 100%" + } + }, + "c995197e66e04874a9f5d34db98b8890": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_83f2d1dfaba54da38f0421b69930c3c1", + "placeholder": "​", + "style": "IPY_MODEL_577cc4b4f27941189c62951046db24ec", + "value": " 575/575 [00:00<00:00, 11.1kB/s]" + } + }, + "c9f764b5036042af9f1505e3729cbc32": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b999b3e3af3744a79c0c90657ef37d4e", + "IPY_MODEL_f3baef4fbf4b4ec08480522be921f841", + "IPY_MODEL_bd2740e191a74558a77a965b4f2d7f28" + ], + "layout": "IPY_MODEL_6f6a6cfd50404f1ea09f83e95b04550a" + } + }, + "ca5dc8342ef946a49d9e67a21f1a67c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "caa46820018f47abab4a962afe51cc34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aed53b6480de4dd4bc7463af04840952", + "max": 30, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_447d29db05384c55a57c5fb1bd121af4", + "value": 30 + } + }, + "cb89ecd5a8c14051985495da1797a202": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_61db57127c5845759360bdf8b29dac2d", + "IPY_MODEL_ab9c869439a94bddbbc0c6098f4c5b2a", + "IPY_MODEL_587bd0b90afa450ba82e49cf86ee135d" + ], + "layout": "IPY_MODEL_955ec2551f8b400dbbdba68d7449de76" + } + }, + "cb9a536bc56f4d0ebf285e7f73d4730e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cc06ed7338b74ae6a1c563212aeb9f94": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ccc5bdc185a84901994577ff7f1bc962": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_439cf6c6f9e845cea4008e3219454ff4", + "placeholder": "​", + "style": "IPY_MODEL_460c3c96d1724713b78bddcfc1f3eb97", + "value": " 5.14G/5.14G [00:14<00:00, 393MB/s]" + } + }, + "cd08b99de03c483a965248ff4df752ba": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c05842ed12c848c68c4a69de9aa742a8", + "max": 7, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_18e3ba4a61784f04b3238cf273c90c3e", + "value": 7 + } + }, + "cdd8f9b1592842b48e1ffa80f8ec8246": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cf42fc299989442f94f4a9df63005ab4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cfc6ec59d45d42d187f42061902abbfb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d158a80f4186411a8a9c335a8d5a888e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d18c97fe685e4be080125ae770526255": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e44c018bc76c48cd8738fee5966767ce", + "IPY_MODEL_57b491647f1e49cea7ce34774a963936", + "IPY_MODEL_484f694f734b4a92a14ecc4d048db0af" + ], + "layout": "IPY_MODEL_bcb3ec98d25b4c138c5e8f84c1e937c6" + } + }, + "d1e4d2fd70e644f986104c998db7e53b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f786a0f386f6486083c15e576f6eb3e7", + "IPY_MODEL_6715d91c6b62426aa49c344b65bcd8a2", + "IPY_MODEL_0b0a85e1133c4ca3ba716e2403511703" + ], + "layout": "IPY_MODEL_017dc44dbe1c4de491e003a1e279a218" + } + }, + "d2cd2572973249baa8e130b5777f4147": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b27c74f0c7bf493fa8bcb4c5b9c9c100", + "placeholder": "​", + "style": "IPY_MODEL_09638c8da74f4dddaf1d5d94dd8ad885", + "value": "model.fp16.safetensors: 100%" + } + }, + "d2ed1988cf8c4bcdb1793b3d5068efed": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d33c90e8ea0945d397659f6a90cf51b6": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d35b3848508c4b6390c243866649439d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d70508c304794bc79e80aab136eaf65a", + "max": 167335342, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_01b20535e40b47068723073ac6c819ee", + "value": 167335342 + } + }, + "d37c6ac25fd34a65bf307896443a5063": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_42a623abc5d84c0eb7de4e5323bb6546", + "placeholder": "​", + "style": "IPY_MODEL_a65484354d254516936fcb425917a4b7", + "value": " 7/7 [00:01<00:00,  6.68it/s]" + } + }, + "d3b73a841e68425994632d0f05cf4f16": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d432098a941c463599648b156abea24b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d62465d39d7e4265832901e9b9707993", + "placeholder": "​", + "style": "IPY_MODEL_4f56214f69034077bafdfdabc1c2aebf", + "value": " 460/460 [00:00<00:00, 33.3kB/s]" + } + }, + "d488374da5e74ec3a5973003590a7d69": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cb9a536bc56f4d0ebf285e7f73d4730e", + "max": 47271, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_49bb475a11104e9496f2623e3d5caebd", + "value": 47271 + } + }, + "d4baf7891f854c9c9898314633f97356": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d4f1dbe4ce244abc987b1089876e080f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d62465d39d7e4265832901e9b9707993": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d70508c304794bc79e80aab136eaf65a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d727913663634e368ade4a7dc64fe74b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d987907f09084d44b452f939aadff65e", + "placeholder": "​", + "style": "IPY_MODEL_e976b994189343f5ba7d762ef92c79e2", + "value": "toy_face_sdxl.safetensors: 100%" + } + }, + "d74b1c667d42472b865ee1cbefc33a60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1074a274530e46c5b5a3e43653da43d0", + "IPY_MODEL_dfde3984062442869bc8091bb94f2c36", + "IPY_MODEL_a6f2ce8830734be4b8efe5ca0e14e990" + ], + "layout": "IPY_MODEL_07da49088e8d480fad03a2e828357872" + } + }, + "d872c3900b8b4275b2224c9ec5e7d78f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d8bbb7402f3e44b2899fc98f02cee87e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_19679186751b42e3ad2c44ea46c82a9c", + "placeholder": "​", + "style": "IPY_MODEL_d4baf7891f854c9c9898314633f97356", + "value": "Fetching 17 files: 100%" + } + }, + "d987907f09084d44b452f939aadff65e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d99a364420454ba5bfd510d1226b94af": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4d327c9e91b34c7b84cedd8f9660e9fd", + "placeholder": "​", + "style": "IPY_MODEL_b44f7154c55146a3bf5f4bd9e438086f", + "value": " 1.68k/1.68k [00:00<00:00, 126kB/s]" + } + }, + "daad0d12aff8470d990fbbbbe19d5891": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "db862ffbb44d450db514173df4c7f301": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fe958df746be4dc1871bd58628697c3c", + "max": 1059962, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_54417d8b9c5249d0a028d9e831dd8be6", + "value": 1059962 + } + }, + "db8fd6b2687c449fa0600d3e87c96999": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_355efc45ddaf42498d72d6134a28c87b", + "placeholder": "​", + "style": "IPY_MODEL_8b6464ce614c4aa29ac66ecce29b6cbf", + "value": "adapter_model.safetensors: 100%" + } + }, + "dc4391fe30694a788134fffdd2a23d1a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dd42a2ff90854b74ba5fde1de26b4e15": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dd9666d76af04b72b08f59023eb04ee3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ddbeb13bb8174fc0b7d5543108d1c4f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9a37ffb9810f482b80f245f64947c371", + "placeholder": "​", + "style": "IPY_MODEL_bdfe4e4109a14a41bcd2e1e4242d82bb", + "value": " 1.06M/1.06M [00:00<00:00, 42.3MB/s]" + } + }, + "de0b54a59d9f47408d92915ad746cd5e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de31002ed7fc475c915b4a29253108af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de583920d3b54774a486aef4c052e50d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dfabe7aa70024d1aa868ef5e6650dc6d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_60e8e9f8e6ce40dd910ce1a9410b5e24", + "placeholder": "​", + "style": "IPY_MODEL_6703a0417c474db5bf261fe8679051e9", + "value": " 1.06M/1.06M [00:00<00:00, 1.49MB/s]" + } + }, + "dfde3984062442869bc8091bb94f2c36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7c6c4dff0a814bc6a7ac677980b45add", + "max": 47271, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9a9da0d0e3d84a19b5d188c9bd6a83bb", + "value": 47271 + } + }, + "e08d739f59874064994212363a307f6e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e15aab8dd01f4d5582db80e6ad9931fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e17e3253c16743a29f09b82d23c3b26d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a7767d5a440f4c819cdb87414f2187ff", + "placeholder": "​", + "style": "IPY_MODEL_f0bc6b14a299445ca705b888b3047064", + "value": " 525k/525k [00:00<00:00, 9.01MB/s]" + } + }, + "e3a1a5e9f29d4d28b0b9496493dafa21": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e44c018bc76c48cd8738fee5966767ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b0abce2d8a2046dba320e788e33e9d66", + "placeholder": "​", + "style": "IPY_MODEL_aef81ec1a7e844f883beba8c5754a8af", + "value": "pixel-art-xl.safetensors: 100%" + } + }, + "e57d317b3dda43bba13ecd4514f776d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3a017f1d0ebf4a4aab57ac3eb0788774", + "placeholder": "​", + "style": "IPY_MODEL_48643ea67f2f4762bcd27de1d4cf0fd2", + "value": " 170M/170M [00:07<00:00, 24.6MB/s]" + } + }, + "e67a69c294334b01974f8bef36f133a0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e820c557697648378966ed0a073826c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e87dffe17f1948e9ba794eddb605a908": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e976b994189343f5ba7d762ef92c79e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ea0910fc31e44597968b2129272cc94d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0371aa5607604c06a868deb2a413cb31", + "max": 30, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c212598c5a8747f783a6efc18816e868", + "value": 30 + } + }, + "ea257c1c73524141b87ab3c1ef85c908": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eacd646e2b984e60ab603bfc6d631de8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2ece04bc10934b3cb9d383abfc5ccd6e", + "placeholder": "​", + "style": "IPY_MODEL_67a03631ebc54f99928f0feb18ab38af", + "value": " 737/737 [00:00<00:00, 41.5kB/s]" + } + }, + "eb73095c804a4272856fe348fa3cb1e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9810873713024e79ae6d338dfeae5876", + "max": 170543292, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2e18ce21c01a4a3ca992622957e7d297", + "value": 170543292 + } + }, + "eb9a5f255fa0447eba6a33e1c30ba166": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ee8407365f5d42d9b98536152c9efe92": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eec76868d92f45d7a6db2e232a45e0c2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "efd33121bdfc4ce195a07c9ef523a477": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d2cd2572973249baa8e130b5777f4147", + "IPY_MODEL_4e77d8b6cdb94fc68974d27b24cfb3fd", + "IPY_MODEL_c292a598350d4dd4bb9b70aab1320c29" + ], + "layout": "IPY_MODEL_c68a5ad3bb664e8785e724085d208e96" + } + }, + "f02041b1d5e1485bb2ba02b00fc2c242": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f0bc6b14a299445ca705b888b3047064": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f2596717405c40e1a39b721386e7a972": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f29673e57d174839a0bde70bfa165715": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f2c67c29e1224df3b2def5a87eb8d368": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "f3baef4fbf4b4ec08480522be921f841": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f2c67c29e1224df3b2def5a87eb8d368", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_486282a4ead148868005c592d74a4ed4", + "value": 0 + } + }, + "f46df85f441e4ada831f0e2b142f296a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f668dd13af6f41d8be358f7db5261c54": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f786a0f386f6486083c15e576f6eb3e7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e3a1a5e9f29d4d28b0b9496493dafa21", + "placeholder": "​", + "style": "IPY_MODEL_c008577d922e436aabb8680ca0d13117", + "value": "Loading pipeline components...: 100%" + } + }, + "f8e6babf4fdd4c8e80d6dd24ff22d464": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f9ca5d4810b34938b6f997ff66a8d541": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fa7876ade8e240fc89a35a1f8c7c7d3c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_52c7e22284b0468c8bc0c3b1cad047fb", + "placeholder": "​", + "style": "IPY_MODEL_17c29bbcbc0c437c9c8bc83e0b085f1a", + "value": " 7/7 [00:01<00:00,  6.49it/s]" + } + }, + "faddc146c69545cdaeb81edc8a0cda70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b600178b161d4a87a0b832a169d7caf2", + "placeholder": "​", + "style": "IPY_MODEL_b3eaa188cc2e48d081488eea4ed2971f", + "value": "Loading pipeline components...: 100%" + } + }, + "fae9d16daace412492b048b012b8d6dc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fbf3d268f30344b7864ce691d5bcb1f3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fc1391aaeaad4eecad967e800a669ec1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fd0ff16b68b2488d8c31ebe700dee9c9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0e49d820da754da785bec2e5940eb9f6", + "IPY_MODEL_0b53b908088648e3b2beadaeba0f5da1", + "IPY_MODEL_804e7ee768794bba88aec3137f418868" + ], + "layout": "IPY_MODEL_0d786d8386ba49d0b53a5452d52e722d" + } + }, + "fd13a58d6b444a0f955832647f64df12": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fd672cd5ba0c4695be4240707dcf4bf3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fdb1fd279a0241429e5721ae2e92d217": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fdb799739700447d8a5198f1f4f9b17f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe19dcea6d9a44d28f077e065f1671c4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe958df746be4dc1871bd58628697c3c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ff3bf3f1873c4b01b0a547dfe02923ce": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/multilayer_perceptron/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/multilayer_perceptron/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fa3b05e2cb5487791ddbea5a3945ef6a0923c04e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/multilayer_perceptron/README.md @@ -0,0 +1,5 @@ +# Fine-tuning a multilayer perceptron using LoRA and 🤗 PEFT + +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/multilayer_perceptron/multilayer_perceptron_lora.ipynb) + +PEFT supports fine-tuning any type of model as long as the layers being used are supported. The model does not have to be a transformers model, for instance. To demonstrate this, the accompanying notebook `multilayer_perceptron_lora.ipynb` shows how to apply LoRA to a simple multilayer perceptron and use it to train a model to perform a classification task. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/multilayer_perceptron/multilayer_perceptron_lora.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/multilayer_perceptron/multilayer_perceptron_lora.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..d5ce302e0754a5cf283471b299ec563a05a8a086 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/multilayer_perceptron/multilayer_perceptron_lora.ipynb @@ -0,0 +1,752 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8e8743c8", + "metadata": {}, + "source": [ + "# Using PEFT with custom models" + ] + }, + { + "cell_type": "markdown", + "id": "c42c67e1", + "metadata": {}, + "source": [ + "`peft` allows us to fine-tune models efficiently with LoRA. In this short notebook, we will demonstrate how to train a simple multilayer perceptron (MLP) using `peft`." + ] + }, + { + "cell_type": "markdown", + "id": "ce314af5", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "markdown", + "id": "b28b214d", + "metadata": {}, + "source": [ + "Make sure that you have the latest version of `peft` installed. To ensure that, run this in your Python environment:\n", + " \n", + " python -m pip install --upgrade peft" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4d9da3d9", + "metadata": {}, + "outputs": [], + "source": [ + "import copy\n", + "import os\n", + "\n", + "# ignore bnb warnings\n", + "os.environ[\"BITSANDBYTES_NOWELCOME\"] = \"1\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "44075f54", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/dist-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import peft\n", + "import torch\n", + "from torch import nn\n", + "import torch.nn.functional as F" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f72acdfb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.manual_seed(0)" + ] + }, + { + "cell_type": "markdown", + "id": "2b127a78", + "metadata": {}, + "source": [ + "## Data" + ] + }, + { + "cell_type": "markdown", + "id": "f265da76", + "metadata": {}, + "source": [ + "We will create a toy dataset consisting of random data for a classification task. There is a little bit of signal in the data, so we should expect that the loss of the model can improve during training." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b355567e", + "metadata": {}, + "outputs": [], + "source": [ + "X = torch.rand((1000, 20))\n", + "y = (X.sum(1) > 10).long()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a60a869d", + "metadata": {}, + "outputs": [], + "source": [ + "n_train = 800\n", + "batch_size = 64" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8859572e", + "metadata": {}, + "outputs": [], + "source": [ + "train_dataloader = torch.utils.data.DataLoader(\n", + " torch.utils.data.TensorDataset(X[:n_train], y[:n_train]),\n", + " batch_size=batch_size,\n", + " shuffle=True,\n", + ")\n", + "eval_dataloader = torch.utils.data.DataLoader(\n", + " torch.utils.data.TensorDataset(X[n_train:], y[n_train:]),\n", + " batch_size=batch_size,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "97bddd2c", + "metadata": {}, + "source": [ + "## Model" + ] + }, + { + "cell_type": "markdown", + "id": "db694a58", + "metadata": {}, + "source": [ + "As a model, we use a simple multilayer perceptron (MLP). For demonstration purposes, we use a very large number of hidden units. This is totally overkill for this task but it helps to demonstrate the advantages of `peft`. In more realistic settings, models will also be quite large on average, so this is not far-fetched." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1b43cd8f", + "metadata": {}, + "outputs": [], + "source": [ + "class MLP(nn.Module):\n", + " def __init__(self, num_units_hidden=2000):\n", + " super().__init__()\n", + " self.seq = nn.Sequential(\n", + " nn.Linear(20, num_units_hidden),\n", + " nn.ReLU(),\n", + " nn.Linear(num_units_hidden, num_units_hidden),\n", + " nn.ReLU(),\n", + " nn.Linear(num_units_hidden, 2),\n", + " nn.LogSoftmax(dim=-1),\n", + " )\n", + "\n", + " def forward(self, X):\n", + " return self.seq(X)" + ] + }, + { + "cell_type": "markdown", + "id": "1277bf00", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "markdown", + "id": "02caf26a", + "metadata": {}, + "source": [ + "Here are just a few training hyper-parameters and a simple function that performs the training and evaluation loop." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5d14c0c4", + "metadata": {}, + "outputs": [], + "source": [ + "lr = 0.002\n", + "batch_size = 64\n", + "max_epochs = 30\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "657d6b3e", + "metadata": {}, + "outputs": [], + "source": [ + "def train(model, optimizer, criterion, train_dataloader, eval_dataloader, epochs):\n", + " for epoch in range(epochs):\n", + " model.train()\n", + " train_loss = 0\n", + " for xb, yb in train_dataloader:\n", + " xb = xb.to(device)\n", + " yb = yb.to(device)\n", + " outputs = model(xb)\n", + " loss = criterion(outputs, yb)\n", + " train_loss += loss.detach().float()\n", + " loss.backward()\n", + " optimizer.step()\n", + " optimizer.zero_grad()\n", + "\n", + " model.eval()\n", + " eval_loss = 0\n", + " for xb, yb in eval_dataloader:\n", + " xb = xb.to(device)\n", + " yb = yb.to(device)\n", + " with torch.no_grad():\n", + " outputs = model(xb)\n", + " loss = criterion(outputs, yb)\n", + " eval_loss += loss.detach().float()\n", + "\n", + " eval_loss_total = (eval_loss / len(eval_dataloader)).item()\n", + " train_loss_total = (train_loss / len(train_dataloader)).item()\n", + " print(f\"{epoch=:<2} {train_loss_total=:.4f} {eval_loss_total=:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b382dcbe", + "metadata": {}, + "source": [ + "### Training without peft" + ] + }, + { + "cell_type": "markdown", + "id": "b40d4873", + "metadata": {}, + "source": [ + "Let's start without using `peft` to see what we can expect from the model training." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f059ced4", + "metadata": {}, + "outputs": [], + "source": [ + "module = MLP().to(device)\n", + "optimizer = torch.optim.Adam(module.parameters(), lr=lr)\n", + "criterion = nn.CrossEntropyLoss()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "17698863", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=0 train_loss_total=0.7970 eval_loss_total=0.6472\n", + "epoch=1 train_loss_total=0.5597 eval_loss_total=0.4898\n", + "epoch=2 train_loss_total=0.3696 eval_loss_total=0.3323\n", + "epoch=3 train_loss_total=0.2364 eval_loss_total=0.5454\n", + "epoch=4 train_loss_total=0.2428 eval_loss_total=0.2843\n", + "epoch=5 train_loss_total=0.1251 eval_loss_total=0.2514\n", + "epoch=6 train_loss_total=0.0952 eval_loss_total=0.2068\n", + "epoch=7 train_loss_total=0.0831 eval_loss_total=0.2395\n", + "epoch=8 train_loss_total=0.0655 eval_loss_total=0.2524\n", + "epoch=9 train_loss_total=0.0380 eval_loss_total=0.3650\n", + "epoch=10 train_loss_total=0.0363 eval_loss_total=0.3495\n", + "epoch=11 train_loss_total=0.0231 eval_loss_total=0.2360\n", + "epoch=12 train_loss_total=0.0162 eval_loss_total=0.2276\n", + "epoch=13 train_loss_total=0.0094 eval_loss_total=0.2716\n", + "epoch=14 train_loss_total=0.0065 eval_loss_total=0.2237\n", + "epoch=15 train_loss_total=0.0054 eval_loss_total=0.2366\n", + "epoch=16 train_loss_total=0.0035 eval_loss_total=0.2673\n", + "epoch=17 train_loss_total=0.0028 eval_loss_total=0.2630\n", + "epoch=18 train_loss_total=0.0023 eval_loss_total=0.2835\n", + "epoch=19 train_loss_total=0.0021 eval_loss_total=0.2727\n", + "epoch=20 train_loss_total=0.0018 eval_loss_total=0.2597\n", + "epoch=21 train_loss_total=0.0016 eval_loss_total=0.2553\n", + "epoch=22 train_loss_total=0.0014 eval_loss_total=0.2712\n", + "epoch=23 train_loss_total=0.0013 eval_loss_total=0.2637\n", + "epoch=24 train_loss_total=0.0012 eval_loss_total=0.2733\n", + "epoch=25 train_loss_total=0.0011 eval_loss_total=0.2738\n", + "epoch=26 train_loss_total=0.0010 eval_loss_total=0.2477\n", + "epoch=27 train_loss_total=0.0010 eval_loss_total=0.2584\n", + "epoch=28 train_loss_total=0.0009 eval_loss_total=0.2844\n", + "epoch=29 train_loss_total=0.0008 eval_loss_total=0.2633\n", + "CPU times: user 1.31 s, sys: 236 ms, total: 1.54 s\n", + "Wall time: 1.56 s\n" + ] + } + ], + "source": [ + "%time train(module, optimizer, criterion, train_dataloader, eval_dataloader, epochs=max_epochs)" + ] + }, + { + "cell_type": "markdown", + "id": "4cef0029", + "metadata": {}, + "source": [ + "Okay, so we got an eval loss of ~0.26, which is much better than random." + ] + }, + { + "cell_type": "markdown", + "id": "4f106078", + "metadata": {}, + "source": [ + "### Training with peft" + ] + }, + { + "cell_type": "markdown", + "id": "8dd47aa4", + "metadata": {}, + "source": [ + "Now let's train with `peft`. First we check the names of the modules, so that we can configure `peft` to fine-tune the right modules." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "922db29b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('', __main__.MLP),\n", + " ('seq', torch.nn.modules.container.Sequential),\n", + " ('seq.0', torch.nn.modules.linear.Linear),\n", + " ('seq.1', torch.nn.modules.activation.ReLU),\n", + " ('seq.2', torch.nn.modules.linear.Linear),\n", + " ('seq.3', torch.nn.modules.activation.ReLU),\n", + " ('seq.4', torch.nn.modules.linear.Linear),\n", + " ('seq.5', torch.nn.modules.activation.LogSoftmax)]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[(n, type(m)) for n, m in MLP().named_modules()]" + ] + }, + { + "cell_type": "markdown", + "id": "5efb275d", + "metadata": {}, + "source": [ + "Next we can define the LoRA config. There is nothing special going on here. We set the LoRA rank to 8 and select the layers `seq.0` and `seq.2` to be used for LoRA fine-tuning. As for `seq.4`, which is the output layer, we set it as `module_to_save`, which means it is also trained but no LoRA is applied." + ] + }, + { + "cell_type": "markdown", + "id": "cf2c608d", + "metadata": {}, + "source": [ + "*Note: Not all layers types can be fine-tuned with LoRA. At the moment, linear layers, embeddings, `Conv2D` and `transformers.pytorch_utils.Conv1D` are supported." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b342438f", + "metadata": {}, + "outputs": [], + "source": [ + "config = peft.LoraConfig(\n", + " r=8,\n", + " target_modules=[\"seq.0\", \"seq.2\"],\n", + " modules_to_save=[\"seq.4\"],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "829b4e2d", + "metadata": {}, + "source": [ + "Now let's create the `peft` model by passing our initial MLP, as well as the config we just defined, to `get_peft_model`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "602b6658", + "metadata": {}, + "outputs": [], + "source": [ + "module = MLP().to(device)\n", + "module_copy = copy.deepcopy(module) # we keep a copy of the original model for later\n", + "peft_model = peft.get_peft_model(module, config)\n", + "optimizer = torch.optim.Adam(peft_model.parameters(), lr=lr)\n", + "criterion = nn.CrossEntropyLoss()\n", + "peft_model.print_trainable_parameters()" + ] + }, + { + "cell_type": "markdown", + "id": "2103737d", + "metadata": {}, + "source": [ + "Checking the numbers, we see that only ~1% of parameters are actually trained, which is what we like to see.\n", + "\n", + "Now let's start the training:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "9200cbc6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch=0 train_loss_total=0.6695 eval_loss_total=0.6388\n", + "epoch=1 train_loss_total=0.5614 eval_loss_total=0.5456\n", + "epoch=2 train_loss_total=0.3897 eval_loss_total=0.3035\n", + "epoch=3 train_loss_total=0.2529 eval_loss_total=0.2510\n", + "epoch=4 train_loss_total=0.1914 eval_loss_total=0.2191\n", + "epoch=5 train_loss_total=0.1236 eval_loss_total=0.2586\n", + "epoch=6 train_loss_total=0.1076 eval_loss_total=0.3205\n", + "epoch=7 train_loss_total=0.1834 eval_loss_total=0.3951\n", + "epoch=8 train_loss_total=0.1037 eval_loss_total=0.1646\n", + "epoch=9 train_loss_total=0.0724 eval_loss_total=0.1409\n", + "epoch=10 train_loss_total=0.0691 eval_loss_total=0.1725\n", + "epoch=11 train_loss_total=0.0641 eval_loss_total=0.1423\n", + "epoch=12 train_loss_total=0.0382 eval_loss_total=0.1490\n", + "epoch=13 train_loss_total=0.0214 eval_loss_total=0.1517\n", + "epoch=14 train_loss_total=0.0119 eval_loss_total=0.1717\n", + "epoch=15 train_loss_total=0.0060 eval_loss_total=0.2366\n", + "epoch=16 train_loss_total=0.0029 eval_loss_total=0.2069\n", + "epoch=17 train_loss_total=0.0021 eval_loss_total=0.2082\n", + "epoch=18 train_loss_total=0.0016 eval_loss_total=0.2119\n", + "epoch=19 train_loss_total=0.0011 eval_loss_total=0.1984\n", + "epoch=20 train_loss_total=0.0010 eval_loss_total=0.1821\n", + "epoch=21 train_loss_total=0.0009 eval_loss_total=0.1892\n", + "epoch=22 train_loss_total=0.0007 eval_loss_total=0.2062\n", + "epoch=23 train_loss_total=0.0006 eval_loss_total=0.2408\n", + "epoch=24 train_loss_total=0.0006 eval_loss_total=0.2038\n", + "epoch=25 train_loss_total=0.0005 eval_loss_total=0.2374\n", + "epoch=26 train_loss_total=0.0004 eval_loss_total=0.2139\n", + "epoch=27 train_loss_total=0.0004 eval_loss_total=0.2085\n", + "epoch=28 train_loss_total=0.0004 eval_loss_total=0.2395\n", + "epoch=29 train_loss_total=0.0003 eval_loss_total=0.2100\n", + "CPU times: user 1.41 s, sys: 48.9 ms, total: 1.46 s\n", + "Wall time: 1.46 s\n" + ] + } + ], + "source": [ + "%time train(peft_model, optimizer, criterion, train_dataloader, eval_dataloader, epochs=max_epochs)" + ] + }, + { + "cell_type": "markdown", + "id": "20f6f452", + "metadata": {}, + "source": [ + "In the end, we see that the eval loss is very similar to the one we saw earlier when we trained without `peft`. This is quite nice to see, given that we are training a much smaller number of parameters." + ] + }, + { + "cell_type": "markdown", + "id": "fa55d1d4", + "metadata": {}, + "source": [ + "#### Check which parameters were updated" + ] + }, + { + "cell_type": "markdown", + "id": "a6e2146b", + "metadata": {}, + "source": [ + "Finally, just to check that LoRA was applied as expected, we check what original weights were updated what weights stayed the same." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c7dcde21", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New parameter model.seq.0.lora_A.default.weight | 160 parameters | updated\n", + "New parameter model.seq.0.lora_B.default.weight | 16000 parameters | updated\n", + "New parameter model.seq.2.lora_A.default.weight | 16000 parameters | updated\n", + "New parameter model.seq.2.lora_B.default.weight | 16000 parameters | updated\n" + ] + } + ], + "source": [ + "for name, param in peft_model.base_model.named_parameters():\n", + " if \"lora\" not in name:\n", + " continue\n", + "\n", + " print(f\"New parameter {name:<13} | {param.numel():>5} parameters | updated\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "022e6c41", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter seq.0.weight | 40000 parameters | not updated\n", + "Parameter seq.0.bias | 2000 parameters | not updated\n", + "Parameter seq.2.weight | 4000000 parameters | not updated\n", + "Parameter seq.2.bias | 2000 parameters | not updated\n", + "Parameter seq.4.weight | 4000 parameters | not updated\n", + "Parameter seq.4.bias | 2 parameters | not updated\n", + "Parameter seq.4.weight | 4000 parameters | updated\n", + "Parameter seq.4.bias | 2 parameters | updated\n" + ] + } + ], + "source": [ + "params_before = dict(module_copy.named_parameters())\n", + "for name, param in peft_model.base_model.named_parameters():\n", + " if \"lora\" in name:\n", + " continue\n", + "\n", + " name_before = (\n", + " name.partition(\".\")[-1].replace(\"base_layer.\", \"\").replace(\"original_\", \"\").replace(\"module.\", \"\").replace(\"modules_to_save.default.\", \"\")\n", + " )\n", + " param_before = params_before[name_before]\n", + " if torch.allclose(param, param_before):\n", + " print(f\"Parameter {name_before:<13} | {param.numel():>7} parameters | not updated\")\n", + " else:\n", + " print(f\"Parameter {name_before:<13} | {param.numel():>7} parameters | updated\")" + ] + }, + { + "cell_type": "markdown", + "id": "4c09b43d", + "metadata": {}, + "source": [ + "So we can see that apart from the new LoRA weights that were added, only the last layer was updated. Since the LoRA weights and the last layer have comparitively few parameters, this gives us a big boost in efficiency." + ] + }, + { + "cell_type": "markdown", + "id": "b46c6198", + "metadata": {}, + "source": [ + "## Sharing the model through Hugging Face Hub" + ] + }, + { + "cell_type": "markdown", + "id": "6289e647", + "metadata": {}, + "source": [ + "### Pushing the model to HF Hub" + ] + }, + { + "cell_type": "markdown", + "id": "06dcdfa0", + "metadata": {}, + "source": [ + "With the `peft` model, it is also very easy to push a model the Hugging Face Hub. Below, we demonstrate how it works. It is assumed that you have a valid Hugging Face account and are logged in:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "1b91a0af", + "metadata": {}, + "outputs": [], + "source": [ + "user = \"BenjaminB\" # put your user name here\n", + "model_name = \"peft-lora-with-custom-model\"\n", + "model_id = f\"{user}/{model_name}\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1430fffd", + "metadata": {}, + "outputs": [], + "source": [ + "peft_model.push_to_hub(model_id);" + ] + }, + { + "cell_type": "markdown", + "id": "632bd799", + "metadata": {}, + "source": [ + "As we can see, the adapter size is only 211 kB." + ] + }, + { + "cell_type": "markdown", + "id": "4ff78c0c", + "metadata": {}, + "source": [ + "### Loading the model from HF Hub" + ] + }, + { + "cell_type": "markdown", + "id": "e5c7e87f", + "metadata": {}, + "source": [ + "Now, it only takes one step to load the model from HF Hub. To do this, we can use `PeftModel.from_pretrained`, passing our base model and the model ID:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce0fcced", + "metadata": {}, + "outputs": [], + "source": [ + "loaded = peft.PeftModel.from_pretrained(module_copy, model_id)\n", + "type(loaded)" + ] + }, + { + "cell_type": "markdown", + "id": "cd4b4eac", + "metadata": {}, + "source": [ + "Let's check that the two models produce the same output:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f2cf6ac4", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "y_peft = peft_model(X.to(device))\n", + "y_loaded = loaded(X.to(device))\n", + "torch.allclose(y_peft, y_loaded)" + ] + }, + { + "cell_type": "markdown", + "id": "eeeb653f", + "metadata": {}, + "source": [ + "### Clean up" + ] + }, + { + "cell_type": "markdown", + "id": "61c60355", + "metadata": {}, + "source": [ + "Finally, as a clean up step, you may want to delete the repo." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "b747038f", + "metadata": {}, + "outputs": [], + "source": [ + "from huggingface_hub import delete_repo" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "7e5ab237", + "metadata": {}, + "outputs": [], + "source": [ + "delete_repo(model_id)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/oft_dreambooth/oft_dreambooth_inference.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/oft_dreambooth/oft_dreambooth_inference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..24ed24218c66609b6db8a838415c9641257eb831 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/oft_dreambooth/oft_dreambooth_inference.ipynb @@ -0,0 +1,116 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "acd7b15e", + "metadata": {}, + "source": [ + "# Dreambooth with OFT\n", + "This Notebook assumes that you already ran the train_dreambooth.py script to create your own adapter." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "acab479f", + "metadata": {}, + "outputs": [], + "source": [ + "from diffusers import DiffusionPipeline\n", + "from diffusers.utils import check_min_version, get_logger\n", + "from peft import PeftModel\n", + "\n", + "# Will error if the minimal version of diffusers is not installed. Remove at your own risks.\n", + "check_min_version(\"0.10.0.dev0\")\n", + "\n", + "logger = get_logger(__name__)\n", + "\n", + "BASE_MODEL_NAME = \"stabilityai/stable-diffusion-2-1-base\"\n", + "ADAPTER_MODEL_PATH = \"INSERT MODEL PATH HERE\"" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading pipeline components...: 100%|██████████| 6/6 [00:00<00:00, 24.13it/s]\n" + ] + } + ], + "source": [ + "import torch\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "pipe = DiffusionPipeline.from_pretrained(\n", + " BASE_MODEL_NAME,\n", + ")\n", + "pipe.to(device)\n", + "pipe.unet = PeftModel.from_pretrained(pipe.unet, ADAPTER_MODEL_PATH + \"/unet\", adapter_name=\"default\")\n", + "pipe.text_encoder = PeftModel.from_pretrained(\n", + " pipe.text_encoder, ADAPTER_MODEL_PATH + \"/text_encoder\", adapter_name=\"default\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50/50 [00:11<00:00, 4.46it/s]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prompt = \"A photo of a sks dog\"\n", + "image = pipe(\n", + " prompt,\n", + " num_inference_steps=50,\n", + " height=512,\n", + " width=512,\n", + ").images[0]\n", + "image" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/oft_dreambooth/train_dreambooth.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/oft_dreambooth/train_dreambooth.py new file mode 100644 index 0000000000000000000000000000000000000000..6afee9e280744dfc1ad01c1fa88307c34d98af17 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/oft_dreambooth/train_dreambooth.py @@ -0,0 +1,1115 @@ +import argparse +import gc +import hashlib +import itertools +import logging +import math +import os +import threading +import warnings +from contextlib import nullcontext +from pathlib import Path + +import datasets +import diffusers +import numpy as np +import psutil +import torch +import torch.nn.functional as F +import torch.utils.checkpoint +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import set_seed +from diffusers import ( + AutoencoderKL, + DDPMScheduler, + DiffusionPipeline, + DPMSolverMultistepScheduler, + UNet2DConditionModel, +) +from diffusers.optimization import get_scheduler +from diffusers.utils import check_min_version +from diffusers.utils.import_utils import is_xformers_available +from huggingface_hub import HfApi +from PIL import Image +from torch.utils.data import Dataset +from torchvision import transforms +from tqdm.auto import tqdm +from transformers import AutoTokenizer, PretrainedConfig + +from peft import get_peft_model +from peft.tuners.oft.config import OFTConfig + + +# Will error if the minimal version of diffusers is not installed. Remove at your own risks. +check_min_version("0.10.0.dev0") + +logger = get_logger(__name__) + +UNET_TARGET_MODULES = ["to_q", "to_v", "query", "value"] # , "ff.net.0.proj"] +TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"] + + +def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str): + text_encoder_config = PretrainedConfig.from_pretrained( + pretrained_model_name_or_path, + subfolder="text_encoder", + revision=revision, + ) + model_class = text_encoder_config.architectures[0] + + if model_class == "CLIPTextModel": + from transformers import CLIPTextModel + + return CLIPTextModel + elif model_class == "RobertaSeriesModelWithTransformation": + from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation + + return RobertaSeriesModelWithTransformation + else: + raise ValueError(f"{model_class} is not supported.") + + +def parse_args(input_args=None): + parser = argparse.ArgumentParser(description="Simple example of a training script.") + parser.add_argument( + "--pretrained_model_name_or_path", + type=str, + default=None, + required=True, + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--tokenizer_name", + type=str, + default=None, + help="Pretrained tokenizer name or path if not the same as model_name", + ) + parser.add_argument( + "--instance_data_dir", + type=str, + default=None, + required=True, + help="A folder containing the training data of instance images.", + ) + parser.add_argument( + "--class_data_dir", + type=str, + default=None, + required=False, + help="A folder containing the training data of class images.", + ) + parser.add_argument( + "--instance_prompt", + type=str, + default=None, + required=True, + help="The prompt with identifier specifying the instance", + ) + parser.add_argument( + "--class_prompt", + type=str, + default=None, + help="The prompt to specify images in the same class as provided instance images.", + ) + parser.add_argument( + "--with_prior_preservation", + default=False, + action="store_true", + help="Flag to add prior preservation loss.", + ) + parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.") + parser.add_argument( + "--num_class_images", + type=int, + default=100, + help=( + "Minimal class images for prior preservation loss. If there are not enough images already present in" + " class_data_dir, additional images will be sampled with class_prompt." + ), + ) + parser.add_argument( + "--validation_prompt", + type=str, + default=None, + help="A prompt that is used during validation to verify that the model is learning.", + ) + parser.add_argument( + "--num_validation_images", + type=int, + default=4, + help="Number of images that should be generated during validation with `validation_prompt`.", + ) + parser.add_argument( + "--validation_steps", + type=int, + default=100, + help=( + "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt" + " `args.validation_prompt` multiple times: `args.num_validation_images`." + ), + ) + parser.add_argument( + "--output_dir", + type=str, + default="text-inversion-model", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution" + ) + parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder") + + # oft args + parser.add_argument("--use_oft", action="store_true", help="Whether to use OFT for parameter efficient tuning") + parser.add_argument("--oft_r", type=int, default=0, help="OFT rank, only used if use_oft is True") + parser.add_argument("--oft_block_size", type=int, default=32, help="OFT block size, only used if use_oft is True") + parser.add_argument("--oft_dropout", type=float, default=0.0, help="OFT dropout, only used if use_oft is True") + parser.add_argument( + "--oft_use_coft", action="store_true", help="Using constrained OFT, only used if use_oft is True" + ) + parser.add_argument( + "--oft_eps", + type=float, + default=0.0, + help="The control strength of COFT. Only has an effect if `oft_use_coft` is set to True.", + ) + + parser.add_argument( + "--oft_text_encoder_r", + type=int, + default=0, + help="OFT rank for text encoder, only used if `use_oft` and `train_text_encoder` are True", + ) + parser.add_argument( + "--oft_text_encoder_block_size", + type=int, + default=32, + help="OFT block size for text encoder, only used if `use_oft` and `train_text_encoder` are True", + ) + parser.add_argument( + "--oft_text_encoder_dropout", + type=float, + default=0.0, + help="OFT dropout for text encoder, only used if `use_oft` and `train_text_encoder` are True", + ) + parser.add_argument( + "--oft_text_encoder_use_coft", + action="store_true", + help="Using constrained OFT on the text encoder, only used if use_oft is True", + ) + parser.add_argument( + "--oft_text_encoder_eps", + type=float, + default=0.0, + help="The control strength of COFT on the text encoder. Only has an effect if `oft_text_encoder_use_coft` is set to True.", + ) + + parser.add_argument( + "--num_dataloader_workers", type=int, default=1, help="Num of workers for the training dataloader." + ) + + parser.add_argument( + "--no_tracemalloc", + default=False, + action="store_true", + help="Flag to stop memory allocation tracing during training. This could speed up training on Windows.", + ) + + parser.add_argument( + "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader." + ) + parser.add_argument( + "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images." + ) + parser.add_argument("--num_train_epochs", type=int, default=1) + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help=( + "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final" + " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming" + " training using `--resume_from_checkpoint`." + ), + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help=( + "Whether training should be resumed from a previous checkpoint. Use a path saved by" + ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.' + ), + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=5e-6, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of accelerators, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler." + ) + parser.add_argument( + "--lr_num_cycles", + type=int, + default=1, + help="Number of hard resets of the lr in cosine_with_restarts scheduler.", + ) + parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.") + parser.add_argument( + "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes." + ) + parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.") + parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.") + parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.") + parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer") + parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.") + parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.") + parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.") + parser.add_argument( + "--hub_model_id", + type=str, + default=None, + help="The name of the repository to keep in sync with the local `output_dir`.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument( + "--report_to", + type=str, + default="tensorboard", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`' + ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument( + "--wandb_key", + type=str, + default=None, + help=("If report to option is set to wandb, api-key for wandb used for login to wandb "), + ) + parser.add_argument( + "--wandb_project_name", + type=str, + default=None, + help=("If report to option is set to wandb, project name in wandb for log tracking "), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default=None, + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU or Intel XPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--prior_generation_precision", + type=str, + default=None, + choices=["no", "fp32", "fp16", "bf16"], + help=( + "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU or Intel XPU. Default to fp16 if a GPU/XPU is available else fp32." + ), + ) + parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank") + parser.add_argument( + "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers." + ) + + if input_args is not None: + args = parser.parse_args(input_args) + else: + args = parser.parse_args() + + env_local_rank = int(os.environ.get("LOCAL_RANK", "-1")) + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + if args.with_prior_preservation: + if args.class_data_dir is None: + raise ValueError("You must specify a data directory for class images.") + if args.class_prompt is None: + raise ValueError("You must specify prompt for class images.") + else: + # logger is not available yet + if args.class_data_dir is not None: + warnings.warn("You need not use --class_data_dir without --with_prior_preservation.") + if args.class_prompt is not None: + warnings.warn("You need not use --class_prompt without --with_prior_preservation.") + + return args + + +# Converting Bytes to Megabytes +def b2mb(x): + return int(x / 2**20) + + +# This context manager is used to track the peak memory usage of the process +class TorchTracemalloc: + def __enter__(self): + self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + self.device_module = getattr(torch, self.device_type, torch.cuda) + gc.collect() + self.device_module.empty_cache() + self.device_module.reset_peak_memory_stats() # reset the peak gauge to zero + self.begin = self.device_module.memory_allocated() + self.process = psutil.Process() + + self.cpu_begin = self.cpu_mem_used() + self.peak_monitoring = True + peak_monitor_thread = threading.Thread(target=self.peak_monitor_func) + peak_monitor_thread.daemon = True + peak_monitor_thread.start() + return self + + def cpu_mem_used(self): + """get resident set size memory for the current process""" + return self.process.memory_info().rss + + def peak_monitor_func(self): + self.cpu_peak = -1 + + while True: + self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak) + + # can't sleep or will not catch the peak right (this comment is here on purpose) + # time.sleep(0.001) # 1msec + + if not self.peak_monitoring: + break + + def __exit__(self, *exc): + self.peak_monitoring = False + + gc.collect() + self.device_module.empty_cache() + self.end = self.device_module.memory_allocated() + self.peak = self.device_module.max_memory_allocated() + self.used = b2mb(self.end - self.begin) + self.peaked = b2mb(self.peak - self.begin) + + self.cpu_end = self.cpu_mem_used() + self.cpu_used = b2mb(self.cpu_end - self.cpu_begin) + self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin) + # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}") + + +class DreamBoothDataset(Dataset): + """ + A dataset to prepare the instance and class images with the prompts for fine-tuning the model. + It pre-processes the images and the tokenizes prompts. + """ + + def __init__( + self, + instance_data_root, + instance_prompt, + tokenizer, + class_data_root=None, + class_prompt=None, + size=512, + center_crop=False, + ): + self.size = size + self.center_crop = center_crop + self.tokenizer = tokenizer + + self.instance_data_root = Path(instance_data_root) + if not self.instance_data_root.exists(): + raise ValueError("Instance images root doesn't exists.") + + self.instance_images_path = list(Path(instance_data_root).iterdir()) + self.num_instance_images = len(self.instance_images_path) + self.instance_prompt = instance_prompt + self._length = self.num_instance_images + + if class_data_root is not None: + self.class_data_root = Path(class_data_root) + self.class_data_root.mkdir(parents=True, exist_ok=True) + self.class_images_path = list(self.class_data_root.iterdir()) + self.num_class_images = len(self.class_images_path) + self._length = max(self.num_class_images, self.num_instance_images) + self.class_prompt = class_prompt + else: + self.class_data_root = None + + self.image_transforms = transforms.Compose( + [ + transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR), + transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + + def __len__(self): + return self._length + + def __getitem__(self, index): + example = {} + instance_image = Image.open(self.instance_images_path[index % self.num_instance_images]) + if instance_image.mode != "RGB": + instance_image = instance_image.convert("RGB") + example["instance_images"] = self.image_transforms(instance_image) + example["instance_prompt_ids"] = self.tokenizer( + self.instance_prompt, + truncation=True, + padding="max_length", + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + if self.class_data_root: + class_image = Image.open(self.class_images_path[index % self.num_class_images]) + if class_image.mode != "RGB": + class_image = class_image.convert("RGB") + example["class_images"] = self.image_transforms(class_image) + example["class_prompt_ids"] = self.tokenizer( + self.class_prompt, + truncation=True, + padding="max_length", + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + return example + + +def collate_fn(examples, with_prior_preservation=False): + input_ids = [example["instance_prompt_ids"] for example in examples] + pixel_values = [example["instance_images"] for example in examples] + + # Concat class and instance examples for prior preservation. + # We do this to avoid doing two forward passes. + if with_prior_preservation: + input_ids += [example["class_prompt_ids"] for example in examples] + pixel_values += [example["class_images"] for example in examples] + + pixel_values = torch.stack(pixel_values) + pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float() + + input_ids = torch.cat(input_ids, dim=0) + + batch = { + "input_ids": input_ids, + "pixel_values": pixel_values, + } + return batch + + +class PromptDataset(Dataset): + "A simple dataset to prepare the prompts to generate class images on multiple accelerators." + + def __init__(self, prompt, num_samples): + self.prompt = prompt + self.num_samples = num_samples + + def __len__(self): + return self.num_samples + + def __getitem__(self, index): + example = {} + example["prompt"] = self.prompt + example["index"] = index + return example + + +def main(args): + logging_dir = Path(args.output_dir, args.logging_dir) + + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_dir=logging_dir, + ) + if args.report_to == "wandb": + import wandb + + wandb.login(key=args.wandb_key) + wandb.init(project=args.wandb_project_name) + # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate + # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models. + # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate. + if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1: + raise ValueError( + "Gradient accumulation is not supported when training the text encoder in distributed training. " + "Please set gradient_accumulation_steps to 1. This feature will be supported in the future." + ) + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + datasets.utils.logging.set_verbosity_warning() + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + datasets.utils.logging.set_verbosity_error() + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + set_seed(args.seed) + + # Generate class images if prior preservation is enabled. + if args.with_prior_preservation: + class_images_dir = Path(args.class_data_dir) + if not class_images_dir.exists(): + class_images_dir.mkdir(parents=True) + cur_class_images = len(list(class_images_dir.iterdir())) + + if cur_class_images < args.num_class_images: + dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32 + if args.prior_generation_precision == "fp32": + dtype = torch.float32 + elif args.prior_generation_precision == "fp16": + dtype = torch.float16 + elif args.prior_generation_precision == "bf16": + dtype = torch.bfloat16 + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + dtype=dtype, + safety_checker=None, + revision=args.revision, + ) + pipeline.set_progress_bar_config(disable=True) + + num_new_images = args.num_class_images - cur_class_images + logger.info(f"Number of class images to sample: {num_new_images}.") + + sample_dataset = PromptDataset(args.class_prompt, num_new_images) + sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size) + + sample_dataloader = accelerator.prepare(sample_dataloader) + pipeline.to(accelerator.device) + + for example in tqdm( + sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process + ): + images = pipeline(example["prompt"]).images + + for i, image in enumerate(images): + hash_image = hashlib.sha1(image.tobytes()).hexdigest() + image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg" + image.save(image_filename) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + # Handle the repository creation + if accelerator.is_main_process: + if args.push_to_hub: + api = HfApi(token=args.hub_token) + + # Create repo (repo_name from args or inferred) + repo_name = args.hub_model_id + if repo_name is None: + repo_name = Path(args.output_dir).absolute().name + repo_id = api.create_repo(repo_name, exist_ok=True).repo_id + + with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore: + if "step_*" not in gitignore: + gitignore.write("step_*\n") + if "epoch_*" not in gitignore: + gitignore.write("epoch_*\n") + elif args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + # Load the tokenizer + if args.tokenizer_name: + tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False) + elif args.pretrained_model_name_or_path: + tokenizer = AutoTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.revision, + use_fast=False, + ) + + # import correct text encoder class + text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision) + + # Load scheduler and models + noise_scheduler = DDPMScheduler( + beta_start=0.00085, + beta_end=0.012, + beta_schedule="scaled_linear", + num_train_timesteps=1000, + ) # DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler") + text_encoder = text_encoder_cls.from_pretrained( + args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision + ) + vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision) + unet = UNet2DConditionModel.from_pretrained( + args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision + ) + + if args.use_oft: + config = OFTConfig( + r=args.oft_r, + oft_block_size=args.oft_block_size, + target_modules=UNET_TARGET_MODULES, + module_dropout=args.oft_dropout, + init_weights=True, + coft=args.oft_use_coft, + eps=args.oft_eps, + ) + unet = get_peft_model(unet, config) + unet.print_trainable_parameters() + print(unet) + + vae.requires_grad_(False) + if not args.train_text_encoder: + text_encoder.requires_grad_(False) + elif args.train_text_encoder and args.use_oft: + config = OFTConfig( + r=args.oft_text_encoder_r, + oft_block_size=args.oft_text_encoder_block_size, + target_modules=TEXT_ENCODER_TARGET_MODULES, + module_dropout=args.oft_text_encoder_dropout, + init_weights=True, + coft=args.oft_text_encoder_use_coft, + eps=args.oft_text_encoder_eps, + ) + text_encoder = get_peft_model(text_encoder, config) + text_encoder.print_trainable_parameters() + print(text_encoder) + + if args.enable_xformers_memory_efficient_attention: + if accelerator.device.type == "xpu": + logger.warning("XPU hasn't support xformers yet, ignore it.") + elif is_xformers_available(): + unet.enable_xformers_memory_efficient_attention() + else: + raise ValueError("xformers is not available. Make sure it is installed correctly") + + if args.gradient_checkpointing: + unet.enable_gradient_checkpointing() + # below fails when using oft so commenting it out + if args.train_text_encoder and not args.use_oft: + text_encoder.gradient_checkpointing_enable() + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.allow_tf32 and torch.cuda.is_available(): + torch.backends.cuda.matmul.allow_tf32 = True + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes + ) + + # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB accelerators + if args.use_8bit_adam: + try: + import bitsandbytes as bnb + except ImportError: + raise ImportError( + "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`." + ) + + optimizer_class = bnb.optim.AdamW8bit + else: + optimizer_class = torch.optim.AdamW + + # Optimizer creation + params_to_optimize = ( + itertools.chain(unet.parameters(), text_encoder.parameters()) if args.train_text_encoder else unet.parameters() + ) + optimizer = optimizer_class( + params_to_optimize, + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + # Dataset and DataLoaders creation: + train_dataset = DreamBoothDataset( + instance_data_root=args.instance_data_dir, + instance_prompt=args.instance_prompt, + class_data_root=args.class_data_dir if args.with_prior_preservation else None, + class_prompt=args.class_prompt, + tokenizer=tokenizer, + size=args.resolution, + center_crop=args.center_crop, + ) + + train_dataloader = torch.utils.data.DataLoader( + train_dataset, + batch_size=args.train_batch_size, + shuffle=True, + collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation), + num_workers=args.num_dataloader_workers, + ) + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, + num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, + num_cycles=args.lr_num_cycles, + power=args.lr_power, + ) + + # Prepare everything with our `accelerator`. + if args.train_text_encoder: + unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, text_encoder, optimizer, train_dataloader, lr_scheduler + ) + else: + unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, optimizer, train_dataloader, lr_scheduler + ) + + # For mixed precision training we cast the text_encoder and vae weights to half-precision + # as these models are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + # Move vae and text_encoder to device and cast to weight_dtype + vae.to(accelerator.device, dtype=weight_dtype) + if not args.train_text_encoder: + text_encoder.to(accelerator.device, dtype=weight_dtype) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + accelerator.init_trackers("dreambooth", config=vars(args)) + + # Train! + total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + + logger.info("***** Running training *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num batches each epoch = {len(train_dataloader)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {args.max_train_steps}") + global_step = 0 + first_epoch = 0 + + # Potentially load in the weights and states from a previous save + if args.resume_from_checkpoint: + if args.resume_from_checkpoint != "latest": + path = os.path.basename(args.resume_from_checkpoint) + else: + # Get the mos recent checkpoint + dirs = os.listdir(args.output_dir) + dirs = [d for d in dirs if d.startswith("checkpoint")] + dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) + path = dirs[-1] + accelerator.print(f"Resuming from checkpoint {path}") + accelerator.load_state(os.path.join(args.output_dir, path)) + global_step = int(path.split("-")[1]) + + resume_global_step = global_step * args.gradient_accumulation_steps + first_epoch = resume_global_step // num_update_steps_per_epoch + resume_step = resume_global_step % num_update_steps_per_epoch + + # Only show the progress bar once on each machine. + progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process) + progress_bar.set_description("Steps") + + for epoch in range(first_epoch, args.num_train_epochs): + unet.train() + if args.train_text_encoder: + text_encoder.train() + with TorchTracemalloc() if not args.no_tracemalloc else nullcontext() as tracemalloc: + for step, batch in enumerate(train_dataloader): + # Skip steps until we reach the resumed step + if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step: + if step % args.gradient_accumulation_steps == 0: + progress_bar.update(1) + if args.report_to == "wandb": + accelerator.print(progress_bar) + continue + + with accelerator.accumulate(unet): + # Convert images to latent space + latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample() + latents = latents * 0.18215 + + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + bsz = latents.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint( + 0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device + ) + timesteps = timesteps.long() + + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + # Get the text embedding for conditioning + encoder_hidden_states = text_encoder(batch["input_ids"])[0] + + # Predict the noise residual + model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample + + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + if args.with_prior_preservation: + # Chunk the noise and model_pred into two parts and compute the loss on each part separately. + model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0) + target, target_prior = torch.chunk(target, 2, dim=0) + + # Compute instance loss + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + # Compute prior loss + prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean") + + # Add the prior loss to the instance loss. + loss = loss + args.prior_loss_weight * prior_loss + else: + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + accelerator.backward(loss) + if accelerator.sync_gradients: + params_to_clip = ( + itertools.chain(unet.parameters(), text_encoder.parameters()) + if args.train_text_encoder + else unet.parameters() + ) + accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm) + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + if args.report_to == "wandb": + accelerator.print(progress_bar) + global_step += 1 + + logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + accelerator.log(logs, step=global_step) + + if ( + args.validation_prompt is not None + and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0 + ): + logger.info( + f"Running validation... \n Generating {args.num_validation_images} images with prompt:" + f" {args.validation_prompt}." + ) + # create pipeline + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + safety_checker=None, + revision=args.revision, + ) + # set `keep_fp32_wrapper` to True because we do not want to remove + # mixed precision hooks while we are still training + pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True) + pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True) + pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config) + pipeline = pipeline.to(accelerator.device) + pipeline.set_progress_bar_config(disable=True) + + # run inference + if args.seed is not None: + generator = torch.Generator(device=accelerator.device).manual_seed(args.seed) + else: + generator = None + images = [] + for _ in range(args.num_validation_images): + image = pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0] + images.append(image) + + for tracker in accelerator.trackers: + if tracker.name == "tensorboard": + np_images = np.stack([np.asarray(img) for img in images]) + tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC") + if tracker.name == "wandb": + import wandb + + tracker.log( + { + "validation": [ + wandb.Image(image, caption=f"{i}: {args.validation_prompt}") + for i, image in enumerate(images) + ] + } + ) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + if global_step >= args.max_train_steps: + break + + # Printing the accelerator memory usage details such as allocated memory, peak memory, and total memory usage + if not args.no_tracemalloc: + accelerator.print( + f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}" + ) + accelerator.print( + f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}" + ) + + accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}") + accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}") + accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}") + accelerator.print( + f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}" + ) + + # Create the pipeline using using the trained modules and save it. + accelerator.wait_for_everyone() + if accelerator.is_main_process: + if args.use_oft: + unwarpped_unet = accelerator.unwrap_model(unet) + unwarpped_unet.save_pretrained( + os.path.join(args.output_dir, "unet"), state_dict=accelerator.get_state_dict(unet) + ) + if args.train_text_encoder: + unwarpped_text_encoder = accelerator.unwrap_model(text_encoder) + unwarpped_text_encoder.save_pretrained( + os.path.join(args.output_dir, "text_encoder"), + state_dict=accelerator.get_state_dict(text_encoder), + ) + else: + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + unet=accelerator.unwrap_model(unet), + text_encoder=accelerator.unwrap_model(text_encoder), + revision=args.revision, + ) + pipeline.save_pretrained(args.output_dir) + + if args.push_to_hub: + api.upload_folder( + repo_id=repo_id, + folder_path=args.output_dir, + commit_message="End of training", + run_as_future=True, + ) + + accelerator.end_training() + + +if __name__ == "__main__": + args = parse_args() + main(args) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/olora_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/olora_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3b9bbf68ee5e961d7049d0f8f4119ed503dfa154 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/olora_finetuning/README.md @@ -0,0 +1,96 @@ +# OLoRA: Orthonormal Low Rank Adaptation of Large Language Models + +## Introduction +[OLoRA](https://huggingface.co/papers/2406.01775) is a novel approach that leverages orthonormal low rank adaptation through QR decomposition. Unlike the default LoRA implementation, OLoRA decomposes original weights into their $\mathbf{Q}$ and $\mathbf{R}$ parts, and then uses the first `rank` rows of $\mathbf{R}$ and the first `rank` columns of $\mathbf{Q}$ to initialize $\mathbf{A}$ and $\mathbf{B}$, respectively. This results in significantly faster convergence, more stable training, and superior performance. + +## Quick start +```python +import torch +from peft import LoraConfig, get_peft_model +from transformers import AutoTokenizer, AutoModelForCausalLM +from trl import SFTConfig, SFTTrainer +from datasets import load_dataset + +model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m", dtype=torch.bfloat16, device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m") +dataset = load_dataset("imdb", split="train[:1%]") +lora_config = LoraConfig( + init_lora_weights="olora" +) +peft_model = get_peft_model(model, lora_config) +training_args = SFTConfig(dataset_text_field="text", max_length=128) +trainer = SFTTrainer( + model=peft_model, + train_dataset=dataset, + processing_class=tokenizer, +) +trainer.train() +peft_model.save_pretrained("olora-opt-350m") +``` + +There is no additional change needed to your standard LoRA procedure, except for specifying `init_lora_weights = "olora"` option in your lora configuration. + +Additionally you can refer to olora finetuning script. +Run the script simply by running: +```bash +python3 examples/olora_finetuning/olora_finetuning.py --base_model facebook/opt-350m +``` +OLoRA also supports quantization. To use 4-bit quantization try: +```bash +python3 examples/olora_finetuning/olora_finetuning.py --base_model facebook/opt-350m --quantize +``` +or you can just pass a quantized model without the quantize flag. + +If you want to run DDP by [accelerate](https://huggingface.co/docs/accelerate/en/index), please run `accelerate config` to set your ddp config, and run: +```bash +accelerate launch examples/olora_finetuning/olora_finetuning.py --base_model facebook/opt-350m +``` +please add `--device_map cpu` if you want to run finetune on CPU. + +If you want to train a quantized model like AWQ and GPTQ which do not support olora init method, please pass `--init_lora_weights gaussian`. For example: +```bash +python3 examples/olora_finetuning/olora_finetuning.py --base_model hugging-quants/Meta-Llama-3.1-8B-Instruct-AWQ-INT4 --init_lora_weights gaussian + +``` + + +## Use the model +You can load and use the model as any other 🤗 PEFT model +```python +from peft import PeftModel +model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m") +tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m") +olora_model = PeftModel.from_pretrained(model, "olora-opt-350m") +``` + +## OLoRA and LoRA +OLoRA differs from LoRA in that it mutates the original weights. To utilize multiple adapters simultaneously, you can leverage the `path_initial_model_for_weight_conversion` option. Below is a simple template illustrating how to convert OLoRA to conventional LoRA: +```python +base_model = AutoModel.from_pretrained("facebook/opt-350m") +olora_config = LoraConfig( + ... + init_lora_weights = "olora" # Initialize the model with OLoRA +) +olora_model = get_peft_model(base_model, olora_config) +init_path = +olora_model.save_pretrained(init_path) # Save the model *before* performing any training + +# Train the model +train(olora_model) # Your training loop + +#Save the model after training +olora_model.save_pretrained(output_dir, path_initial_model_for_weight_conversion=init_path) +``` +After completing training, you can save and convert your OLoRA model to a conventional LoRA model by setting `path_initial_model_for_weight_conversion` to `init_path`, that is the path of your untrained OLoRA model. This conversion enables you to use multiple adapters with your LoRA model. Note that this conversion is not supported if `rslora` is used in combination with `rank_pattern` or `alpha_pattern`. + +## Citation +``` +@misc{büyükakyüz2024olora, + title={OLoRA: Orthonormal Low-Rank Adaptation of Large Language Models}, + author={Kerim Büyükakyüz}, + year={2024}, + eprint={2406.01775}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/olora_finetuning/olora_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/olora_finetuning/olora_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..32dca9be637d61765d602bd48ae4e374f17a5c71 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/olora_finetuning/olora_finetuning.py @@ -0,0 +1,199 @@ +# Copyright 2024-present the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import os +from typing import Optional + +import torch +import transformers +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, set_seed + +from peft import ( + LoraConfig, + get_peft_model, +) + + +def train( + base_model: str = "path/to/model", + data_path: str = "yahma/alpaca-cleaned", + output_dir: str = "olora", + batch_size: int = 16, + num_epochs: int = 1, + learning_rate: float = 3e-4, + cutoff_len: int = 256, + val_set_size: int = 16, + quantize: bool = False, + eval_step: int = 100, + save_step: int = 100, + device_map: str = "auto", + lora_r: int = 32, + lora_alpha: int = 16, + lora_dropout: float = 0.05, + lora_target_modules: Optional[list[str]] = None, + dtype: str = "float16", + init_lora_weights="olora", + seed: Optional[int] = None, +): + # Set device_map to the right place when enabling DDP. + world_size = int(os.environ.get("WORLD_SIZE", "0")) or int(os.environ.get("PMI_SIZE", "0")) + if world_size > 1 and device_map != "cpu": + from accelerate import Accelerator + + device_map = {"": Accelerator().process_index} + # Set seed + if seed is not None: + set_seed(seed) + model_kwargs = {"dtype": getattr(torch, dtype), "device_map": device_map} + if quantize: + model_kwargs["quantization_config"] = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=torch.bfloat16, + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_type="nf4", + ) + model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs) + + tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True) + # For some tokenizer with no pad token like llama + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + def tokenize(prompt, add_eos_token=True): + result = tokenizer( + prompt, + truncation=True, + max_length=cutoff_len, + padding=False, + return_tensors=None, + ) + if ( + result["input_ids"][-1] != tokenizer.eos_token_id + and len(result["input_ids"]) < cutoff_len + and add_eos_token + ): + result["input_ids"].append(tokenizer.eos_token_id) + result["attention_mask"].append(1) + + result["labels"] = result["input_ids"].copy() + + return result + + def generate_and_tokenize_prompt(example): + full_prompt = generate_prompt(example) + tokenized_full_prompt = tokenize(full_prompt) + return tokenized_full_prompt + + config = LoraConfig( + r=lora_r, + lora_alpha=lora_alpha, + target_modules=lora_target_modules, + lora_dropout=lora_dropout, + bias="none", + task_type="CAUSAL_LM", + init_lora_weights=init_lora_weights, + ) + model = get_peft_model(model, config) + + data = load_dataset(data_path) + + train_val = data["train"].train_test_split(test_size=val_set_size, shuffle=True, seed=42) + train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt) + val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt) + + trainer = transformers.Trainer( + model=model, + train_dataset=train_data, + eval_dataset=val_data, + args=transformers.TrainingArguments( + per_device_train_batch_size=batch_size, + warmup_steps=100, + num_train_epochs=num_epochs, + learning_rate=learning_rate, + logging_steps=100, + optim="adamw_torch", + eval_strategy="steps", + save_strategy="steps", + eval_steps=eval_step, + save_steps=save_step, + output_dir=output_dir, + save_total_limit=3, + load_best_model_at_end=True, + ddp_find_unused_parameters=False if world_size > 1 else None, + ), + data_collator=transformers.DataCollatorForSeq2Seq( + tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True + ), + ) + trainer.train() + model.save_pretrained(output_dir) + + +def generate_prompt(example): + return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request. + ### Instruction: + {example["instruction"]} + ### Response: + {example["output"]}""" + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("--base_model", type=str, default="path/to/model") + parser.add_argument("--data_path", type=str, default="yahma/alpaca-cleaned") + parser.add_argument("--output_dir", type=str, default="olora") + parser.add_argument("--batch_size", type=int, default=16) + parser.add_argument("--num_epochs", type=int, default=1) + parser.add_argument("--learning_rate", type=float, default=3e-4) + parser.add_argument("--cutoff_len", type=int, default=256) + parser.add_argument("--val_set_size", type=int, default=16) + parser.add_argument("--quantize", action="store_true") + parser.add_argument("--eval_step", type=int, default=100) + parser.add_argument("--save_step", type=int, default=100) + parser.add_argument("--device_map", type=str, default="auto") + parser.add_argument("--lora_r", type=int, default=32) + parser.add_argument("--lora_alpha", type=int, default=16) + parser.add_argument("--lora_dropout", type=float, default=0.05) + parser.add_argument("--lora_target_modules", type=str, default=None) + parser.add_argument("--dtype", type=str, default="float16") + parser.add_argument("--init_lora_weights", type=str, default="olora") + parser.add_argument("--seed", type=int, default=None) + + args = parser.parse_args() + + train( + base_model=args.base_model, + data_path=args.data_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + val_set_size=args.val_set_size, + quantize=args.quantize, + eval_step=args.eval_step, + save_step=args.save_step, + device_map=args.device_map, + lora_r=args.lora_r, + lora_alpha=args.lora_alpha, + lora_dropout=args.lora_dropout, + lora_target_modules=args.lora_target_modules, + dtype=args.dtype, + init_lora_weights=args.init_lora_weights, + seed=args.seed, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/orthogonal_subspace_learning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/orthogonal_subspace_learning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6ad91bfe0b4ec9e233fa15510c1dce045685103c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/orthogonal_subspace_learning/README.md @@ -0,0 +1,299 @@ +# Orthogonal Subspace Fine-tuning (OSF) - Continual Learning Example + +This example demonstrates OSF's ability to learn multiple tasks sequentially while preventing catastrophic forgetting, a key challenge in continual learning. + +## Introduction + +**Orthogonal Subspace Fine-tuning (OSF)** is a parameter-efficient fine-tuning method designed specifically for continual learning scenarios. Unlike traditional fine-tuning which suffers from catastrophic forgetting when learning new tasks, OSF constrains parameter updates to be orthogonal to previously important directions, effectively preserving knowledge from earlier tasks. + +### Key Features + +- **Prevents Catastrophic Forgetting**: Maintains performance on previous tasks while learning new ones +- **Full Model Capacity**: Unlike LoRA-based methods, OSF allows full-rank updates within the trainable subspace +- **Progressive Budget Allocation**: Gradually allocates more capacity to preserve previous knowledge +- **No Additional Parameters**: Modifies weights in-place without adding extra parameters per task + +## Quick Start + +### Installation + +```bash +pip install -e ".[dev]" +``` + +### Basic Usage + +Run the continual learning example with OSF: + +```bash +python osf_continual_learning.py \ + --model_name meta-llama/Llama-3.1-8B-Instruct \ + --num_train 1000 \ + --num_eval 200 \ + --num_epochs 2 \ + --output_dir ./outputs +``` + +To compare with full fine-tuning baseline: + +```bash +python osf_continual_learning.py \ + --model_name meta-llama/Llama-3.1-8B-Instruct \ + --run_baseline \ + --output_dir ./outputs +``` + +## Continual Learning Scenario + +This example trains a model on three different tasks sequentially: + +1. **ScienceQA** - Science question answering across natural, language, and social sciences +2. **NumGLUE** - Mathematical reasoning and numerical understanding +3. **FOMC** - Financial sentiment classification (Dovish/Hawkish/Neutral) + +### Progressive Capacity Allocation + +OSF uses a progressive budget allocation strategy where each task gets decreasing trainable capacity while preserving more knowledge from previous tasks: + +| Task | Effective Rank | Preserved | Trainable | Description | +|------|----------------|-----------|-----------|-------------| +| Task 1 (ScienceQA) | 0.3 | 30% | 70% | Maximum capacity for first task | +| Task 2 (NumGLUE) | 0.5 | 50% | 50% | Balanced capacity allocation | +| Task 3 (FOMC) | 0.7 | 70% | 30% | Minimal capacity, maximum preservation | + +This allocation ensures: +- Early tasks get sufficient capacity to learn effectively +- Later tasks can still learn new patterns +- Previous knowledge is progressively protected from interference + +## How OSF Works + +OSF decomposes each weight matrix using SVD into high-rank (preserved) and low-rank (trainable) components: + +``` +W = U_high @ S_high @ V_high^T + U_low @ S_low @ V_low^T + └─────────┬─────────┘ └──────┬──────┘ + frozen trainable + (previous tasks) (current task) +``` + +During training: +1. **Initialization**: Perform SVD on each weight matrix +2. **Partitioning**: Split singular values based on `effective_rank` +3. **Freezing**: Freeze top-k singular directions (high-rank subspace) +4. **Training**: Update remaining directions (low-rank subspace) +5. **Gradient Projection**: Ensure updates are orthogonal to frozen subspace + +Between tasks: +1. **Unload**: Merge OSF components back into base model +2. **Re-initialize**: Perform fresh SVD with increased `effective_rank` +3. **Continue**: Train on next task with larger frozen subspace + +## Command Line Arguments + +``` +--model_name Model to use (default: meta-llama/Llama-3.1-8B-Instruct) +--num_train Number of training samples per task (default: 1000) +--num_eval Number of evaluation samples per task (default: 200) +--output_dir Directory for outputs (default: ./osf_continual_learning_outputs) +--num_epochs Training epochs per task (default: 2) +--learning_rate Learning rate (default: 5e-6) +--batch_size Batch size per device (default: 32) +--gradient_accumulation_steps Gradient accumulation (default: 1) +--max_length Maximum sequence length (default: 512) +--seed Random seed (default: 42) +--run_baseline Also run full fine-tuning baseline for comparison +``` + +## Expected Results + +### OSF Performance + +When using OSF (with 2 epochs per task), you should observe: +- **Reduced catastrophic forgetting**: Performance on earlier tasks degrades less compared to full fine-tuning +- **Continued learning**: Model successfully learns each new task +- **Better retention**: OSF maintains higher average accuracy across all tasks + +### Full Fine-tuning Baseline + +Standard full fine-tuning typically shows: +- **Catastrophic forgetting**: Significant performance degradation on earlier tasks +- **Last task bias**: Model performs well only on the most recent task +- **Task interference**: New task learning overwrites previous knowledge + +## Understanding the Results + +### Forgetting Analysis + +The script prints a forgetting analysis showing how much earlier task performance changes. + +**Example results from training with 2 epochs per task:** + +``` +SUMMARY METRICS +================================================================================ + +1. Average Accuracy Across All 3 Tasks (After Final Task): + OSF: 53.42% + Full FT: 46.26% + Difference: +7.17% (OSF better) + +2. Average Forgetting (Task 1 & 2): + Forgetting = Final Accuracy - Initial Accuracy (negative is worse) + + ScienceQA: + OSF: +30.50% (initial: 55.00% → final: 85.50%) + Full FT: -13.00% (initial: 84.50% → final: 71.50%) + Difference: +43.50% (OSF better) + + NumGLUE: + OSF: +30.00% (initial: 16.00% → final: 46.00%) + Full FT: +1.00% (initial: 37.50% → final: 38.50%) + Difference: +29.00% (OSF better) + + Average Forgetting: + OSF: +30.25% + Full FT: -6.00% + Difference: +36.25% (OSF better) +``` + +**Interpreting Forgetting Metrics:** +- **Negative values** = Forgetting occurred (performance decreased) +- **Positive values** = Backward transfer occurred (performance improved) +- **Values closer to 0** = Better retention + +In this example, OSF shows significant positive backward transfer (+30.25% average), while Full FT shows slight forgetting (-6.00% average). This demonstrates OSF's ability to not only prevent catastrophic forgetting but also enable beneficial knowledge transfer across tasks. + +## Advanced Usage + +### Custom Task Configuration + +You can modify the tasks and capacity allocation in the script: + +```python +tasks = [ + { + "name": "Task1", + "train": task1_train, + "eval": task1_eval, + "effective_rank": 0.2, # Freeze 20%, train 80% + }, + { + "name": "Task2", + "train": task2_train, + "eval": task2_eval, + "effective_rank": 0.6, # Freeze 60%, train 40% + }, +] +``` + +### Using Different Models + +OSF works with any transformer-based model: + +```bash +# Smaller model for faster experimentation +python osf_continual_learning.py --model_name gpt2 + +# Different LLaMA variant +python osf_continual_learning.py --model_name meta-llama/Llama-2-7b-hf +``` + +### Adjusting Target Modules + +In the script, you can modify which modules to apply OSF to: + +```python +config = OSFConfig( + target_modules=["q_proj", "k_proj", "v_proj", "o_proj"], # Attention only + effective_rank=task["effective_rank"], +) +``` + +Common configurations: +- **Attention only**: `["q_proj", "k_proj", "v_proj", "o_proj"]` +- **Attention + MLP**: `["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]` +- **All linear**: `target_modules="all-linear"` + +## Customization + +### Adding Your Own Tasks + +To add custom tasks, create data loading and formatting functions in `utils.py`: + +```python +def load_my_task(num_train=1000, num_eval=200, seed=42): + """Load your custom dataset.""" + dataset = load_dataset("your/dataset") + # ... split and return + return train_dataset, eval_dataset + +def format_my_task_for_llama(examples, tokenizer, max_length=512): + """Format your task for instruction following.""" + prompts = [] + labels_text = [] + + for i in range(len(examples)): + prompt = f"Your instruction template: {examples['input'][i]}" + label = examples['output'][i] + + prompts.append(prompt) + labels_text.append(label) + + # ... tokenization logic + return formatted_examples +``` + +Then add to the tasks list in `osf_continual_learning.py`. + +## Performance Tips + +### Memory Optimization + +For large models, consider: +- Reducing `batch_size` and increasing `gradient_accumulation_steps` +- Using smaller `max_length` +- Enabling gradient checkpointing (add to model before OSF): + ```python + model.gradient_checkpointing_enable() + ``` + +### Training Speed + +To speed up training: +- Reduce `num_train` and `num_eval` for initial testing +- Use smaller models (e.g., `gpt2` or `Llama-2-7b`) +- Reduce `max_length` for shorter sequences + +### Better Results + +For improved continual learning performance: +- Play around with `num_epochs` per task (try 2-3 epochs) +- Adjust `learning_rate` +- Experiment with different capacity allocation strategies + +## Citation + +If you use OSF in your research, please cite: + +```bibtex +@misc{nayak2025sculptingsubspacesconstrainedfinetuning, + title={Sculpting Subspaces: Constrained Full Fine-Tuning in LLMs for Continual Learning}, + author={Nikhil Shivakumar Nayak and Krishnateja Killamsetty and Ligong Han and Abhishek Bhandwaldar and Prateek Chanda and Kai Xu and Hao Wang and Aldo Pareja and Oleg Silkin and Mustafa Eyceoz and Akash Srivastava}, + year={2025}, + eprint={2504.07097}, + archivePrefix={arXiv}, + primaryClass={cs.LG}, + url={https://arxiv.org/abs/2504.07097}, +} +``` + +## Additional Resources + +- [OSF Documentation](../../docs/source/package_reference/osf.md) +- [PEFT Documentation](https://huggingface.co/docs/peft) +- [Original Paper](https://huggingface.co/papers/2504.07097) + +## License + +This example is licensed under Apache 2.0. See the PEFT repository for full license details. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/orthogonal_subspace_learning/osf_continual_learning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/orthogonal_subspace_learning/osf_continual_learning.py new file mode 100644 index 0000000000000000000000000000000000000000..c4584d2e06e468f6ce6669714295f2cf39b38a6e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/orthogonal_subspace_learning/osf_continual_learning.py @@ -0,0 +1,693 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# 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. + +""" +OSF Continual Learning Example + +This script demonstrates OSF's ability to learn multiple tasks sequentially while preventing +catastrophic forgetting, compared to standard full fine-tuning. + +Tasks: +1. ScienceQA - Science question answering +2. NumGLUE - Mathematical reasoning +3. FOMC - Financial sentiment classification + +OSF Configuration: +- Task 1: effective_rank=0.3 (train 70%, freeze 30%) +- Task 2: effective_rank=0.5 (train 50%, freeze 50%) +- Task 3: effective_rank=0.7 (train 30%, freeze 70%) +""" + +import argparse +import os +import re + +import torch +from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments +from utils import ( + DataCollatorForCompletionOnly, + format_fomc_for_llama, + format_numglue_for_llama, + format_scienceqa_for_llama, + load_fomc, + load_numglue, + load_scienceqa, +) + +from peft import OSFConfig, get_peft_model + + +def compute_accuracy_scienceqa(model, eval_dataset, tokenizer, data_collator): + """Compute accuracy for ScienceQA (extract predicted letter).""" + model.eval() + correct = 0 + total = 0 + + # Create a simple dataloader + from torch.utils.data import DataLoader + + dataloader = DataLoader(eval_dataset, batch_size=8, collate_fn=data_collator) + + with torch.no_grad(): + for batch in dataloader: + input_ids = batch["input_ids"].to(model.device) + attention_mask = batch["attention_mask"].to(model.device) + labels = batch["labels"] + + # Generate predictions + outputs = model.generate( + input_ids=input_ids, + attention_mask=attention_mask, + max_new_tokens=5, + pad_token_id=tokenizer.pad_token_id, + do_sample=False, + ) + + # Extract predictions and ground truth + for i in range(len(outputs)): + # Decode the generated text + generated_text = tokenizer.decode(outputs[i], skip_special_tokens=True) + + # Extract the answer (last letter in the generated text) + # Look for single capital letters A, B, C, D + matches = re.findall(r"\b([A-D])\b", generated_text) + pred = matches[-1] if matches else "X" + + # Get ground truth (find the label that's not -100) + label_ids = labels[i][labels[i] != -100] + if len(label_ids) > 0: + gt = tokenizer.decode(label_ids, skip_special_tokens=True).strip() + if pred == gt: + correct += 1 + total += 1 + + accuracy = correct / total if total > 0 else 0.0 + return accuracy + + +def compute_accuracy_numglue(model, eval_dataset, tokenizer, data_collator): + """Compute accuracy for NumGLUE (extract predicted number).""" + model.eval() + correct = 0 + total = 0 + + from torch.utils.data import DataLoader + + dataloader = DataLoader(eval_dataset, batch_size=8, collate_fn=data_collator) + + with torch.no_grad(): + for batch in dataloader: + input_ids = batch["input_ids"].to(model.device) + attention_mask = batch["attention_mask"].to(model.device) + labels = batch["labels"] + + outputs = model.generate( + input_ids=input_ids, + attention_mask=attention_mask, + max_new_tokens=20, + pad_token_id=tokenizer.pad_token_id, + do_sample=False, + ) + + for i in range(len(outputs)): + generated_text = tokenizer.decode(outputs[i], skip_special_tokens=True) + + # Extract number from generated text + numbers = re.findall(r"-?\d+\.?\d*", generated_text) + pred = numbers[-1] if numbers else "-999" + + # Get ground truth + label_ids = labels[i][labels[i] != -100] + if len(label_ids) > 0: + gt = tokenizer.decode(label_ids, skip_special_tokens=True).strip() + if pred == gt: + correct += 1 + total += 1 + + accuracy = correct / total if total > 0 else 0.0 + return accuracy + + +def compute_accuracy_fomc(model, eval_dataset, tokenizer, data_collator): + """Compute accuracy for FOMC (extract predicted sentiment).""" + model.eval() + correct = 0 + total = 0 + + from torch.utils.data import DataLoader + + dataloader = DataLoader(eval_dataset, batch_size=8, collate_fn=data_collator) + + valid_labels = ["Dovish", "Hawkish", "Neutral"] + + with torch.no_grad(): + for batch in dataloader: + input_ids = batch["input_ids"].to(model.device) + attention_mask = batch["attention_mask"].to(model.device) + labels = batch["labels"] + + outputs = model.generate( + input_ids=input_ids, + attention_mask=attention_mask, + max_new_tokens=10, + pad_token_id=tokenizer.pad_token_id, + do_sample=False, + ) + + for i in range(len(outputs)): + generated_text = tokenizer.decode(outputs[i], skip_special_tokens=True) + + # Extract sentiment label + pred = None + for label in valid_labels: + if label in generated_text: + pred = label + break + + # Get ground truth + label_ids = labels[i][labels[i] != -100] + if len(label_ids) > 0: + gt = tokenizer.decode(label_ids, skip_special_tokens=True).strip() + if pred == gt: + correct += 1 + total += 1 + + accuracy = correct / total if total > 0 else 0.0 + return accuracy + + +def evaluate_model(model, eval_dataset, data_collator, tokenizer, task_name, task_type): + """Evaluate model on a dataset and return loss and accuracy.""" + # Compute loss + trainer = Trainer( + model=model, + data_collator=data_collator, + eval_dataset=eval_dataset, + args=TrainingArguments( + label_names=["labels"], + ), + ) + results = trainer.evaluate() + loss = results["eval_loss"] + + # Compute accuracy based on task type + if task_type == "scienceqa": + accuracy = compute_accuracy_scienceqa(model, eval_dataset, tokenizer, data_collator) + elif task_type == "numglue": + accuracy = compute_accuracy_numglue(model, eval_dataset, tokenizer, data_collator) + elif task_type == "fomc": + accuracy = compute_accuracy_fomc(model, eval_dataset, tokenizer, data_collator) + else: + accuracy = 0.0 + + print(f" {task_name}: Loss = {loss:.4f}, Accuracy = {accuracy * 100:.2f}%") + return loss, accuracy + + +def train_with_osf( + model_name, + num_train, + num_eval, + output_dir, + num_epochs, + learning_rate, + batch_size, + gradient_accumulation_steps, + max_length, + seed, +): + """Train using OSF with progressive rank allocation.""" + print("\n" + "=" * 80) + print("TRAINING WITH OSF (Orthogonal Subspace Fine-tuning)") + print("=" * 80) + + # Load tokenizer and base model + tokenizer = AutoTokenizer.from_pretrained(model_name) + tokenizer.pad_token = tokenizer.eos_token + + base_model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16, device_map="auto") + + # Load all datasets with task-specific sizes + # FOMC only has 496 samples total, so we use 350 train + 146 eval for it + print("\nLoading datasets...") + scienceqa_train, scienceqa_eval = load_scienceqa(1000, 200, seed) + numglue_train, numglue_eval = load_numglue(1000, 200, seed) + fomc_train, fomc_eval = load_fomc(350, 146, seed) + + # Store original eval datasets for later + scienceqa_eval_original = scienceqa_eval + numglue_eval_original = numglue_eval + fomc_eval_original = fomc_eval + + # Format datasets + scienceqa_train = scienceqa_train.map( + lambda x: format_scienceqa_for_llama(x, tokenizer, max_length), + batched=True, + remove_columns=scienceqa_train.column_names, + ) + scienceqa_eval = scienceqa_eval.map( + lambda x: format_scienceqa_for_llama(x, tokenizer, max_length), + batched=True, + remove_columns=scienceqa_eval.column_names, + ) + + numglue_train = numglue_train.map( + lambda x: format_numglue_for_llama(x, tokenizer, max_length), + batched=True, + remove_columns=numglue_train.column_names, + ) + numglue_eval = numglue_eval.map( + lambda x: format_numglue_for_llama(x, tokenizer, max_length), + batched=True, + remove_columns=numglue_eval.column_names, + ) + + fomc_train = fomc_train.map( + lambda x: format_fomc_for_llama(x, tokenizer, max_length), batched=True, remove_columns=fomc_train.column_names + ) + fomc_eval = fomc_eval.map( + lambda x: format_fomc_for_llama(x, tokenizer, max_length), batched=True, remove_columns=fomc_eval.column_names + ) + + data_collator = DataCollatorForCompletionOnly(tokenizer, max_length) + + # Task configurations + tasks = [ + { + "name": "ScienceQA", + "train": scienceqa_train, + "eval": scienceqa_eval, + "eval_original": scienceqa_eval_original, + "effective_rank": 0.3, # Freeze 30%, train 70% + "type": "scienceqa", + }, + { + "name": "NumGLUE", + "train": numglue_train, + "eval": numglue_eval, + "eval_original": numglue_eval_original, + "effective_rank": 0.5, # Freeze 50%, train 50% + "type": "numglue", + }, + { + "name": "FOMC", + "train": fomc_train, + "eval": fomc_eval, + "eval_original": fomc_eval_original, + "effective_rank": 0.7, # Freeze 70%, train 30% + "type": "fomc", + }, + ] + + # Store evaluation history: {task_name: [(loss, accuracy), ...]} + eval_history = { + "ScienceQA": [], + "NumGLUE": [], + "FOMC": [], + } + + # Sequential task training + model = base_model + for task_idx, task in enumerate(tasks): + print(f"\n{'=' * 80}") + print(f"TASK {task_idx + 1}: {task['name']}") + print(f"Effective Rank: {task['effective_rank']} (preserving {task['effective_rank'] * 100:.0f}%)") + print(f"{'=' * 80}") + + # Configure OSF for this task + config = OSFConfig( + target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"], + effective_rank=task["effective_rank"], + ) + + # Apply OSF to the model + model = get_peft_model(model, config) + + # Training arguments + training_args = TrainingArguments( + output_dir=f"{output_dir}/osf_{task['name'].lower()}", + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + gradient_accumulation_steps=gradient_accumulation_steps, + learning_rate=learning_rate, + logging_steps=10, + save_strategy="no", + bf16=True, + remove_unused_columns=False, + ) + + # Train on current task + trainer = Trainer( + model=model, + args=training_args, + train_dataset=task["train"], + data_collator=data_collator, + ) + + print(f"\nTraining on {task['name']}...") + trainer.train() + + # Evaluate on all tasks seen so far + print(f"\nEvaluating on all tasks after training on {task['name']}:") + for eval_task_idx in range(task_idx + 1): + eval_task = tasks[eval_task_idx] + loss, accuracy = evaluate_model( + model, eval_task["eval"], data_collator, tokenizer, eval_task["name"], eval_task["type"] + ) + eval_history[eval_task["name"]].append((loss, accuracy)) + + # Unload OSF to get the updated base model for next task (if not last task) + if task_idx < len(tasks) - 1: + print("\nUnloading OSF adapter to prepare for next task...") + model = model.unload() + + # Save final model + final_model_path = f"{output_dir}/osf_final" + model.save_pretrained(final_model_path) + print(f"\nFinal OSF model saved to {final_model_path}") + + return eval_history + + +def train_full_finetuning( + model_name, + num_train, + num_eval, + output_dir, + num_epochs, + learning_rate, + batch_size, + gradient_accumulation_steps, + max_length, + seed, +): + """Train using standard full fine-tuning (baseline for comparison).""" + print("\n" + "=" * 80) + print("TRAINING WITH FULL FINE-TUNING (Baseline)") + print("=" * 80) + + # Load tokenizer + tokenizer = AutoTokenizer.from_pretrained(model_name) + tokenizer.pad_token = tokenizer.eos_token + + # Load all datasets with task-specific sizes + # FOMC only has 496 samples total, so we use 350 train + 146 eval for it + print("\nLoading datasets...") + scienceqa_train, scienceqa_eval = load_scienceqa(1000, 200, seed) + numglue_train, numglue_eval = load_numglue(1000, 200, seed) + fomc_train, fomc_eval = load_fomc(350, 146, seed) + + # Store original eval datasets + scienceqa_eval_original = scienceqa_eval + numglue_eval_original = numglue_eval + fomc_eval_original = fomc_eval + + # Format datasets + scienceqa_train = scienceqa_train.map( + lambda x: format_scienceqa_for_llama(x, tokenizer, max_length), + batched=True, + remove_columns=scienceqa_train.column_names, + ) + scienceqa_eval = scienceqa_eval.map( + lambda x: format_scienceqa_for_llama(x, tokenizer, max_length), + batched=True, + remove_columns=scienceqa_eval.column_names, + ) + + numglue_train = numglue_train.map( + lambda x: format_numglue_for_llama(x, tokenizer, max_length), + batched=True, + remove_columns=numglue_train.column_names, + ) + numglue_eval = numglue_eval.map( + lambda x: format_numglue_for_llama(x, tokenizer, max_length), + batched=True, + remove_columns=numglue_eval.column_names, + ) + + fomc_train = fomc_train.map( + lambda x: format_fomc_for_llama(x, tokenizer, max_length), batched=True, remove_columns=fomc_train.column_names + ) + fomc_eval = fomc_eval.map( + lambda x: format_fomc_for_llama(x, tokenizer, max_length), batched=True, remove_columns=fomc_eval.column_names + ) + + data_collator = DataCollatorForCompletionOnly(tokenizer, max_length) + + tasks = [ + {"name": "ScienceQA", "train": scienceqa_train, "eval": scienceqa_eval, "type": "scienceqa"}, + {"name": "NumGLUE", "train": numglue_train, "eval": numglue_eval, "type": "numglue"}, + {"name": "FOMC", "train": fomc_train, "eval": fomc_eval, "type": "fomc"}, + ] + + # Store evaluation history + eval_history = { + "ScienceQA": [], + "NumGLUE": [], + "FOMC": [], + } + + # Load base model once + model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16, device_map="auto") + + # Sequential task training + for task_idx, task in enumerate(tasks): + print(f"\n{'=' * 80}") + print(f"TASK {task_idx + 1}: {task['name']}") + print(f"{'=' * 80}") + + # Training arguments + training_args = TrainingArguments( + output_dir=f"{output_dir}/full_{task['name'].lower()}", + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + gradient_accumulation_steps=gradient_accumulation_steps, + learning_rate=learning_rate, + logging_steps=10, + save_strategy="no", + bf16=True, + remove_unused_columns=False, + ) + + # Train on current task + trainer = Trainer( + model=model, + args=training_args, + train_dataset=task["train"], + data_collator=data_collator, + ) + + print(f"\nTraining on {task['name']}...") + trainer.train() + + # Evaluate on all tasks seen so far + print(f"\nEvaluating on all tasks after training on {task['name']}:") + for eval_task_idx in range(task_idx + 1): + eval_task = tasks[eval_task_idx] + loss, accuracy = evaluate_model( + model, eval_task["eval"], data_collator, tokenizer, eval_task["name"], eval_task["type"] + ) + eval_history[eval_task["name"]].append((loss, accuracy)) + + # Save final model + final_model_path = f"{output_dir}/full_final" + model.save_pretrained(final_model_path) + print(f"\nFinal full fine-tuning model saved to {final_model_path}") + + return eval_history + + +def print_results_comparison(osf_history, full_history): + """Print comparison table of OSF vs Full Fine-tuning.""" + print("\n" + "=" * 80) + print("RESULTS COMPARISON: OSF vs Full Fine-tuning") + print("=" * 80) + + tasks = ["ScienceQA", "NumGLUE", "FOMC"] + + # Print detailed results + print("\n" + "-" * 80) + print("DETAILED RESULTS (Accuracy %)") + print("-" * 80) + print(f"{'Task':<15} {'After Task':<15} {'OSF Acc %':<15} {'Full FT Acc %':<15} {'Difference':<15}") + print("-" * 80) + + for task_idx, task in enumerate(tasks): + for eval_after_idx in range(task_idx, len(tasks)): + eval_after = tasks[eval_after_idx] + osf_acc = osf_history[task][eval_after_idx - task_idx][1] * 100 + full_acc = full_history[task][eval_after_idx - task_idx][1] * 100 + diff = osf_acc - full_acc + + print( + f"{task:<15} {eval_after:<15} {osf_acc:<15.2f} {full_acc:<15.2f} {diff:+15.2f}{' (OSF better)' if diff > 0 else ''}" + ) + + # Summary statistics + print("\n" + "=" * 80) + print("SUMMARY METRICS") + print("=" * 80) + + # Final average accuracy across all 3 tasks + osf_final_accs = [osf_history[task][-1][1] * 100 for task in tasks] + full_final_accs = [full_history[task][-1][1] * 100 for task in tasks] + + osf_avg_final = sum(osf_final_accs) / len(osf_final_accs) + full_avg_final = sum(full_final_accs) / len(full_final_accs) + + print("\n1. Average Accuracy Across All 3 Tasks (After Final Task):") + print(f" OSF: {osf_avg_final:.2f}%") + print(f" Full FT: {full_avg_final:.2f}%") + print( + f" Difference: {osf_avg_final - full_avg_final:+.2f}% {'(OSF better)' if osf_avg_final > full_avg_final else '(Full FT better)'}" + ) + + # Average forgetting (for tasks 1 and 2 only, since task 3 is the final task) + print("\n2. Average Forgetting (Task 1 & 2):") + print(" Forgetting = Final Accuracy - Initial Accuracy (negative is worse)\n") + + osf_forgetting_vals = [] + full_forgetting_vals = [] + + for task_idx, task in enumerate(tasks[:-1]): # Exclude last task + osf_initial_acc = osf_history[task][0][1] * 100 # Right after learning task + osf_final_acc = osf_history[task][-1][1] * 100 # After learning all tasks + osf_forgetting = osf_final_acc - osf_initial_acc + + full_initial_acc = full_history[task][0][1] * 100 + full_final_acc = full_history[task][-1][1] * 100 + full_forgetting = full_final_acc - full_initial_acc + + osf_forgetting_vals.append(osf_forgetting) + full_forgetting_vals.append(full_forgetting) + + print(f" {task}:") + print(f" OSF: {osf_forgetting:+.2f}% (initial: {osf_initial_acc:.2f}% → final: {osf_final_acc:.2f}%)") + print( + f" Full FT: {full_forgetting:+.2f}% (initial: {full_initial_acc:.2f}% → final: {full_final_acc:.2f}%)" + ) + print( + f" Difference: {osf_forgetting - full_forgetting:+.2f}% {'(OSF better)' if osf_forgetting > full_forgetting else '(Full FT better)'}\n" + ) + + osf_avg_forgetting = sum(osf_forgetting_vals) / len(osf_forgetting_vals) + full_avg_forgetting = sum(full_forgetting_vals) / len(full_forgetting_vals) + + print(" Average Forgetting:") + print(f" OSF: {osf_avg_forgetting:+.2f}%") + print(f" Full FT: {full_avg_forgetting:+.2f}%") + print( + f" Difference: {osf_avg_forgetting - full_avg_forgetting:+.2f}% {'(OSF better)' if osf_avg_forgetting > full_avg_forgetting else '(Full FT better)'}" + ) + + print("\n" + "=" * 80) + + +def main(): + parser = argparse.ArgumentParser(description="OSF Continual Learning Example") + parser.add_argument( + "--model_name", + type=str, + default="meta-llama/Llama-3.1-8B-Instruct", + help="Model name or path", + ) + parser.add_argument("--num_train", type=int, default=1000, help="Number of training samples per task") + parser.add_argument("--num_eval", type=int, default=200, help="Number of evaluation samples per task") + parser.add_argument("--output_dir", type=str, default="./osf_continual_learning_outputs", help="Output directory") + parser.add_argument("--num_epochs", type=int, default=2, help="Number of training epochs per task") + parser.add_argument("--learning_rate", type=float, default=5e-6, help="Learning rate") + parser.add_argument("--batch_size", type=int, default=32, help="Batch size per device") + parser.add_argument("--gradient_accumulation_steps", type=int, default=1, help="Gradient accumulation steps") + parser.add_argument("--max_length", type=int, default=512, help="Maximum sequence length") + parser.add_argument("--seed", type=int, default=42, help="Random seed") + parser.add_argument( + "--run_baseline", + action="store_true", + help="Also run full fine-tuning baseline for comparison", + ) + + args = parser.parse_args() + + # Create output directory + os.makedirs(args.output_dir, exist_ok=True) + + # Train with OSF + osf_history = train_with_osf( + args.model_name, + args.num_train, + args.num_eval, + args.output_dir, + args.num_epochs, + args.learning_rate, + args.batch_size, + args.gradient_accumulation_steps, + args.max_length, + args.seed, + ) + + # Optionally train with full fine-tuning baseline + if args.run_baseline: + full_history = train_full_finetuning( + args.model_name, + args.num_train, + args.num_eval, + args.output_dir, + args.num_epochs, + args.learning_rate, + args.batch_size, + args.gradient_accumulation_steps, + args.max_length, + args.seed, + ) + + # Print comparison + print_results_comparison(osf_history, full_history) + else: + print("\n" + "=" * 80) + print("OSF TRAINING COMPLETE") + print("=" * 80) + print("\nTo compare with full fine-tuning baseline, run with --run_baseline flag") + + # Print OSF-only summary + tasks = ["ScienceQA", "NumGLUE", "FOMC"] + print("\n" + "=" * 80) + print("OSF SUMMARY METRICS") + print("=" * 80) + + # Final average accuracy + osf_final_accs = [osf_history[task][-1][1] * 100 for task in tasks] + osf_avg_final = sum(osf_final_accs) / len(osf_final_accs) + + print(f"\n1. Average Accuracy Across All 3 Tasks (After Final Task): {osf_avg_final:.2f}%") + for task, acc in zip(tasks, osf_final_accs): + print(f" {task}: {acc:.2f}%") + + # Average forgetting + print("\n2. Average Forgetting (Task 1 & 2):") + osf_forgetting_vals = [] + for task_idx, task in enumerate(tasks[:-1]): + osf_initial_acc = osf_history[task][0][1] * 100 + osf_final_acc = osf_history[task][-1][1] * 100 + osf_forgetting = osf_initial_acc - osf_final_acc + osf_forgetting_vals.append(osf_forgetting) + + print(f" {task}: {osf_forgetting:+.2f}% (initial: {osf_initial_acc:.2f}% → final: {osf_final_acc:.2f}%)") + + osf_avg_forgetting = sum(osf_forgetting_vals) / len(osf_forgetting_vals) + print(f" Average: {osf_avg_forgetting:+.2f}%") + print("\n" + "=" * 80) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/orthogonal_subspace_learning/utils.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/orthogonal_subspace_learning/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..6dd8ddeb9f85567b803e334504855c81617ad825 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/orthogonal_subspace_learning/utils.py @@ -0,0 +1,304 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# 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 torch +from datasets import load_dataset + + +def load_scienceqa(num_train=1000, num_eval=200, seed=42): + """ + Load ScienceQA dataset for science question answering. + + Args: + num_train: Number of training samples + num_eval: Number of evaluation samples + seed: Random seed for reproducibility + + Returns: + train_dataset, eval_dataset + """ + dataset = load_dataset("derek-thomas/ScienceQA", split="train") + + # Shuffle and split + dataset = dataset.shuffle(seed=seed) + train_dataset = dataset.select(range(num_train)) + eval_dataset = dataset.select(range(num_train, num_train + num_eval)) + + return train_dataset, eval_dataset + + +def load_numglue(num_train=1000, num_eval=200, seed=42): + """ + Load NumGLUE dataset for mathematical reasoning. + + Args: + num_train: Number of training samples + num_eval: Number of evaluation samples + seed: Random seed for reproducibility + + Returns: + train_dataset, eval_dataset + """ + import json + + from datasets import Dataset + from huggingface_hub import hf_hub_download + + # Download the NumGLUE JSON file manually + json_path = hf_hub_download(repo_id="metaeval/num-glue", filename="NumGLUE_train.json", repo_type="dataset") + + # Read and process the JSON file line by line + data = [] + with open(json_path) as f: + for line in f: + if line.strip(): # Skip empty lines + item = json.loads(line) + # Extract the number from the answer JSON structure + answer = item.get("answer", "") + if isinstance(answer, dict): + # NumGLUE answers are JSON with 'number' and 'date' fields + # Extract just the number field + answer_str = answer.get("number", "") + else: + answer_str = str(answer) + + data.append({"question": item.get("question", ""), "answer": answer_str}) + + # Create dataset from processed data + dataset = Dataset.from_list(data) + + # Shuffle and split + dataset = dataset.shuffle(seed=seed) + train_dataset = dataset.select(range(min(num_train, len(dataset)))) + + # If not enough samples, use what's available + eval_start = min(num_train, len(dataset)) + eval_end = min(num_train + num_eval, len(dataset)) + eval_dataset = dataset.select(range(eval_start, eval_end)) + + return train_dataset, eval_dataset + + +def load_fomc(num_train=1000, num_eval=200, seed=42): + """ + Load FOMC dataset for financial sentiment classification. + + Args: + num_train: Number of training samples + num_eval: Number of evaluation samples + seed: Random seed for reproducibility + + Returns: + train_dataset, eval_dataset + """ + dataset = load_dataset("TheFinAI/finben-fomc", split="test") + + # Shuffle and split + dataset = dataset.shuffle(seed=seed) + train_dataset = dataset.select(range(min(num_train, len(dataset)))) + + eval_start = min(num_train, len(dataset)) + eval_end = min(num_train + num_eval, len(dataset)) + eval_dataset = dataset.select(range(eval_start, eval_end)) + + return train_dataset, eval_dataset + + +def format_scienceqa_for_llama(examples, tokenizer, max_length=512): + """Format ScienceQA examples for Llama instruction following.""" + prompts = [] + labels_text = [] + + for i in range(len(examples["question"])): + # Build the question with choices + question = examples["question"][i] + choices = examples["choices"][i] + + # Format choices + choices_text = "\n".join([f"{chr(65 + j)}. {choice}" for j, choice in enumerate(choices)]) + + prompt = f"""Answer the following science question by selecting the correct option. + Question: {question} + + Choices: +{choices_text} + +Answer (just the letter):""" + + # Get the answer (convert index to letter) + answer_idx = examples["answer"][i] + answer = chr(65 + answer_idx) + + prompts.append(prompt) + labels_text.append(answer) + + # Tokenize + model_inputs = tokenizer(prompts, max_length=max_length, truncation=True, padding=False) + + # Tokenize labels + labels = tokenizer(labels_text, max_length=10, truncation=True, padding=False) + + # Combine input and label for training + combined_input_ids = [] + combined_attention_mask = [] + combined_labels = [] + + for i in range(len(model_inputs["input_ids"])): + input_ids = model_inputs["input_ids"][i] + label_ids = labels["input_ids"][i] + + # Combine input and label + combined = input_ids + label_ids + [tokenizer.eos_token_id] + combined_input_ids.append(combined) + + # Attention mask + combined_attention_mask.append([1] * len(combined)) + + # Labels (mask the prompt part, only train on answer) + label_masked = [-100] * len(input_ids) + label_ids + [tokenizer.eos_token_id] + combined_labels.append(label_masked) + + return { + "input_ids": combined_input_ids, + "attention_mask": combined_attention_mask, + "labels": combined_labels, + } + + +def format_numglue_for_llama(examples, tokenizer, max_length=512): + """Format NumGLUE examples for Llama instruction following.""" + prompts = [] + labels_text = [] + + for i in range(len(examples["question"])): + question = examples["question"][i] + answer = str(examples["answer"][i]) + + prompt = f"""Solve the following math problem and provide just the numerical answer. + +Question: {question} + +Answer:""" + + prompts.append(prompt) + labels_text.append(answer) + + # Tokenize + model_inputs = tokenizer(prompts, max_length=max_length, truncation=True, padding=False) + labels = tokenizer(labels_text, max_length=20, truncation=True, padding=False) + + combined_input_ids = [] + combined_attention_mask = [] + combined_labels = [] + + for i in range(len(model_inputs["input_ids"])): + input_ids = model_inputs["input_ids"][i] + label_ids = labels["input_ids"][i] + + combined = input_ids + label_ids + [tokenizer.eos_token_id] + combined_input_ids.append(combined) + combined_attention_mask.append([1] * len(combined)) + + label_masked = [-100] * len(input_ids) + label_ids + [tokenizer.eos_token_id] + combined_labels.append(label_masked) + + return { + "input_ids": combined_input_ids, + "attention_mask": combined_attention_mask, + "labels": combined_labels, + } + + +def format_fomc_for_llama(examples, tokenizer, max_length=512): + """Format FOMC examples for Llama instruction following.""" + prompts = [] + labels_text = [] + + for i in range(len(examples["text"])): + text = examples["text"][i] + # FOMC dataset has 'answer' column with values like 'dovish', 'hawkish', 'neutral' + label = examples["answer"][i].capitalize() # Capitalize first letter + + prompt = f"""Classify the sentiment of the following Federal Reserve statement as Dovish, Hawkish, or Neutral. + +Statement: {text} + +Sentiment:""" + + prompts.append(prompt) + labels_text.append(label) + + # Tokenize + model_inputs = tokenizer(prompts, max_length=max_length, truncation=True, padding=False) + labels = tokenizer(labels_text, max_length=10, truncation=True, padding=False) + + combined_input_ids = [] + combined_attention_mask = [] + combined_labels = [] + + for i in range(len(model_inputs["input_ids"])): + input_ids = model_inputs["input_ids"][i] + label_ids = labels["input_ids"][i] + + combined = input_ids + label_ids + [tokenizer.eos_token_id] + combined_input_ids.append(combined) + combined_attention_mask.append([1] * len(combined)) + + label_masked = [-100] * len(input_ids) + label_ids + [tokenizer.eos_token_id] + combined_labels.append(label_masked) + + return { + "input_ids": combined_input_ids, + "attention_mask": combined_attention_mask, + "labels": combined_labels, + } + + +class DataCollatorForCompletionOnly: + """Data collator that pads sequences for training.""" + + def __init__(self, tokenizer, max_length=512): + self.tokenizer = tokenizer + self.max_length = max_length + + def __call__(self, features): + # Pad sequences + max_len = min(max(len(f["input_ids"]) for f in features), self.max_length) + + input_ids = [] + attention_mask = [] + labels = [] + + for f in features: + # Truncate if needed + curr_input_ids = f["input_ids"][:max_len] + curr_attention_mask = f["attention_mask"][:max_len] + curr_labels = f["labels"][:max_len] + + # Pad + padding_length = max_len - len(curr_input_ids) + curr_input_ids = curr_input_ids + [self.tokenizer.pad_token_id] * padding_length + curr_attention_mask = curr_attention_mask + [0] * padding_length + curr_labels = curr_labels + [-100] * padding_length + + input_ids.append(curr_input_ids) + attention_mask.append(curr_attention_mask) + labels.append(curr_labels) + + return { + "input_ids": torch.tensor(input_ids, dtype=torch.long), + "attention_mask": torch.tensor(attention_mask, dtype=torch.long), + "labels": torch.tensor(labels, dtype=torch.long), + } diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/peanut_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/peanut_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..edd13a713cad3ac5e2b15c26ade718d6b180a202 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/peanut_finetuning/README.md @@ -0,0 +1,86 @@ +# PEANuT: Parameter-Efficient Adaptation with Weight-aware Neural Tweakers + +## Introduction +[**PEANuT**](https://arxiv.org/abs/2410.01870) is a PEFT method that introduces a **weight-aware neural tweaker** to generate adapter updates from the base weight itself. Instead of directly learning a low-rank decomposition `Delta W = A @ B` as in LoRA, PEANuT transforms the target layer weight through a small neural network (the neural tweaker) to produce `Delta W`. + +PEANuT is built on three key ideas: + +- **Weight-aware adaptation**: `Delta W` is produced by transforming the base weight using `A`, `B`, and optional intermediate layers. Because PEANuT applies `A` on the output dimension of the base weight, `A` has shape `(out_features, r)` instead of LoRA's typical `(in_features, r)`. When `in_features > out_features`, PEANuT can use fewer parameters than LoRA at the same rank. +- **Non-linearity inside the tweaker**: PEANuT inserts activation functions in the neural tweaker (default: `relu`) to increase expressiveness. +- **Depth capacity increase**: Besides mandatory `A` and `B`, PEANuT can insert intermediate `r x r` layers in residual encoder/decoder pairs. Here, `depth` counts the number of residual pairs, so `depth=0` means only `A` and `B`. + +## Quick start + +With respect to your standard PEFT training procedure with LoRA, simply swap your `LoraConfig` for a `PeanutConfig`. + +```python +import torch +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoTokenizer +from trl import SFTConfig, SFTTrainer + +from peft import PeanutConfig + +model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B") +dataset = load_dataset("timdettmers/openassistant-guanaco", split="train") +peanut_config = PeanutConfig() + +trainer = SFTTrainer( + model=model, + train_dataset=dataset, + processing_class=tokenizer, + peft_config=peanut_config, + args=SFTConfig( + max_length=2048, + dataset_text_field="text", + per_device_train_batch_size=2, + ), +) +trainer.train() +trainer.model.save_pretrained("peanut-llama-3.2-3b") +``` + +Run the finetuning script simply by running: +```sh +python examples/peanut_finetuning/peanut_finetuning.py --base_model meta-llama/Llama-3.2-3B --data_path timdettmers/openassistant-guanaco +``` + +## Use the model on Hugging Face +You can load and use the model as any other Hugging Face model. + +```python +import torch +from peft import PeftModel +from transformers import AutoModelForCausalLM + +model = AutoModelForCausalLM.from_pretrained( + "meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto" +) +peft_model = PeftModel.from_pretrained(model, "peanut-llama-3.2-3b") +``` + +## Additional Notes + +- `r` controls the hidden rank of the neural tweaker. Larger `r` increases capacity and trainable parameters. +- `depth` controls the number of intermediate encoder/decoder residual pairs. It must be a non-negative integer. +- `depth=0` means only `A` and `B`. +- `depth=1` adds one encoder/decoder residual pair between `A` and `B`. +- Larger depths add more `r x r` residual pairs. +- `act_fn` controls the non-linearity inside PEANuT and defaults to `relu`. +- `scaling` is a direct scalar multiplier on the adapter output before it is added to the frozen base layer output. +- PEANuT can perform better than LoRA across a range of tasks. We also find it strong in very low-parameter regimes (for example around `0.2M` trainable parameters). +- Compared with LoRA, PEANuT typically uses more GPU memory and runs slower because it explicitly constructs `Delta W` during forward passes. Adding intermediate layers (higher `depth`) increases this overhead further. + +## Citation +```bibtex +@misc{zhong2025peanutparameterefficientadaptationweightaware, + title={PEANuT: Parameter-Efficient Adaptation with Weight-aware Neural Tweakers}, + author={Yibo Zhong and Haoxiang Jiang and Lincan Li and Ryumei Nakada and Tianci Liu and Linjun Zhang and Huaxiu Yao and Haoyu Wang}, + year={2025}, + eprint={2410.01870}, + archivePrefix={arXiv}, + primaryClass={cs.LG}, + url={https://arxiv.org/abs/2410.01870}, +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/peanut_finetuning/peanut_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/peanut_finetuning/peanut_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..a74ed748efa4f7bb4467f3efb7b81dd0c5185c98 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/peanut_finetuning/peanut_finetuning.py @@ -0,0 +1,207 @@ +# This script is based on examples/lily_finetuning/lily_finetuning.py +import os + +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + DataCollatorForLanguageModeling, + Trainer, + TrainingArguments, +) + +from peft import PeanutConfig, get_peft_model + + +def train_model( + base_model: str, + data_path: str, + output_dir: str, + batch_size: int, + num_epochs: int, + learning_rate: float, + cutoff_len: int, + val_set_size: int, + eval_step: int, + save_step: int, + device: str, + peanut_r: int, + peanut_depth: int, + peanut_scaling: float, + peanut_act_fn: str, + peanut_target_modules: str, + peanut_init_weights: bool, + hub_model_id: str, + push_to_hub: bool, +): + os.environ["TOKENIZERS_PARALLELISM"] = "false" + hf_token = os.getenv("HF_TOKEN") + + # Setup device + if device == "auto": + device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + else: + device = torch.device(device) + print(f"Using device: {device}") + + # load tokenizer + tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token) + + model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token) + + # PEANuT config for the PEFT model + peanut_config = PeanutConfig( + r=peanut_r, + depth=peanut_depth, + scaling=peanut_scaling, + act_fn=peanut_act_fn, + init_weights=peanut_init_weights, + target_modules=( + peanut_target_modules.split(",") + if peanut_target_modules + else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] + ), + ) + + # get the peft model with PEANuT config + model = get_peft_model(model, peanut_config) + model.print_trainable_parameters() + + model.to(device) + tokenizer.pad_token = tokenizer.eos_token + + # Load the dataset + dataset = load_dataset(data_path) + + def tokenize_function(examples): + inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len) + inputs["labels"] = inputs["input_ids"].copy() # setting labels for a language modeling task + return inputs + + # Tokenize the dataset and prepare for training + tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names) + + # Data collator to dynamically pad the batched examples + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + + # Define training arguments + training_args = TrainingArguments( + output_dir=output_dir, + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + per_device_eval_batch_size=batch_size, + warmup_steps=100, + weight_decay=0.01, + logging_steps=eval_step, + save_steps=save_step, + save_total_limit=2, + push_to_hub=push_to_hub, + hub_model_id=hub_model_id, + gradient_accumulation_steps=16, + fp16=True, + learning_rate=learning_rate, + hub_token=hf_token, + ) + + # Clear device cache to free memory + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + # Initialize the Trainer + trainer = Trainer( + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["test"], + data_collator=data_collator, + ) + + # Start model training + trainer.train() + + # Save and push the trained model and tokenizer + if push_to_hub: + trainer.push_to_hub(commit_message="Fine-tuned model with PEANuT") + + # Save the model and tokenizer locally + model.save_pretrained(output_dir) + tokenizer.save_pretrained(output_dir) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Fine-tune LLaMA with PEANuT and PEFT") + parser.add_argument("--base_model", type=str, default="meta-llama/Llama-3.2-3B", help="Base model path or name") + parser.add_argument( + "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name" + ) + parser.add_argument( + "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model" + ) + parser.add_argument("--batch_size", type=int, default=1, help="Batch size") + parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs") + parser.add_argument("--learning_rate", type=float, default=1e-4, help="Learning rate") + parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization") + parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size") + parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval") + parser.add_argument("--save_step", type=int, default=100, help="Save step interval") + parser.add_argument("--device", type=str, default="auto", help="Device to use for training") + parser.add_argument("--peanut_r", type=int, default=32, help="PEANuT rank") + parser.add_argument( + "--peanut_depth", + type=int, + default=0, + help="Total number of PEANuT transforms including A and B (must be even and >= 2)", + ) + parser.add_argument( + "--peanut_scaling", type=float, default=1.0, help="PEANuT scaling factor applied to adapter output" + ) + parser.add_argument( + "--peanut_act_fn", + type=str, + default="relu", + help="Activation used inside PEANuT neural tweakers (must be a valid transformers ACT2FN key)", + ) + parser.add_argument( + "--peanut_target_modules", type=str, default=None, help="Comma-separated list of target modules for PEANuT" + ) + parser.add_argument( + "--peanut_init_weights", + action=argparse.BooleanOptionalAction, + default=True, + help="Use PEANuT default init: zero-init B and Kaiming-init the other layers", + ) + parser.add_argument( + "--hub_model_id", + type=str, + default="path/to/repo", + help="Repository name to push the model on the Hugging Face Hub", + ) + parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub") + args = parser.parse_args() + + train_model( + base_model=args.base_model, + data_path=args.data_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + val_set_size=args.val_set_size, + eval_step=args.eval_step, + save_step=args.save_step, + device=args.device, + peanut_r=args.peanut_r, + peanut_depth=args.peanut_depth, + peanut_scaling=args.peanut_scaling, + peanut_act_fn=args.peanut_act_fn, + peanut_target_modules=args.peanut_target_modules, + peanut_init_weights=args.peanut_init_weights, + hub_model_id=args.hub_model_id, + push_to_hub=args.push_to_hub, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/pissa_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/pissa_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..44f9e23cc0e295d646e762703b8bb8639b3dd20e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/pissa_finetuning/README.md @@ -0,0 +1,131 @@ +# PiSSA: Principal Singular values and Singular vectors Adaptation +## Introduction ([Paper](https://huggingface.co/papers/2404.02948), [code](https://github.com/GraphPKU/PiSSA)) +PiSSA represents a matrix $W\in\mathbb{R}^{m\times n}$ within the model by the product of two trainable matrices $A \in \mathbb{R}^{m\times r}$ and $B \in \mathbb{R}^{r\times n}$, where $r \ll \min(m, n)$, plus a residual matrix $W^{res}\in\mathbb{R}^{m\times n}$ for error correction. Singular value decomposition (SVD) is employed to factorize $W$, and the principal singular values and vectors of $W$ are utilized to initialize $A$ and $B$. The residual singular values and vectors initialize the residual matrix $W^{res}$, which keeps frozen during fine-tuning. This straightforward modification allows PiSSA to converge more rapidly than LoRA and ultimately attain superior performance. Moreover, PiSSA reduces the quantization error compared to QLoRA, leading to further enhancements. + +## Quick Start +```python +import torch +from peft import LoraConfig, get_peft_model +from transformers import AutoTokenizer, AutoModelForCausalLM +from trl import SFTConfig, SFTTrainer +from datasets import load_dataset + +model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf") +tokenizer.pad_token_id = tokenizer.eos_token_id +lora_config = LoraConfig( + # init_lora_weights="pissa", # Configure the initialization method to "pissa", which may take several minutes to execute SVD on the pre-trained model. + init_lora_weights="pissa_niter_4", # Initialize the PiSSA with fast SVD, which completes in just a few seconds. +) +peft_model = get_peft_model(model, lora_config) + +peft_model.print_trainable_parameters() + +dataset = load_dataset("imdb", split="train[:1%]") + +training_args = SFTConfig(dataset_text_field="text", max_length=128) +trainer = SFTTrainer( + model=peft_model, + args=training_args, + train_dataset=dataset, + processing_class=tokenizer, +) +trainer.train() +peft_model.save_pretrained("pissa-llama-2-7b") +``` +When utilizing fast SVD, reducing the rank and the number of iterations decreases the time required. However, this approach leads to higher errors in the computed matrices $A$ and $B$. To preserve the model's initial capabilities, we calculate the residual matrix by $W^{res} = W - BA$. Even with potential errors in $A$ and $B$, the sum of $W^{res}$ and $BA$ accurately equals $W$. + + +To utilize the fine-tuned PiSSA modules, simply run the following command: +```python +import torch +from peft import PeftModel +from transformers import AutoModelForCausalLM + +model = AutoModelForCausalLM.from_pretrained( + "meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto" +) +# Performs SVD again to initialize the residual model and loads the state_dict of the fine-tuned PiSSA modules. +peft_model = PeftModel.from_pretrained(model, "pissa-llama-2-7b") +``` + +## Advanced Usage + +### Access the preprocessed models +We recommend downloading decomposed models directly from the [Hugging Face Collections](https://huggingface.co/collections/fxmeng/pissa-661ce700721235e542a5d7a8) instead of performing SVD every time. +If the existing models do not meet your needs, apply PiSSA initialization to a pre-trained model and store the decomposed model locally: +```bash +python preprocess.py \ + --base_model_name_or_path meta-llama/Llama-2-7b-hf \ + --init_lora_weights pissa \ + --output_dir pissa-llama-2-7b-r32-alpha-32 \ + --lora_r 32 \ + --lora_alpha 32 \ + --lora_dropout 0 \ + --bits bf16 +``` + +### Convert PiSSA to LoRA +The main advantage of PiSSA is concentrated during the training phase. For a trained PiSSA adapter, we recommend converting it equivalently to the LoRA adapter for using and sharing. +```python +# The fine-tuned matrices $A$ and $B$ in PiSSA adapter is saved and should be combined with the residual model. +peft_model.save_pretrained(output_dir) +# Given the matrices $A_0$ and $B_0$, initialized by PiSSA and untrained, and the trained matrices $A$ and $B$, +# we can convert these to LoRA by setting $\Delta W = A \times B - A_0 \times B_0 = [A \mid A_0] \times [B \mid -B_0]^T = A'B'$. +peft_model.save_pretrained(output_dir, path_initial_model_for_weight_conversion="pissa_init") + +``` +This conversion enables the loading of LoRA on top of a standard base model: + +```python +import torch +from peft import PeftModel +from transformers import AutoModelForCausalLM + +model = AutoModelForCausalLM.from_pretrained( + "meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto" +) +# No SVD is performed during this step, and the base model remains unaltered. +peft_model = PeftModel.from_pretrained(model, "pissa-llama-2-7b-lora") +``` +Utilizing the converted LoRA does not require modifying the parameters of the base model. When multiple converted LoRAs are needed simultaneously, each adapter operates independently without interference, allowing for the adapters to be freely deleted or added. + +Note that this conversion is not supported if `rslora` is used in combination with `rank_pattern` or `alpha_pattern`. + +### Fine-tune in 4-bit or 8-bit +If quantization fine-tuning is desired, it is necessary to first decompose the original model at full precision and then reload the residual model in either 4-bit or 8-bit configurations. +```shell +python pissa_finetuning.py \ + --residual_model_name_or_path fxmeng/pissa-llama-2-7b-r16-alpha-16 \ + --output_dir output/pissa-llama-2-7b-r16-alpha-16-metamath-10k \ + --bits nf4 \ + --data_path meta-math/MetaMathQA \ + --dataset_split train[:100000] \ + --dataset_field query response \ + --bf16 True \ + --num_train_epochs 1 \ + --per_device_train_batch_size 32 \ + --gradient_accumulation_steps 4 \ + --save_strategy "steps" \ + --save_steps 1000 \ + --save_total_limit 1 \ + --logging_steps 1 \ + --learning_rate 2e-5 \ + --weight_decay 0. \ + --warmup_steps 0.03 \ + --tf32 True \ + --report_to none \ + --convert_pissa_to_lora +``` + +This approach ensures the preservation of high-frequency, out-of-distribution parameters in the low-rank PiSSA modules, resulting in reduced quantization errors during the quantization of the residual model. + +## Citation +``` +@article{meng2024pissa, + title={PiSSA: Principal Singular Values and Singular Vectors Adaptation of Large Language Models}, + author={Meng, Fanxu and Wang, Zhaohui and Zhang, Muhan}, + journal={arXiv preprint arXiv:2404.02948}, + year={2024} +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/pissa_finetuning/pissa_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/pissa_finetuning/pissa_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..259efb41fe4cf6a0c649ba58482ba6189c84e6a0 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/pissa_finetuning/pissa_finetuning.py @@ -0,0 +1,150 @@ +# Copyright 2023-present the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from dataclasses import dataclass, field +from typing import Optional + +import torch +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, HfArgumentParser +from trl import SFTConfig, SFTTrainer + +from peft import LoraConfig, PeftModel, get_peft_model, prepare_model_for_kbit_training + + +@dataclass +class ScriptArguments(SFTConfig): + # model configs + base_model_name_or_path: Optional[str] = field( + default=None, metadata={"help": "The name or path of the fp32/16 base model."} + ) + residual_model_name_or_path: Optional[str] = field( + default=None, + metadata={ + "help": "The name or path of the fp32/16 residual model. (`['fxmeng/pissa-llama-2-7b-r16-alpha-16']`)" + }, + ) + bits: str = field(default="fp32", metadata={"help": "(`['fp4', 'nf4', 'int8', 'bf16', 'fp16', fp32]`)"}) + init_lora_weights: str = field(default="pissa", metadata={"help": "(`['gaussian', 'pissa', 'pissa_niter_4']`)"}) + lora_r: int = field(default=16) + lora_alpha: int = field(default=16) + lora_dropout: float = field(default=0) + convert_pissa_to_lora: bool = field(default=False) + merge_and_save: bool = field(default=False) + # dataset configs + data_path: str = field(default="imdb", metadata={"help": "Path to the training data."}) + dataset_split: str = field(default="train[:1%]", metadata={"help": "(`['train', 'test', 'eval']`):"}) + dataset_field: list[str] = field(default=None, metadata={"help": "Fields of dataset input and output."}) + + +parser = HfArgumentParser(ScriptArguments) +script_args = parser.parse_args_into_dataclasses()[0] +print(script_args) + +print(f"Load pre-processed residual model in {script_args.bits} bits.") +if script_args.bits in ["nf4", "fp4", "int8"]: + quantization_config = BitsAndBytesConfig( + load_in_4bit=(script_args.bits == "nf4" or script_args.bits == "fp4"), + load_in_8bit=script_args.bits == "int8", + bnb_4bit_quant_type=script_args.bits, + bnb_4bit_use_double_quant=True, + bnb_4bit_compute_dtype=torch.bfloat16, + ) + res_model = AutoModelForCausalLM.from_pretrained( + script_args.residual_model_name_or_path, quantization_config=quantization_config, low_cpu_mem_usage=True + ) + res_model = prepare_model_for_kbit_training(res_model) + print("Wrapping the residual model with PiSSA.") + peft_model = PeftModel.from_pretrained( + res_model, script_args.residual_model_name_or_path, subfolder="pissa_init", is_trainable=True + ) + tokenizer = AutoTokenizer.from_pretrained(script_args.residual_model_name_or_path) + +elif script_args.residual_model_name_or_path is not None: + res_model = AutoModelForCausalLM.from_pretrained( + script_args.residual_model_name_or_path, + dtype=( + torch.float16 + if script_args.bits == "fp16" + else (torch.bfloat16 if script_args.bits == "bf16" else torch.float32) + ), + device_map="auto", + ) + print("Wrapping the residual model with PiSSA.") + peft_model = PeftModel.from_pretrained( + res_model, script_args.residual_model_name_or_path, subfolder="pissa_init", is_trainable=True + ) + tokenizer = AutoTokenizer.from_pretrained(script_args.residual_model_name_or_path) + +elif script_args.base_model_name_or_path is not None: + print( + f"No available pre-processed model, manually initialize a PiSSA using {script_args.base_model_name_or_path}." + ) + model = AutoModelForCausalLM.from_pretrained( + script_args.base_model_name_or_path, + dtype=( + torch.float16 + if script_args.bits == "fp16" + else (torch.bfloat16 if script_args.bits == "bf16" else torch.float32) + ), + device_map="auto", + ) + tokenizer = AutoTokenizer.from_pretrained(script_args.base_model_name_or_path) + tokenizer.pad_token_id = tokenizer.eos_token_id + lora_config = LoraConfig( + r=script_args.lora_r, + lora_alpha=script_args.lora_alpha, + init_lora_weights=script_args.init_lora_weights, + lora_dropout=script_args.lora_dropout, + target_modules=["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"], + bias="none", + task_type="CAUSAL_LM", + ) + peft_model = get_peft_model(model, lora_config) + +print(peft_model) +peft_model.print_trainable_parameters() + +print(f"Training PiSSA with trl on the {script_args.data_path}[{script_args.dataset_split}] dataset.") +dataset = load_dataset(script_args.data_path, split=script_args.dataset_split) +dataset = dataset.map( + lambda example: { + "text": f"### USER: {example[script_args.dataset_field[0]]}\n### ASSISTANT: {example[script_args.dataset_field[1]]}" + } +) + +trainer = SFTTrainer( + model=peft_model, + args=script_args, + train_dataset=dataset, + processing_class=tokenizer, +) +trainer.train() +trainer.save_state() +############################## Upon training completion, convert and save PiSSA in LoRA format ############################## +if script_args.convert_pissa_to_lora: + peft_model.save_pretrained( + os.path.join(script_args.output_dir, "pissa_lora"), + path_initial_model_for_weight_conversion=os.path.join(script_args.residual_model_name_or_path, "pissa_init"), + ) +else: + peft_model.save_pretrained( + os.path.join(script_args.output_dir, "pissa_ft"), + ) + +if script_args.merge_and_save: + model = peft_model.merge_and_unload() + model.save_pretrained(os.path.join(script_args.output_dir, "pissa_merged")) + tokenizer.save_pretrained(os.path.join(script_args.output_dir, "pissa_merged")) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/pissa_finetuning/preprocess.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/pissa_finetuning/preprocess.py new file mode 100644 index 0000000000000000000000000000000000000000..9cac153208ab3c03e6cc77cc5f3c45b2e9f78dec --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/pissa_finetuning/preprocess.py @@ -0,0 +1,69 @@ +# Copyright 2023-present the HuggingFace Inc. team. +# +# 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 argparse +import os + +import torch +from transformers import AutoModelForCausalLM, AutoTokenizer + +from peft import LoraConfig, get_peft_model + + +parser = argparse.ArgumentParser(description="Merge Adapter to Base Model") +parser.add_argument( + "--base_model_name_or_path", + help="The name or path of the fp32/16 base model.", +) +parser.add_argument("--output_dir", type=str, help="The directory to save the PiSSA model.") +parser.add_argument("--bits", type=str, default="bf16", choices=["bf16", "fp16", "fp32"]) +parser.add_argument( + "--init_lora_weights", type=str, default="pissa", help="(`['pissa', 'pissa_niter_[number of iters]']`)" +) +parser.add_argument("--lora_r", type=int, default=128) +parser.add_argument("--lora_alpha", type=int, default=128) +parser.add_argument("--lora_dropout", type=int, default=0) +script_args = parser.parse_args() +print(script_args) + +model = AutoModelForCausalLM.from_pretrained( + script_args.base_model_name_or_path, + dtype=( + torch.float16 + if script_args.bits == "fp16" + else (torch.bfloat16 if script_args.bits == "bf16" else torch.float32) + ), + device_map="auto", +) +tokenizer = AutoTokenizer.from_pretrained(script_args.base_model_name_or_path) +tokenizer.pad_token_id = tokenizer.eos_token_id +lora_config = LoraConfig( + r=script_args.lora_r, + lora_alpha=script_args.lora_alpha, + init_lora_weights=script_args.init_lora_weights, + lora_dropout=script_args.lora_dropout, + target_modules=["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"], + bias="none", + task_type="CAUSAL_LM", +) +peft_model = get_peft_model(model, lora_config) + +# Save PiSSA modules: +peft_model.peft_config["default"].init_lora_weights = True +peft_model.save_pretrained(os.path.join(script_args.output_dir, "pissa_init")) +# Save residual model: +peft_model = peft_model.unload() +peft_model.save_pretrained(script_args.output_dir) +# Save the tokenizer: +tokenizer.save_pretrained(script_args.output_dir) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/poly/peft_poly_seq2seq_with_generate.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/poly/peft_poly_seq2seq_with_generate.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..d6768d01fc0730a357a14e4bdce96889efee028f --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/poly/peft_poly_seq2seq_with_generate.ipynb @@ -0,0 +1,14776 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "2edec24d8563b583", + "metadata": { + "collapsed": false, + "execution": { + "shell.execute_reply.end": "2023-12-22T03:34:15.998083Z", + "shell.execute_reply.started": "2023-12-22T03:34:15.994854Z", + "to_execute": "2023-12-22T03:34:15.875Z" + }, + "libroFormatter": "formatter-string" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: CUDA_VISIBLE_DEVICES=0 # force using CUDA GPU device 0\n", + "env: ZE_AFFINITY_MASK=0 # force using Intel XPU device 0\n", + "env: TOKENIZERS_PARALLELISM=false\n" + ] + } + ], + "source": [ + "%env CUDA_VISIBLE_DEVICES=0 # force using CUDA GPU device 0\n", + "%env ZE_AFFINITY_MASK=0 # force using Intel XPU device 0\n", + "%env TOKENIZERS_PARALLELISM=false" + ] + }, + { + "cell_type": "markdown", + "id": "95b4cfd741795038", + "metadata": { + "id": "95b4cfd741795038", + "libroFormatter": "formatter-string" + }, + "source": [ + "## Initialize PolyModel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a5c7a99-5208-4d22-ac15-bacebe1b52f9", + "metadata": { + "execution": { + "shell.execute_reply.end": "2023-12-22T03:34:29.137789Z", + "shell.execute_reply.started": "2023-12-22T03:34:18.146604Z", + "to_execute": "2023-12-22T03:34:18.025Z" + }, + "id": "1a5c7a99-5208-4d22-ac15-bacebe1b52f9", + "libroFormatter": "formatter-string" + }, + "outputs": [], + "source": [ + "import torch\n", + "from transformers import (\n", + " AutoModelForSeq2SeqLM,\n", + " AutoTokenizer,\n", + " default_data_collator,\n", + " Seq2SeqTrainingArguments,\n", + " Seq2SeqTrainer,\n", + ")\n", + "from datasets import load_dataset, concatenate_datasets\n", + "from peft import PolyConfig, get_peft_model, TaskType, PeftModel, PeftConfig\n", + "\n", + "model_name_or_path = \"google/flan-t5-xl\"\n", + "\n", + "r = 8 # rank of lora in poly\n", + "n_tasks = 4 # number of tasks\n", + "n_skills = 2 # number of skills (loras)\n", + "n_splits = 4 # number of heads\n", + "\n", + "batch_size = 8\n", + "lr = 5e-5\n", + "num_epochs = 8" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "89a1d2c6-0d35-4254-b9fb-035a426d86ae", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 241, + "referenced_widgets": [ + "dc5d4672fcd149239cfe1a837094ce53", + "eded01d7629e4a4faad592e8e20a3ca3", + "5d1e94d40f514faaa5819096f167d29c", + "f98f73664a974ae7804e494425fbe20d", + "1c0bd751a3294b8ea0cf828866169121", + "6c3ed2de06fe40c09315ff72d43d5c8c", + "2e3d6b5d46db4295829002fc311a9c74", + "5ff0d4da7342457089f0961b189307f4", + "a08c4e6628bd440fb31eebbb2693f327", + "379357ab63f5479fad469c181b054bb0", + "f860e1c3467348f0802b733fbef45c15", + "567e165c27a4494bbf4810ecb7de40cf", + "015fd47fdbdf47c5a619eff218052b45", + "ec33a4325b6f4dcfb8a9fa4c80a5c704", + "3241189c875a471ab0831f0f4411d2d3", + "268fe971a0bc45c6b7c37586e0f9da49", + "8851d4a04cb9410c849b6606a812c52b", + "3b5ab7d9f27944d8ae1b172231c9c6fc", + "85f57b44dbe442a4952c65e1db4c1176", + "3f173a7293cd4ff8a54da8c8174cfb43", + "40ac1e38c100435fbe95b669c69a31c5", + "a634013728be457ba590aa333908addd", + "376242d1cfd74c88aaeaa76a6813d855", + "a17443b5713d4b60aeb85da3adce6cf2", + "91f821fb888046b6a2f8ade2cc58db2d", + "4bea407148e846babefdc88eff8a9131", + "26a75e6f6628472b91f3214505afa935", + "c7c0b0fd45dc448eb9456f58e36fb3bb", + "a14f26db56d04b8b840a9ce366e913e6", + "09fa4b156f174dbcacdf976f2b39a280", + "c9ca89486def4220967599e5b159b980", + "558b98eb76654045a5eae24170a5dc9c", + "7edf2ac4dd264843a7838a0130668757", + "c3aa97f46a60409091dc4d33a946c6d3", + "e6315c5d217b4922b461c9ac22528e62", + "04c34c92e4374c50bd0636c72953a8ba", + "32a6ac79c27e47c1a4b32098bfe25807", + "bb99715a25d94422b0048de94f2fe563", + "637bbd213f3345178742523d055993e6", + "6113f1920c5743aa8f2c6cc9739029e1", + "24bbd7b810b34c4c9baeed628961c64b", + "1c63e99470824a3aa0f98a94862733d5", + "98c677014f1a48ac804cec0714a22172", + "a4097270b9b947b0ad0b3b5d217eecc0", + "8eaed8cbbf1943328dc80fc43bd5b97c", + "6b1972a032af41de9bf99a6582c53f39", + "b4eb16a8153048ea9aa5c9d43b44820c", + "9bd66a63faf9416d9e774a5d8221c5f5", + "40b859a2fd68457db691bb5e7eb23591", + "533151b377d64d3484772b3173dab306", + "2cd302d306e3440dac4b70fc46741544", + "41b36d52e98249b1b506d369d2d8e994", + "ac83130fdd374b7c8f41e0f8f011ecae", + "66b0e949143e46faab77458a49a9fe1a", + "abd34fa3e94c49869ea7cf514dba6d1d", + "8ffe87ece7e54294a160540fbbbe124b", + "9c3c68da285449958a3d8745bbc50305", + "ae517eef5a004b16b4ae34cdf2aa851e", + "08a572aefb63488d8125ae3b881c0729", + "f2131e286f704514a61b5af0785dde8b", + "43d9b3de4a6949f787d9733d1ae4d18e", + "06716294f2244cc48f78af918cc063f2", + "e69b0005e91a478297d17e4089cda650", + "f92f9afc2c694f0cbcdf4ebcca98221e", + "7ffe5fd0a64c40cebc784eca83154069", + "d622b006621e4110a157fb4cb43c9762", + "874e05e0b861466ba57a08d8f5a5b7ee", + "8ebe69a07de64c3cb6dfd6433e222186", + "2aceeebfd0dc42fcbbc1b3a7e1f54c56", + "93c6f7c0d1ba49a295ae60a73bf509a9", + "6c3ebb812cfd493bb954a6b1d7455c72", + "a27edbdb4c824979b1b56e8fbd867595", + "5bdf79c178074ebf8757936190bc37b3", + "3c076081fd7942e184f8d4f171a17e1c", + "0a03bee83ddf4ad297bfdc9b4de3b075", + "6f59ae0a20cf4cc5859925e3259291a7", + "49ac9897f49843fd8c5fed4bcdfdbb56" + ] + }, + "execution": { + "shell.execute_reply.end": "2023-12-22T03:35:33.229420Z", + "shell.execute_reply.started": "2023-12-22T03:34:37.266443Z", + "to_execute": "2023-12-22T03:34:37.242Z" + }, + "id": "89a1d2c6-0d35-4254-b9fb-035a426d86ae", + "libroFormatter": "formatter-string", + "outputId": "fc90c2cc-9cab-40ed-bf4a-d76bec85b72f" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading checkpoint shards: 100%|██████████| 2/2 [00:00<00:00, 22.43it/s]\n" + ] + } + ], + "source": [ + "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, trust_remote_code=True)\n", + "base_model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path, trust_remote_code=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "29d701a4-7a4f-4eae-84bd-9e3a02b7ffca", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "shell.execute_reply.end": "2023-12-22T03:35:33.396336Z", + "shell.execute_reply.started": "2023-12-22T03:35:33.250286Z", + "to_execute": "2023-12-22T03:35:33.272Z" + }, + "id": "29d701a4-7a4f-4eae-84bd-9e3a02b7ffca", + "libroFormatter": "formatter-string", + "outputId": "63898f68-926e-40c4-ca13-ffd1df32fcce" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 9,441,792 || all params: 2,859,198,976 || trainable%: 0.3302\n" + ] + } + ], + "source": [ + "peft_config = PolyConfig(\n", + " task_type=TaskType.SEQ_2_SEQ_LM,\n", + " poly_type=\"poly\",\n", + " r=r,\n", + " n_tasks=n_tasks,\n", + " n_skills=n_skills,\n", + " n_splits=n_splits,\n", + ")\n", + "\n", + "model = get_peft_model(base_model, peft_config)\n", + "model.print_trainable_parameters()" + ] + }, + { + "cell_type": "markdown", + "id": "aa695c2d-cf9c-432c-ab74-7e89f816ba13", + "metadata": { + "id": "aa695c2d-cf9c-432c-ab74-7e89f816ba13", + "libroFormatter": "formatter-string" + }, + "source": [ + "## Prepare datasets\n", + "\n", + "For this example, we selected four `SuperGLUE` benchmark datasets: `boolq`, `multirc`, `rte`, and `wic`, each with a training set of 1,000 examples and an evaluation set of 100 examples." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d0b36e7eff50657c", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "d6250bff76d7454a8216572ab28e4a72", + "384d10ea2a354f24bae33c3a1d564b82", + "a2deecc9aa3d42d381d78199f6e29d1c", + "17fc618034bf4aadaef811b0e7c80eed", + "6757bc0834fc4e69b7b588ae6de14ec9", + "b9ec517b4b084d548525ac41381ef69e", + "6f3679fe9b60498da864bda9ba6d899e", + "ef16f8bac38044c3b6a092caf5da320b", + "19e50ecdda3b493184611d97724ac1fc", + "c2ed87d5599a467bba084cddb9e40713", + "2cfc492ab0ed454dbf2c4da18cd24d02", + "91e6e0685a4c4d26b6154d3ed18418eb", + "ba1864322c0d49fd915e9dcc2469ef6f", + "67b108def57749edb2564b3e507959a3", + "c04a17f40c974f378c60858473f49fd0", + "4189c6e9c59e44d3a776b49c38cc8f06", + "7550307b4e894844b8d032df7eea6d82", + "bcf20733fb504a71be5cf0455928b587", + "cc6c1b2d4fcb4ffea016a139738e1ead", + "6bd3da08b5074e81bffbfe6d92b8ce8b", + "03d340641a414362b0356e8178148d9a", + "61fec3b2596c4803924ed1fb087d52d1", + "4fc54c5844aa44f2b335824c3544a334", + "736443c7e26642379ca66ed3e5dd34cb", + "3c3d747638004a08a898cff7c6f59acc", + "1cb2dcb242334f46b7f195929dd1f341", + "f577bbac4eab439b9ccea0a49eb99d86", + "8822d3a8fa794fc0addb5885a862d205", + "10436da727ec45c8a5e8b783696636d5", + "0622e1de75f34da590f241232613cf5e", + "5b868029728541dc9da977312da38cf0", + "33add0384c36462ab44fe3e0b03f63c7", + "e227fb95b00b4af8b82286c75db84611", + "54d4afa42e9346578c0a1a193ee8caea", + "2918f1fd9e104c09967d698e11728785", + "170853712c0c4a8d997696f74090d7c6", + "fcdb61acbf0d470f881ba8f283360e0f", + "4803c9aece3346488295338254217aff", + "d725549ca34a4d54ae684e7e4741be29", + "d94392afd01246ff942af838a995379e", + "7eaee1cd25d0442092846922cdd6c413", + "483b9c219aa94ea1952e3534a02395aa", + "10d7a41588744be1b29678b4a9dfdd27", + "c4fce7e5a2b44835ab8723e0022d1e50", + "ba3a7258734b4edb86b8eef074d65222", + "4b3dc87d00ed42b0956d0bfa39bd466f", + "2c5eaf38e66d492d8661852cacc4e527", + "b7f169f931074d1283cbfe912f11ba98", + "e86771ea303a4b1b86ecf5128f3ea421", + "b3a18689eefa4660997034094df0df04", + "91cb4404dd794d22b2bbaf31eee207b5", + "d8594695c03e4fb7965dcbe04074d4eb", + "f972a2e10dde405c8aec8f7cd1be4317", + "6c9a5a39cb4841ba8a0b93283be0cac2", + "2deb046362ed4570a3f550f4f288529e", + "2cdddd0398e045a6a13124bf6fd85506", + "a1f5618e59d148409d6ccf4bfffca2fa", + "c870763add1745d9acfc2762f468c984", + "be70aecc5b294c4c93b0dcc09d6d1cb3", + "37b18b2ae9504b6c91066798a19a1319", + "b17eef10573f44689ce6add6231eaa19", + "3e8f08e000f248b59331d2430bbc8e3c", + "d8886d5af17f4468a26554831c9c05f1", + "b1cad4191755493893bbb46dcf27e03b", + "589120da6f464686bbeff0d44643d17d", + "ea89ea173ff3482c8a9c91dfb15946b2", + "b38693117df44071b7baaf123215ea60", + "9d716c9e43e04a6c9496620633ca28be", + "4de322f2413f44bcb03d41dcc8ff1963", + "3087335b98964b9eb4da474487ca4864", + "c010fad90578489cbfeb0764e3a11286", + "627f32f04b544b4db834b79645f36733", + "7d39222af2474a68b0db99f407ccf380", + "775687d3962242d6aff3feb0627754a9", + "92bb9917ab194a1eb1dc6fc5c4c4195d", + "43717a0ae4c043f9947d8fd844d71997", + "3f0008931054433c838a6633ca1347e6", + "da0dfe11648d4ae8a70852ce1fac87b0", + "29ad37e81b7f44a9aafa982b52f05a7a", + "bb468a6fe3f04692a211d5519aec455a", + "b1ad08dbe61b4064985ecdaa119870d8", + "d91093e80b814a018edaabe49f529ef5", + "1e3f013edc6341a0837af33ff4866d0b", + "1ed6f4595ec540729d776a81db96c403", + "cd7371ff8504454292559c18adb76645", + "d4994c6d7fa240d0ac6bb31f5c835192", + "ee1a9269b6c843e28cc49f3b5f17da96", + "a12a6638b2a54e88a020be42c139646e", + "2f2dc993705b447aa771cf0cc13c3b1d", + "69dffb139cab46b1b93bef960f702655", + "e7dc30a09a64401393e43618b51059de", + "75c397c506a04d0d9ca62e8d7f990813", + "eb7e509acfea4e1bb2f59b2fde11603d", + "b75a3d92aaa64a3098c6e1aabbc50856", + "3b056671c3fd41aeb4d6da821d562b95", + "9ac87f9e5b7847aaa90e3208ad405c23", + "cb21cadacb294854b304af8df2157299", + "30b3667258174beaa01322ffa055759b", + "48cb432d95dc49deae6077fb5c76bec3", + "763eec2b33234fd5ac192f25489b2844", + "f7fde1c95e3946659c6208fc52c254e9", + "6e1cdd75ae2246278c80f8e5d4e340b7", + "6af159109303490eab7192815fce0d6b", + "315575253cb9433d81f7d26770907f29", + "daf61ecd65bd41d9829e8a1872b82f33", + "54823295494d441fb9f26a70fb2c3973", + "df13aabfde0140d68db8b5a69759091c", + "cadbbc94bfd24daa933bb7d188dcdf92", + "f271a7dc607b4c05b02f6c5621203bd6", + "4e60ffab53dd4aba9e094098ed5297e6", + "a91dd2c07c51483eb326d010a82e2920", + "4188c097387a408dae680f67bd97752b", + "2a6cf3f2b4c349a9adc26351c2f0b222", + "8efe1cb67f30446a8fdaaf96782e843d", + "bdecbe50f693451b87bd331fd9e684ba", + "ff00f4c2c63a467098b119ae2259f529", + "d6754db1364144e69e3ab320aa1faeb9", + "9f1feddbe0d449a0b93fc5b1027e4319", + "1507ea5f89534b10856b99488ed5da65", + "f69205c589cf42829eea248f378a1436", + "85843fd6df264d25a4642cbeee260459", + "c2a415c28fe0418bb6032d4b91efbb07", + "b02796bf6e5547cf9418d109ad772537", + "de7a527901014a6b8abf6b714bd09535", + "143eaab6e65f4c8eb7a4314cadf323ba", + "e0603f00ceb2468692a36abd7bafaba8", + "8abf122ed835496aa09945ba8edd4688", + "663b9bd2f1af4df4b757624f53c2f2b8", + "c352adea84b043db8d43eb1c36d4bd4f", + "8fda102684834d21b4efbb472823ced9", + "ee7eccaca57b4460becfe0d5d5afb3f9", + "554a1ef44aea4ff484f0944878bb58a2", + "8ae15293ec5e4296a625087e7d965249", + "db067e50373840b19d6925deb950a20a", + "ab409caa3be24c18becaf9146b1ae69c", + "63236709413940f59d2622f2927c8d55", + "3e6d67d246e54fa497f4398e3aeddb00", + "118967bdd4a348858cc7572d36c1b736", + "8cc3c0558720400e9ed89170883f6370", + "59ee159eec154095a368efceb9d1e042", + "f78c80dd733d48a687d8a47bfc792ea4", + "9da9d7eb9a97495194a3ac4a2786e1de", + "3f1d345037604e01911ef344f3b51742", + "eeff19b29a6a4c6d9ae34e365c78c310", + "a098c442cc8149a5aa562c86fc64528e", + "badae7117ab644ffa80d099c17397329", + "13ccc23d506248d5b66ffe7732ead149", + "16938b11881741af8e6633094a4402dc", + "8d796692add94119a4e9fdc6530a6878", + "9202902fd37446cda1678c0d83e0c641", + "2cd168e5e3c4481ba151aa8a655e7ce8", + "f773b949a9cf46ca9fd56476398a3191", + "c6a00e1b00684bb7930fb27d6499932e", + "4395227decf642f7b8fbc6616f9ec826", + "205a7844670249bf83d468fe3af0e139", + "28a78fb894a4413e960c1e40d7df8173", + "46bd38ac919e4e66a72226c1f0da67d6", + "9557a05279544cd8a5f2ba4d3429f576", + "2e0e7f437b5d4e4086b38ee6da51dc4f", + "73a0ea365433404babb83a2d1caa9c66", + "855a155046904aaa9b91b01dd6a86088", + "d49e405525ec467bb7a69a9aaedf82d9", + "b8ccdebb7b11490e8222ff79ecfc9a33", + "9edc1d5792644f79bc04d853b13dac46", + "1b78ff7e32254777abe2c802b6879b9c", + "32168837680e41eaad4e5e4cdf09877d", + "319bf5c6332f41958974d9c3af87a382", + "c1e065fa36344f509e7863c3ec0428b8", + "5b9510c694a24afbb1c8318fea1a1bc5", + "f12d118a6b3f46b580fbe2018f4cf5e9", + "726e82f2b6c94e8eb5620c18872aabb6", + "12bb708857e84e5b893ca3e9ff176082", + "53acddb088564a73aef61618797bfe85", + "fb208f3792174ac2bdfb077450b2218f", + "0fa8ddd8da924c089221611c98e7da6e", + "b4a5fdee693d455686507306da804b17", + "045c5ac6981440c996ac7dda054fc112", + "f6a6f03ea7f140189a277742ff7082f8", + "ecff5b6dfb784c96b69d1a39b7acb171", + "43a32f261eaf42af978a6bf98502b1fc", + "8b7bb3fb502f4c3185709d6c40638d70", + "bf1d0b17974049c6ac5653ac18f1169c", + "32672cb3395045bcb9c2d370032356cc", + "4728eddf9fcc49d68d71a30379f08335", + "8676e2232dc242c39d4f19b0eea90dff", + "167e67c018e441d8baab4127b25773c6", + "88405a75b92743e589f424ee8c4d4d79", + "b5e3536d816c45488bb83336eaa5d53f", + "b9bed2c861df4c019ab4fff46b11a1a3", + "35bf380a7c6243859a459560288ffe49", + "b65af12dbf9143778412adb7b4c0bfdd", + "cb2433a0096845468b26c4bbde625ed8", + "8d4df1cf62d2427b8e850b031164ff97", + "0fd8ca256b8b49e1906a2a8e21156164", + "9801a82eda354815b6b3abbc8d1e0140", + "b10768b6bc654da8b822b4878889639b", + "c56ea889f51848e4aed83bcc46c83395", + "c75508086f6f4406a0aa9ce5a391e0ee", + "d92dbe59ace74f598efc7fbedb4c5ee6", + "675c937cf0ef4bf582f4bf90df6fa28e", + "e1cf760846bd4ba988c29665a6593220", + "768735ea9663429ba9f24efd86682f71", + "4d2a10e9307a47f4a1cbf512380c65bc", + "e8738d4181b04545a0418c1dd5b6b1b5", + "2aab7297963040f1900f0bc1f24e7b2a", + "8182a23b5be640cc8a48c09a4ed9585c", + "c3e198ae77684d61bf5fc30a35d8fc11", + "aaa71d52156549a4b8d7aad390497ac3", + "6387cbc474144e59aac5e3b42e714887", + "efc4f9ade28a4bb2a67c0ae4ceecbf28", + "7c105cfe1f344bf7896c7ddc0fcdc322", + "c1f71dcbe98f4ee9847af6b800979e06", + "e12dbfa20e9d40448366c9528c1a2c02", + "b3d7aad60442432e96c8c8bd3ead8427", + "0d40464e81fe4c06ac3400204116f243", + "69a0d832b77e47b8a2adcf47efe3f7ab", + "947f13ea22654b4ca6fca7ebed29d64e", + "45becb2c72714dfcb721b3a20a92d28f", + "4ddb5f1d8260448981c67308bcedecbf", + "d43db93804c24908bb6d75f26b640199", + "71d656fe70004c6db5d23d86bc6b108b", + "9f2ecadf1f3f4e399aad1882f2fe9b00", + "8826a0177e334508932a43563d2ae97d", + "f9ecbb00f95548d5b0c5cad345b1e38a", + "ac78d9726bc541df9907425442d3a51a", + "854937001e534695b08ee25f6e443962", + "06b21316e1ef41c9b7c9d943a9ff91ec", + "d38618d4c0e64b7baa61c0eca47427e5", + "86e235a532f347c781d6654c3ac25ba3", + "1727de01c47144b2958babfb91e887cb", + "5ac310c605f64948ad744bc1f196441d", + "32c1cc0d5327462d9175c74b91d67c4d", + "910d8a34abaa4f92a899dd4f5ab03d74", + "fbd92ad5a793482aac5570387e917188", + "ac81634b0e0946d690fb7d8ad7aed911", + "01097fb41b9c4cbf91300e049d9f3617", + "abeae554ecff4bb0ad8c38fa2829f706", + "a2d84cfc801f4657bade62d42be7046f", + "06a2114630234393bc0f07b3a64455f8", + "c6f31bcf48de4d9fbc7f2a2d9984b247", + "d5eace6b280e446ead2d1517801e4612", + "e29da03f6e474f1ca97ecfa6cd09658c", + "35bfe48a1b744262a8ea68bf5b5d495d", + "eed4b0b927824444aa8d875281cca1c4", + "e77316215dbe41daa8e89d8b2cc0f032", + "11c60d67f2204518b007ef47c801fbff", + "da21830428b54f76aa31b03efce202b9", + "a90285006dda4eb8a3e77964294a76ea", + "8164a08b9b3f49288963539305eadabe", + "591e6dc92b5c44418260cf659c5807cf", + "2bd3c665eb784f149dc21853103e8ff0", + "1ff4bcdb97294287ae8f3e9f2dc6bafa", + "bc265b1f822348469e3c8df0ea608abb", + "3635aa8a2cee484b945ddf7379ff4102", + "94ce06b3df27425eb8ae1a0aade4244d", + "e8ab0bcb4d7f4a298b2b3555d866a11f", + "5570fad8913d4bb495681b5e1dbe3950", + "47735f6c830149db965660d6b2f200d7", + "61d980530bf0408c8e2ed9a7997ba615", + "8a9f0a924d53496c8a8f228738ec140d", + "60ab33e3e0d84395a1269604f0fae91f", + "64d829532bb94214b805c2de4cf529cc", + "438c02b8134e45d5b2760b2e1f72f004", + "0f09296d37ee44b89871fa22cdd0127f", + "0fd475cb9e064d10a8ed031957cf2044", + "d1d2687d51a4442d8555ed4071837da4", + "0d80cc1f4fcc49d59e3a80862678fd86", + "9e556858d4a44b5bbc3e3af87d138a55", + "d86eb0ba47884ab081128a8761e9654b", + "620e2fa48504435a85d95c2d4b264b6e", + "af9af54477cc4972bf0f0a99c1344974", + "0b5d06cb83334b53a91c929f8e308543", + "8b9f3c47205d474b97efc6e9c6fb5f68", + "b63d8ddcad7745f3b4d7e683d23f393a", + "b83993ef787047cb9a31652fdd7f9ee7", + "f4ee33b4a2d145bab3c5c2e14c73a3f8", + "bebb055c0ac14d59a8b617399d60e602", + "888e04dcb56f4c43954d49d3e392ab25", + "6058ac7bc0b345ee8f5d2f631b7b6940", + "ec94298c63ab4b0e83c074a9d2ed4fc9", + "0d56de85d9244f38a8a0b3d84ee5d7da", + "b0053efc5ecc411f902fcf3b19cd362e", + "1d69552268b74bfb824c4f783e362949", + "de35e43c6aea490b917084a93c4571fb", + "8fdc7615fa0b412283eb3beb36b97872", + "d5542140ebd34dfaa8c66f2f3e48fe92", + "9eaafbfddcec4cdb998770d2cefc8fb7", + "a9e2ae7f987b4d9d9636c3963530d8ed", + "283159e7918540efa39d255f475dd984", + "2f5aa471e247475691da674db1d8514c", + "c67e91be78c74ba9b816e40dd5c181ae", + "d02de13e2d7843298e61b8f47d8dee33", + "76d9a70692e34521a609b337755d9901", + "8a1465ca8728490dba4fd79730ea6a30", + "3d563f4f9d28464788cab663cc814cf4", + "6fe391246afa49e08eec5793a97690db", + "47cc4883459449af8f9b35cd74b84002", + "69da0360a8ae4737b6e1af2e790f2b85", + "d7cc01fb605b4dd58cac287c36b6afea", + "638f9ac5607b42d3a467295cb8f7c50d", + "8e885a254c6f4311a3774d816e5ef5ac", + "580addd60f83499386b626c6440c6fca", + "6bb5cbb9ce7645c4ad45cdf056af0445", + "2e3ea9571d364a40aa9917a6f49b45f7", + "665f8e9a73b94639aa42743d16726a96", + "34a2309f1b78432ab51a87c964946da8", + "078db166712a4daba8e99ccdf44eb16f", + "dde4b35063b64a28a2fd5412eb9474f0", + "4d9c96f9caa54ac69dbee2755cfd804d", + "aa9d3e82fed541cca0fffe35b55aaabf", + "3221446fbbc24420a923884c67e0b87c", + "abf0151dabeb49eab089f921c8f364b5", + "488797401b9e419ab393ad5b2438039e", + "4394b231af2f4e1499a308c93b0ff951", + "4f1a59e4dff4470fb123ab315ded6e4f", + "5ead730bc1c34a28b5b046ae270d04e6", + "13b77ec58e65475b95d0041f90639e9a", + "deb2a67f32e64ebf87758c3ace7916e8", + "c594b48ac5b347f78c099d581dc4cd96", + "68fd129101844ab18b2b107778873d54", + "d7e07795e63c4ab78ca92961ba089b07", + "d3450ca5684b4a5680c114d29a7ce8f5", + "61ed075433b94feda586eec035251768", + "c46be587d0fe4ef0b364f822f5ff903d", + "c7f7e4ee797749c0939c9a3926937b41", + "2a4d28248796477994a17db0fb8485dc", + "0dbdea008e964ad887f112336be78449", + "47977de9d961442682805f37f7217387", + "241f6ce34fd242ca9a46f8232a9fb838", + "846eac2286dd4d6991f80b6ae03ce804", + "72858c26d6154ef3b8f90ffb0339781e", + "4085f5c89ca94a31b346452cd8009dad", + "47c175c19d6b4268a2ade2966327de78", + "f3dc7118a9fa4b188cc3a9aaf366b125", + "9f07e155db5a473abdd7b7ae0617e770", + "05feab0298c54df4a2372152d4f3a891", + "abeb4c3be90344469c004e29465e1580", + "540e6158656d412591a5442eb89d1e65", + "51a0e1eb84eb4dd6a95f30268541ccbc", + "fe7d093f30854ee1b66f080c5b8fb68b", + "880e13da115f4e2e9d413b75b0eecdcb" + ] + }, + "execution": { + "shell.execute_reply.end": "2023-12-22T03:35:36.853391Z", + "shell.execute_reply.started": "2023-12-22T03:35:33.398019Z", + "to_execute": "2023-12-22T03:35:33.384Z" + }, + "id": "d0b36e7eff50657c", + "libroFormatter": "formatter-string", + "outputId": "4198784f-15c6-4812-f96a-c3f62914dbbb", + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "boolq example: \n", + "{'input': 'Persian language -- Persian (/ˈpɜːrʒən, -ʃən/), also known by its endonym Farsi (فارسی fārsi (fɒːɾˈsiː) ( listen)), is one of the Western Iranian languages within the Indo-Iranian branch of the Indo-European language family. It is primarily spoken in Iran, Afghanistan (officially known as Dari since 1958), and Tajikistan (officially known as Tajiki since the Soviet era), and some other regions which historically were Persianate societies and considered part of Greater Iran. It is written in the Persian alphabet, a modified variant of the Arabic script, which itself evolved from the Aramaic alphabet.\\nQuestion: do iran and afghanistan speak the same language\\nA. Yes\\nB. No\\nAnswer:', 'output': 'A', 'task_name': 'boolq'}\n", + "multirc example: \n", + "{'input': 'While this process moved along, diplomacy continued its rounds. Direct pressure on the Taliban had proved unsuccessful. As one NSC staff note put it, \"Under the Taliban, Afghanistan is not so much a state sponsor of terrorism as it is a state sponsored by terrorists.\" In early 2000, the United States began a high-level effort to persuade Pakistan to use its influence over the Taliban. In January 2000, Assistant Secretary of State Karl Inderfurth and the State Department\\'s counterterrorism coordinator, Michael Sheehan, met with General Musharraf in Islamabad, dangling before him the possibility of a presidential visit in March as a reward for Pakistani cooperation. Such a visit was coveted by Musharraf, partly as a sign of his government\\'s legitimacy. He told the two envoys that he would meet with Mullah Omar and press him on Bin Laden. They left, however, reporting to Washington that Pakistan was unlikely in fact to do anything,\" given what it sees as the benefits of Taliban control of Afghanistan.\" President Clinton was scheduled to travel to India. The State Department felt that he should not visit India without also visiting Pakistan. The Secret Service and the CIA, however, warned in the strongest terms that visiting Pakistan would risk the President\\'s life. Counterterrorism officials also argued that Pakistan had not done enough to merit a presidential visit. But President Clinton insisted on including Pakistan in the itinerary for his trip to South Asia. His one-day stopover on March 25, 2000, was the first time a U.S. president had been there since 1969. At his meeting with Musharraf and others, President Clinton concentrated on tensions between Pakistan and India and the dangers of nuclear proliferation, but also discussed Bin Laden. President Clinton told us that when he pulled Musharraf aside for a brief, one-on-one meeting, he pleaded with the general for help regarding Bin Laden.\" I offered him the moon when I went to see him, in terms of better relations with the United States, if he\\'d help us get Bin Laden and deal with another issue or two.\" The U.S. effort continued. \\nQuestion: What did the high-level effort to persuade Pakistan include?\\nAnswer: Children, Gerd, or Dorian Popa\\nIs it true?\\nA. Yes\\nB. No\\nAnswer:', 'output': 'B', 'task_name': 'multirc'}\n", + "rte example: \n", + "{'input': 'No Weapons of Mass Destruction Found in Iraq Yet.\\nWeapons of Mass Destruction Found in Iraq.\\nIs the sentence below entailed by the sentence above?\\nA. Yes\\nB. No\\nAnswer:', 'output': 'B', 'task_name': 'rte'}\n", + "wic example: \n", + "{'input': \"Sentence 1: Do you want to come over to my place later?\\nSentence 2: A political system with no place for the less prominent groups.\\nAre 'place' in the above two sentences the same?\\nA. Yes\\nB. No\\nAnswer:\", 'output': 'B', 'task_name': 'wic'}\n" + ] + } + ], + "source": [ + "# boolq\n", + "boolq_dataset = (\n", + " load_dataset(\"super_glue\", \"boolq\")\n", + " .map(\n", + " lambda x: {\n", + " \"input\": f\"{x['passage']}\\nQuestion: {x['question']}\\nA. Yes\\nB. No\\nAnswer:\",\n", + " # 0 - False\n", + " # 1 - True\n", + " \"output\": [\"B\", \"A\"][int(x[\"label\"])],\n", + " \"task_name\": \"boolq\",\n", + " }\n", + " )\n", + " .select_columns([\"input\", \"output\", \"task_name\"])\n", + ")\n", + "print(\"boolq example: \")\n", + "print(boolq_dataset[\"train\"][0])\n", + "\n", + "# multirc\n", + "multirc_dataset = (\n", + " load_dataset(\"super_glue\", \"multirc\")\n", + " .map(\n", + " lambda x: {\n", + " \"input\": (\n", + " f\"{x['paragraph']}\\nQuestion: {x['question']}\\nAnswer: {x['answer']}\\nIs it\"\n", + " \" true?\\nA. Yes\\nB. No\\nAnswer:\"\n", + " ),\n", + " # 0 - False\n", + " # 1 - True\n", + " \"output\": [\"B\", \"A\"][int(x[\"label\"])],\n", + " \"task_name\": \"multirc\",\n", + " }\n", + " )\n", + " .select_columns([\"input\", \"output\", \"task_name\"])\n", + ")\n", + "print(\"multirc example: \")\n", + "print(multirc_dataset[\"train\"][0])\n", + "\n", + "# rte\n", + "rte_dataset = (\n", + " load_dataset(\"super_glue\", \"rte\")\n", + " .map(\n", + " lambda x: {\n", + " \"input\": (\n", + " f\"{x['premise']}\\n{x['hypothesis']}\\nIs the sentence below entailed by the\"\n", + " \" sentence above?\\nA. Yes\\nB. No\\nAnswer:\"\n", + " ),\n", + " # 0 - entailment\n", + " # 1 - not_entailment\n", + " \"output\": [\"A\", \"B\"][int(x[\"label\"])],\n", + " \"task_name\": \"rte\",\n", + " }\n", + " )\n", + " .select_columns([\"input\", \"output\", \"task_name\"])\n", + ")\n", + "print(\"rte example: \")\n", + "print(rte_dataset[\"train\"][0])\n", + "\n", + "# wic\n", + "wic_dataset = (\n", + " load_dataset(\"super_glue\", \"wic\")\n", + " .map(\n", + " lambda x: {\n", + " \"input\": (\n", + " f\"Sentence 1: {x['sentence1']}\\nSentence 2: {x['sentence2']}\\nAre '{x['word']}'\"\n", + " \" in the above two sentences the same?\\nA. Yes\\nB. No\\nAnswer:\"\n", + " ),\n", + " # 0 - False\n", + " # 1 - True\n", + " \"output\": [\"B\", \"A\"][int(x[\"label\"])],\n", + " \"task_name\": \"wic\",\n", + " }\n", + " )\n", + " .select_columns([\"input\", \"output\", \"task_name\"])\n", + ")\n", + "print(\"wic example: \")\n", + "print(wic_dataset[\"train\"][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9fca2225-aaee-47aa-957a-5f8ed3177cdb", + "metadata": { + "execution": { + "shell.execute_reply.end": "2023-12-22T03:35:36.858952Z", + "shell.execute_reply.started": "2023-12-22T03:35:36.855329Z", + "to_execute": "2023-12-22T03:35:36.819Z" + }, + "id": "9fca2225-aaee-47aa-957a-5f8ed3177cdb", + "libroFormatter": "formatter-string" + }, + "outputs": [], + "source": [ + "# define a task2id map\n", + "TASK2ID = {\n", + " \"boolq\": 0,\n", + " \"multirc\": 1,\n", + " \"rte\": 2,\n", + " \"wic\": 3,\n", + "}\n", + "\n", + "\n", + "def tokenize(examples):\n", + " inputs, targets = examples[\"input\"], examples[\"output\"]\n", + " features = tokenizer(inputs, max_length=512, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n", + " labels = tokenizer(targets, max_length=2, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n", + " labels = labels[\"input_ids\"]\n", + " labels[labels == tokenizer.pad_token_id] = -100\n", + " features[\"labels\"] = labels\n", + " features[\"task_ids\"] = torch.tensor([[TASK2ID[t]] for t in examples[\"task_name\"]]).long()\n", + " return features" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0bf6c31c-73cd-4eed-931b-0cad5d7290fb", + "metadata": { + "execution": { + "shell.execute_reply.end": "2023-12-22T03:35:36.929414Z", + "shell.execute_reply.started": "2023-12-22T03:35:36.860477Z", + "to_execute": "2023-12-22T03:35:36.849Z" + }, + "id": "0bf6c31c-73cd-4eed-931b-0cad5d7290fb", + "libroFormatter": "formatter-string", + "tags": [] + }, + "outputs": [], + "source": [ + "def get_superglue_dataset(\n", + " split=\"train\",\n", + " n_samples=500,\n", + "):\n", + " ds = concatenate_datasets(\n", + " [\n", + " boolq_dataset[split].shuffle().select(range(n_samples)),\n", + " multirc_dataset[split].shuffle().select(range(n_samples)),\n", + " rte_dataset[split].shuffle().select(range(n_samples)),\n", + " wic_dataset[split].shuffle().select(range(n_samples)),\n", + " ]\n", + " )\n", + " ds = ds.map(\n", + " tokenize,\n", + " batched=True,\n", + " remove_columns=[\"input\", \"output\", \"task_name\"],\n", + " load_from_cache_file=False,\n", + " )\n", + " return ds" + ] + }, + { + "cell_type": "markdown", + "id": "oNvh2WGlLo4z", + "metadata": { + "id": "oNvh2WGlLo4z", + "libroFormatter": "formatter-string" + }, + "source": [ + "As a toy example, we only select 1,000 from each subdataset for training and 100 each for eval." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1bf88dd1a6aaa6a5", + "metadata": { + "collapsed": false, + "execution": { + "shell.execute_reply.end": "2023-12-22T03:35:44.953151Z", + "shell.execute_reply.started": "2023-12-22T03:35:37.023791Z", + "to_execute": "2023-12-22T03:35:37.009Z" + }, + "libroFormatter": "formatter-string" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Map: 0%| | 0/4000 [00:00\\n### ASSISTANT: '. " + "If None, must already have a 'text' column." + ) + }, + ) + + +def _dtype_from_bits(bits: str) -> torch.dtype: + bits = bits.lower() + if bits == "bf16": + return torch.bfloat16 + if bits == "fp16": + return torch.float16 + if bits == "fp32": + return torch.float32 + raise ValueError(f"Unknown bits={bits}. Use one of: bf16, fp16, fp32.") + + +def main(): + parser = HfArgumentParser(ScriptArguments) + script_args = parser.parse_args_into_dataclasses()[0] + print(script_args) + + if script_args.base_model_name_or_path is None: + raise ValueError("--base_model_name_or_path is required.") + + # PSOFT does NOT support quantized layers (nf4/int8/etc.). + # We only allow fp16/bf16/fp32 here to avoid accidental quantized loading. + if script_args.bits.lower() not in {"bf16", "fp16", "fp32"}: + raise ValueError("PSOFT example only supports bits in ['bf16','fp16','fp32'] (no quantization).") + + torch_dtype = _dtype_from_bits(script_args.bits) + + # Load base model + model = AutoModelForCausalLM.from_pretrained( + script_args.base_model_name_or_path, + dtype=torch_dtype, + device_map="auto", + ) + tokenizer = AutoTokenizer.from_pretrained(script_args.base_model_name_or_path) + if tokenizer.pad_token_id is None: + tokenizer.pad_token_id = tokenizer.eos_token_id + + # Build PSOFT config + psoft_kwargs = { + "r": script_args.r, + "psoft_alpha": script_args.psoft_alpha, + "target_modules": script_args.target_modules, + "ab_svd_init": script_args.ab_svd_init, + "psoft_svd": script_args.psoft_svd, + "psoft_orth": script_args.psoft_orth, + "psoft_mag_a": script_args.psoft_mag_a, + "psoft_mag_b": script_args.psoft_mag_b, + "use_cayley_neumann": script_args.use_cayley_neumann, + "num_cayley_neumann_terms": script_args.num_cayley_neumann_terms, + "cayley_neumann_eps": script_args.cayley_neumann_eps, + "task_type": "CAUSAL_LM", + } + # Only pass lowrank_niter when user sets it (and typically when psoft_svd='lowrank') + if script_args.psoft_svd_lowrank_niter is not None: + psoft_kwargs["psoft_svd_lowrank_niter"] = script_args.psoft_svd_lowrank_niter + + peft_config = PsoftConfig(**psoft_kwargs) + model = get_peft_model(model, peft_config) + + model.print_trainable_parameters() + + # Load dataset + dataset = load_dataset(script_args.data_path, split=script_args.dataset_split) + + # Ensure a "text" field for SFTTrainer + if script_args.dataset_field is not None: + if len(script_args.dataset_field) != 2: + raise ValueError("dataset_field must be a list of exactly 2 field names: [input_field, output_field].") + + in_f, out_f = script_args.dataset_field[0], script_args.dataset_field[1] + + def to_sft_text(example): + return {"text": f"### USER: {example[in_f]}\n### ASSISTANT: {example[out_f]}"} + + dataset = dataset.map(to_sft_text) + else: + if "text" not in dataset.column_names: + raise ValueError("dataset_field is None but dataset has no 'text' column. Provide dataset_field.") + + # Train + trainer = SFTTrainer( + model=model, + args=script_args, + train_dataset=dataset, + processing_class=tokenizer, + ) + trainer.train() + trainer.save_state() + + # Save adapter (PSOFT) + os.makedirs(script_args.output_dir, exist_ok=True) + model.save_pretrained(os.path.join(script_args.output_dir, "psoft_ft")) + tokenizer.save_pretrained(os.path.join(script_args.output_dir, "psoft_ft")) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/pvera/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/pvera/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3d5f7ed80f92152b879383640d207248db3411a8 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/pvera/README.md @@ -0,0 +1,3 @@ +# Generating confidence intervals with PVeRA + +In normal mode, PVeRA samples from the learned distribution during training, and does a deterministic sample during inference at the learned latent distribution mean. Setting `sample_at_inference=True` enables to generate Monte Carlo confidence interval estimations by running multiple passes through each sample. The accompanying `examples/pvera/confidence_interval_generation.py` script shows an example of training a model on a simple dataset, saving the adapters, loading them with ```sample_at_inference=True```, and running a Monte Carlo confidence interval estimation on a sample. \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/pvera/confidence_interval_generation.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/pvera/confidence_interval_generation.py new file mode 100644 index 0000000000000000000000000000000000000000..4e79fdaf5b37ee9be54acff8ca79a396ea28298e --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/pvera/confidence_interval_generation.py @@ -0,0 +1,75 @@ +import tempfile + +import numpy as np +import scipy +import torch +from datasets import load_dataset +from torch.nn import LazyLinear, Sequential, Softmax +from torchvision.transforms import Compose, Normalize, Resize +from tqdm import tqdm +from transformers import AutoModel + +from peft import PeftModel, PveraConfig, get_peft_model + + +# load the dataset +device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" +dataset = load_dataset("beans", split="train").with_format("torch") +transform = Compose((Resize((224, 224)), Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)))) +num_classes = dataset.features["labels"].num_classes + +# load the model with adapters and create the linear probe +base_model = AutoModel.from_pretrained("facebook/dinov2-base") +config = PveraConfig(r=128, sample_at_inference=False) +model = get_peft_model(base_model, config).to(device) +linear_probe = Sequential(LazyLinear(num_classes), Softmax(-1)).to(device) + +# train the model +criterion = torch.nn.CrossEntropyLoss() +optimizer = torch.optim.Adam(list(model.parameters()) + list(linear_probe.parameters()), lr=1e-4) +dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True) +for batch in tqdm(dataloader): + imgs, lbls = transform(batch["image"].float()), batch["labels"] + pred = linear_probe(model(imgs.to(device)).pooler_output) + loss = criterion(pred, lbls.to(device)) + loss.backward() + optimizer.step() + +# save the model and load it with sample_at_inference=True +model.eval() +linear_probe.eval() +with tempfile.TemporaryDirectory() as tmpdir: + # save the model and the linear probe + model.save_pretrained(tmpdir) + torch.save(linear_probe.state_dict(), tmpdir + "/linear_probe.bin") + + # load the model with sample_at_inference=True + base_model = AutoModel.from_pretrained("facebook/dinov2-base") + config = PveraConfig.from_pretrained(tmpdir) + config.sample_at_inference = True + loaded_model = PeftModel.from_pretrained(base_model, tmpdir, config=config).to(device) + loaded_model.eval() + + # load the linear probe + loaded_linear_probe = Sequential(LazyLinear(num_classes), Softmax(-1)).to(device) + loaded_linear_probe.load_state_dict(torch.load(tmpdir + "/linear_probe.bin")) + loaded_linear_probe.eval() + +# make multiple predictions on an image +img = dataset[0]["image"].unsqueeze(0).to(device) +with torch.no_grad(): + all_preds = [loaded_linear_probe(loaded_model(img).pooler_output) for _ in range(16)] +all_preds = torch.vstack(all_preds) +top_pred = all_preds.argmax(-1).mode(0).values +softmax_top_pred = all_preds[:, top_pred] + + +def mean_confidence_interval(data, confidence=0.95): + a = 1.0 * np.array(data) + n = len(a) + m, se = np.mean(a), scipy.stats.sem(a) + h = se * scipy.stats.t.ppf((1 + confidence) / 2.0, n - 1) + return max(0, m - h), min(1, m + h) + + +print(mean_confidence_interval(softmax_top_pred.cpu())) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/qalora_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/qalora_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a1dfea11c077fda716b5c6434780fd7d191e7171 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/qalora_finetuning/README.md @@ -0,0 +1,157 @@ +# QALoRA: Quantization-Aware Low-Rank Adaptation + +## Introduction +[QALoRA](https://huggingface.co/papers/2309.14717) is a quantization-aware version of Low-Rank Adaptation that enables efficient fine-tuning of quantized large language models. +QALoRA uses input feature pooling and a specialized grouping technique to work with quantized weights, significantly reducing memory requirements while preserving performance. +QALoRA enables fine-tuning of models that would otherwise be too large for consumer GPUs. In PEFT it only works for GPTQ. + +## Quick start +```python +import torch +from peft import LoraConfig, get_peft_model +from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer +from datasets import load_dataset + +# Load a quantized model (example with GPTQ quantization) +model = AutoModelForCausalLM.from_pretrained( + "TheBloke/Llama-2-7b-GPTQ", + revision="gptq-4bit-32g-actorder_True", + device_map="auto" +) +tokenizer = AutoTokenizer.from_pretrained("TheBloke/Llama-2-7b-GPTQ") +dataset = load_dataset("timdettmers/openassistant-guanaco", split="train") + +# Configure QALoRA parameters +lora_config = LoraConfig( + use_qalora=True, + qalora_group_size=8, + r=16, + lora_alpha=32, + target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"], + lora_dropout=0.05, +) + +# Create the PEFT model +peft_model = get_peft_model(model, lora_config) + +# Set up trainer and train +trainer = Trainer( + model=peft_model, + train_dataset=dataset, + args=TrainingArguments( + per_device_train_batch_size=1, + gradient_accumulation_steps=4, + num_train_epochs=3, + learning_rate=3e-4, + output_dir="qalora-llama-2-7b" + ), + data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False), +) +trainer.train() +peft_model.save_pretrained("qalora-llama-2-7b") +``` + +To use QALoRA, simply set `use_qalora = True` and specify a `qalora_group_size` in your LoRA configuration. The group size controls the memory/performance tradeoff - smaller values use less memory but may affect performance. + +## Command Line Examples + +Run the finetuning script with a GPTQ quantized model: + +You can customize the pooling group size (default is 16): +```bash +python examples/qalora_finetuning/qalora_gptq_finetuning.py \ + --base_model TheBloke/Llama-2-7b-GPTQ \ + --use_qalora \ + --qalora_group_size 32 +``` + +### Full example of the script +```bash +python qalora_gptq_finetuning.py \ + --base_model "TheBloke/Llama-2-13b-GPTQ" \ + --output_dir "PATH_TO_OUTPUT_DIR" \ + --batch_size 1 \ + --num_epochs 3 \ + --learning_rate 3e-4 \ + --cutoff_len 512 \ + --use_qalora \ + --qalora_group_size 32 \ + --eval_step 10 \ + --save_step 100 \ + --device "auto" \ + --lora_r 16 \ + --lora_alpha 32 \ + --lora_dropout 0.05 \ + --lora_target_modules "q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj" \ + --push_to_hub +``` + +## Use the model on 🤗 +You can load and use the finetuned model like any other PEFT model: +```python +from peft import PeftModel, PeftConfig +from transformers import AutoModelForCausalLM, AutoTokenizer + +# Load the base quantized model +base_model = AutoModelForCausalLM.from_pretrained( + "TheBloke/Llama-2-7b-GPTQ", + device_map="auto" +) +tokenizer = AutoTokenizer.from_pretrained("TheBloke/Llama-2-7b-GPTQ") + +# Load the PEFT adapter +peft_model_id = "YOUR_HF_REPO" +model = PeftModel.from_pretrained(base_model, peft_model_id) + +# Generate text +input_text = "Hello, I'm a language model" +inputs = tokenizer(input_text, return_tensors="pt").to(model.device) +outputs = model.generate(**inputs, max_length=100) +print(tokenizer.decode(outputs[0], skip_special_tokens=True)) +``` + +## QALoRA vs. LoRA + +QALoRA offers several advantages over standard LoRA: + +1. **Memory efficiency**: QALoRA works directly with quantized models, reducing memory usage by up to 60-70% compared to standard LoRA. + +2. **Hardware accessibility**: Enables fine-tuning of larger models (13B, 70B) on consumer GPUs that would be impossible with standard LoRA. + +3. **Performance preservation**: Despite quantization, QALoRA can achieve comparable performance to full-precision LoRA in many tasks. + + +## Implementation Details: Merging with Quantized Models + +> **Note:** The current implementation differs from the original QA-LoRA paper's approach. + +While the QA-LoRA paper describes a direct weight modification technique using "beta shift" to modify quantized weights without full dequantization, this implementation uses a different approach: + +1. The quantized model is first dequantized to full precision +2. The QALoRA adapter weights are then merged with the dequantized model +3. The merged model must be re-quantized if quantization is still desired + + +### Memory Considerations + +This process requires significant memory (enough to hold the full dequantized model) and additional computation for the re-quantization step. For large models, this may not be possible on consumer hardware. + +For most use cases, we recommend keeping the base quantized model and the QALoRA adapter separate, loading them with `PeftModel.from_pretrained()` as shown in the usage example above. This approach maintains the memory efficiency benefits of quantization throughout the deployment pipeline. + + +## Citation +``` +@article{dettmers2023qlora, + title={QLoRA: Efficient Finetuning of Quantized LLMs}, + author={Dettmers, Tim and Pagnoni, Artidoro and Holtzman, Ari and Zettlemoyer, Luke}, + journal={arXiv preprint arXiv:2305.14314}, + year={2023} +} + +@article{xu2023qalora, + title={QA-LoRA: Quantization-Aware Low-Rank Adaptation of Large Language Models}, + author={Xu, Yuhui and Liu, Lingxi and Rao, Longhui and Zhao, Teng and Xiong, Zhiwei and Gao, Mingkui}, + journal={arXiv preprint arXiv:2309.14717}, + year={2023} +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/qalora_finetuning/qalora_gptq_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/qalora_finetuning/qalora_gptq_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..1520c3743c01a7500b90fb24db653a36b4c28fa1 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/qalora_finetuning/qalora_gptq_finetuning.py @@ -0,0 +1,356 @@ +""" +Training script for fine-tuning language models with QALoRA using GPTQ quantization. +This script supports cached quantization to avoid repeating expensive quantization processes. +""" + +import argparse +import os + +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + DataCollatorForLanguageModeling, + GPTQConfig, + Trainer, + TrainingArguments, +) + +from peft import LoraConfig, get_peft_model + + +def load_or_quantize_model( + base_model: str, tokenizer, bits: int = 4, cache_dir: str = "./quantized_models" +) -> AutoModelForCausalLM: + """ + Load a pre-quantized model from cache or quantize and cache a new one. + Automatically detects if the model is already GPTQ-quantized. + + Args: + base_model: Model identifier or path + tokenizer: Tokenizer for the model + bits: Bit-width for quantization (default: 4) + cache_dir: Directory to store quantized models + + Returns: + The loaded (quantized) model + """ + # First, check if the model is already GPTQ-quantized by trying to load it + print(f"Checking if {base_model} is already GPTQ-quantized...") + try: + # Try to load the model and check if it has GPTQ quantization + test_model = AutoModelForCausalLM.from_pretrained( + base_model, + device_map="auto", + dtype=torch.float16, + trust_remote_code=True, # Some GPTQ models might need this + ) + + # Check if the model has GPTQ quantization attributes + has_gptq = False + for module in test_model.modules(): + if hasattr(module, "qweight") or hasattr(module, "qzeros") or "gptq" in str(type(module)).lower(): + has_gptq = True + break + + if has_gptq: + print(f"✅ Model {base_model} is already GPTQ-quantized. Using directly.") + return test_model + else: + print(f"Model {base_model} is not GPTQ-quantized. Will quantize it.") + # Clean up the test model to free memory + del test_model + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + except Exception as e: + print(f"Could not load model {base_model} directly: {e}") + print("Will attempt to quantize it...") + + # If we get here, the model needs to be quantized + os.makedirs(cache_dir, exist_ok=True) + model_id = base_model.replace("/", "_").replace("\\", "_") # Handle Windows paths too + quantized_model_path = os.path.join(cache_dir, f"{model_id}_gptq_{bits}bit") + + # Check if we already have a cached quantized version + if os.path.exists(quantized_model_path) and os.path.exists(os.path.join(quantized_model_path, "config.json")): + print(f"Loading pre-quantized model from cache: {quantized_model_path}") + return AutoModelForCausalLM.from_pretrained(quantized_model_path, device_map="auto") + + print(f"Quantizing model and saving to cache: {quantized_model_path}") + + # Configure GPTQ for first-time quantization + gptq_config = GPTQConfig( + bits=bits, + dataset="c4", + tokenizer=tokenizer, + group_size=128, + desc_act=False, + sym=False, + ) + + # Load and quantize the model + model = AutoModelForCausalLM.from_pretrained( + base_model, device_map="auto", quantization_config=gptq_config, dtype=torch.float16 + ) + + # Save the quantized model to cache + print(f"Saving quantized model to {quantized_model_path}") + model.save_pretrained(quantized_model_path) + tokenizer.save_pretrained(quantized_model_path) + + return model + + +def tokenize_and_preprocess(examples, tokenizer, max_length: int = 128): + """ + Tokenize text data and prepare it for language modeling. + + Args: + examples: Dataset examples with 'text' field + tokenizer: Tokenizer to use + max_length: Maximum sequence length + + Returns: + Processed examples with input_ids and labels + """ + # Tokenize the text with truncation and padding + tokenized_output = tokenizer(examples["text"], truncation=True, padding="max_length", max_length=max_length) + + # Preprocess labels (set pad tokens to -100 for loss masking) + labels = tokenized_output["input_ids"].copy() + labels = [[-100 if token == tokenizer.pad_token_id else token for token in seq] for seq in labels] + tokenized_output["labels"] = labels + + return tokenized_output + + +def train_model( + base_model: str, + data_path: str, + data_split: str, + output_dir: str, + batch_size: int, + num_epochs: int, + learning_rate: float, + cutoff_len: int, + use_qalora: bool, + eval_step: int, + save_step: int, + device: str, + lora_r: int, + lora_alpha: int, + lora_dropout: float, + lora_target_modules: str, + push_to_hub: bool, + qalora_group_size: int, + bits: int, +) -> None: + """ + Train a model with QALoRA and GPTQ quantization. + + Args: + base_model: Base model to fine-tune + data_path: Dataset path + output_dir: Directory to save model outputs + batch_size: Training batch size + num_epochs: Number of training epochs + learning_rate: Learning rate + cutoff_len: Maximum sequence length + val_set_size: Validation set size + use_dora: Whether to use DoRA + use_qalora: Whether to use QALoRA + quantize: Whether to use quantization + eval_step: Steps between evaluations + save_step: Steps between saving checkpoints + device: Device to use (cuda:0, xpu:0, etc.) + lora_r: LoRA rank + lora_alpha: LoRA alpha + lora_dropout: LoRA dropout rate + lora_target_modules: Target modules for LoRA + push_to_hub: Whether to push to Hugging Face Hub + """ + os.environ["TOKENIZERS_PARALLELISM"] = "false" + hf_token = os.getenv("HF_TOKEN") + device = torch.device(device) + print(f"Using device: {device}") + + # Load tokenizer + tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token) + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + # Load or quantize model + model = load_or_quantize_model(base_model, tokenizer, bits=bits) + + # Configure LoRA + target_modules = ( + lora_target_modules.split(",") + if lora_target_modules + else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] + ) + + print("use_qalora", use_qalora) + lora_config = LoraConfig( + task_type="CAUSAL_LM", + use_qalora=use_qalora, + qalora_group_size=qalora_group_size, + r=lora_r, + lora_alpha=lora_alpha, + target_modules=target_modules, + lora_dropout=lora_dropout, + bias="none", + ) + + # Get PEFT model with adapters + model = get_peft_model(model, lora_config) + + model.print_trainable_parameters() + + # Move model to device if not already there + if not hasattr(model, "device") or model.device.type != device.type: + model = model.to(device) + + # Load and prepare dataset + dataset = load_dataset(data_path, data_split) + + tokenized_datasets = { + "train": dataset["train"].map( + lambda x: tokenize_and_preprocess(x, tokenizer, max_length=cutoff_len), + batched=True, + remove_columns=["text"], + load_from_cache_file=True, + ), + "test": dataset["test"].map( + lambda x: tokenize_and_preprocess(x, tokenizer, max_length=cutoff_len), + batched=True, + remove_columns=["text"], + load_from_cache_file=True, + ), + } + + # Data collator for language modeling + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + + # Configure training arguments + training_args = TrainingArguments( + output_dir=output_dir, + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + per_device_eval_batch_size=batch_size, + warmup_steps=100, + weight_decay=0.01, + logging_dir="./logs", + logging_steps=eval_step, + save_steps=save_step, + save_total_limit=2, + push_to_hub=push_to_hub, + gradient_accumulation_steps=16, + fp16=True, + learning_rate=learning_rate, + hub_token=hf_token, + label_names=["labels"], + ) + + # Clear accelerator cache to free memory + if torch.cuda.is_available(): + torch.cuda.empty_cache() + elif torch.xpu.is_available(): + torch.xpu.empty_cache() + + # Initialize trainer + trainer = Trainer( + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["test"], + data_collator=data_collator, + ) + + # Start training + print("\nStarting training...") + trainer.train() + + # Save the final model + if push_to_hub: + trainer.push_to_hub(commit_message="Fine-tuned model with QALoRA") + + # Always save locally + model.save_pretrained(output_dir) + tokenizer.save_pretrained(output_dir) + print(f"\nTraining complete. Model saved to {output_dir}") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Fine-tune LLMs with QALoRA and GPTQ quantization") + + # Model and dataset parameters + parser.add_argument("--base_model", type=str, default="TheBloke/Llama-2-7b-GPTQ", help="Base model path or name") + parser.add_argument( + "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name" + ) + parser.add_argument("--data_split", type=str, default="", help="Dataset path or name") + + parser.add_argument( + "--output_dir", type=str, default="./qalora_output", help="Output directory for the fine-tuned model" + ) + parser.add_argument("--bits", type=int, default=4, help="Init quantization bits") + + # Training parameters + parser.add_argument("--batch_size", type=int, default=4, help="Batch size") + parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs") + parser.add_argument("--learning_rate", type=float, default=3e-4, help="Learning rate") + parser.add_argument("--cutoff_len", type=int, default=128, help="Max sequence length") + + # Adapter configuration + parser.add_argument("--use_qalora", action="store_true", help="Apply QALoRA") + parser.add_argument("--qalora_group_size", type=int, default=32, help="LoRA rank") + parser.add_argument("--lora_r", type=int, default=8, help="LoRA rank") + parser.add_argument("--lora_alpha", type=int, default=16, help="LoRA alpha") + parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout rate") + parser.add_argument( + "--lora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA" + ) + + # Training process options + parser.add_argument("--eval_step", type=int, default=100, help="Evaluation step interval") + parser.add_argument("--save_step", type=int, default=500, help="Save step interval") + parser.add_argument("--device", type=str, default="auto", help="Device to use for training") + + # Hugging Face Hub options + parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub") + + args = parser.parse_args() + + device = args.device + if args.device == "auto": + device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + + # If use_qalora isn't explicitly set in args but passed to train_model + if not args.use_qalora: + args.use_qalora = True # Default to True as in the original code + + train_model( + base_model=args.base_model, + data_path=args.data_path, + data_split=args.data_split, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + use_qalora=args.use_qalora, + eval_step=args.eval_step, + save_step=args.save_step, + device=device, + lora_r=args.lora_r, + lora_alpha=args.lora_alpha, + lora_dropout=args.lora_dropout, + lora_target_modules=args.lora_target_modules, + push_to_hub=args.push_to_hub, + qalora_group_size=args.qalora_group_size, + bits=args.bits, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/randlora_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/randlora_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e64ca42c5a3c2f65c74e0879afffc908419083e9 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/randlora_finetuning/README.md @@ -0,0 +1,112 @@ +# RandLora: Full-rank parameter-efficient fine-tuning of large models + +## Introduction +[RandLora](https://huggingface.co/papers/2502.00987) is a parameter-efficient fine-tuning technique that is similar to LoRA and VeRA but performs full rank updates to improve performance. RandLora can be particularly useful when adapting large model to hard tasks that require complex updates while preserving the parameter efficiency of LoRA. The full rank update of RandLora is achieved by linearly scaling random bases. The random bases are a collection of multiple low rank matrices such that the summation of their ranks if greater or equal to the full rank of the parameter matrices. The trainable parameters of RandLora are two diagonal matrices (vectors) that get multiplied with the right hand low rank random bases, in a similar way to VeRA's update. To maintain low memory usage, RandLora uses a custom function that prevents storing unnecessary bases in memory for backpropagation. + +## Quick start +```python +import torch +from peft import RandLoraConfig, get_peft_model +from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer +from datasets import load_dataset + +model = AutoModelForCausalLM.from_pretrained("huggyllama/llama-7b", device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-7b") +dataset = load_dataset("timdettmers/openassistant-guanaco", split="train") +randlora_config = RandLoraConfig() + +peft_model = get_peft_model(model, lora_config) +trainer = transformers.Trainer( + model=peft_model, + train_dataset=dataset, + dataset_text_field="text", + max_length=2048, + processing_class=tokenizer, +) +trainer.train() +peft_model.save_pretrained("randlora-llama-7b") +``` + +There is no additional change needed to your standard PEFT training procedure, simply swap your `LoraConfig` for a `RandLoraConfig`. Note however that RandLora's trainable parameter count is **inversely proportional** to the rank parameter `r`. Lower `r` to increase and increase it to reduce trainable parameters of RandLora. + +Run the finetuning script simply by running: +```bash +python examples/randlora_finetuning/randlora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco +``` +This 👆🏻 by default will load the model in peft set up with RandLora config. Now if you wanna quickly compare it with Lora, all you need to do is to input ` --use_lora` in the command line and reduce `--randlora_alpha` to 2x the rank. So same above example would be 👇🏻; + +```bash +python examples/randlora_finetuning/randlora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco --use_lora --rank 32 --randlora_alpha 64 +``` + +RandLora can be made to use sparse or very sparse random bases. These sparse matrices can help reduce overfitting. Add `--very_sparse` to run with very sparse matrices or `--sparse` for sparse matrices: + +```bash +python examples/randlora_finetuning/randlora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --sparse +``` + +RandLora also supports quantization. To use 4-bit quantization try: + +```bash +python examples/randlora_finetuning/randlora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --quantize +``` + +By default the RandLora layers are the key and value layers of LLama model. Adding adapters on more layers will increase memory usage. If you wish to choose a different set of layers for RandLora to be applied on, you can simply define it using: +```bash +python examples/randlora_finetuning/randlora_finetuning.py --randlora_target_modules "q_proj,k_proj,v_proj" +``` + +### Full example of the script +```bash +python randlora_finetuning.py \ + --base_model "PATH_TO_MODEL" \ + --data_path "PATH_TO_DATASET" \ + --output_dir "PATH_TO_OUTPUT_DIR" \ + --batch_size 1 \ + --num_epochs 3 \ + --learning_rate 3e-4 \ + --cutoff_len 512 \ + --val_set_size 500 \ + --quantize \ + --eval_step 10 \ + --save_step 100 \ + --device "auto" \ + --rank 32 \ + --randlora_alpha 640 \ + --randlora_dropout 0.05 \ + --randlora_target_modules "k_proj,v_proj" \ + --hub_model_id "YOUR_HF_REPO" \ + --push_to_hub +``` + +## RandLora vs. LoRA +RandLora differs from LoRA and other related low rank approximation algorithms by chanllenging the low rank paradigm. RandLora adapters learn **full-rank** updates as the [paper](https://huggingface.co/papers/2502.00987) shows that the low rank constraint of LoRA can constrain performance gains as trainable parameters increase (with higher ranks). As a result, using RandLora is specifically recommended for difficult tasks that are underfit by LoRA. RandLoRA however also often improves performance for common tasks. If increasing LoRA's rank improves performance for your task, RandLora will most likely outperform. + +RandLora is expected to increase performance over LoRA for equivalent amounts of trainable parameters, mostly for larger equivalent amounts (> LoRA rank 4). + +RandLora's performance increase comes with two limitations: + +1. Performance is dependent on using a large `randlora_alpha` scaling parameter (usually 20x the basis rank). This large parameter can sometimes make training the update unstable, reduce the learning rate or the scaling parameter if this is the case. + +2. Increase training time over LoRA when using very low RandLora basis ranks. + +## RandLora vs. VeRA +RandLora shares similarities with VeRA in that both algorithms use random basis combinations to address some of LoRA's limitations. The limitations addressed by each algorithm is however different. +VeRA aims to reduce trainable parameters beyond rank 1 LoRAs while RandLoRA reduces the performance limitation due to the low rank of the update as the trainable parameter count increases. + +RandLora is expected to: + +1. Improve performance over VeRA when more trainable parameters are required (hard tasks) + +2. Reduce memory usage over VeRA thanks to RandLora's random base sharing strategy + + +## Citation +``` +@inproceedings{2025_ICLR_RandLoRA, + title="{RandLoRA: Full rank parameter-efficient fine-tuning of large models}", + author="Albert, Paul and Zhang, Frederic Z. and Saratchandran, Hemanth and Rodriguez-Opazo, Cristian and van den Hengel, Anton and Abbasnejad, Ehsan", + booktitle="{International Conference on Learning Representations (ICLR)}", + year="2025" +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/randlora_finetuning/qrandlora_finetuning.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/randlora_finetuning/qrandlora_finetuning.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..887cf1f516975c7cbf2d78e04bd524e83abc111d --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/randlora_finetuning/qrandlora_finetuning.ipynb @@ -0,0 +1,8100 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "CV_gQs58bsvM" + }, + "source": [ + "# Fine-tuning [Llama3-8b](https://huggingface.co/meta-llama/Meta-Llama-3-8B) on [timdettmers/openassistant-guanaco](https://huggingface.co/datasets/timdettmers/openassistant-guanaco) Dataset using QRandLora (quantized RandLora) on T4 Free Colab GPU." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FuXIFTFapAMI", + "outputId": "b95d8260-65bd-405f-f1e2-8d353aa46814" + }, + "outputs": [], + "source": [ + "# Install the libraries\n", + "!pip install -q -U bitsandbytes\n", + "!pip install -q -U git+https://github.com/huggingface/transformers.git\n", + "!pip install -q -U git+https://github.com/huggingface/peft.git\n", + "!pip install -q -U git+https://github.com/huggingface/accelerate.git\n", + "!pip install -q datasets" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 145, + "referenced_widgets": [ + "8cc86330c2af436c9af314e8c04c8c2b", + "e25f9ca445b14e3f8397779df071dfb4", + "8365680c634a44aa880317e36fa5e46e", + "0c4ac7c3db0b431397cc812f7c9e785c", + "c84f542c863043dea8a3675fa153e78d", + "b3b3f4ddd4ed4d938c923887939a0440", + "35186465f87341f683affb9399661540", + "791df472db174df69b8c9f0e200af254", + "6bb9c7182d2a464ea21809e59043562a", + "31c574113731403b88edc5bb0798bc6d", + "3b8bc5b9392e45758813a1db9db824a9", + "90661b333d6f496ca606b3046622660e", + "5f551f9b217e44cf8b5433f314b3844b", + "d2d81cc8296c4b10bf80b86c0a3302d3", + "7e3a386e672f4748882211227b7721a9", + "57f251691b4c453896b2508c431dfc2f", + "4bdb196cd1494f809829651ec5b6cbf8", + "7cd50bcc8fcc4b83abcda6d3604bd4cc", + "7a00aa4a97a34da39cc052c6926dbe13", + "14c73d88df9e46e3bbb6690fdb48ad07", + "0e2beab611114239b6ee48a3cbb09c49", + "006b78b5191b4fb888d98bdf6c20ec1e", + "5f6ffa1d929443a5bd9c7c550f0690f0", + "668a7f88506148a9ba2b48920afc028f", + "57b0096985ab44aea342e52795c4f999", + "a4c404e420cc4ce781ce569f9ab3f987", + "ee4e4af964ec4dd597cb04a90f0697f9", + "974e3687f18a4e1a975969b880d086aa", + "93a50117ece543d4857ba02505dc4514", + "71a3a56edbdb45669d382fef4b097e1b", + "53f287d4927541d08e2ae7d4d0b3c396", + "afa442ab223b46cb82569438c0047823" + ] + }, + "id": "wAAPv5CRmg7e", + "outputId": "687f979a-04c1-4160-d71c-4de8ecdb07d9" + }, + "outputs": [], + "source": [ + "# Required when training models/data that are gated on HuggingFace, and required for pushing models to HuggingFace\n", + "from huggingface_hub import notebook_login\n", + "\n", + "notebook_login()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MJ-5idQwzvg-" + }, + "source": [ + "### Loading the model and its tokenizer in quantized setup!\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 546, + "referenced_widgets": [ + "5924b266e95a42039634a334ff561a82", + "eadeec171e7b4c0f9e26964f031cfb71", + "feae525923d5407bb69a922954c474f7", + "00371a48e64c45cd97020a78b710e64c", + "156f95b0012449e8a0c604e6e03bf35f", + "de3757d6125a4c07b502dd60816bafec", + "8c4d6f4eea3742289a2604e66b0c6182", + "bac377ed96ae4e8db9b298bb623888ec", + "02d6cc4c2717434c895798601bda7c86", + "3f9fa554747743f8a86b40a4f7530617", + "ffe561df8772443ebf40a3b8b656079f", + "800e9453214848b69bc4c6ca2d5e8f79", + "6b0ec8d5f7294d44a5fa15d8ef12471e", + "7d3a7be9ed6f48988a2c4a1a4a2271cf", + "c40f583823574e40b6b29d4914143c0e", + "a4368e6da8f046aaa32f3152b7d333d1", + "8ea89e52123643268857285e0e1db1c0", + "a8514e34378d47a28fbf0831a14ede8f", + "f86b969ef69b48119619e1a424b50460", + "7725e9d443e249ada02e5ac7056d00db", + "f81756eb9e554899b0778311f2c407c4", + "3b614b9712874fac990d2c557b0791a6", + "43d12a98d90a4bf7a96c033172c646e2", + "c35b16156253402f90a432f3f07c2e0a", + "1ae1d2702da5483a85504f59939ffa39", + "1b2abf90003e4165a3293acd6a5ea9ff", + "3e45aea9f7444a4db885c4cca4c9c4ff", + "6b6ed29053ec4aaa8fc5526a35f17c2b", + "e69cd88ccbae4bb7b238fa112a60f0f9", + "8cd63d3908e4411c9fcb42bc32c8dd16", + "64624b26145b42db82f7afc36c32e117", + "cffdf12fbe97462ab74e88ccca943aeb", + "bcaf4c81ba9d437bb6223dbb22d011ed", + "8800c351b6da450eace0c3890d36c8d7", + "7037c32dfce84e70ac86537dbbc6a495", + "31c10fa464e24f97b379675a204a09b5", + "6149752353fe4f9cbb7b26bcc25199a9", + "0b145e421f4840f2872c29256b49f168", + "0f4c664612364dc89acf78eb1c740980", + "0f60f9aa76b941809e013ffcae83604a", + "1d27ab2bc6ae463a806292b68b7891f8", + "2a57bb48e1c6475abba242994a79d44a", + "6cb8065803724d80b82b06dc95ded91e", + "8301c6302df54bbc9f15295f11cec208", + "0aad2d9d1cba40cbb64308ede3242ed7", + "0711e28e06a440c2a241acbc1f90d1e8", + "77704d2e27e94cd3a0c5f6b5ceeffd1c", + "3b82b8d41b134bec9bd77ed8d4f00eb4", + "25fef90e209f4b14a73f3e39d226d913", + "f4ca7b63d7d749ff83a848e250f03ec1", + "8c149bc655a34fe5b91853c66db458a9", + "0f54e8fda93144f6a95493e6ec535e9d", + "880124db7dc04aaea09edd75e1ec7921", + "14bf612f6ad7416c8ddd6085c72eee0e", + "f7e59b47f9b74523843f37268212d566", + "a34b3fd5859a441f89cbe7f6e6df9da9", + "8f5b8c513b164dab9e0892422163c483", + "5b2a671976fa446db408d58a215b8249", + "c934919f617447cfb9226929e7a68d79", + "124a70bfad434c5c946f611c04a91c8f", + "cd11fb7d54bb43ae821f2272d075a1b3", + "fbc6a2834c5442fbb6667f1b3612bb5b", + "63899ac621ff4e9cb8e215d5ab63bef8", + "6b2b59d2b62b4f7da8c60ff783138397", + "c27e8ce031884a90b41d8220b1870bc4", + "88024cd312ee42c2925ebfbe52077780", + "cf6d1be81b6c4ffc81ce8fdabfc5ad28", + "07e0aed682fd4cc88fa75c0592dc04a7", + "67b4473eb8a44a96ba34983762ab38fa", + "c7e06fd82f7f4f9fb81c68e8758f2de1", + "3d9d8278667d496aaea1eaaa4d24ae93", + "47944ad8cadf4a57b170193c46d4389c", + "db05b25cb38140bdb21e6f3b7fde7e66", + "6f474268da0f4337a2ccecc1ca2098a1", + "c2ceccfdb59b4336a24003cd6bc2403d", + "a8999d04e4114693bb6be358bdbe9b83", + "2540d57e3bf545e3812da1ee72b85fc8", + "c56d8289513441688f9bc5f4b52d60a0", + "a53b4776f95f4dd38197193e6c5f649e", + "b4ba435f6d1c448f99b533bc6df32e76", + "42eb041021214110a860924d28d73409", + "17c797e08bd2493fa685918129415309", + "aea74071600f483b9e6de1a61743c03a", + "21bf14b771c14d2dab9e98a326302e14", + "35c2c635c2024bcda3265bf95d330f63", + "ec014d847e394a309b6a82c30a6fdfc5", + "4c369386ba5f4862b11a50e50130663b", + "bbdf3bb657e64fc2b0a90e78e8886480", + "d7ef74cf4a914ad38a69c84c34fff393", + "8d0f1d547c384094b10aa00a3ede3c06", + "9bdebf06b6874bbb88404f4ad14e1dbc", + "a2249f364b914662b54045a1f8d6dfd1", + "7504986b8d8d4d0da58ad79e80a81948", + "082b6990ce5e4812adc0ad6a7b376dac", + "610e1ddfb7a44d51a54ebea6dad3a5f0", + "5f60910d1e744432bdf87518f0f45874", + "2ab86b3fbd49488bb02f8205a572e752", + "9f13437a44b8434b9cc3afab998e8d3c", + "8a7c82dcbd414b24b67ccfbc562b2e38", + "d1508f5cde9a43d8abc26dd2d0c34dbd", + "9a0b012915c54abeb100f466fa99d303", + "99529129d7f0435da0fdcfc9803a2f11", + "5b56ac3009714a5a84dd8749db4a7bce", + "546b76a22f1046cd856a8fa2f9ff2d9f", + "fffbf696c07744fc8e3d81ab51dc9c90", + "a153cc3ca0cc45c18a941bd57e363ec3", + "5a8ac674153248999007a713299b2644", + "1f82a5685eef4b47a2dbf7618362907c", + "51b3af446ace409dbcdf5de499552061", + "9a12124915994b70a71ebd64b99e93e9", + "57f87d4780634d36ae8159d987c22993", + "58ea619f81bf42ddb8b166db3deb0e86", + "8bb83ae3229e4f38b1733f92f536fad0", + "5c0104210ee34ca8a072ee5121f424a1", + "34e381adbd9242759b57f2a305c5d2e3", + "e4e1a4338c5e46b3ba5a3bb960da7107", + "9a5072b8d16d4a1eb0652da61bda0ac8", + "1f75d85e6c7e4eb6a91b03f0c8adb644", + "9da33f07ea354b5798e85298e132b017", + "604582e8cbff4dc9876551a3307b5b77", + "a98165ee656643ad85ac9ea1447cc775", + "5cf4a57d21a545029b6448258a5ebd84", + "0d2ae3466a3447c58e23ccd2b3733deb", + "ba7f32c41f9247ec9d4c40e6396b55a9", + "ea1bdb5f2da64332960bccd967a84b4a", + "b08631e4cffa445c912da0c8eac2ef23", + "921a1a037f7b47f8b57d1da8192a437a", + "892ff4e2f0e44c23bc5c2be7547cf0bd", + "4c8e98294bd240a6869cb199caee66e1", + "4e1f5423311b4dc0930c21c9ad5a88f5", + "347540dc03d34e65b7ffbb0f5fc569aa", + "7243d8e2e1cc4043a2ee310eabd0ac09" + ] + }, + "id": "E0Nl5mWL0k2T", + "outputId": "a942d9b0-1f38-4a9b-ea20-e55bd7593920" + }, + "outputs": [], + "source": [ + "# setting up the config for 4-bit quantization of QRandLora\n", + "import torch\n", + "from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig\n", + "\n", + "model_id = \"meta-llama/Meta-Llama-3-8B\"\n", + "bnb_config = BitsAndBytesConfig(\n", + " load_in_4bit=True, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type=\"nf4\", bnb_4bit_compute_dtype=torch.bfloat16\n", + ")\n", + "\n", + "tokenizer = AutoTokenizer.from_pretrained(model_id)\n", + "model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config, device_map={\"\": 0})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Xpx2Fq-icX56" + }, + "outputs": [], + "source": [ + "print(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mp2gMi1ZzGET" + }, + "source": [ + "#### Prepare model for PEFT fine-tuning" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "a9EUEDAl0ss3" + }, + "outputs": [], + "source": [ + "from peft import prepare_model_for_kbit_training\n", + "\n", + "model.gradient_checkpointing_enable()\n", + "model = prepare_model_for_kbit_training(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "gkIcwsSU01EB" + }, + "outputs": [], + "source": [ + "def print_trainable_parameters(model):\n", + " \"\"\"\n", + " Prints the number of trainable parameters in the model.\n", + " \"\"\"\n", + " trainable_params = 0\n", + " all_param = 0\n", + " for _, param in model.named_parameters():\n", + " all_param += param.numel()\n", + " if param.requires_grad:\n", + " trainable_params += param.numel()\n", + " print(\n", + " f\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HVTAJuKyM0gX" + }, + "source": [ + "### Setup `RandLoraConfig`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ybeyl20n3dYH", + "outputId": "ea35ec70-13e4-4f23-9481-1b33b1b06dec" + }, + "outputs": [], + "source": [ + "from peft import RandLoraConfig, get_peft_model\n", + "\n", + "config = RandLoraConfig(\n", + " r=32,\n", + " randlora_alpha=640,\n", + " target_modules=[\n", + " \"q_proj\",\n", + " \"k_proj\",\n", + " \"v_proj\",\n", + " \"o_proj\",\n", + " \"gate_proj\",\n", + " \"up_proj\",\n", + " \"down_proj\",\n", + " ], # parameters specific to llama\n", + " randlora_dropout=0.05,\n", + " bias=\"none\",\n", + " task_type=\"CAUSAL_LM\",\n", + ")\n", + "\n", + "model = get_peft_model(model, config)\n", + "print_trainable_parameters(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ybeyl20n3dYH", + "outputId": "ea35ec70-13e4-4f23-9481-1b33b1b06dec" + }, + "outputs": [], + "source": [ + "print(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FCc64bfnmd3j" + }, + "source": [ + "## Step 2) Fine-tuning process 💥\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 277, + "referenced_widgets": [ + "b2a19b6092c44b20886987b30f1bf48a", + "1f0efc167b3744b38ff832b71d529318", + "a06b2bd0236249999adffa44e53cf80e", + "23012118a7314a3f838870a2aee9ec90", + "dcff079d850c423a83eb70105b816ee4", + "64911f0e52e74067a1a986c5edfc7f59", + "b4a274fc9e324b80bf559c4dbd05e319", + "5fb4a4ef8afe4ea4af6655faea17f354", + "b1a03a5e9bae46129830daeeb23bf6ff", + "e297072ab5d64815b90bc89d22503378", + "67fbabb9082c4241b8f937b24e0cdd03", + "b1de7b283eeb41828e8093e60c83f2c4", + "bb640a5c858349d29c13ce5629e72f22", + "37523a6cac1047e9a261698212d47737", + "661f76474252493caae8f7d6aa8f99b7", + "849cdc1912aa4df4b0c721a8c63ca0f9", + "5962e77eea5a4d88ba6dbc5e9f51c709", + "f07c8a6ec12f46ea9e32a2208e70bccd", + "191caf3a38eb4191a35f623ce25238f9", + "30b74bd2db8d40d08408013cebcd7661", + "83c355e1418140a5bbad11bf0646b332", + "84d6d2a6afcd423f9b609cbb2d10f00e", + "51180cce01564821a170d1d4b8a9a918", + "03dd6c24f6d94fe7ab85b79d6f6cbeaf", + "f2ab2fa803e94328a237e84cd4ea0027", + "1bd0a270c7ee409c970763398e54fc36", + "e92b30d0b4234af6b5a33bff989b1b45", + "cc5ce633746949ed98418cae9f68afe3", + "4b1f795c4c004cacbf3660d935e52995", + "5690d92586494b9187147f32fa708405", + "317cda72329c4043ab0b224b46b259d3", + "076357d4bb9943bdaa1d6846897786af", + "7b3e136fc9e74a699497a947006f4f1d", + "7e2e097c703a4a0d8556733a0739469c", + "e0fd6d00f0ba4e59bdaa5779556ec4ea", + "cd318c6bfc8e421a9bfcdab16be5eaa7", + "4bc1fd9d480a4799954c69031c071b30", + "25fc6aaf37fc49fa822df29236bf2f90", + "7ac8e88f29f04b859f592a003d39836b", + "0ec2643d9fd44785addb37d9ecd23989", + "d10ba011d05045b18bbfeb9660e4d9d3", + "e56c22f77c884caaacfafd48dfa51a55", + "068eb104d5d346b1897f8cbe9860d267", + "b621c6a8c0e9440fa840d75a1b1b02fc", + "434fe18d50a14920b30fd2d0650297ac", + "353bf45a4bbc46d6a798175f152399cb", + "bfcbfe4184774fd3a8320f4f0e1baf54", + "99c5c846cc5e43429905f071670b4310", + "8d988c86648244788f6dc5aa0fea38fd", + "740604526cc44cd58b811827d4787d96", + "2558c2dd7d394ecf9fc67a69ce8fc97a", + "a2a7b715b16a41a288209dee1de5d2d1", + "bf77e5aaab0547f7b2beb015687552ef", + "a2c543008f444cf49972a4f35c32b8e3", + "bb7b8a9e42f6478f851236685a1392d6", + "9cfaf17064bc49a5aded0fc53dd7cd7f", + "ede66e196fa9482498f58dcdffd494a2", + "a26cc7fea1a64d7bac1769d33cc74e28", + "c2f24a8930be4b70b4bbbcf5d908b01d", + "1f59dd66813f419999336e59a3efc56a", + "026072374b7d47c194707a50f5c99099", + "63ac7dafeb27446cb30aaddf4cd27c9f", + "854e35df771f470b82a59f878a2a6a46", + "d1cbe0ab9379453588eb438d13fd272d", + "b0b7457a8b47496483da1506fb2505b3", + "c7dc386d978a44ff885763ecec94dc38", + "4a7c8dfd88db4bc893da2bced0560d47", + "27a587021d854b79a279a510a55f9d73", + "4227474e986546d1a7d31dce35a2410c", + "1561cd47c42e46368677d34e7b7084cd", + "8b9e961c837a464fb7a8c44756dc41e7", + "d4092198673141d3b4a824d629d73f64", + "d3cbfd564fe8485ba7afdb1cc54abed3", + "7e51e8e0612e46b1a3403d448b39aa50", + "061c45266c484ff6807dcaf4722fd73b", + "04188e0cec0542818894ebc6a534fb51", + "4a13203d132b45beadf140c02dc8a566" + ] + }, + "id": "s6f4z8EYmcJ6", + "outputId": "8ece7a1a-cf27-4602-c70b-ce4f3d7e11bf" + }, + "outputs": [], + "source": [ + "# Load the dataset from HF\n", + "from datasets import load_dataset\n", + "\n", + "data = load_dataset(\"timdettmers/openassistant-guanaco\")\n", + "data = data.map(lambda samples: tokenizer(samples[\"text\"]), batched=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_0MOtwf3zdZp" + }, + "source": [ + "## Training\n", + "\n", + "For the sake of the demo, we just ran it for 10 steps just to showcase how to use this integration with existing tools on the HF ecosystem." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 498 + }, + "id": "jq0nX33BmfaC", + "outputId": "94e17005-065b-48ab-9192-e3ab55c0c292" + }, + "outputs": [], + "source": [ + "import transformers\n", + "\n", + "tokenizer.pad_token = tokenizer.eos_token\n", + "\n", + "trainer = transformers.Trainer(\n", + " model=model,\n", + " train_dataset=data[\"train\"],\n", + " args=transformers.TrainingArguments(\n", + " per_device_train_batch_size=1,\n", + " gradient_accumulation_steps=4,\n", + " warmup_steps=2,\n", + " max_steps=10,\n", + " learning_rate=2e-4,\n", + " fp16=True,\n", + " logging_steps=1,\n", + " output_dir=\"path/to/your/HF/repo\", # change it to your desired repo!\n", + " optim=\"paged_adamw_8bit\",\n", + " label_names=[\"labels\"],\n", + " ),\n", + " data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),\n", + ")\n", + "model.config.use_cache = False # silence the warnings. Please re-enable for inference!\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Mr3rLrHwqhf6" + }, + "source": [ + "## Usage Example" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "9mrOJ9l8SMHv" + }, + "outputs": [], + "source": [ + "model.config.use_cache = True\n", + "model.eval();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 122 + }, + "id": "AM6FNOFzqKfI", + "outputId": "fdbe28b1-e440-45d3-bd6d-c15e744ad23d" + }, + "outputs": [], + "source": [ + "from transformers import GenerationConfig\n", + "\n", + "max_new_tokens = 120\n", + "top_p = 0.9\n", + "temperature = 0.7\n", + "user_question = \"What is the purpose of quantization in LLMs?\"\n", + "\n", + "\n", + "prompt = (\n", + " \"A chat between a curious human and an artificial intelligence assistant. \"\n", + " \"The assistant gives helpful, detailed, and polite answers to the user's questions. \"\n", + " \"### Human: {user_question}\"\n", + " \"### Assistant: \"\n", + ")\n", + "\n", + "\n", + "def generate(model, user_question, max_new_tokens=max_new_tokens, top_p=top_p, temperature=temperature):\n", + " device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + " inputs = tokenizer(prompt.format(user_question=user_question), return_tensors=\"pt\").to(device)\n", + "\n", + " outputs = model.generate(\n", + " **inputs,\n", + " generation_config=GenerationConfig(\n", + " do_sample=True,\n", + " max_new_tokens=max_new_tokens,\n", + " top_p=top_p,\n", + " temperature=temperature,\n", + " ),\n", + " )\n", + "\n", + " text = tokenizer.decode(outputs[0], skip_special_tokens=True)\n", + " # print(text)\n", + " return text\n", + "\n", + "\n", + "generate(model, user_question)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "T5t_gl2_f5OO" + }, + "outputs": [], + "source": [ + "# trainer.push_to_hub()" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "00371a48e64c45cd97020a78b710e64c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3f9fa554747743f8a86b40a4f7530617", + "placeholder": "​", + "style": "IPY_MODEL_ffe561df8772443ebf40a3b8b656079f", + "value": " 50.6k/50.6k [00:00<00:00, 3.65MB/s]" + } + }, + "006b78b5191b4fb888d98bdf6c20ec1e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ee4e4af964ec4dd597cb04a90f0697f9", + "placeholder": "​", + "style": "IPY_MODEL_974e3687f18a4e1a975969b880d086aa", + "value": "Your token has been saved in your configured git credential helpers (store)." + } + }, + "026072374b7d47c194707a50f5c99099": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "02d6cc4c2717434c895798601bda7c86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "03dd6c24f6d94fe7ab85b79d6f6cbeaf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cc5ce633746949ed98418cae9f68afe3", + "placeholder": "​", + "style": "IPY_MODEL_4b1f795c4c004cacbf3660d935e52995", + "value": "Downloading data: 100%" + } + }, + "04188e0cec0542818894ebc6a534fb51": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "061c45266c484ff6807dcaf4722fd73b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "068eb104d5d346b1897f8cbe9860d267": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0711e28e06a440c2a241acbc1f90d1e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f4ca7b63d7d749ff83a848e250f03ec1", + "placeholder": "​", + "style": "IPY_MODEL_8c149bc655a34fe5b91853c66db458a9", + "value": "model.safetensors.index.json: 100%" + } + }, + "076357d4bb9943bdaa1d6846897786af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07e0aed682fd4cc88fa75c0592dc04a7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_47944ad8cadf4a57b170193c46d4389c", + "placeholder": "​", + "style": "IPY_MODEL_db05b25cb38140bdb21e6f3b7fde7e66", + "value": "model-00001-of-00004.safetensors: 100%" + } + }, + "082b6990ce5e4812adc0ad6a7b376dac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0aad2d9d1cba40cbb64308ede3242ed7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0711e28e06a440c2a241acbc1f90d1e8", + "IPY_MODEL_77704d2e27e94cd3a0c5f6b5ceeffd1c", + "IPY_MODEL_3b82b8d41b134bec9bd77ed8d4f00eb4" + ], + "layout": "IPY_MODEL_25fef90e209f4b14a73f3e39d226d913" + } + }, + "0b145e421f4840f2872c29256b49f168": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c4ac7c3db0b431397cc812f7c9e785c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "CheckboxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "CheckboxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "CheckboxView", + "description": "Add token as git credential?", + "description_tooltip": null, + "disabled": false, + "indent": true, + "layout": "IPY_MODEL_90661b333d6f496ca606b3046622660e", + "style": "IPY_MODEL_5f551f9b217e44cf8b5433f314b3844b", + "value": true + } + }, + "0d2ae3466a3447c58e23ccd2b3733deb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_921a1a037f7b47f8b57d1da8192a437a", + "placeholder": "​", + "style": "IPY_MODEL_892ff4e2f0e44c23bc5c2be7547cf0bd", + "value": "generation_config.json: 100%" + } + }, + "0e2beab611114239b6ee48a3cbb09c49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_57b0096985ab44aea342e52795c4f999", + "placeholder": "​", + "style": "IPY_MODEL_a4c404e420cc4ce781ce569f9ab3f987", + "value": "Token is valid (permission: write)." + } + }, + "0ec2643d9fd44785addb37d9ecd23989": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0f4c664612364dc89acf78eb1c740980": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f54e8fda93144f6a95493e6ec535e9d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0f60f9aa76b941809e013ffcae83604a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "124a70bfad434c5c946f611c04a91c8f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "14bf612f6ad7416c8ddd6085c72eee0e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "14c73d88df9e46e3bbb6690fdb48ad07": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1561cd47c42e46368677d34e7b7084cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_04188e0cec0542818894ebc6a534fb51", + "placeholder": "​", + "style": "IPY_MODEL_4a13203d132b45beadf140c02dc8a566", + "value": " 518/518 [00:00<00:00, 976.36 examples/s]" + } + }, + "156f95b0012449e8a0c604e6e03bf35f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17c797e08bd2493fa685918129415309": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "191caf3a38eb4191a35f623ce25238f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1ae1d2702da5483a85504f59939ffa39": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8cd63d3908e4411c9fcb42bc32c8dd16", + "max": 73, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_64624b26145b42db82f7afc36c32e117", + "value": 73 + } + }, + "1b2abf90003e4165a3293acd6a5ea9ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cffdf12fbe97462ab74e88ccca943aeb", + "placeholder": "​", + "style": "IPY_MODEL_bcaf4c81ba9d437bb6223dbb22d011ed", + "value": " 73.0/73.0 [00:00<00:00, 4.75kB/s]" + } + }, + "1bd0a270c7ee409c970763398e54fc36": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_076357d4bb9943bdaa1d6846897786af", + "placeholder": "​", + "style": "IPY_MODEL_7b3e136fc9e74a699497a947006f4f1d", + "value": " 1.11M/1.11M [00:00<00:00, 8.23MB/s]" + } + }, + "1d27ab2bc6ae463a806292b68b7891f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f0efc167b3744b38ff832b71d529318": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_64911f0e52e74067a1a986c5edfc7f59", + "placeholder": "​", + "style": "IPY_MODEL_b4a274fc9e324b80bf559c4dbd05e319", + "value": "Downloading readme: 100%" + } + }, + "1f59dd66813f419999336e59a3efc56a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f75d85e6c7e4eb6a91b03f0c8adb644": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1f82a5685eef4b47a2dbf7618362907c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "21bf14b771c14d2dab9e98a326302e14": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "23012118a7314a3f838870a2aee9ec90": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e297072ab5d64815b90bc89d22503378", + "placeholder": "​", + "style": "IPY_MODEL_67fbabb9082c4241b8f937b24e0cdd03", + "value": " 395/395 [00:00<00:00, 16.6kB/s]" + } + }, + "2540d57e3bf545e3812da1ee72b85fc8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2558c2dd7d394ecf9fc67a69ce8fc97a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "25fc6aaf37fc49fa822df29236bf2f90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "25fef90e209f4b14a73f3e39d226d913": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "27a587021d854b79a279a510a55f9d73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d4092198673141d3b4a824d629d73f64", + "placeholder": "​", + "style": "IPY_MODEL_d3cbfd564fe8485ba7afdb1cc54abed3", + "value": "Map: 100%" + } + }, + "2a57bb48e1c6475abba242994a79d44a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2ab86b3fbd49488bb02f8205a572e752": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "30b74bd2db8d40d08408013cebcd7661": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "317cda72329c4043ab0b224b46b259d3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "31c10fa464e24f97b379675a204a09b5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1d27ab2bc6ae463a806292b68b7891f8", + "max": 654, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2a57bb48e1c6475abba242994a79d44a", + "value": 654 + } + }, + "31c574113731403b88edc5bb0798bc6d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "347540dc03d34e65b7ffbb0f5fc569aa": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "34e381adbd9242759b57f2a305c5d2e3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35186465f87341f683affb9399661540": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": "center", + "align_self": null, + "border": null, + "bottom": null, + "display": "flex", + "flex": null, + "flex_flow": "column", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "50%" + } + }, + "353bf45a4bbc46d6a798175f152399cb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_740604526cc44cd58b811827d4787d96", + "placeholder": "​", + "style": "IPY_MODEL_2558c2dd7d394ecf9fc67a69ce8fc97a", + "value": "Generating test split: 100%" + } + }, + "35c2c635c2024bcda3265bf95d330f63": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "37523a6cac1047e9a261698212d47737": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_191caf3a38eb4191a35f623ce25238f9", + "max": 20877686, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_30b74bd2db8d40d08408013cebcd7661", + "value": 20877686 + } + }, + "3b614b9712874fac990d2c557b0791a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3b82b8d41b134bec9bd77ed8d4f00eb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_14bf612f6ad7416c8ddd6085c72eee0e", + "placeholder": "​", + "style": "IPY_MODEL_f7e59b47f9b74523843f37268212d566", + "value": " 23.9k/23.9k [00:00<00:00, 1.51MB/s]" + } + }, + "3b8bc5b9392e45758813a1db9db824a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3d9d8278667d496aaea1eaaa4d24ae93": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e45aea9f7444a4db885c4cca4c9c4ff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f9fa554747743f8a86b40a4f7530617": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4227474e986546d1a7d31dce35a2410c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7e51e8e0612e46b1a3403d448b39aa50", + "max": 518, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_061c45266c484ff6807dcaf4722fd73b", + "value": 518 + } + }, + "42eb041021214110a860924d28d73409": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4c369386ba5f4862b11a50e50130663b", + "placeholder": "​", + "style": "IPY_MODEL_bbdf3bb657e64fc2b0a90e78e8886480", + "value": " 5.00G/5.00G [00:24<00:00, 249MB/s]" + } + }, + "434fe18d50a14920b30fd2d0650297ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_353bf45a4bbc46d6a798175f152399cb", + "IPY_MODEL_bfcbfe4184774fd3a8320f4f0e1baf54", + "IPY_MODEL_99c5c846cc5e43429905f071670b4310" + ], + "layout": "IPY_MODEL_8d988c86648244788f6dc5aa0fea38fd" + } + }, + "43d12a98d90a4bf7a96c033172c646e2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c35b16156253402f90a432f3f07c2e0a", + "IPY_MODEL_1ae1d2702da5483a85504f59939ffa39", + "IPY_MODEL_1b2abf90003e4165a3293acd6a5ea9ff" + ], + "layout": "IPY_MODEL_3e45aea9f7444a4db885c4cca4c9c4ff" + } + }, + "47944ad8cadf4a57b170193c46d4389c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4a13203d132b45beadf140c02dc8a566": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4a7c8dfd88db4bc893da2bced0560d47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_27a587021d854b79a279a510a55f9d73", + "IPY_MODEL_4227474e986546d1a7d31dce35a2410c", + "IPY_MODEL_1561cd47c42e46368677d34e7b7084cd" + ], + "layout": "IPY_MODEL_8b9e961c837a464fb7a8c44756dc41e7" + } + }, + "4b1f795c4c004cacbf3660d935e52995": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4bc1fd9d480a4799954c69031c071b30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_068eb104d5d346b1897f8cbe9860d267", + "placeholder": "​", + "style": "IPY_MODEL_b621c6a8c0e9440fa840d75a1b1b02fc", + "value": " 9846/9846 [00:00<00:00, 38881.08 examples/s]" + } + }, + "4bdb196cd1494f809829651ec5b6cbf8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4c369386ba5f4862b11a50e50130663b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4c8e98294bd240a6869cb199caee66e1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4e1f5423311b4dc0930c21c9ad5a88f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "51180cce01564821a170d1d4b8a9a918": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_03dd6c24f6d94fe7ab85b79d6f6cbeaf", + "IPY_MODEL_f2ab2fa803e94328a237e84cd4ea0027", + "IPY_MODEL_1bd0a270c7ee409c970763398e54fc36" + ], + "layout": "IPY_MODEL_e92b30d0b4234af6b5a33bff989b1b45" + } + }, + "51b3af446ace409dbcdf5de499552061": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53f287d4927541d08e2ae7d4d0b3c396": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "546b76a22f1046cd856a8fa2f9ff2d9f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5690d92586494b9187147f32fa708405": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57b0096985ab44aea342e52795c4f999": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57f251691b4c453896b2508c431dfc2f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "57f87d4780634d36ae8159d987c22993": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_58ea619f81bf42ddb8b166db3deb0e86", + "IPY_MODEL_8bb83ae3229e4f38b1733f92f536fad0", + "IPY_MODEL_5c0104210ee34ca8a072ee5121f424a1" + ], + "layout": "IPY_MODEL_34e381adbd9242759b57f2a305c5d2e3" + } + }, + "58ea619f81bf42ddb8b166db3deb0e86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e4e1a4338c5e46b3ba5a3bb960da7107", + "placeholder": "​", + "style": "IPY_MODEL_9a5072b8d16d4a1eb0652da61bda0ac8", + "value": "Loading checkpoint shards: 100%" + } + }, + "5924b266e95a42039634a334ff561a82": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eadeec171e7b4c0f9e26964f031cfb71", + "IPY_MODEL_feae525923d5407bb69a922954c474f7", + "IPY_MODEL_00371a48e64c45cd97020a78b710e64c" + ], + "layout": "IPY_MODEL_156f95b0012449e8a0c604e6e03bf35f" + } + }, + "5962e77eea5a4d88ba6dbc5e9f51c709": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5a8ac674153248999007a713299b2644": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5b2a671976fa446db408d58a215b8249": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_63899ac621ff4e9cb8e215d5ab63bef8", + "max": 4, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_6b2b59d2b62b4f7da8c60ff783138397", + "value": 4 + } + }, + "5b56ac3009714a5a84dd8749db4a7bce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_51b3af446ace409dbcdf5de499552061", + "placeholder": "​", + "style": "IPY_MODEL_9a12124915994b70a71ebd64b99e93e9", + "value": " 1.17G/1.17G [00:09<00:00, 45.8MB/s]" + } + }, + "5c0104210ee34ca8a072ee5121f424a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_604582e8cbff4dc9876551a3307b5b77", + "placeholder": "​", + "style": "IPY_MODEL_a98165ee656643ad85ac9ea1447cc775", + "value": " 4/4 [01:13<00:00, 15.74s/it]" + } + }, + "5cf4a57d21a545029b6448258a5ebd84": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0d2ae3466a3447c58e23ccd2b3733deb", + "IPY_MODEL_ba7f32c41f9247ec9d4c40e6396b55a9", + "IPY_MODEL_ea1bdb5f2da64332960bccd967a84b4a" + ], + "layout": "IPY_MODEL_b08631e4cffa445c912da0c8eac2ef23" + } + }, + "5f551f9b217e44cf8b5433f314b3844b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5f60910d1e744432bdf87518f0f45874": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5f6ffa1d929443a5bd9c7c550f0690f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_93a50117ece543d4857ba02505dc4514", + "placeholder": "​", + "style": "IPY_MODEL_71a3a56edbdb45669d382fef4b097e1b", + "value": "Your token has been saved to /root/.cache/huggingface/token" + } + }, + "5fb4a4ef8afe4ea4af6655faea17f354": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "604582e8cbff4dc9876551a3307b5b77": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "610e1ddfb7a44d51a54ebea6dad3a5f0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6149752353fe4f9cbb7b26bcc25199a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6cb8065803724d80b82b06dc95ded91e", + "placeholder": "​", + "style": "IPY_MODEL_8301c6302df54bbc9f15295f11cec208", + "value": " 654/654 [00:00<00:00, 46.9kB/s]" + } + }, + "63899ac621ff4e9cb8e215d5ab63bef8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63ac7dafeb27446cb30aaddf4cd27c9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "64624b26145b42db82f7afc36c32e117": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "64911f0e52e74067a1a986c5edfc7f59": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "661f76474252493caae8f7d6aa8f99b7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_83c355e1418140a5bbad11bf0646b332", + "placeholder": "​", + "style": "IPY_MODEL_84d6d2a6afcd423f9b609cbb2d10f00e", + "value": " 20.9M/20.9M [00:00<00:00, 44.7MB/s]" + } + }, + "668a7f88506148a9ba2b48920afc028f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_53f287d4927541d08e2ae7d4d0b3c396", + "placeholder": "​", + "style": "IPY_MODEL_afa442ab223b46cb82569438c0047823", + "value": "Login successful" + } + }, + "67b4473eb8a44a96ba34983762ab38fa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6f474268da0f4337a2ccecc1ca2098a1", + "max": 4976698672, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c2ceccfdb59b4336a24003cd6bc2403d", + "value": 4976698672 + } + }, + "67fbabb9082c4241b8f937b24e0cdd03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6b0ec8d5f7294d44a5fa15d8ef12471e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8ea89e52123643268857285e0e1db1c0", + "placeholder": "​", + "style": "IPY_MODEL_a8514e34378d47a28fbf0831a14ede8f", + "value": "tokenizer.json: 100%" + } + }, + "6b2b59d2b62b4f7da8c60ff783138397": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "6b6ed29053ec4aaa8fc5526a35f17c2b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6bb9c7182d2a464ea21809e59043562a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6cb8065803724d80b82b06dc95ded91e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f474268da0f4337a2ccecc1ca2098a1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7037c32dfce84e70ac86537dbbc6a495": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0f4c664612364dc89acf78eb1c740980", + "placeholder": "​", + "style": "IPY_MODEL_0f60f9aa76b941809e013ffcae83604a", + "value": "config.json: 100%" + } + }, + "71a3a56edbdb45669d382fef4b097e1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7243d8e2e1cc4043a2ee310eabd0ac09": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "740604526cc44cd58b811827d4787d96": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7504986b8d8d4d0da58ad79e80a81948": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7725e9d443e249ada02e5ac7056d00db": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "77704d2e27e94cd3a0c5f6b5ceeffd1c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0f54e8fda93144f6a95493e6ec535e9d", + "max": 23950, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_880124db7dc04aaea09edd75e1ec7921", + "value": 23950 + } + }, + "791df472db174df69b8c9f0e200af254": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7a00aa4a97a34da39cc052c6926dbe13": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7ac8e88f29f04b859f592a003d39836b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b3e136fc9e74a699497a947006f4f1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7cd50bcc8fcc4b83abcda6d3604bd4cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "LabelModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "LabelModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "LabelView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a00aa4a97a34da39cc052c6926dbe13", + "placeholder": "​", + "style": "IPY_MODEL_14c73d88df9e46e3bbb6690fdb48ad07", + "value": "Connecting..." + } + }, + "7d3a7be9ed6f48988a2c4a1a4a2271cf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f86b969ef69b48119619e1a424b50460", + "max": 9085698, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7725e9d443e249ada02e5ac7056d00db", + "value": 9085698 + } + }, + "7e2e097c703a4a0d8556733a0739469c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e0fd6d00f0ba4e59bdaa5779556ec4ea", + "IPY_MODEL_cd318c6bfc8e421a9bfcdab16be5eaa7", + "IPY_MODEL_4bc1fd9d480a4799954c69031c071b30" + ], + "layout": "IPY_MODEL_25fc6aaf37fc49fa822df29236bf2f90" + } + }, + "7e3a386e672f4748882211227b7721a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "button_color": null, + "font_weight": "" + } + }, + "7e51e8e0612e46b1a3403d448b39aa50": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "800e9453214848b69bc4c6ca2d5e8f79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6b0ec8d5f7294d44a5fa15d8ef12471e", + "IPY_MODEL_7d3a7be9ed6f48988a2c4a1a4a2271cf", + "IPY_MODEL_c40f583823574e40b6b29d4914143c0e" + ], + "layout": "IPY_MODEL_a4368e6da8f046aaa32f3152b7d333d1" + } + }, + "8301c6302df54bbc9f15295f11cec208": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8365680c634a44aa880317e36fa5e46e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "PasswordModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "PasswordModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "PasswordView", + "continuous_update": true, + "description": "Token:", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_31c574113731403b88edc5bb0798bc6d", + "placeholder": "​", + "style": "IPY_MODEL_3b8bc5b9392e45758813a1db9db824a9", + "value": "" + } + }, + "83c355e1418140a5bbad11bf0646b332": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "849cdc1912aa4df4b0c721a8c63ca0f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "84d6d2a6afcd423f9b609cbb2d10f00e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "854e35df771f470b82a59f878a2a6a46": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8800c351b6da450eace0c3890d36c8d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7037c32dfce84e70ac86537dbbc6a495", + "IPY_MODEL_31c10fa464e24f97b379675a204a09b5", + "IPY_MODEL_6149752353fe4f9cbb7b26bcc25199a9" + ], + "layout": "IPY_MODEL_0b145e421f4840f2872c29256b49f168" + } + }, + "880124db7dc04aaea09edd75e1ec7921": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "88024cd312ee42c2925ebfbe52077780": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "892ff4e2f0e44c23bc5c2be7547cf0bd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8a7c82dcbd414b24b67ccfbc562b2e38": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8b9e961c837a464fb7a8c44756dc41e7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8bb83ae3229e4f38b1733f92f536fad0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1f75d85e6c7e4eb6a91b03f0c8adb644", + "max": 4, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9da33f07ea354b5798e85298e132b017", + "value": 4 + } + }, + "8c149bc655a34fe5b91853c66db458a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8c4d6f4eea3742289a2604e66b0c6182": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "8cc86330c2af436c9af314e8c04c8c2b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0e2beab611114239b6ee48a3cbb09c49", + "IPY_MODEL_006b78b5191b4fb888d98bdf6c20ec1e", + "IPY_MODEL_5f6ffa1d929443a5bd9c7c550f0690f0", + "IPY_MODEL_668a7f88506148a9ba2b48920afc028f" + ], + "layout": "IPY_MODEL_35186465f87341f683affb9399661540" + } + }, + "8cd63d3908e4411c9fcb42bc32c8dd16": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d0f1d547c384094b10aa00a3ede3c06": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_082b6990ce5e4812adc0ad6a7b376dac", + "placeholder": "​", + "style": "IPY_MODEL_610e1ddfb7a44d51a54ebea6dad3a5f0", + "value": "model-00003-of-00004.safetensors: 100%" + } + }, + "8d988c86648244788f6dc5aa0fea38fd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8ea89e52123643268857285e0e1db1c0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8f5b8c513b164dab9e0892422163c483": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cd11fb7d54bb43ae821f2272d075a1b3", + "placeholder": "​", + "style": "IPY_MODEL_fbc6a2834c5442fbb6667f1b3612bb5b", + "value": "Downloading shards: 100%" + } + }, + "90661b333d6f496ca606b3046622660e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "921a1a037f7b47f8b57d1da8192a437a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93a50117ece543d4857ba02505dc4514": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "974e3687f18a4e1a975969b880d086aa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "99529129d7f0435da0fdcfc9803a2f11": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5a8ac674153248999007a713299b2644", + "max": 1168138808, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1f82a5685eef4b47a2dbf7618362907c", + "value": 1168138808 + } + }, + "99c5c846cc5e43429905f071670b4310": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a2c543008f444cf49972a4f35c32b8e3", + "placeholder": "​", + "style": "IPY_MODEL_bb7b8a9e42f6478f851236685a1392d6", + "value": " 518/518 [00:00<00:00, 13408.85 examples/s]" + } + }, + "9a0b012915c54abeb100f466fa99d303": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fffbf696c07744fc8e3d81ab51dc9c90", + "placeholder": "​", + "style": "IPY_MODEL_a153cc3ca0cc45c18a941bd57e363ec3", + "value": "model-00004-of-00004.safetensors: 100%" + } + }, + "9a12124915994b70a71ebd64b99e93e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9a5072b8d16d4a1eb0652da61bda0ac8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9bdebf06b6874bbb88404f4ad14e1dbc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5f60910d1e744432bdf87518f0f45874", + "max": 4915916176, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2ab86b3fbd49488bb02f8205a572e752", + "value": 4915916176 + } + }, + "9cfaf17064bc49a5aded0fc53dd7cd7f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ede66e196fa9482498f58dcdffd494a2", + "IPY_MODEL_a26cc7fea1a64d7bac1769d33cc74e28", + "IPY_MODEL_c2f24a8930be4b70b4bbbcf5d908b01d" + ], + "layout": "IPY_MODEL_1f59dd66813f419999336e59a3efc56a" + } + }, + "9da33f07ea354b5798e85298e132b017": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9f13437a44b8434b9cc3afab998e8d3c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a06b2bd0236249999adffa44e53cf80e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5fb4a4ef8afe4ea4af6655faea17f354", + "max": 395, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b1a03a5e9bae46129830daeeb23bf6ff", + "value": 395 + } + }, + "a153cc3ca0cc45c18a941bd57e363ec3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a2249f364b914662b54045a1f8d6dfd1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f13437a44b8434b9cc3afab998e8d3c", + "placeholder": "​", + "style": "IPY_MODEL_8a7c82dcbd414b24b67ccfbc562b2e38", + "value": " 4.92G/4.92G [00:32<00:00, 171MB/s]" + } + }, + "a26cc7fea1a64d7bac1769d33cc74e28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_854e35df771f470b82a59f878a2a6a46", + "max": 9846, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d1cbe0ab9379453588eb438d13fd272d", + "value": 9846 + } + }, + "a2a7b715b16a41a288209dee1de5d2d1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a2c543008f444cf49972a4f35c32b8e3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a34b3fd5859a441f89cbe7f6e6df9da9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8f5b8c513b164dab9e0892422163c483", + "IPY_MODEL_5b2a671976fa446db408d58a215b8249", + "IPY_MODEL_c934919f617447cfb9226929e7a68d79" + ], + "layout": "IPY_MODEL_124a70bfad434c5c946f611c04a91c8f" + } + }, + "a4368e6da8f046aaa32f3152b7d333d1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4c404e420cc4ce781ce569f9ab3f987": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a53b4776f95f4dd38197193e6c5f649e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_aea74071600f483b9e6de1a61743c03a", + "placeholder": "​", + "style": "IPY_MODEL_21bf14b771c14d2dab9e98a326302e14", + "value": "model-00002-of-00004.safetensors: 100%" + } + }, + "a8514e34378d47a28fbf0831a14ede8f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a8999d04e4114693bb6be358bdbe9b83": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a98165ee656643ad85ac9ea1447cc775": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "aea74071600f483b9e6de1a61743c03a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "afa442ab223b46cb82569438c0047823": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b08631e4cffa445c912da0c8eac2ef23": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b0b7457a8b47496483da1506fb2505b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b1a03a5e9bae46129830daeeb23bf6ff": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b1de7b283eeb41828e8093e60c83f2c4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bb640a5c858349d29c13ce5629e72f22", + "IPY_MODEL_37523a6cac1047e9a261698212d47737", + "IPY_MODEL_661f76474252493caae8f7d6aa8f99b7" + ], + "layout": "IPY_MODEL_849cdc1912aa4df4b0c721a8c63ca0f9" + } + }, + "b2a19b6092c44b20886987b30f1bf48a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1f0efc167b3744b38ff832b71d529318", + "IPY_MODEL_a06b2bd0236249999adffa44e53cf80e", + "IPY_MODEL_23012118a7314a3f838870a2aee9ec90" + ], + "layout": "IPY_MODEL_dcff079d850c423a83eb70105b816ee4" + } + }, + "b3b3f4ddd4ed4d938c923887939a0440": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_57f251691b4c453896b2508c431dfc2f", + "placeholder": "​", + "style": "IPY_MODEL_4bdb196cd1494f809829651ec5b6cbf8", + "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. " + } + }, + "b4a274fc9e324b80bf559c4dbd05e319": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b4ba435f6d1c448f99b533bc6df32e76": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_35c2c635c2024bcda3265bf95d330f63", + "max": 4999802720, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_ec014d847e394a309b6a82c30a6fdfc5", + "value": 4999802720 + } + }, + "b621c6a8c0e9440fa840d75a1b1b02fc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ba7f32c41f9247ec9d4c40e6396b55a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4c8e98294bd240a6869cb199caee66e1", + "max": 177, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4e1f5423311b4dc0930c21c9ad5a88f5", + "value": 177 + } + }, + "bac377ed96ae4e8db9b298bb623888ec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb640a5c858349d29c13ce5629e72f22": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5962e77eea5a4d88ba6dbc5e9f51c709", + "placeholder": "​", + "style": "IPY_MODEL_f07c8a6ec12f46ea9e32a2208e70bccd", + "value": "Downloading data: 100%" + } + }, + "bb7b8a9e42f6478f851236685a1392d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bbdf3bb657e64fc2b0a90e78e8886480": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bcaf4c81ba9d437bb6223dbb22d011ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bf77e5aaab0547f7b2beb015687552ef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bfcbfe4184774fd3a8320f4f0e1baf54": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a2a7b715b16a41a288209dee1de5d2d1", + "max": 518, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bf77e5aaab0547f7b2beb015687552ef", + "value": 518 + } + }, + "c27e8ce031884a90b41d8220b1870bc4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c2ceccfdb59b4336a24003cd6bc2403d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c2f24a8930be4b70b4bbbcf5d908b01d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b0b7457a8b47496483da1506fb2505b3", + "placeholder": "​", + "style": "IPY_MODEL_c7dc386d978a44ff885763ecec94dc38", + "value": " 9846/9846 [00:09<00:00, 1066.17 examples/s]" + } + }, + "c35b16156253402f90a432f3f07c2e0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_6b6ed29053ec4aaa8fc5526a35f17c2b", + "placeholder": "​", + "style": "IPY_MODEL_e69cd88ccbae4bb7b238fa112a60f0f9", + "value": "special_tokens_map.json: 100%" + } + }, + "c40f583823574e40b6b29d4914143c0e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f81756eb9e554899b0778311f2c407c4", + "placeholder": "​", + "style": "IPY_MODEL_3b614b9712874fac990d2c557b0791a6", + "value": " 9.09M/9.09M [00:00<00:00, 19.3MB/s]" + } + }, + "c56d8289513441688f9bc5f4b52d60a0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a53b4776f95f4dd38197193e6c5f649e", + "IPY_MODEL_b4ba435f6d1c448f99b533bc6df32e76", + "IPY_MODEL_42eb041021214110a860924d28d73409" + ], + "layout": "IPY_MODEL_17c797e08bd2493fa685918129415309" + } + }, + "c7dc386d978a44ff885763ecec94dc38": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c7e06fd82f7f4f9fb81c68e8758f2de1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a8999d04e4114693bb6be358bdbe9b83", + "placeholder": "​", + "style": "IPY_MODEL_2540d57e3bf545e3812da1ee72b85fc8", + "value": " 4.98G/4.98G [00:34<00:00, 232MB/s]" + } + }, + "c84f542c863043dea8a3675fa153e78d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ButtonView", + "button_style": "", + "description": "Login", + "disabled": false, + "icon": "", + "layout": "IPY_MODEL_d2d81cc8296c4b10bf80b86c0a3302d3", + "style": "IPY_MODEL_7e3a386e672f4748882211227b7721a9", + "tooltip": "" + } + }, + "c934919f617447cfb9226929e7a68d79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c27e8ce031884a90b41d8220b1870bc4", + "placeholder": "​", + "style": "IPY_MODEL_88024cd312ee42c2925ebfbe52077780", + "value": " 4/4 [01:41<00:00, 22.30s/it]" + } + }, + "cc5ce633746949ed98418cae9f68afe3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd11fb7d54bb43ae821f2272d075a1b3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cd318c6bfc8e421a9bfcdab16be5eaa7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d10ba011d05045b18bbfeb9660e4d9d3", + "max": 9846, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e56c22f77c884caaacfafd48dfa51a55", + "value": 9846 + } + }, + "cf6d1be81b6c4ffc81ce8fdabfc5ad28": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07e0aed682fd4cc88fa75c0592dc04a7", + "IPY_MODEL_67b4473eb8a44a96ba34983762ab38fa", + "IPY_MODEL_c7e06fd82f7f4f9fb81c68e8758f2de1" + ], + "layout": "IPY_MODEL_3d9d8278667d496aaea1eaaa4d24ae93" + } + }, + "cffdf12fbe97462ab74e88ccca943aeb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d10ba011d05045b18bbfeb9660e4d9d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d1508f5cde9a43d8abc26dd2d0c34dbd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9a0b012915c54abeb100f466fa99d303", + "IPY_MODEL_99529129d7f0435da0fdcfc9803a2f11", + "IPY_MODEL_5b56ac3009714a5a84dd8749db4a7bce" + ], + "layout": "IPY_MODEL_546b76a22f1046cd856a8fa2f9ff2d9f" + } + }, + "d1cbe0ab9379453588eb438d13fd272d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d2d81cc8296c4b10bf80b86c0a3302d3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d3cbfd564fe8485ba7afdb1cc54abed3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d4092198673141d3b4a824d629d73f64": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7ef74cf4a914ad38a69c84c34fff393": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8d0f1d547c384094b10aa00a3ede3c06", + "IPY_MODEL_9bdebf06b6874bbb88404f4ad14e1dbc", + "IPY_MODEL_a2249f364b914662b54045a1f8d6dfd1" + ], + "layout": "IPY_MODEL_7504986b8d8d4d0da58ad79e80a81948" + } + }, + "db05b25cb38140bdb21e6f3b7fde7e66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dcff079d850c423a83eb70105b816ee4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de3757d6125a4c07b502dd60816bafec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0fd6d00f0ba4e59bdaa5779556ec4ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7ac8e88f29f04b859f592a003d39836b", + "placeholder": "​", + "style": "IPY_MODEL_0ec2643d9fd44785addb37d9ecd23989", + "value": "Generating train split: 100%" + } + }, + "e25f9ca445b14e3f8397779df071dfb4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_791df472db174df69b8c9f0e200af254", + "placeholder": "​", + "style": "IPY_MODEL_6bb9c7182d2a464ea21809e59043562a", + "value": "


Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" + } + }, + "e297072ab5d64815b90bc89d22503378": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4e1a4338c5e46b3ba5a3bb960da7107": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e56c22f77c884caaacfafd48dfa51a55": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e69cd88ccbae4bb7b238fa112a60f0f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e92b30d0b4234af6b5a33bff989b1b45": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ea1bdb5f2da64332960bccd967a84b4a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_347540dc03d34e65b7ffbb0f5fc569aa", + "placeholder": "​", + "style": "IPY_MODEL_7243d8e2e1cc4043a2ee310eabd0ac09", + "value": " 177/177 [00:00<00:00, 11.4kB/s]" + } + }, + "eadeec171e7b4c0f9e26964f031cfb71": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_de3757d6125a4c07b502dd60816bafec", + "placeholder": "​", + "style": "IPY_MODEL_8c4d6f4eea3742289a2604e66b0c6182", + "value": "tokenizer_config.json: 100%" + } + }, + "ec014d847e394a309b6a82c30a6fdfc5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ede66e196fa9482498f58dcdffd494a2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_026072374b7d47c194707a50f5c99099", + "placeholder": "​", + "style": "IPY_MODEL_63ac7dafeb27446cb30aaddf4cd27c9f", + "value": "Map: 100%" + } + }, + "ee4e4af964ec4dd597cb04a90f0697f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f07c8a6ec12f46ea9e32a2208e70bccd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f2ab2fa803e94328a237e84cd4ea0027": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5690d92586494b9187147f32fa708405", + "max": 1105272, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_317cda72329c4043ab0b224b46b259d3", + "value": 1105272 + } + }, + "f4ca7b63d7d749ff83a848e250f03ec1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f7e59b47f9b74523843f37268212d566": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f81756eb9e554899b0778311f2c407c4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f86b969ef69b48119619e1a424b50460": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fbc6a2834c5442fbb6667f1b3612bb5b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "feae525923d5407bb69a922954c474f7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bac377ed96ae4e8db9b298bb623888ec", + "max": 50566, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_02d6cc4c2717434c895798601bda7c86", + "value": 50566 + } + }, + "ffe561df8772443ebf40a3b8b656079f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "fffbf696c07744fc8e3d81ab51dc9c90": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/randlora_finetuning/randlora_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/randlora_finetuning/randlora_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..01afdf2041691378184c596d1c56c54f29f474c9 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/randlora_finetuning/randlora_finetuning.py @@ -0,0 +1,230 @@ +# This script is based on examples/dora_finetuning/dora_finetuning.py +import os + +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + BitsAndBytesConfig, + DataCollatorForLanguageModeling, + Trainer, + TrainingArguments, +) + +from peft import LoraConfig, RandLoraConfig, get_peft_model, prepare_model_for_kbit_training + + +def train_model( + base_model: str, + data_path: str, + output_dir: str, + batch_size: int, + num_epochs: int, + learning_rate: float, + cutoff_len: int, + val_set_size: int, + use_lora: bool, + quantize: bool, + eval_step: int, + save_step: int, + device: str, + rank: int, + randlora_alpha: int, + randlora_dropout: float, + randlora_target_modules: str, + hub_model_id: str, + push_to_hub: bool, + sparse: bool, + very_sparse: bool, +): + os.environ["TOKENIZERS_PARALLELISM"] = "false" + hf_token = os.getenv("HF_TOKEN") + + # Setup device + device = torch.device(device) + print(f"Using device: {device}") + + # load tokenizer + tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token) + + # Compute type + device_type = device.type + device_module = getattr(torch, device_type, torch.cuda) + bf16_suppotrted = device_module.is_available() and device_module.is_bf16_supported() + dtype = torch.bfloat16 if bf16_suppotrted else torch.float16 + + # QRandLora (quantized randlora): IF YOU WANNA QUANTIZE THE MODEL + if quantize: + model = AutoModelForCausalLM.from_pretrained( + base_model, + token=hf_token, + quantization_config=BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=torch.bfloat16 if bf16_suppotrted else torch.float16, + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_type="nf4", + ), + dtype=dtype, + ) + # setup for quantized training + model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True) + else: + model = AutoModelForCausalLM.from_pretrained( + base_model, + dtype=dtype, + token=hf_token, + ) + # LoRa config for the PEFT model + if use_lora: + peft_config = LoraConfig( + r=rank, # Rank of matrix + lora_alpha=randlora_alpha, + target_modules=(randlora_target_modules.split(",") if randlora_target_modules else ["k_proj", "v_proj"]), + lora_dropout=randlora_dropout, + bias="none", + ) + else: + peft_config = RandLoraConfig( + r=rank, # Rank of random bases + randlora_alpha=randlora_alpha, + target_modules=(randlora_target_modules.split(",") if randlora_target_modules else ["k_proj", "v_proj"]), + randlora_dropout=randlora_dropout, + bias="none", + sparse=sparse, + very_sparse=very_sparse, + ) + + # get the peft model with RandLora config + model = get_peft_model(model, peft_config) + + model.to(device) # MODEL TO ACCELERATOR + tokenizer.pad_token = tokenizer.eos_token + + # Load the dataset + dataset = load_dataset(data_path) + + def tokenize_function(examples): + inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len) + inputs["labels"] = inputs["input_ids"].copy() # setting labels for a language modeling task + return inputs + + # Tokenize the dataset and prepare for training + tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names) + + # Data collator to dynamically pad the batched examples + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + + # Compute the total amount of training step for warmup + max_steps = int((len(dataset) // batch_size) * num_epochs) + + # Define training arguments + training_args = TrainingArguments( + output_dir=output_dir, + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + per_device_eval_batch_size=batch_size, + warmup_steps=int(max_steps * 0.1), # 10% of total trainig steps + weight_decay=0.01, + logging_dir="./logs", + logging_steps=eval_step, + save_steps=save_step, + save_total_limit=2, + push_to_hub=push_to_hub, + hub_model_id=hub_model_id, + gradient_accumulation_steps=16 + // batch_size, # Maintaining a minimum batch size of 16 post accumulation is recommended to ensure good performance + learning_rate=learning_rate, + hub_token=hf_token, + label_names=["labels"], + ) + + # Clear accelerator cache to free memory + device_module.empty_cache() + + # Initialize the Trainer + trainer = Trainer( + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["test"], + data_collator=data_collator, + ) + + # Start model training + trainer.train() + + # Save and push the trained model and tokenizer + if push_to_hub: + # Push the main model to the hub + trainer.push_to_hub(commit_message="Fine-tuned model") + + # Save the model and tokenizer locally + model.save_pretrained(output_dir) + tokenizer.save_pretrained(output_dir) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DoRA and PEFT") + parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name") + parser.add_argument( + "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name" + ) + parser.add_argument( + "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model" + ) + parser.add_argument("--batch_size", type=int, default=1, help="Batch size") + parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs") + parser.add_argument("--learning_rate", type=float, default=3e-4, help="Learning rate") + parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization") + parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size") + parser.add_argument("--use_lora", action="store_true", help="Apply Lora instead of RandLora") + parser.add_argument("--quantize", action="store_true", help="Use quantization") + parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval") + parser.add_argument("--save_step", type=int, default=100, help="Save step interval") + parser.add_argument("--device", type=str, default="auto", help="Device to use for training") + parser.add_argument("--rank", type=int, default=32, help="RandLora basis rank") + parser.add_argument("--randlora_alpha", type=int, default=640, help="RandLora alpha") + parser.add_argument("--randlora_dropout", type=float, default=0.05, help="RandLora dropout rate") + parser.add_argument( + "--randlora_target_modules", type=str, default=None, help="Comma-separated list of target modules for RandLora" + ) + parser.add_argument("--sparse", action="store_true", help="Use sparse matrix multiplication") + parser.add_argument("--very_sparse", action="store_true", help="Use very sparse matrix multiplication") + parser.add_argument( + "--hub_model_id", + type=str, + default="path/to/repo", + help="Repository name to push the model on the Hugging Face Hub", + ) + parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub") + args = parser.parse_args() + + if args.device == "auto": + args.device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda" + + train_model( + base_model=args.base_model, + data_path=args.data_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + val_set_size=args.val_set_size, + use_lora=args.use_lora, + quantize=args.quantize, + eval_step=args.eval_step, + save_step=args.save_step, + device=args.device, + rank=args.rank, + randlora_alpha=args.randlora_alpha, + randlora_dropout=args.randlora_dropout, + randlora_target_modules=args.randlora_target_modules, + hub_model_id=args.hub_model_id, + push_to_hub=args.push_to_hub, + sparse=args.sparse, + very_sparse=args.very_sparse, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/road_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/road_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3d8716574f239127b7d187b0098a6845624aec0f --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/road_finetuning/README.md @@ -0,0 +1,88 @@ +# RoAd: 3-in-1: 2D Rotary Adaptation for Efficient Finetuning, Efficient Batching and Composability + + +## Introduction + +[RoAd](https://huggingface.co/papers/2409.00119) is a novel method that adapts LLMs using simple 2D rotations. It is highly parameter-efficient, +achieving strong performance with less than 0.1% trainable parameters. +RoAd also supports efficient serving of mixed-adapter requests within a batch, incurring only element-wise computation overhead rather than costly batch matrix multiplications. +Additionally, it improves model interpretability through structured and composable transformations. + +## Quick start +```python +import torch +from peft import RoadConfig, get_peft_model +from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer +from datasets import load_dataset + +model = AutoModelForCausalLM.from_pretrained("huggyllama/llama-7b", device_map="cuda") +tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-7b") +dataset = load_dataset("timdettmers/openassistant-guanaco", split="train") +road_config = RoadConfig( + variant="1", +) +peft_model = get_peft_model(model, road_config) +trainer = transformers.Trainer( + model=peft_model, + train_dataset=dataset, + dataset_text_field="text", + max_length=2048, + tokenizer=tokenizer, +) +trainer.train() +peft_model.save_pretrained("road-llama-3-8b") +``` + +RoAd requires a higher learning rate compared to LoRa and similar approaches, set it to around 1e-3. + +Run the finetuning script simply by running: + +```bash +python examples/road_finetuning/road_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco +``` + +RoAd also supports quantization. To use 4-bit quantization try: + +```bash +python examples/road_finetuning/road_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --quantize +``` + +### Full example of the script +```bash +python road_finetuning.py \ + --base_model "PATH_TO_MODEL" \ + --data_path "PATH_TO_DATASET" \ + --output_dir "PATH_TO_OUTPUT_DIR" \ + --batch_size 1 \ + --num_epochs 3 \ + --learning_rate 1e-3 \ + --cutoff_len 512 \ + --val_set_size 500 \ + --quantize \ + --eval_step 10 \ + --save_step 100 \ + --device "cuda:0" \ + --variant 1 \ + --road_target_modules "q_proj,k_proj,v_proj,o_proj" \ + --hub_model_id "YOUR_HF_REPO" \ + --push_to_hub +``` +## Use the model on 🤗 +You can load and use the model as any other 🤗 models. +```python +from transformers import AutoModel +model = AutoModel.from_pretrained("ppetrushkov/llama-2-7b-sql-road-test") +``` + + +## Citation +``` +@inproceedings{ + liao2024in, + title={3-in-1: 2D Rotary Adaptation for Efficient Finetuning, Efficient Batching and Composability}, + author={Baohao Liao and Christof Monz}, + booktitle={The Thirty-eighth Annual Conference on Neural Information Processing Systems}, + year={2024}, + url={https://openreview.net/forum?id=rYjYwuM6yH} +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/road_finetuning/road_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/road_finetuning/road_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..0469785db44a15f622962bc3da8447390c511290 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/road_finetuning/road_finetuning.py @@ -0,0 +1,203 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os + +import torch +from datasets import load_dataset +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + BitsAndBytesConfig, + DataCollatorForLanguageModeling, + Trainer, + TrainingArguments, +) + +from peft import RoadConfig, get_peft_model, prepare_model_for_kbit_training + + +def train_model( + base_model: str, + data_path: str, + output_dir: str, + batch_size: int, + num_epochs: int, + learning_rate: float, + cutoff_len: int, + val_set_size: int, + quantize: bool, + eval_step: int, + save_step: int, + device: str, + variant: str, + road_target_modules: str, + hub_model_id: str, + push_to_hub: bool, +): + os.environ["TOKENIZERS_PARALLELISM"] = "false" + hf_token = os.getenv("HF_TOKEN") + + # Setup device + device = torch.device(device) + print(f"Using device: {device}") + + # load tokenizer + tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token) + + # IF YOU WANNA QUANTIZE THE MODEL + if quantize: + model = AutoModelForCausalLM.from_pretrained( + base_model, + token=hf_token, + quantization_config=BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=( + torch.bfloat16 if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else torch.float16 + ), + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_type="nf4", + ), + ) + # setup for quantized training + model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True) + else: + model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token, device_map="auto") + # RoAd config for the PEFT model + road_config = RoadConfig( + variant=variant, # Rank of matrix + target_modules=( + road_target_modules.split(",") + if road_target_modules + else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] + ), + ) + + # get the peft model with RoAd config + model = get_peft_model(model, road_config) + + model.to(device) # MODEL TO GPU/CUDA + tokenizer.pad_token = tokenizer.eos_token + + # Load the dataset + dataset = load_dataset(data_path) + + def tokenize_function(examples): + inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len) + inputs["labels"] = inputs["input_ids"].copy() # setting labels for a language modeling task + return inputs + + # Tokenize the dataset and prepare for training + tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names) + + # Data collator to dynamically pad the batched examples + data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False) + + # Define training arguments + training_args = TrainingArguments( + output_dir=output_dir, + num_train_epochs=num_epochs, + per_device_train_batch_size=batch_size, + per_device_eval_batch_size=batch_size, + warmup_steps=100, + weight_decay=0.01, + logging_dir="./logs", + logging_steps=eval_step, + save_steps=save_step, + save_total_limit=2, + push_to_hub=push_to_hub, + hub_model_id=hub_model_id, + gradient_accumulation_steps=16, + fp16=True, + learning_rate=learning_rate, + hub_token=hf_token, + ) + + # Clear CUDA cache to free memory + torch.cuda.empty_cache() + + # Initialize the Trainer + trainer = Trainer( + model=model, + args=training_args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["test"], + data_collator=data_collator, + ) + + # Start model training + trainer.train() + + # Save and push the trained model and tokenizer + if push_to_hub: + # Push the main model to the hub + trainer.push_to_hub(commit_message="Fine-tuned model") + + # Save the model and tokenizer locally + model.save_pretrained(output_dir) + tokenizer.save_pretrained(output_dir) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DoRA and PEFT") + parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name") + parser.add_argument( + "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name" + ) + parser.add_argument( + "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model" + ) + parser.add_argument("--batch_size", type=int, default=1, help="Batch size") + parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs") + parser.add_argument("--learning_rate", type=float, default=3e-3, help="Learning rate") + parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization") + parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size") + parser.add_argument("--quantize", action="store_true", help="Use quantization") + parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval") + parser.add_argument("--save_step", type=int, default=100, help="Save step interval") + parser.add_argument("--device", type=str, default="cuda:0", help="Device to use for training") + parser.add_argument( + "--variant", type=str, default="road_1", choices=["road_1", "road_2", "road_4"], help="RoAD variant" + ) + parser.add_argument( + "--road_target_modules", type=str, default=None, help="Comma-separated list of target modules for RoAd" + ) + parser.add_argument( + "--hub_model_id", + type=str, + default="path/to/repo", + help="Repository name to push the model on the Hugging Face Hub", + ) + parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub") + args = parser.parse_args() + train_model( + base_model=args.base_model, + data_path=args.data_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + val_set_size=args.val_set_size, + quantize=args.quantize, + eval_step=args.eval_step, + save_step=args.save_step, + device=args.device, + variant=args.variant, + road_target_modules=args.road_target_modules, + hub_model_id=args.hub_model_id, + push_to_hub=args.push_to_hub, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/semantic_segmentation/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/semantic_segmentation/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fa23cb02cd6cca1f6e2595e0091dbd912c655ece --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/semantic_segmentation/README.md @@ -0,0 +1,7 @@ +# Fine-tuning for semantic segmentation using LoRA and 🤗 PEFT + +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb) + +We provide a notebook (`semantic_segmentation_peft_lora.ipynb`) where we learn how to use [LoRA](https://huggingface.co/papers/2106.09685) from 🤗 PEFT to fine-tune an semantic segmentation by ONLY using **14%%** of the original trainable parameters of the model. + +LoRA adds low-rank "update matrices" to certain blocks in the underlying model (in this case the attention blocks) and ONLY trains those matrices during fine-tuning. During inference, these update matrices are _merged_ with the original model parameters. For more details, check out the [original LoRA paper](https://huggingface.co/papers/2106.09685). diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..e21503279d32fa25fc2fef95bef29c38d8431ac9 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb @@ -0,0 +1,1556 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "JAeWcsvLF2_6" + }, + "source": [ + "## Introduction\n", + "\n", + "In this notebook, we will learn how to use [LoRA](https://huggingface.co/papers/2106.09685) from 🤗 PEFT to fine-tune a SegFormer model variant for semantic segmentation by ONLY using **14%** of the original trainable parameters of the model. \n", + "\n", + "LoRA adds low-rank \"update matrices\" to certain blocks in the underlying model (in this case the attention blocks) and ONLY trains those matrices during fine-tuning. During inference, these update matrices are _merged_ with the original model parameters. For more details, check out the [original LoRA paper](https://huggingface.co/papers/2106.09685). \n", + "\n", + "Let's get started by installing the dependencies. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lveGHtBcGNyc" + }, + "source": [ + "## Install dependencies\n", + "\n", + "Here we're installing `peft` from source to ensure we have access to all the bleeding edge features of `peft`. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lbYTKXv4ZTwg", + "outputId": "5a033ebd-6bbd-4bf4-802c-a1bac6a48a07" + }, + "outputs": [], + "source": [ + "!pip install transformers accelerate evaluate datasets==3.6.0 git+https://github.com/huggingface/peft -q" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B0fmCvTsGPah" + }, + "source": [ + "## Authentication\n", + "\n", + "We will share our fine-tuned model at the end of training. So, to do that we just authenticate using our 🤗 token. This token is available from [here](https://huggingface.co/settings/tokens). If you don't have a 🤗 account already, we highly encourage you to do so; it's free!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 331, + "referenced_widgets": [ + "f2a722f371904cce80dc1c087b153ad6", + "6c88a55a635b4c9f946a1aa838d69f20", + "6c6d19cd893e4d82bae9972fa10c6d74", + "fc48ee28c2e44f1daa03149c8004c314", + "cb4053f102fc4207a1c9513f81ad6415", + "0dcc5a2866a349e0843673bef499dc66", + "b7431f99d93b4e9b8c8177ac4a7b4070", + "14ac809ba0bc4cd5bcd51f83105947b0", + "e7393e78f41b496495982490b72ef2a3", + "42a7b8268d8945b5bbe9d3f20bc8840c", + "554b55f29a5e4d5a81608d912d3635e8", + "3f69c7b15e5e48039777e4b6b1a51f53", + "5bcfe3da0ffb41ccbb9404ac35ae8945", + "21bf954f54db41e6ba78f76195721614", + "f83dd354396e4aa3acd214a6fd98efb2", + "24fde588dc1a49a397e379cda320ed71", + "9746875e74b845daab06619393b4d46b" + ] + }, + "id": "OYhwMOj5ZTwm", + "outputId": "ff2d4cc4-4363-4093-8bdc-763761cbe3ef" + }, + "outputs": [], + "source": [ + "from huggingface_hub import notebook_login\n", + "\n", + "notebook_login()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B9Cu7j_QGVbH" + }, + "source": [ + "## Load a dataset\n", + "\n", + "We're only loading the first 150 instances from the training set of the [SceneParse150 dataset](https://huggingface.co/datasets/scene_parse_150) to keep this example runtime short. " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sGJWDwtHZTwn", + "outputId": "260c874e-1844-42ba-9dc2-0f727e2930cc" + }, + "outputs": [], + "source": [ + "from datasets import load_dataset\n", + "\n", + "ds = load_dataset(\"scene_parse_150\", split=\"train[:150]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RpSPx8EHGeLM" + }, + "source": [ + "## Prepare train and test splits" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "ydWKIqCUZTwo" + }, + "outputs": [], + "source": [ + "ds = ds.train_test_split(test_size=0.1)\n", + "train_ds = ds[\"train\"]\n", + "test_ds = ds[\"test\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yHtqAQ2WGhlR" + }, + "source": [ + "## Prepare label mappers\n", + "\n", + "We create two dictionaries:\n", + "\n", + "* `label2id`: maps the semantic classes of the dataset to integer ids.\n", + "* `id2label`: `label2id` reversed. " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Hu8Y4dEIZTwq", + "outputId": "eba72235-c1a7-4c95-8c89-5ef5588d6581" + }, + "outputs": [], + "source": [ + "import json\n", + "from huggingface_hub import hf_hub_download\n", + "\n", + "repo_id = \"huggingface/label-files\"\n", + "filename = \"ade20k-id2label.json\"\n", + "id2label = json.load(open(hf_hub_download(repo_id=repo_id, filename=filename, repo_type=\"dataset\"), \"r\"))\n", + "id2label = {int(k): v for k, v in id2label.items()}\n", + "label2id = {v: k for k, v in id2label.items()}\n", + "num_labels = len(id2label)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5V8nhdt0HBsk" + }, + "source": [ + "## Prepare datasets for training and evaluation" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fNi_TKYpZTwq", + "outputId": "a28647b4-0deb-49cc-a1b8-c4a2ab99bb4d" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/dist-packages/transformers/image_processing_base.py:412: UserWarning: The following named arguments are not valid for `SegformerImageProcessor.__init__` and were ignored: 'reduce_labels'\n", + " image_processor = cls(**image_processor_dict)\n" + ] + } + ], + "source": [ + "from transformers import AutoImageProcessor\n", + "\n", + "checkpoint = \"nvidia/mit-b0\"\n", + "image_processor = AutoImageProcessor.from_pretrained(checkpoint, do_reduce_labels=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "id": "JAjiYzklZTwr" + }, + "outputs": [], + "source": [ + "from torchvision.transforms import ColorJitter\n", + "\n", + "jitter = ColorJitter(brightness=0.25, contrast=0.25, saturation=0.25, hue=0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "id": "_HaS12U0ZTwr" + }, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "\n", + "def handle_grayscale_image(image):\n", + " np_image = np.array(image)\n", + " if np_image.ndim == 2:\n", + " tiled_image = np.tile(np.expand_dims(np_image, -1), 3)\n", + " return Image.fromarray(tiled_image)\n", + " else:\n", + " return Image.fromarray(np_image)\n", + "\n", + "\n", + "def train_transforms(example_batch):\n", + " images = [jitter(handle_grayscale_image(x)) for x in example_batch[\"image\"]]\n", + " labels = [x for x in example_batch[\"annotation\"]]\n", + " inputs = image_processor(images, labels)\n", + " return inputs\n", + "\n", + "\n", + "def val_transforms(example_batch):\n", + " images = [handle_grayscale_image(x) for x in example_batch[\"image\"]]\n", + " labels = [x for x in example_batch[\"annotation\"]]\n", + " inputs = image_processor(images, labels)\n", + " return inputs" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "id": "Qyjsvup2ZTws" + }, + "outputs": [], + "source": [ + "train_ds.set_transform(train_transforms)\n", + "test_ds.set_transform(val_transforms)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Lu8RjicxHJiO" + }, + "source": [ + "## Evaluation function\n", + "\n", + "Including a metric during training is often helpful for evaluating your model’s performance. You can quickly load a evaluation method with the [🤗 Evaluate](https://huggingface.co/docs/evaluate/index) library. For this task, load the [mean Intersection over Union (IoU)](https://huggingface.co/spaces/evaluate-metric/accuracy) metric (see the 🤗 Evaluate [quick tour](https://huggingface.co/docs/evaluate/a_quick_tour) to learn more about how to load and compute a metric):" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "id": "TMSnlebfZTwt" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading builder script: 12.9kB [00:00, 34.2MB/s]\n" + ] + } + ], + "source": [ + "import torch\n", + "from torch import nn\n", + "import evaluate\n", + "\n", + "metric = evaluate.load(\"mean_iou\")\n", + "\n", + "\n", + "def compute_metrics(eval_pred):\n", + " with torch.no_grad():\n", + " logits, labels = eval_pred\n", + " logits_tensor = torch.from_numpy(logits)\n", + " # scale the logits to the size of the label\n", + " logits_tensor = nn.functional.interpolate(\n", + " logits_tensor,\n", + " size=labels.shape[-2:],\n", + " mode=\"bilinear\",\n", + " align_corners=False,\n", + " ).argmax(dim=1)\n", + "\n", + " pred_labels = logits_tensor.detach().cpu().numpy()\n", + " # currently using _compute instead of compute\n", + " # see this issue for more info: https://github.com/huggingface/evaluate/pull/328#issuecomment-1286866576\n", + " metrics = metric._compute(\n", + " predictions=pred_labels,\n", + " references=labels,\n", + " num_labels=len(id2label),\n", + " ignore_index=0,\n", + " reduce_labels=image_processor.do_reduce_labels,\n", + " )\n", + "\n", + " # add per category metrics as individual key-value pairs\n", + " per_category_accuracy = metrics.pop(\"per_category_accuracy\").tolist()\n", + " per_category_iou = metrics.pop(\"per_category_iou\").tolist()\n", + "\n", + " metrics.update({f\"accuracy_{id2label[i]}\": v for i, v in enumerate(per_category_accuracy)})\n", + " metrics.update({f\"iou_{id2label[i]}\": v for i, v in enumerate(per_category_iou)})\n", + "\n", + " return metrics" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r304cnpxHxp5" + }, + "source": [ + "## Load a base model\n", + "\n", + "For this example, we use the [SegFormer B0 variant](https://huggingface.co/nvidia/mit-b0). " + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "id": "Krvppe44a_7y" + }, + "outputs": [], + "source": [ + "def print_trainable_parameters(model):\n", + " \"\"\"\n", + " Prints the number of trainable parameters in the model.\n", + " \"\"\"\n", + " trainable_params = 0\n", + " all_param = 0\n", + " for _, param in model.named_parameters():\n", + " all_param += param.numel()\n", + " if param.requires_grad:\n", + " trainable_params += param.numel()\n", + " print(\n", + " f\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param:.2f}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "q_Wwl_ewID9I" + }, + "source": [ + "We pass the `label2id` and `id2label` dictionaries to let the `AutoModelForSemanticSegmentation` class know that we're interested in a custom base model where the decoder head should be randomly initialized w.r.t our custom dataset. Note, however, that the rest of the model parameters are pre-trained and will be fine-tuned in a regular transfer learning setup.\n", + "\n", + "We also notice that the 100% parameters in the `model` are trainable. " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kcdLdvIlZTwt", + "outputId": "a6b71dce-905e-4389-dcf6-46b43e769fcc" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of SegformerForSemanticSegmentation were not initialized from the model checkpoint at nvidia/mit-b0 and are newly initialized: ['decode_head.batch_norm.bias', 'decode_head.batch_norm.num_batches_tracked', 'decode_head.batch_norm.running_mean', 'decode_head.batch_norm.running_var', 'decode_head.batch_norm.weight', 'decode_head.classifier.bias', 'decode_head.classifier.weight', 'decode_head.linear_c.0.proj.bias', 'decode_head.linear_c.0.proj.weight', 'decode_head.linear_c.1.proj.bias', 'decode_head.linear_c.1.proj.weight', 'decode_head.linear_c.2.proj.bias', 'decode_head.linear_c.2.proj.weight', 'decode_head.linear_c.3.proj.bias', 'decode_head.linear_c.3.proj.weight', 'decode_head.linear_fuse.weight']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 3752694 || all params: 3752694 || trainable%: 100.00\n" + ] + } + ], + "source": [ + "from transformers import AutoModelForSemanticSegmentation, TrainingArguments, Trainer\n", + "\n", + "model = AutoModelForSemanticSegmentation.from_pretrained(\n", + " checkpoint, id2label=id2label, label2id=label2id, ignore_mismatched_sizes=True\n", + ")\n", + "print_trainable_parameters(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4yhyYVTCInF0" + }, + "source": [ + "## Wrap `model` as a `PeftModel` for LoRA training\n", + "\n", + "This involves two steps:\n", + "\n", + "* Defining a config with `LoraConfig`\n", + "* Wrapping the original `model` with `get_peft_model()` with the config defined in the step above. " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YPg4W5eFB__n", + "outputId": "9995eb44-1c30-43e7-cc4e-691ecb1b1878" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 566422 || all params: 4317068 || trainable%: 13.12\n" + ] + } + ], + "source": [ + "from peft import LoraConfig, get_peft_model\n", + "\n", + "config = LoraConfig(\n", + " r=32,\n", + " lora_alpha=32,\n", + " target_modules=[\"query\", \"value\"],\n", + " lora_dropout=0.1,\n", + " bias=\"lora_only\",\n", + " modules_to_save=[\"decode_head\"],\n", + ")\n", + "lora_model = get_peft_model(model, config)\n", + "print_trainable_parameters(lora_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4M3wYekOI95X" + }, + "source": [ + " Let's unpack what's going on here. \n", + "\n", + "In order for LoRA to take effect, we need to specify the target modules to `LoraConfig` so that `PeftModel` knows which modules inside our model needs to be amended with LoRA matrices. In this case, we're only interested in targetting the query and value matrices of the attention blocks of the base model. Since the parameters corresponding to these matrices are \"named\" with `query` and `value` respectively, we specify them accordingly in the `target_modules` argument of `LoraConfig`. \n", + "\n", + "We also specify `modules_to_save`. After we wrap our base model `model` with `PeftModel` along with the `config`, we get a new model where only the LoRA parameters are trainable (so-called \"update matrices\") while the pre-trained parameters are kept frozen. These include the parameters of the randomly initialized classifier parameters too. This is NOT we want when fine-tuning the base model on our custom dataset. To ensure that the classifier parameters are also trained, we specify `modules_to_save`. This also ensures that these modules are serialized alongside the LoRA trainable parameters when using utilities like `save_pretrained()` and `push_to_hub()`. \n", + "\n", + "Regarding the other parameters:\n", + "\n", + "* `r`: The dimension used by the LoRA update matrices.\n", + "* `alpha`: Scaling factor.\n", + "* `bias`: Specifying if the `bias` parameters should be trained. `lora_only` denotes only the LoRA `bias` parameters will be trained. \n", + "\n", + "`r` and `alpha` together control the total number of final trainable parameters when using LoRA giving us the flexbility to balance a trade-off between end performance and compute efficiency.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XTF68xfjJEci" + }, + "source": [ + "We can also how many parameters we're actually training. Since we're interested in performing **parameter-efficient fine-tuning**, we should expect to notice a less number of trainable parameters from the `lora_model` in comparison to the original `model` which is indeed the case here. \n", + "\n", + "For sanity, let's also manually verify the modules that are actually trainable in `lora_model`. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PUe1Gzvd1PEP", + "outputId": "7b8ba17f-01fd-4ab4-d703-9a0c01cff31b" + }, + "outputs": [], + "source": [ + "for name, param in lora_model.named_parameters():\n", + " if param.requires_grad:\n", + " print(name, param.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can confirm that only the LoRA parameters appended to the attention blocks and the `decode_head` parameters are trainable." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rX75AyI7JYVC" + }, + "source": [ + "## Train!\n", + "\n", + "This is a two-step process: \n", + "\n", + "1. Define your training hyperparameters in [TrainingArguments](https://huggingface.co/docs/transformers/v4.26.0/en/main_classes/trainer#transformers.TrainingArguments). It is important you don’t remove unused columns because this’ll drop the image column. Without the image column, you can’t create `pixel_values`. Set `remove_unused_columns=False` to prevent this behavior! The only other required parameter is output_dir which specifies where to save your model. At the end of each epoch, the `Trainer` will evaluate the IoU metric and save the training checkpoint.\n", + "2. Pass the training arguments to [Trainer](https://huggingface.co/docs/transformers/v4.26.0/en/main_classes/trainer#transformers.Trainer) along with the model, dataset, tokenizer, data collator, and `compute_metrics` function.\n", + "3. Call `train()` to finetune your model.\n", + "\n", + "\n", + "**Note** that This example is meant to walk you through the workflow when using PEFT for semantic segmentation. We didn't perform extensive hyperparameter tuning to achieve optimal results. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "K6HVcNkDZTwu", + "outputId": "1b28a072-0e16-4b1a-ec32-d78e93630ef3" + }, + "outputs": [], + "source": [ + "model_name = checkpoint.split(\"/\")[-1]\n", + "\n", + "training_args = TrainingArguments(\n", + " output_dir=f\"{model_name}-scene-parse-150-lora\",\n", + " learning_rate=5e-4,\n", + " num_train_epochs=50,\n", + " per_device_train_batch_size=4,\n", + " per_device_eval_batch_size=2,\n", + " save_total_limit=3,\n", + " eval_strategy=\"epoch\",\n", + " save_strategy=\"epoch\",\n", + " logging_steps=5,\n", + " remove_unused_columns=False,\n", + " push_to_hub=True,\n", + " label_names=[\"labels\"],\n", + ")\n", + "\n", + "trainer = Trainer(\n", + " model=lora_model,\n", + " args=training_args,\n", + " train_dataset=train_ds,\n", + " eval_dataset=test_ds,\n", + " compute_metrics=compute_metrics,\n", + ")\n", + "\n", + "trainer.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dacaBLE6KLdu" + }, + "source": [ + "## Saving the model and inference \n", + "\n", + "Here we use the `save_pretrained()` method of the `lora_model` to save the *LoRA-only parameters* locally. However, you can also use thr `push_to_hub()` method to upload these parameters directly to the Hugging Face Hub (as shown [here](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/image_classification/image_classification_peft_lora.ipynb)). " + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "id": "pvkLkrQo-6l6" + }, + "outputs": [], + "source": [ + "model_id = \"segformer-scene-parse-150-lora\"\n", + "lora_model.save_pretrained(model_id)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ur8n41kBK4uj" + }, + "source": [ + "We can see that the LoRA-only parameters are just **2.2 MB in size**! This greatly improves the portability when using very large models. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "grzLeOT-__ht", + "outputId": "1ce26a27-2f38-43f3-9454-8ba11f2cfc59" + }, + "outputs": [], + "source": [ + "!ls -lh {model_id}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KFYC6Z3FLB5F" + }, + "source": [ + "Let's now prepare our `inference_model` and run an inference. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "T7zeMQTaACur", + "outputId": "762b7fbc-07d4-4572-f107-c836e3e7928a" + }, + "outputs": [], + "source": [ + "from peft import PeftConfig, PeftModel\n", + "\n", + "config = PeftConfig.from_pretrained(model_id)\n", + "model = AutoModelForSemanticSegmentation.from_pretrained(\n", + " checkpoint, id2label=id2label, label2id=label2id, ignore_mismatched_sizes=True\n", + ")\n", + "# Load the Lora model\n", + "inference_model = PeftModel.from_pretrained(model, model_id)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2L1R0LDWLImd" + }, + "source": [ + "Fetch an image." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 444 + }, + "id": "lwjRvZOmA7Hh", + "outputId": "44ab267d-e2b9-4bda-a52b-91968eabce29" + }, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import requests\n", + "\n", + "url = \"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/semantic-seg-image.png\"\n", + "image = Image.open(requests.get(url, stream=True).raw)\n", + "image" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kdK_bGhsLKKE" + }, + "source": [ + "Preprocess the image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "G0z-3R-PBKc9", + "outputId": "56c91198-0116-4c2c-fc63-147dc7431b89" + }, + "outputs": [], + "source": [ + "# prepare image for the model\n", + "encoding = image_processor(image.convert(\"RGB\"), return_tensors=\"pt\")\n", + "print(encoding.pixel_values.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hJRijta4LLu9" + }, + "source": [ + "Run an inference. " + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "id": "z1p-QDoiBP56" + }, + "outputs": [], + "source": [ + "with torch.no_grad():\n", + " outputs = inference_model(pixel_values=encoding.pixel_values)\n", + " logits = outputs.logits\n", + "\n", + "upsampled_logits = nn.functional.interpolate(\n", + " logits,\n", + " size=image.size[::-1],\n", + " mode=\"bilinear\",\n", + " align_corners=False,\n", + ")\n", + "\n", + "pred_seg = upsampled_logits.argmax(dim=1)[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gmYIcfL4LNtj" + }, + "source": [ + "Visualize the results.\n", + "\n", + "We need a color palette to visualize the results. Here, we use [one provided by the TensorFlow Model Garden repository](https://github.com/tensorflow/models/blob/3f1ca33afe3c1631b733ea7e40c294273b9e406d/research/deeplab/utils/get_dataset_colormap.py#L51)." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "id": "jy5c6vmzBqzC" + }, + "outputs": [], + "source": [ + "def ade_palette():\n", + " \"\"\"Creates a label colormap used in ADE20K segmentation benchmark.\n", + " Returns:\n", + " A colormap for visualizing segmentation results.\n", + " \"\"\"\n", + " return np.asarray(\n", + " [\n", + " [0, 0, 0],\n", + " [120, 120, 120],\n", + " [180, 120, 120],\n", + " [6, 230, 230],\n", + " [80, 50, 50],\n", + " [4, 200, 3],\n", + " [120, 120, 80],\n", + " [140, 140, 140],\n", + " [204, 5, 255],\n", + " [230, 230, 230],\n", + " [4, 250, 7],\n", + " [224, 5, 255],\n", + " [235, 255, 7],\n", + " [150, 5, 61],\n", + " [120, 120, 70],\n", + " [8, 255, 51],\n", + " [255, 6, 82],\n", + " [143, 255, 140],\n", + " [204, 255, 4],\n", + " [255, 51, 7],\n", + " [204, 70, 3],\n", + " [0, 102, 200],\n", + " [61, 230, 250],\n", + " [255, 6, 51],\n", + " [11, 102, 255],\n", + " [255, 7, 71],\n", + " [255, 9, 224],\n", + " [9, 7, 230],\n", + " [220, 220, 220],\n", + " [255, 9, 92],\n", + " [112, 9, 255],\n", + " [8, 255, 214],\n", + " [7, 255, 224],\n", + " [255, 184, 6],\n", + " [10, 255, 71],\n", + " [255, 41, 10],\n", + " [7, 255, 255],\n", + " [224, 255, 8],\n", + " [102, 8, 255],\n", + " [255, 61, 6],\n", + " [255, 194, 7],\n", + " [255, 122, 8],\n", + " [0, 255, 20],\n", + " [255, 8, 41],\n", + " [255, 5, 153],\n", + " [6, 51, 255],\n", + " [235, 12, 255],\n", + " [160, 150, 20],\n", + " [0, 163, 255],\n", + " [140, 140, 140],\n", + " [250, 10, 15],\n", + " [20, 255, 0],\n", + " [31, 255, 0],\n", + " [255, 31, 0],\n", + " [255, 224, 0],\n", + " [153, 255, 0],\n", + " [0, 0, 255],\n", + " [255, 71, 0],\n", + " [0, 235, 255],\n", + " [0, 173, 255],\n", + " [31, 0, 255],\n", + " [11, 200, 200],\n", + " [255, 82, 0],\n", + " [0, 255, 245],\n", + " [0, 61, 255],\n", + " [0, 255, 112],\n", + " [0, 255, 133],\n", + " [255, 0, 0],\n", + " [255, 163, 0],\n", + " [255, 102, 0],\n", + " [194, 255, 0],\n", + " [0, 143, 255],\n", + " [51, 255, 0],\n", + " [0, 82, 255],\n", + " [0, 255, 41],\n", + " [0, 255, 173],\n", + " [10, 0, 255],\n", + " [173, 255, 0],\n", + " [0, 255, 153],\n", + " [255, 92, 0],\n", + " [255, 0, 255],\n", + " [255, 0, 245],\n", + " [255, 0, 102],\n", + " [255, 173, 0],\n", + " [255, 0, 20],\n", + " [255, 184, 184],\n", + " [0, 31, 255],\n", + " [0, 255, 61],\n", + " [0, 71, 255],\n", + " [255, 0, 204],\n", + " [0, 255, 194],\n", + " [0, 255, 82],\n", + " [0, 10, 255],\n", + " [0, 112, 255],\n", + " [51, 0, 255],\n", + " [0, 194, 255],\n", + " [0, 122, 255],\n", + " [0, 255, 163],\n", + " [255, 153, 0],\n", + " [0, 255, 10],\n", + " [255, 112, 0],\n", + " [143, 255, 0],\n", + " [82, 0, 255],\n", + " [163, 255, 0],\n", + " [255, 235, 0],\n", + " [8, 184, 170],\n", + " [133, 0, 255],\n", + " [0, 255, 92],\n", + " [184, 0, 255],\n", + " [255, 0, 31],\n", + " [0, 184, 255],\n", + " [0, 214, 255],\n", + " [255, 0, 112],\n", + " [92, 255, 0],\n", + " [0, 224, 255],\n", + " [112, 224, 255],\n", + " [70, 184, 160],\n", + " [163, 0, 255],\n", + " [153, 0, 255],\n", + " [71, 255, 0],\n", + " [255, 0, 163],\n", + " [255, 204, 0],\n", + " [255, 0, 143],\n", + " [0, 255, 235],\n", + " [133, 255, 0],\n", + " [255, 0, 235],\n", + " [245, 0, 255],\n", + " [255, 0, 122],\n", + " [255, 245, 0],\n", + " [10, 190, 212],\n", + " [214, 255, 0],\n", + " [0, 204, 255],\n", + " [20, 0, 255],\n", + " [255, 255, 0],\n", + " [0, 153, 255],\n", + " [0, 41, 255],\n", + " [0, 255, 204],\n", + " [41, 0, 255],\n", + " [41, 255, 0],\n", + " [173, 0, 255],\n", + " [0, 245, 255],\n", + " [71, 0, 255],\n", + " [122, 0, 255],\n", + " [0, 255, 184],\n", + " [0, 92, 255],\n", + " [184, 255, 0],\n", + " [0, 133, 255],\n", + " [255, 214, 0],\n", + " [25, 194, 194],\n", + " [102, 255, 0],\n", + " [92, 0, 255],\n", + " ]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 595 + }, + "id": "3KJFvgENBih0", + "outputId": "63d42e4f-3867-4d33-8ac0-83bebf8819ca" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "color_seg = np.zeros((pred_seg.shape[0], pred_seg.shape[1], 3), dtype=np.uint8)\n", + "palette = np.array(ade_palette())\n", + "\n", + "for label, color in enumerate(palette):\n", + " color_seg[pred_seg == label, :] = color\n", + "color_seg = color_seg[..., ::-1] # convert to BGR\n", + "\n", + "img = np.array(image) * 0.5 + color_seg * 0.5 # plot the image with the segmentation map\n", + "img = img.astype(np.uint8)\n", + "\n", + "plt.figure(figsize=(15, 10))\n", + "plt.imshow(img)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "q1aGuHYFLP7i" + }, + "source": [ + "The results are definitely not as expected and as mentioned above, this example is not meant to provide a state-of-the-art model. It exists to familiarize you with the end-to-end workflow. \n", + "\n", + "On the other hand, if you perform full fine-tuning on the same setup (same model variant, same dataset, same training schedule, etc.), the results would not have been any different. This is a crucial aspect of parameter-efficient fine-tuning -- to be able to match up to the results of the full fine-tuning but with a fraction of total trainable parameters. \n", + "\n", + "Here are some things that you can try to get better results:\n", + "\n", + "* Increase the number of training samples. \n", + "* Try a larger SegFormer model variant (know about the available model variants [here](https://huggingface.co/models?search=segformer)). \n", + "* Try different values for the arguments available in `LoraConfig`. \n", + "* Tune the learning rate and batch size. " + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "machine_shape": "hm", + "provenance": [] + }, + "gpuClass": "premium", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "0dcc5a2866a349e0843673bef499dc66": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_24fde588dc1a49a397e379cda320ed71", + "placeholder": "​", + "style": "IPY_MODEL_9746875e74b845daab06619393b4d46b", + "value": "\nPro Tip: If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. " + } + }, + "14ac809ba0bc4cd5bcd51f83105947b0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21bf954f54db41e6ba78f76195721614": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "24fde588dc1a49a397e379cda320ed71": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f69c7b15e5e48039777e4b6b1a51f53": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42a7b8268d8945b5bbe9d3f20bc8840c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "554b55f29a5e4d5a81608d912d3635e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5bcfe3da0ffb41ccbb9404ac35ae8945": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6c6d19cd893e4d82bae9972fa10c6d74": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "PasswordModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "PasswordModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "PasswordView", + "continuous_update": true, + "description": "Token:", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_42a7b8268d8945b5bbe9d3f20bc8840c", + "placeholder": "​", + "style": "IPY_MODEL_554b55f29a5e4d5a81608d912d3635e8", + "value": "" + } + }, + "6c88a55a635b4c9f946a1aa838d69f20": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_14ac809ba0bc4cd5bcd51f83105947b0", + "placeholder": "​", + "style": "IPY_MODEL_e7393e78f41b496495982490b72ef2a3", + "value": "

Copy a token from your Hugging Face\ntokens page and paste it below.
Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file.
" + } + }, + "9746875e74b845daab06619393b4d46b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b7431f99d93b4e9b8c8177ac4a7b4070": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": "center", + "align_self": null, + "border": null, + "bottom": null, + "display": "flex", + "flex": null, + "flex_flow": "column", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "50%" + } + }, + "cb4053f102fc4207a1c9513f81ad6415": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ButtonView", + "button_style": "", + "description": "Login", + "disabled": false, + "icon": "", + "layout": "IPY_MODEL_21bf954f54db41e6ba78f76195721614", + "style": "IPY_MODEL_f83dd354396e4aa3acd214a6fd98efb2", + "tooltip": "" + } + }, + "e7393e78f41b496495982490b72ef2a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f2a722f371904cce80dc1c087b153ad6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6c88a55a635b4c9f946a1aa838d69f20", + "IPY_MODEL_6c6d19cd893e4d82bae9972fa10c6d74", + "IPY_MODEL_fc48ee28c2e44f1daa03149c8004c314", + "IPY_MODEL_cb4053f102fc4207a1c9513f81ad6415", + "IPY_MODEL_0dcc5a2866a349e0843673bef499dc66" + ], + "layout": "IPY_MODEL_b7431f99d93b4e9b8c8177ac4a7b4070" + } + }, + "f83dd354396e4aa3acd214a6fd98efb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "button_color": null, + "font_weight": "" + } + }, + "fc48ee28c2e44f1daa03149c8004c314": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "CheckboxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "CheckboxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "CheckboxView", + "description": "Add token as git credential?", + "description_tooltip": null, + "disabled": false, + "indent": true, + "layout": "IPY_MODEL_3f69c7b15e5e48039777e4b6b1a51f53", + "style": "IPY_MODEL_5bcfe3da0ffb41ccbb9404ac35ae8945", + "value": true + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sequence_classification/C3A.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sequence_classification/C3A.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..dbd8282a76cb3e4655d63b2e4411c4c0bd3dd3dc --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sequence_classification/C3A.ipynb @@ -0,0 +1,512 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d36e1e93-ae93-4a4e-93c6-68fd868d2882", + "metadata": {}, + "source": [ + "# Using C3A for sequence classification" + ] + }, + { + "cell_type": "markdown", + "id": "ddfc0610-55f6-4343-a950-125ccf0f45ac", + "metadata": {}, + "source": [ + "In this example, we fine-tune Roberta (base) on a sequence classification task using C3A." + ] + }, + { + "cell_type": "markdown", + "id": "45addd81-d4f3-4dfd-960d-3920d347f0a6", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a9935ae2", + "metadata": {}, + "outputs": [], + "source": [ + "# To run this notebook, please run `pip install evaluate` to install additional dependencies not covered by PEFT.\n", + "import torch\n", + "from torch.optim import AdamW\n", + "from torch.utils.data import DataLoader\n", + "from peft import (\n", + " get_peft_model,\n", + " C3AConfig,\n", + " PeftType,\n", + ")\n", + "from peft.utils import infer_device\n", + "\n", + "import evaluate\n", + "from datasets import load_dataset\n", + "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed, AutoConfig\n", + "from tqdm import tqdm" + ] + }, + { + "cell_type": "markdown", + "id": "62c959bf-7cc2-49e0-b97e-4c10ec3b9bf3", + "metadata": {}, + "source": [ + "## Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3b13308", + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 32\n", + "model_name_or_path = \"roberta-base\"\n", + "task = \"mrpc\"\n", + "peft_type = PeftType.C3A\n", + "device = infer_device()\n", + "num_epochs = 5 # for better results, increase this number\n", + "block_size = 768 # for better results, increase this number\n", + "max_length = 512\n", + "torch.manual_seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0526f571", + "metadata": {}, + "outputs": [], + "source": [ + "peft_config = C3AConfig(\n", + " task_type=\"SEQ_CLS\", \n", + " block_size=block_size,\n", + " target_modules=[\"query\", \"value\"],\n", + ")\n", + "head_lr = 4e-6 # the learning rate for the classification head for NLU tasks\n", + "ft_lr = 3e-1 # the learning rate for C3A parameters, a much larger LR than that is usually used, at least 1e-1" + ] + }, + { + "cell_type": "markdown", + "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972", + "metadata": {}, + "source": [ + "## Loading data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139", + "metadata": {}, + "outputs": [], + "source": [ + "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n", + " padding_side = \"left\"\n", + "else:\n", + " padding_side = \"right\"\n", + "\n", + "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n", + "if getattr(tokenizer, \"pad_token_id\") is None:\n", + " tokenizer.pad_token_id = tokenizer.eos_token_id" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6", + "metadata": {}, + "outputs": [], + "source": [ + "datasets = load_dataset(\"glue\", task)\n", + "metric = evaluate.load(\"glue\", task)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0209f778-c93b-40eb-a4e0-24c25db03980", + "metadata": {}, + "outputs": [], + "source": [ + "def tokenize_function(examples):\n", + " # max_length=None => use the model max length (it's actually the default)\n", + " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n", + " return outputs\n", + "\n", + "\n", + "tokenized_datasets = datasets.map(\n", + " tokenize_function,\n", + " batched=True,\n", + " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n", + ")\n", + "\n", + "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n", + "# transformers library\n", + "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7453954e-982c-46f0-b09c-589776e6d6cb", + "metadata": {}, + "outputs": [], + "source": [ + "def collate_fn(examples):\n", + " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n", + "\n", + "\n", + "# Instantiate dataloaders.\n", + "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n", + "eval_dataloader = DataLoader(\n", + " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea", + "metadata": {}, + "source": [ + "## Preparing the C3A model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2ed5ac74", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 610,562 || all params: 125,257,732 || trainable%: 0.4874\n" + ] + } + ], + "source": [ + "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0d2d0381", + "metadata": {}, + "outputs": [], + "source": [ + "head_param = list(map(id, model.classifier.parameters()))\n", + "\n", + "others_param = filter(lambda p: id(p) not in head_param, model.parameters()) \n", + "\n", + "optimizer = AdamW([\n", + " {\"params\": model.classifier.parameters(), \"lr\": head_lr},\n", + " {\"params\": others_param, \"lr\": ft_lr}\n", + "],weight_decay=0.)\n", + "\n", + "\n", + "# Instantiate scheduler\n", + "lr_scheduler = get_linear_schedule_with_warmup(\n", + " optimizer=optimizer,\n", + " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n", + " num_training_steps=(len(train_dataloader) * num_epochs),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fa0e73be", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/115 [00:00" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch_size = 32\n", + "model_name_or_path = \"roberta-base\"\n", + "task = \"mrpc\"\n", + "peft_type = PeftType.FOURIERFT\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "num_epochs = 5 # for better results, increase this number\n", + "n_frequency = 1000 # for better results, increase this number\n", + "scaling = 150.0\n", + "max_length = 512\n", + "torch.manual_seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0526f571", + "metadata": {}, + "outputs": [], + "source": [ + "peft_config = FourierFTConfig(\n", + " task_type=\"SEQ_CLS\", \n", + " n_frequency=n_frequency,\n", + " target_modules=[\"query\", \"value\"],\n", + " scaling = scaling,\n", + ")\n", + "head_lr = 6e-3 # the learning rate for the classification head for NLU tasks\n", + "fft_lr = 6e-2 # the learning rate for the parameters other than the classification head (q,v in this case)" + ] + }, + { + "cell_type": "markdown", + "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972", + "metadata": {}, + "source": [ + "## Loading data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139", + "metadata": {}, + "outputs": [], + "source": [ + "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n", + " padding_side = \"left\"\n", + "else:\n", + " padding_side = \"right\"\n", + "\n", + "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n", + "if getattr(tokenizer, \"pad_token_id\") is None:\n", + " tokenizer.pad_token_id = tokenizer.eos_token_id" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6", + "metadata": {}, + "outputs": [], + "source": [ + "datasets = load_dataset(\"glue\", task)\n", + "metric = evaluate.load(\"glue\", task)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0209f778-c93b-40eb-a4e0-24c25db03980", + "metadata": {}, + "outputs": [], + "source": [ + "def tokenize_function(examples):\n", + " # max_length=None => use the model max length (it's actually the default)\n", + " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n", + " return outputs\n", + "\n", + "\n", + "tokenized_datasets = datasets.map(\n", + " tokenize_function,\n", + " batched=True,\n", + " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n", + ")\n", + "\n", + "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n", + "# transformers library\n", + "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7453954e-982c-46f0-b09c-589776e6d6cb", + "metadata": {}, + "outputs": [], + "source": [ + "def collate_fn(examples):\n", + " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n", + "\n", + "\n", + "# Instantiate dataloaders.\n", + "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n", + "eval_dataloader = DataLoader(\n", + " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea", + "metadata": {}, + "source": [ + "## Preparing the FourierFT model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2ed5ac74", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 616,130 || all params: 125,263,300 || trainable%: 0.4919\n" + ] + } + ], + "source": [ + "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0d2d0381", + "metadata": {}, + "outputs": [], + "source": [ + "head_param = list(map(id, model.classifier.parameters()))\n", + "\n", + "others_param = filter(lambda p: id(p) not in head_param, model.parameters()) \n", + "\n", + "optimizer = AdamW([\n", + " {\"params\": model.classifier.parameters(), \"lr\": head_lr},\n", + " {\"params\": others_param, \"lr\": fft_lr}\n", + "],weight_decay=0.)\n", + "\n", + "\n", + "# Instantiate scheduler\n", + "lr_scheduler = get_linear_schedule_with_warmup(\n", + " optimizer=optimizer,\n", + " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n", + " num_training_steps=(len(train_dataloader) * num_epochs),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fa0e73be", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/115 [00:00 use the model max length (it's actually the default)\n", + " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n", + " return outputs\n", + "\n", + "\n", + "tokenized_datasets = datasets.map(\n", + " tokenize_function,\n", + " batched=True,\n", + " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n", + ")\n", + "\n", + "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n", + "# transformers library\n", + "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n", + "\n", + "\n", + "def collate_fn(examples):\n", + " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n", + "\n", + "\n", + "# Instantiate dataloaders.\n", + "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n", + "eval_dataloader = DataLoader(\n", + " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n", + ")\n", + "test_dataloader = DataLoader(tokenized_datasets[\"test\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2ed5ac74", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "0cecb897c86c4892b94a1990ab08a926", + "b8af0294819e4280ad41fa1c11006adf", + "c7530d63b2f745e799713284abacbd2c", + "12a1e302a69543c5bc0e0a66be008ca0", + "9c372e9e9b20433faed8530ca0f4424c", + "b07f26a21325493cac19113f1aa1ee96", + "fbdf6c544fb54294903524a69384e773", + "6c6f2223243b4a7485aef7fbbfe07668", + "a93509d61ac94628a74bc0f98c0eec06", + "3a8de0eb7db44647a734590b6b351b44", + "64d8affd2e854a1c9043fec7ca8a2796" + ] + }, + "id": "2ed5ac74", + "outputId": "18ea15ac-ed8d-4d80-b166-706681ee49ab" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0cecb897c86c4892b94a1990ab08a926", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading model.safetensors: 0%| | 0.00/1.42G [00:00 use the model max length (it's actually the default)\n", + " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n", + " return outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cf5ef289-f42f-4582-bd5e-9852ad8beff2", + "metadata": {}, + "outputs": [], + "source": [ + "tokenized_datasets = datasets.map(\n", + " tokenize_function,\n", + " batched=True,\n", + " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n", + ")\n", + "\n", + "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n", + "# transformers library\n", + "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "739b3655-9db0-48bc-8542-308c6d5e0b8b", + "metadata": {}, + "outputs": [], + "source": [ + "def collate_fn(examples):\n", + " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0288f311-8475-4a0e-99af-e4b909d10e01", + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate dataloaders.\n", + "train_dataloader = DataLoader(\n", + " tokenized_datasets[\"train\"],\n", + " shuffle=True,\n", + " collate_fn=collate_fn,\n", + " batch_size=batch_size,\n", + ")\n", + "eval_dataloader = DataLoader(\n", + " tokenized_datasets[\"validation\"],\n", + " shuffle=False,\n", + " collate_fn=collate_fn,\n", + " batch_size=batch_size,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "fcaf6f9e-c9d1-445a-9f08-18ef462f67ce", + "metadata": {}, + "source": [ + "## Model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e5dfff56-ea80-4561-aeaf-43216bbb9af7", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2ac42f98e60d412496fe77ed7eb5c6df", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading checkpoint shards: 0%| | 0/3 [00:00, weight=AffineQuantizedTensor(shape=torch.Size([2048, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n", + " (lora_dropout): ModuleDict(\n", + " (default): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (lora_A): ModuleDict(\n", + " (default): Linear(in_features=2304, out_features=16, bias=False)\n", + " )\n", + " (lora_B): ModuleDict(\n", + " (default): Linear(in_features=16, out_features=2048, bias=False)\n", + " )\n", + " (lora_embedding_A): ParameterDict()\n", + " (lora_embedding_B): ParameterDict()\n", + " (lora_magnitude_vector): ModuleDict()\n", + " )\n", + " (k_proj): Linear(in_features=2304, out_features=1024, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([1024, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n", + " (v_proj): lora.TorchaoLoraLinear(\n", + " (base_layer): Linear(in_features=2304, out_features=1024, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([1024, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n", + " (lora_dropout): ModuleDict(\n", + " (default): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (lora_A): ModuleDict(\n", + " (default): Linear(in_features=2304, out_features=16, bias=False)\n", + " )\n", + " (lora_B): ModuleDict(\n", + " (default): Linear(in_features=16, out_features=1024, bias=False)\n", + " )\n", + " (lora_embedding_A): ParameterDict()\n", + " (lora_embedding_B): ParameterDict()\n", + " (lora_magnitude_vector): ModuleDict()\n", + " )\n", + " (o_proj): Linear(in_features=2048, out_features=2304, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([2304, 2048]), block_size=(1, 2048), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n", + " (rotary_emb): Gemma2RotaryEmbedding()\n", + " )\n", + " (mlp): Gemma2MLP(\n", + " (gate_proj): Linear(in_features=2304, out_features=9216, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([9216, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n", + " (up_proj): Linear(in_features=2304, out_features=9216, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([9216, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n", + " (down_proj): Linear(in_features=9216, out_features=2304, weight=LinearActivationQuantizedTensor(activation=, weight=AffineQuantizedTensor(shape=torch.Size([2304, 9216]), block_size=(1, 9216), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n", + " (act_fn): PytorchGELUTanh()\n", + " )\n", + " (input_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n", + " (post_attention_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n", + " (pre_feedforward_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n", + " (post_feedforward_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n", + " )\n", + " )\n", + " (norm): Gemma2RMSNorm((2304,), eps=1e-06)\n", + " )\n", + " (score): ModulesToSaveWrapper(\n", + " (original_module): Linear(in_features=2304, out_features=2, bias=False)\n", + " (modules_to_save): ModuleDict(\n", + " (default): Linear(in_features=2304, out_features=2, bias=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + ")" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.config.use_cache = False\n", + "model.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "fa0e73be", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/230 [00:00 use the model max length (it's actually the default)\n", + " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n", + " return outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cf5ef289-f42f-4582-bd5e-9852ad8beff2", + "metadata": {}, + "outputs": [], + "source": [ + "tokenized_datasets = datasets.map(\n", + " tokenize_function,\n", + " batched=True,\n", + " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n", + ")\n", + "\n", + "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n", + "# transformers library\n", + "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "739b3655-9db0-48bc-8542-308c6d5e0b8b", + "metadata": {}, + "outputs": [], + "source": [ + "def collate_fn(examples):\n", + " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0288f311-8475-4a0e-99af-e4b909d10e01", + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate dataloaders.\n", + "train_dataloader = DataLoader(\n", + " tokenized_datasets[\"train\"],\n", + " shuffle=True,\n", + " collate_fn=collate_fn,\n", + " batch_size=batch_size,\n", + ")\n", + "eval_dataloader = DataLoader(\n", + " tokenized_datasets[\"validation\"],\n", + " shuffle=False,\n", + " collate_fn=collate_fn,\n", + " batch_size=batch_size,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "fcaf6f9e-c9d1-445a-9f08-18ef462f67ce", + "metadata": {}, + "source": [ + "## Model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e5dfff56-ea80-4561-aeaf-43216bbb9af7", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "512d9dc10a4d4ecc88b9440575b0973a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading checkpoint shards: 0%| | 0/3 [00:00 use the model max length (it's actually the default)\n", + " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n", + " return outputs\n", + "\n", + "\n", + "tokenized_datasets = datasets.map(\n", + " tokenize_function,\n", + " batched=True,\n", + " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n", + ")\n", + "\n", + "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n", + "# transformers library\n", + "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n", + "\n", + "\n", + "def collate_fn(examples):\n", + " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n", + "\n", + "\n", + "# Instantiate dataloaders.\n", + "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n", + "eval_dataloader = DataLoader(\n", + " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2ed5ac74", + "metadata": {}, + "outputs": [], + "source": [ + "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0d2d0381", + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = AdamW(params=model.parameters(), lr=lr)\n", + "\n", + "# Instantiate scheduler\n", + "lr_scheduler = get_linear_schedule_with_warmup(\n", + " optimizer=optimizer,\n", + " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n", + " num_training_steps=(len(train_dataloader) * num_epochs),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fa0e73be", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/115 [00:00 use the model max length (it's actually the default)\n", + " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n", + " return outputs\n", + "\n", + "\n", + "tokenized_datasets = datasets.map(\n", + " tokenize_function,\n", + " batched=True,\n", + " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n", + ")\n", + "\n", + "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n", + "# transformers library\n", + "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n", + "\n", + "\n", + "def collate_fn(examples):\n", + " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n", + "\n", + "\n", + "# Instantiate dataloaders.\n", + "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n", + "eval_dataloader = DataLoader(\n", + " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f6bc8144", + "metadata": {}, + "outputs": [], + "source": [ + "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "af41c571", + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = AdamW(params=model.parameters(), lr=lr)\n", + "\n", + "# Instantiate scheduler\n", + "lr_scheduler = get_linear_schedule_with_warmup(\n", + " optimizer=optimizer,\n", + " num_warmup_steps=0, # 0.06*(len(train_dataloader) * num_epochs),\n", + " num_training_steps=(len(train_dataloader) * num_epochs),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "90993c93", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/115 [00:00 use the model max length (it's actually the default)\n", + " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n", + " return outputs\n", + "\n", + "\n", + "tokenized_datasets = datasets.map(\n", + " tokenize_function,\n", + " batched=True,\n", + " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n", + ")\n", + "\n", + "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n", + "# transformers library\n", + "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n", + "\n", + "\n", + "def collate_fn(examples):\n", + " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n", + "\n", + "\n", + "# Instantiate dataloaders.\n", + "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n", + "eval_dataloader = DataLoader(\n", + " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3c15af0", + "metadata": {}, + "outputs": [], + "source": [ + "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6d3c5edb", + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = AdamW(params=model.parameters(), lr=lr)\n", + "\n", + "# Instantiate scheduler\n", + "lr_scheduler = get_linear_schedule_with_warmup(\n", + " optimizer=optimizer,\n", + " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n", + " num_training_steps=(len(train_dataloader) * num_epochs),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4d279225", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/115 [00:00" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch_size = 32\n", + "model_name_or_path = \"roberta-large\"\n", + "task = \"mrpc\"\n", + "peft_type = PeftType.VBLORA\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "num_epochs = 20\n", + "rank = 4\n", + "max_length = 128\n", + "num_vectors = 90\n", + "vector_length = 256\n", + "torch.manual_seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0526f571", + "metadata": {}, + "outputs": [], + "source": [ + "peft_config = VBLoRAConfig(\n", + " task_type=\"SEQ_CLS\", \n", + " r=rank,\n", + " topk=2,\n", + " target_modules=['key', 'value', 'query', 'output.dense', 'intermediate.dense'],\n", + " num_vectors=num_vectors,\n", + " vector_length=vector_length,\n", + " save_only_topk_weights=True, # Set to True to reduce storage space. Note that the saved parameters cannot be used to resume training from checkpoints.\n", + " vblora_dropout=0.,\n", + ")\n", + "head_lr = 4e-3\n", + "vector_bank_lr = 1e-3\n", + "logits_lr = 1e-2" + ] + }, + { + "cell_type": "markdown", + "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972", + "metadata": {}, + "source": [ + "## Loading data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139", + "metadata": {}, + "outputs": [], + "source": [ + "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n", + " padding_side = \"left\"\n", + "else:\n", + " padding_side = \"right\"\n", + "\n", + "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n", + "if getattr(tokenizer, \"pad_token_id\") is None:\n", + " tokenizer.pad_token_id = tokenizer.eos_token_id" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6", + "metadata": {}, + "outputs": [], + "source": [ + "datasets = load_dataset(\"glue\", task)\n", + "metric = evaluate.load(\"glue\", task)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0209f778-c93b-40eb-a4e0-24c25db03980", + "metadata": {}, + "outputs": [], + "source": [ + "def tokenize_function(examples):\n", + " # max_length=None => use the model max length (it's actually the default)\n", + " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n", + " return outputs\n", + "\n", + "\n", + "tokenized_datasets = datasets.map(\n", + " tokenize_function,\n", + " batched=True,\n", + " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n", + ")\n", + "\n", + "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n", + "# transformers library\n", + "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7453954e-982c-46f0-b09c-589776e6d6cb", + "metadata": {}, + "outputs": [], + "source": [ + "def collate_fn(examples):\n", + " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n", + "\n", + "\n", + "# Instantiate dataloaders.\n", + "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n", + "eval_dataloader = DataLoader(\n", + " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea", + "metadata": {}, + "source": [ + "## Preparing the VB-LoRA model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2ed5ac74", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-large and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 1,696,770 || all params: 357,058,564 || trainable%: 0.4752\n", + "VB-LoRA params to-be-saved (float32-equivalent): 33,408 || total params to-be-saved: 1,085,058\n" + ] + } + ], + "source": [ + "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()\n", + "model.print_savable_parameters()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0d2d0381", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from transformers.pytorch_utils import ALL_LAYERNORM_LAYERS\n", + "from transformers.trainer_pt_utils import get_parameter_names\n", + "\n", + "decay_parameters = get_parameter_names(model, ALL_LAYERNORM_LAYERS)\n", + "decay_parameters = [name for name in decay_parameters if \"bias\" not in name]\n", + "vector_bank_parameters = [name for name, _ in model.named_parameters() if \"vector_bank\" in name]\n", + "logits_parameters = [name for name, _ in model.named_parameters() if \"logits\" in name ]\n", + "\n", + "optimizer_grouped_parameters = [\n", + " {\n", + " \"params\": [p for n, p in model.named_parameters() if n in decay_parameters and \\\n", + " n not in logits_parameters and n not in vector_bank_parameters],\n", + " \"weight_decay\": 0.1,\n", + " \"lr\": head_lr,\n", + " },\n", + " {\n", + " \"params\": [p for n, p in model.named_parameters() if n not in decay_parameters and \\\n", + " n not in logits_parameters and n not in vector_bank_parameters],\n", + " \"weight_decay\": 0.0,\n", + " \"lr\": head_lr,\n", + " },\n", + " {\n", + " \"params\": [p for n, p in model.named_parameters() if n in vector_bank_parameters],\n", + " \"lr\": vector_bank_lr,\n", + " \"weight_decay\": 0.0,\n", + " },\n", + " {\n", + " \"params\": [p for n, p in model.named_parameters() if n in logits_parameters],\n", + " \"lr\": logits_lr,\n", + " \"weight_decay\": 0.0,\n", + " },\n", + "]\n", + "\n", + "optimizer = AdamW(optimizer_grouped_parameters)\n", + "lr_scheduler = get_linear_schedule_with_warmup(\n", + " optimizer=optimizer,\n", + " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n", + " num_training_steps=(len(train_dataloader) * num_epochs),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fa0e73be", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/115 [00:00" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch_size = 128\n", + "model_name_or_path = \"roberta-base\"\n", + "task = \"mrpc\"\n", + "peft_type = PeftType.VERA\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "num_epochs = 5 # for best results, increase this number\n", + "rank = 8 # for best results, increase this number\n", + "max_length = 128\n", + "torch.manual_seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0526f571", + "metadata": {}, + "outputs": [], + "source": [ + "peft_config = VeraConfig(\n", + " task_type=\"SEQ_CLS\", \n", + " r=rank,\n", + " d_initial=0.1,\n", + " target_modules=[\"query\", \"value\", \"intermediate.dense\"],\n", + " save_projection=True,\n", + ")\n", + "head_lr = 1e-2\n", + "vera_lr = 2e-2" + ] + }, + { + "cell_type": "markdown", + "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972", + "metadata": {}, + "source": [ + "## Loading data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139", + "metadata": {}, + "outputs": [], + "source": [ + "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n", + " padding_side = \"left\"\n", + "else:\n", + " padding_side = \"right\"\n", + "\n", + "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n", + "if getattr(tokenizer, \"pad_token_id\") is None:\n", + " tokenizer.pad_token_id = tokenizer.eos_token_id" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6", + "metadata": {}, + "outputs": [], + "source": [ + "datasets = load_dataset(\"glue\", task)\n", + "metric = evaluate.load(\"glue\", task)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0209f778-c93b-40eb-a4e0-24c25db03980", + "metadata": {}, + "outputs": [], + "source": [ + "def tokenize_function(examples):\n", + " # max_length=None => use the model max length (it's actually the default)\n", + " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n", + " return outputs\n", + "\n", + "\n", + "tokenized_datasets = datasets.map(\n", + " tokenize_function,\n", + " batched=True,\n", + " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n", + ")\n", + "\n", + "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n", + "# transformers library\n", + "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7453954e-982c-46f0-b09c-589776e6d6cb", + "metadata": {}, + "outputs": [], + "source": [ + "def collate_fn(examples):\n", + " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n", + "\n", + "\n", + "# Instantiate dataloaders.\n", + "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n", + "eval_dataloader = DataLoader(\n", + " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea", + "metadata": {}, + "source": [ + "## Preparing the VeRA model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2ed5ac74", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 647,714 || all params: 125,294,884 || trainable%: 0.5170\n" + ] + } + ], + "source": [ + "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0d2d0381", + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = AdamW(\n", + " [\n", + " {\"params\": [p for n, p in model.named_parameters() if \"vera_lambda_\" in n], \"lr\": vera_lr},\n", + " {\"params\": [p for n, p in model.named_parameters() if \"classifier\" in n], \"lr\": head_lr},\n", + " ]\n", + ")\n", + "\n", + "# Instantiate scheduler\n", + "lr_scheduler = get_linear_schedule_with_warmup(\n", + " optimizer=optimizer,\n", + " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n", + " num_training_steps=(len(train_dataloader) * num_epochs),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fa0e73be", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/29 [00:00 use the model max length (it's actually the default) + outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None) + return outputs + + def collate_fn(examples): + return tokenizer.pad(examples, padding="longest", return_tensors="pt") + + with accelerator.main_process_first(): + tokenized_datasets = datasets.map( + tokenize_function, + batched=True, + remove_columns=["idx", "sentence1", "sentence2"], + ) + + # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the + # transformers library + tokenized_datasets = tokenized_datasets.rename_column("label", "labels") + + # Instantiate dataloaders. + train_dataloader = DataLoader( + tokenized_datasets["train"], shuffle=True, collate_fn=collate_fn, batch_size=args.per_device_train_batch_size + ) + eval_dataloader = DataLoader( + tokenized_datasets["validation"], + shuffle=False, + collate_fn=collate_fn, + batch_size=args.per_device_eval_batch_size, + ) + + model = AutoModelForSequenceClassification.from_pretrained(args.model_name_or_path) + model = get_peft_model(model, peft_config) + model.print_trainable_parameters() + + if getattr(accelerator.state, "fsdp_plugin", None) is not None: + accelerator.state.fsdp_plugin.auto_wrap_policy = fsdp_auto_wrap_policy(model) + model = accelerator.prepare(model) + + optimizer = AdamW(params=model.parameters(), lr=args.learning_rate) + + # Instantiate scheduler + lr_scheduler = get_linear_schedule_with_warmup( + optimizer=optimizer, + num_warmup_steps=args.num_warmup_steps, + num_training_steps=(len(train_dataloader) * args.num_train_epochs), + ) + + if getattr(accelerator.state, "fsdp_plugin", None) is not None: + train_dataloader, eval_dataloader, optimizer, lr_scheduler = accelerator.prepare( + train_dataloader, eval_dataloader, optimizer, lr_scheduler + ) + else: + model, train_dataloader, eval_dataloader, optimizer, lr_scheduler = accelerator.prepare( + model, train_dataloader, eval_dataloader, optimizer, lr_scheduler + ) + + for epoch in range(args.num_train_epochs): + model.train() + for step, batch in enumerate(tqdm(train_dataloader)): + outputs = model(**batch) + loss = outputs.loss + accelerator.backward(loss) + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + model.eval() + samples_seen = 0 + for step, batch in enumerate(tqdm(eval_dataloader)): + with torch.no_grad(): + outputs = model(**batch) + predictions = outputs.logits.argmax(dim=-1) + predictions, references = accelerator.gather((predictions, batch["labels"])) + # If we are in a multiprocess environment, the last batch has duplicates + if accelerator.num_processes > 1: + if step == len(eval_dataloader) - 1: + predictions = predictions[: len(eval_dataloader.dataset) - samples_seen] + references = references[: len(eval_dataloader.dataset) - samples_seen] + else: + samples_seen += references.shape[0] + metric.add_batch( + predictions=predictions, + references=references, + ) + eval_metric = metric.compute() + accelerator.print(f"epoch {epoch}:", eval_metric) + + accelerator.wait_for_everyone() + unwrapped_model = accelerator.unwrap_model(model) + unwrapped_model.save_pretrained(args.output_dir, state_dict=accelerator.get_state_dict(model)) + if accelerator.is_main_process: + tokenizer.save_pretrained(args.output_dir) + + +if __name__ == "__main__": + main() diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sequence_classification/prefix_tuning.ipynb b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sequence_classification/prefix_tuning.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..bd2fc1fa1b29a795e93662124cfd3412b1c51d66 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sequence_classification/prefix_tuning.ipynb @@ -0,0 +1,710 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a825ba6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "===================================BUG REPORT===================================\n", + "Welcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n", + "For effortless bug reporting copy-paste your error into this form: https://docs.google.com/forms/d/e/1FAIpQLScPB8emS3Thkp66nvqwmjTEgxp8Y9ufuWTzFyr9kJ5AoI47dQ/viewform?usp=sf_link\n", + "================================================================================\n", + "CUDA SETUP: CUDA runtime path found: /home/sourab/miniconda3/envs/ml/lib/libcudart.so\n", + "CUDA SETUP: Highest compute capability among GPUs detected: 7.5\n", + "CUDA SETUP: Detected CUDA version 117\n", + "CUDA SETUP: Loading binary /home/sourab/miniconda3/envs/ml/lib/python3.10/site-packages/bitsandbytes/libbitsandbytes_cuda117.so...\n" + ] + } + ], + "source": [ + "import argparse\n", + "import os\n", + "\n", + "import torch\n", + "from torch.optim import AdamW\n", + "from torch.utils.data import DataLoader\n", + "from peft import (\n", + " get_peft_config,\n", + " get_peft_model,\n", + " get_peft_model_state_dict,\n", + " set_peft_model_state_dict,\n", + " PeftType,\n", + " PrefixTuningConfig,\n", + " PromptEncoderConfig,\n", + ")\n", + "\n", + "import evaluate\n", + "from datasets import load_dataset\n", + "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\n", + "from tqdm import tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2bd7cbb2", + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 32\n", + "model_name_or_path = \"roberta-large\"\n", + "task = \"mrpc\"\n", + "peft_type = PeftType.PREFIX_TUNING\n", + "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n", + "num_epochs = 20" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "33d9b62e", + "metadata": {}, + "outputs": [], + "source": [ + "peft_config = PrefixTuningConfig(task_type=\"SEQ_CLS\", num_virtual_tokens=20)\n", + "lr = 1e-2" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "152b6177", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Found cached dataset glue (/home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "be1eddbb9a7d4e6dae32fd026e167f96", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/3 [00:00 use the model max length (it's actually the default)\n", + " outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n", + " return outputs\n", + "\n", + "\n", + "tokenized_datasets = datasets.map(\n", + " tokenize_function,\n", + " batched=True,\n", + " remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n", + ")\n", + "\n", + "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n", + "# transformers library\n", + "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n", + "\n", + "\n", + "def collate_fn(examples):\n", + " return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n", + "\n", + "\n", + "# Instantiate dataloaders.\n", + "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n", + "eval_dataloader = DataLoader(\n", + " tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f6bc8144", + "metadata": {}, + "outputs": [], + "source": [ + "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "af41c571", + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = AdamW(params=model.parameters(), lr=lr)\n", + "\n", + "# Instantiate scheduler\n", + "lr_scheduler = get_linear_schedule_with_warmup(\n", + " optimizer=optimizer,\n", + " num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n", + " num_training_steps=(len(train_dataloader) * num_epochs),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "90993c93", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/115 [00:00 + + +Optimization in Unsloth to speed up QLoRA finetuning while reducing GPU memory usage + +## Multi-GPU SFT with QLoRA +To speed up QLoRA finetuning when you have access to multiple GPUs, look at the launch command at [run_peft_multigpu.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_multigpu.sh). This example to performs DDP on 8 GPUs. + +Note: +1. At present, `use_reentrant` needs to be `False` when using gradient checkpointing with Multi-GPU QLoRA else it will lead to errors. However, this leads to huge GPU memory consumption. + +## Multi-GPU SFT with LoRA and DeepSpeed +When you have access to multiple GPUs, it would be better to use normal LoRA with DeepSpeed/FSDP. To use LoRA with DeepSpeed, refer to the docs at [PEFT with DeepSpeed](https://huggingface.co/docs/peft/accelerate/deepspeed). + + +## Multi-GPU SFT with LoRA and FSDP +When you have access to multiple GPUs, it would be better to use normal LoRA with DeepSpeed/FSDP. To use LoRA with FSDP, refer to the docs at [PEFT with FSDP](https://huggingface.co/docs/peft/accelerate/fsdp). + +Note: FSDP is currently not compatible with 8bit bitsandbytes quantization. + + +## Multi-GPU SFT with LoRA and FSDP for GPT-QModel: +As in [Multi-GPU SFT with LoRA and FSDP](https://github.com/huggingface/peft/blob/main/examples/sft/README.md#multi-gpu-sft-with-lora-and-fsdp), we also support other quantization methods like GPT-QModel. You may need to install [GPT-QModel](https://github.com/ModelCloud/GPTQModel) >= v7.0.0 or from source. Here is the launch command for reference: [run_peft_fsdp_gptq.sh]. For the `--model_name_or_path` argument, it is important to pass a model that is already quantized with GPT-QModel, like `"hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4"`. + +Note: there is a bug in transformers v4.53.0 for this case, please skip this transformers version. + +## Tip + +Generally try to upgrade to the latest package versions for best results, especially when it comes to `bitsandbytes`, `accelerate`, `transformers`, `trl`, and `peft`. diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/deepspeed_config.yaml b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/deepspeed_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..56eef6e48b75727ede1d522b595b5ecde3a205a1 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/deepspeed_config.yaml @@ -0,0 +1,23 @@ +compute_environment: LOCAL_MACHINE +debug: false +deepspeed_config: + deepspeed_multinode_launcher: standard + gradient_accumulation_steps: 4 + offload_optimizer_device: none + offload_param_device: none + zero3_init_flag: true + zero3_save_16bit_model: true + zero_stage: 3 +distributed_type: DEEPSPEED +downcast_bf16: 'no' +machine_rank: 0 +main_training_function: main +mixed_precision: bf16 +num_machines: 1 +num_processes: 8 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/deepspeed_config_z3_qlora.yaml b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/deepspeed_config_z3_qlora.yaml new file mode 100644 index 0000000000000000000000000000000000000000..07dddcef7853b963ea64d20d39078893c4e21c33 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/deepspeed_config_z3_qlora.yaml @@ -0,0 +1,22 @@ +compute_environment: LOCAL_MACHINE +debug: false +deepspeed_config: + deepspeed_multinode_launcher: standard + offload_optimizer_device: none + offload_param_device: none + zero3_init_flag: true + zero3_save_16bit_model: true + zero_stage: 3 +distributed_type: DEEPSPEED +downcast_bf16: 'no' +machine_rank: 0 +main_training_function: main +mixed_precision: bf16 +num_machines: 1 +num_processes: 2 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/fsdp_config.yaml b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/fsdp_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7cccb74ca0dfa1a916b5057ceee561271c301ec5 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/fsdp_config.yaml @@ -0,0 +1,25 @@ +compute_environment: LOCAL_MACHINE +debug: false +distributed_type: FSDP +downcast_bf16: 'no' +fsdp_config: + fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP + fsdp_backward_prefetch: BACKWARD_PRE + fsdp_cpu_ram_efficient_loading: true + fsdp_forward_prefetch: false + fsdp_offload_params: false + fsdp_sharding_strategy: FULL_SHARD + fsdp_state_dict_type: SHARDED_STATE_DICT + fsdp_sync_module_states: true + fsdp_use_orig_params: false +machine_rank: 0 +main_training_function: main +mixed_precision: bf16 +num_machines: 1 +num_processes: 8 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/fsdp_config_qlora.yaml b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/fsdp_config_qlora.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f28a0f1046a735579045655dcdb9d3bf7c6ffdcc --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/configs/fsdp_config_qlora.yaml @@ -0,0 +1,25 @@ +compute_environment: LOCAL_MACHINE +debug: false +distributed_type: FSDP +downcast_bf16: 'no' +fsdp_config: + fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP + fsdp_backward_prefetch: BACKWARD_PRE + fsdp_cpu_ram_efficient_loading: true + fsdp_forward_prefetch: false + fsdp_offload_params: true + fsdp_sharding_strategy: FULL_SHARD + fsdp_state_dict_type: SHARDED_STATE_DICT + fsdp_sync_module_states: true + fsdp_use_orig_params: false +machine_rank: 0 +main_training_function: main +mixed_precision: 'no' +num_machines: 1 +num_processes: 2 +rdzv_backend: static +same_network: true +tpu_env: [] +tpu_use_cluster: false +tpu_use_sudo: false +use_cpu: false \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/requirements.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..752b6976e62f4acff6193804c5422807bc5e8806 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/requirements.txt @@ -0,0 +1,25 @@ +git+https://github.com/huggingface/transformers +git+https://github.com/huggingface/accelerate +git+https://github.com/huggingface/peft +git+https://github.com/huggingface/trl +git+https://github.com/huggingface/datatrove.git +unsloth[conda]@git+https://github.com/unslothai/unsloth.git +deepspeed +PyGithub +flash-attn +huggingface-hub +evaluate +datasets +bitsandbytes +einops +wandb +tensorboard +tiktoken +pandas +numpy +scipy +matplotlib +sentencepiece +nltk +xformers +hf_transfer \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/requirements_colab.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/requirements_colab.txt new file mode 100644 index 0000000000000000000000000000000000000000..b8c375dc44bf85305fa53964537f4877210b10bd --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/requirements_colab.txt @@ -0,0 +1,25 @@ +git+https://github.com/huggingface/transformers +git+https://github.com/huggingface/accelerate +git+https://github.com/huggingface/peft +git+https://github.com/huggingface/trl +unsloth[colab_ampere] @ git+https://github.com/unslothai/unsloth.git +datasets +deepspeed +PyGithub +flash-attn +huggingface-hub +evaluate +bitsandbytes +einops +wandb +tensorboard +tiktoken +pandas +numpy +scipy +matplotlib +sentencepiece +nltk +xformers +git+https://github.com/huggingface/datatrove.git +hf_transfer \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/requirements_xpu.txt b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/requirements_xpu.txt new file mode 100644 index 0000000000000000000000000000000000000000..9e5918b95180acbdc5789115ba0af71c8adf3aa5 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/requirements_xpu.txt @@ -0,0 +1,22 @@ +git+https://github.com/huggingface/transformers +git+https://github.com/huggingface/accelerate +git+https://github.com/huggingface/peft +git+https://github.com/huggingface/trl +git+https://github.com/huggingface/datatrove.git +deepspeed +PyGithub +huggingface-hub +evaluate +datasets +bitsandbytes +einops +wandb +tensorboard +tiktoken +pandas +numpy +scipy +matplotlib +sentencepiece +nltk +hf_transfer \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft.sh new file mode 100644 index 0000000000000000000000000000000000000000..daa29f14f3cddcc829a68248c8055035f9206a5c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft.sh @@ -0,0 +1,41 @@ +python train.py \ +--seed 100 \ +--model_name_or_path "mistralai/Mistral-7B-v0.1" \ +--dataset_name "smangrul/ultrachat-10k-chatml" \ +--chat_template_format "chatml" \ +--add_special_tokens False \ +--append_concat_token False \ +--splits "train,test" \ +--max_length 2048 \ +--num_train_epochs 1 \ +--logging_steps 5 \ +--log_level "info" \ +--logging_strategy "steps" \ +--eval_strategy "epoch" \ +--save_strategy "epoch" \ +--push_to_hub \ +--hub_private_repo True \ +--hub_strategy "every_save" \ +--bf16 True \ +--packing True \ +--learning_rate 1e-4 \ +--lr_scheduler_type "cosine" \ +--weight_decay 1e-4 \ +--warmup_steps 0 \ +--max_grad_norm 1.0 \ +--output_dir "mistral-sft-lora" \ +--per_device_train_batch_size 8 \ +--per_device_eval_batch_size 8 \ +--gradient_accumulation_steps 8 \ +--gradient_checkpointing True \ +--use_reentrant True \ +--dataset_text_field "content" \ +--use_peft_lora True \ +--lora_r 8 \ +--lora_alpha 16 \ +--lora_dropout 0.1 \ +--lora_target_modules "all-linear" \ +--use_4bit_quantization True \ +--use_nested_quant True \ +--bnb_4bit_compute_dtype "bfloat16" \ +--use_flash_attn True diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_deepspeed.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_deepspeed.sh new file mode 100644 index 0000000000000000000000000000000000000000..8c2bcb13553c0c85c270494377cbcc7d72df9d00 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_deepspeed.sh @@ -0,0 +1,39 @@ +accelerate launch --config_file "configs/deepspeed_config.yaml" train.py \ +--seed 100 \ +--model_name_or_path "meta-llama/Llama-2-70b-hf" \ +--dataset_name "smangrul/ultrachat-10k-chatml" \ +--chat_template_format "chatml" \ +--add_special_tokens False \ +--append_concat_token False \ +--splits "train,test" \ +--max_length 2048 \ +--num_train_epochs 1 \ +--logging_steps 5 \ +--log_level "info" \ +--logging_strategy "steps" \ +--eval_strategy "epoch" \ +--save_strategy "epoch" \ +--push_to_hub \ +--hub_private_repo True \ +--hub_strategy "every_save" \ +--bf16 True \ +--packing True \ +--learning_rate 1e-4 \ +--lr_scheduler_type "cosine" \ +--weight_decay 1e-4 \ +--warmup_steps 0 \ +--max_grad_norm 1.0 \ +--output_dir "mistral-sft-lora-deepspeed" \ +--per_device_train_batch_size 8 \ +--per_device_eval_batch_size 8 \ +--gradient_accumulation_steps 4 \ +--gradient_checkpointing True \ +--use_reentrant False \ +--dataset_text_field "content" \ +--use_flash_attn True \ +--use_peft_lora True \ +--lora_r 8 \ +--lora_alpha 16 \ +--lora_dropout 0.1 \ +--lora_target_modules "all-linear" \ +--use_4bit_quantization False diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_fsdp.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_fsdp.sh new file mode 100644 index 0000000000000000000000000000000000000000..82c595d2d6b99a48ad916015f090bcf908e954d5 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_fsdp.sh @@ -0,0 +1,39 @@ +accelerate launch --config_file "configs/fsdp_config.yaml" train.py \ +--seed 100 \ +--model_name_or_path "meta-llama/Llama-2-70b-hf" \ +--dataset_name "smangrul/ultrachat-10k-chatml" \ +--chat_template_format "chatml" \ +--add_special_tokens False \ +--append_concat_token False \ +--splits "train,test" \ +--max_length 2048 \ +--num_train_epochs 1 \ +--logging_steps 5 \ +--log_level "info" \ +--logging_strategy "steps" \ +--eval_strategy "epoch" \ +--save_strategy "epoch" \ +--push_to_hub \ +--hub_private_repo True \ +--hub_strategy "every_save" \ +--bf16 True \ +--packing True \ +--learning_rate 1e-4 \ +--lr_scheduler_type "cosine" \ +--weight_decay 1e-4 \ +--warmup_steps 0 \ +--max_grad_norm 1.0 \ +--output_dir "mistral-sft-lora-fsdp" \ +--per_device_train_batch_size 8 \ +--per_device_eval_batch_size 8 \ +--gradient_accumulation_steps 4 \ +--gradient_checkpointing True \ +--use_reentrant False \ +--dataset_text_field "content" \ +--use_flash_attn True \ +--use_peft_lora True \ +--lora_r 8 \ +--lora_alpha 16 \ +--lora_dropout 0.1 \ +--lora_target_modules "all-linear" \ +--use_4bit_quantization False \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_fsdp_gptq.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_fsdp_gptq.sh new file mode 100644 index 0000000000000000000000000000000000000000..9f0939e9c923785c4ad3cd23674c7877fc247488 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_fsdp_gptq.sh @@ -0,0 +1,36 @@ +accelerate launch --config_file "configs/fsdp_config.yaml" train.py \ +--seed 100 \ +--model_name_or_path "hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4" \ +--dataset_name "smangrul/ultrachat-10k-chatml" \ +--chat_template_format "chatml" \ +--add_special_tokens False \ +--append_concat_token False \ +--splits "train,test" \ +--max_length 2048 \ +--num_train_epochs 1 \ +--logging_steps 5 \ +--log_level "info" \ +--logging_strategy "steps" \ +--eval_strategy "epoch" \ +--save_strategy "epoch" \ +--bf16 True \ +--packing True \ +--learning_rate 1e-4 \ +--lr_scheduler_type "cosine" \ +--weight_decay 1e-4 \ +--warmup_steps 0 \ +--max_grad_norm 1.0 \ +--output_dir "llama3-8B-gptq-sft-lora-fsdp" \ +--per_device_train_batch_size 8 \ +--per_device_eval_batch_size 8 \ +--gradient_accumulation_steps 4 \ +--gradient_checkpointing True \ +--use_reentrant False \ +--dataset_text_field "content" \ +--use_flash_attn True \ +--use_peft_lora True \ +--lora_r 8 \ +--lora_alpha 16 \ +--lora_dropout 0.1 \ +--lora_target_modules "q_proj,k_proj,v_proj,o_proj,up_proj,gate_proj" \ +--use_4bit_quantization False \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_multigpu.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_multigpu.sh new file mode 100644 index 0000000000000000000000000000000000000000..797df71d6e19b3a6f2bc3a6a92afa2413cfba355 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_multigpu.sh @@ -0,0 +1,41 @@ +torchrun --nproc_per_node 8 --nnodes 1 train.py \ +--seed 100 \ +--model_name_or_path "mistralai/Mistral-7B-v0.1" \ +--dataset_name "smangrul/ultrachat-10k-chatml" \ +--chat_template_format "chatml" \ +--add_special_tokens False \ +--append_concat_token False \ +--splits "train,test" \ +--max_length 2048 \ +--num_train_epochs 1 \ +--logging_steps 5 \ +--log_level "info" \ +--logging_strategy "steps" \ +--eval_strategy "epoch" \ +--save_strategy "epoch" \ +--push_to_hub \ +--hub_private_repo True \ +--hub_strategy "every_save" \ +--bf16 True \ +--packing True \ +--learning_rate 1e-4 \ +--lr_scheduler_type "cosine" \ +--weight_decay 1e-4 \ +--warmup_steps 0 \ +--max_grad_norm 1.0 \ +--output_dir "mistral-sft-lora-multigpu" \ +--per_device_train_batch_size 8 \ +--per_device_eval_batch_size 8 \ +--gradient_accumulation_steps 8 \ +--gradient_checkpointing True \ +--use_reentrant False \ +--dataset_text_field "content" \ +--use_peft_lora True \ +--lora_r 8 \ +--lora_alpha 16 \ +--lora_dropout 0.1 \ +--lora_target_modules "all-linear" \ +--use_4bit_quantization True \ +--use_nested_quant True \ +--bnb_4bit_compute_dtype "bfloat16" \ +--use_flash_attn True diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_qlora_deepspeed_stage3.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_qlora_deepspeed_stage3.sh new file mode 100644 index 0000000000000000000000000000000000000000..9c0fa3a63784f8afb36f610651a00737ab912de1 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_qlora_deepspeed_stage3.sh @@ -0,0 +1,42 @@ +accelerate launch --config_file "configs/deepspeed_config_z3_qlora.yaml" train.py \ +--seed 100 \ +--model_name_or_path "meta-llama/Llama-2-70b-hf" \ +--dataset_name "smangrul/ultrachat-10k-chatml" \ +--chat_template_format "chatml" \ +--add_special_tokens False \ +--append_concat_token False \ +--splits "train,test" \ +--max_length 2048 \ +--num_train_epochs 1 \ +--logging_steps 5 \ +--log_level "info" \ +--logging_strategy "steps" \ +--eval_strategy "epoch" \ +--save_strategy "epoch" \ +--push_to_hub \ +--hub_private_repo True \ +--hub_strategy "every_save" \ +--bf16 True \ +--packing True \ +--learning_rate 1e-4 \ +--lr_scheduler_type "cosine" \ +--weight_decay 1e-4 \ +--warmup_steps 0 \ +--max_grad_norm 1.0 \ +--output_dir "llama-sft-qlora-dsz3" \ +--per_device_train_batch_size 2 \ +--per_device_eval_batch_size 2 \ +--gradient_accumulation_steps 2 \ +--gradient_checkpointing True \ +--use_reentrant True \ +--dataset_text_field "content" \ +--use_flash_attn True \ +--use_peft_lora True \ +--lora_r 8 \ +--lora_alpha 16 \ +--lora_dropout 0.1 \ +--lora_target_modules "all-linear" \ +--use_4bit_quantization True \ +--use_nested_quant True \ +--bnb_4bit_compute_dtype "bfloat16" \ +--bnb_4bit_quant_storage_dtype "bfloat16" diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_qlora_fsdp.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_qlora_fsdp.sh new file mode 100644 index 0000000000000000000000000000000000000000..ca448cf34bfc44fcdabd715078fabbbc48d67782 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_peft_qlora_fsdp.sh @@ -0,0 +1,42 @@ +accelerate launch --config_file "configs/fsdp_config_qlora.yaml" train.py \ +--seed 100 \ +--model_name_or_path "meta-llama/Llama-2-70b-hf" \ +--dataset_name "smangrul/ultrachat-10k-chatml" \ +--chat_template_format "chatml" \ +--add_special_tokens False \ +--append_concat_token False \ +--splits "train,test" \ +--max_length 2048 \ +--num_train_epochs 1 \ +--logging_steps 5 \ +--log_level "info" \ +--logging_strategy "steps" \ +--eval_strategy "epoch" \ +--save_strategy "epoch" \ +--push_to_hub \ +--hub_private_repo True \ +--hub_strategy "every_save" \ +--bf16 True \ +--packing True \ +--learning_rate 1e-4 \ +--lr_scheduler_type "cosine" \ +--weight_decay 1e-4 \ +--warmup_steps 0 \ +--max_grad_norm 1.0 \ +--output_dir "llama-sft-qlora-fsdp" \ +--per_device_train_batch_size 2 \ +--per_device_eval_batch_size 2 \ +--gradient_accumulation_steps 2 \ +--gradient_checkpointing True \ +--use_reentrant True \ +--dataset_text_field "content" \ +--use_flash_attn True \ +--use_peft_lora True \ +--lora_r 8 \ +--lora_alpha 16 \ +--lora_dropout 0.1 \ +--lora_target_modules "all-linear" \ +--use_4bit_quantization True \ +--use_nested_quant True \ +--bnb_4bit_compute_dtype "bfloat16" \ +--bnb_4bit_quant_storage_dtype "bfloat16" \ No newline at end of file diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_unsloth_peft.sh b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_unsloth_peft.sh new file mode 100644 index 0000000000000000000000000000000000000000..608a1d93940fd72583009e204a796f510b7fe12c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/run_unsloth_peft.sh @@ -0,0 +1,42 @@ +python train.py \ +--seed 100 \ +--model_name_or_path "mistralai/Mistral-7B-v0.1" \ +--dataset_name "smangrul/ultrachat-10k-chatml" \ +--chat_template_format "chatml" \ +--add_special_tokens False \ +--append_concat_token False \ +--splits "train,test" \ +--max_length 2048 \ +--num_train_epochs 1 \ +--logging_steps 5 \ +--log_level "info" \ +--logging_strategy "steps" \ +--eval_strategy "epoch" \ +--save_strategy "epoch" \ +--push_to_hub \ +--hub_private_repo True \ +--hub_strategy "every_save" \ +--bf16 True \ +--packing True \ +--learning_rate 1e-4 \ +--lr_scheduler_type "cosine" \ +--weight_decay 1e-4 \ +--warmup_steps 0 \ +--max_grad_norm 1.0 \ +--output_dir "mistral-sft-lora-unsloth" \ +--per_device_train_batch_size 8 \ +--per_device_eval_batch_size 8 \ +--gradient_accumulation_steps 8 \ +--gradient_checkpointing True \ +--use_reentrant True \ +--dataset_text_field "content" \ +--use_peft_lora True \ +--use_unsloth True \ +--lora_r 8 \ +--lora_alpha 16 \ +--lora_dropout 0.1 \ +--lora_target_modules "q_proj,k_proj,v_proj,o_proj,down_proj,up_proj,gate_proj" \ +--use_4bit_quantization True \ +--use_nested_quant True \ +--bnb_4bit_compute_dtype "bfloat16" \ +--use_flash_attn True diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/train.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/train.py new file mode 100644 index 0000000000000000000000000000000000000000..921ae9910488caf2ff0c51fdc709494b2a084ab9 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/train.py @@ -0,0 +1,156 @@ +import os +import sys +from dataclasses import dataclass, field +from typing import Optional + +from transformers import HfArgumentParser, set_seed +from trl import SFTConfig, SFTTrainer +from utils import create_and_prepare_model, create_datasets + + +# Define and parse arguments. +@dataclass +class ModelArguments: + """ + Arguments pertaining to which model/config/tokenizer we are going to fine-tune from. + """ + + model_name_or_path: str = field( + metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"} + ) + chat_template_format: Optional[str] = field( + default="none", + metadata={ + "help": "chatml|zephyr|none. Pass `none` if the dataset is already formatted with the chat template." + }, + ) + lora_alpha: Optional[int] = field(default=16) + lora_dropout: Optional[float] = field(default=0.1) + lora_r: Optional[int] = field(default=64) + lora_target_modules: Optional[str] = field( + default="q_proj,k_proj,v_proj,o_proj,down_proj,up_proj,gate_proj", + metadata={"help": "comma separated list of target modules to apply LoRA layers to"}, + ) + use_nested_quant: Optional[bool] = field( + default=False, + metadata={"help": "Activate nested quantization for 4bit base models"}, + ) + bnb_4bit_compute_dtype: Optional[str] = field( + default="float16", + metadata={"help": "Compute dtype for 4bit base models"}, + ) + bnb_4bit_quant_storage_dtype: Optional[str] = field( + default="uint8", + metadata={"help": "Quantization storage dtype for 4bit base models"}, + ) + bnb_4bit_quant_type: Optional[str] = field( + default="nf4", + metadata={"help": "Quantization type fp4 or nf4"}, + ) + use_flash_attn: Optional[bool] = field( + default=False, + metadata={"help": "Enables Flash attention for training."}, + ) + use_peft_lora: Optional[bool] = field( + default=False, + metadata={"help": "Enables PEFT LoRA for training."}, + ) + use_8bit_quantization: Optional[bool] = field( + default=False, + metadata={"help": "Enables loading model in 8bit."}, + ) + use_4bit_quantization: Optional[bool] = field( + default=False, + metadata={"help": "Enables loading model in 4bit."}, + ) + use_reentrant: Optional[bool] = field( + default=False, + metadata={"help": "Gradient Checkpointing param. Refer the related docs"}, + ) + use_unsloth: Optional[bool] = field( + default=False, + metadata={"help": "Enables UnSloth for training."}, + ) + + +@dataclass +class DataTrainingArguments: + dataset_name: Optional[str] = field( + default="timdettmers/openassistant-guanaco", + metadata={"help": "The preference dataset to use."}, + ) + append_concat_token: Optional[bool] = field( + default=False, + metadata={"help": "If True, appends `eos_token_id` at the end of each sample being packed."}, + ) + add_special_tokens: Optional[bool] = field( + default=False, + metadata={"help": "If True, tokenizers adds special tokens to each sample being packed."}, + ) + splits: Optional[str] = field( + default="train,test", + metadata={"help": "Comma separate list of the splits to use from the dataset."}, + ) + + +def main(model_args, data_args, training_args): + # Set seed for reproducibility + set_seed(training_args.seed) + + # model + model, peft_config, tokenizer = create_and_prepare_model(model_args, data_args, training_args) + + # gradient ckpt + model.config.use_cache = not training_args.gradient_checkpointing + training_args.gradient_checkpointing = training_args.gradient_checkpointing and not model_args.use_unsloth + if training_args.gradient_checkpointing: + training_args.gradient_checkpointing_kwargs = {"use_reentrant": model_args.use_reentrant} + + training_args.dataset_kwargs = { + "append_concat_token": data_args.append_concat_token, + "add_special_tokens": data_args.add_special_tokens, + } + + # datasets + train_dataset, eval_dataset = create_datasets( + tokenizer, + data_args, + training_args, + apply_chat_template=model_args.chat_template_format != "none", + ) + + # trainer + trainer = SFTTrainer( + model=model, + processing_class=tokenizer, + args=training_args, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + peft_config=peft_config, + ) + trainer.accelerator.print(f"{trainer.model}") + if hasattr(trainer.model, "print_trainable_parameters"): + trainer.model.print_trainable_parameters() + + # train + checkpoint = None + if training_args.resume_from_checkpoint is not None: + checkpoint = training_args.resume_from_checkpoint + trainer.train(resume_from_checkpoint=checkpoint) + + # saving final model + if trainer.is_fsdp_enabled: + trainer.accelerator.state.fsdp_plugin.set_state_dict_type("FULL_STATE_DICT") + trainer.save_model() + + +if __name__ == "__main__": + parser = HfArgumentParser((ModelArguments, DataTrainingArguments, SFTConfig)) + if len(sys.argv) == 2 and sys.argv[1].endswith(".json"): + # If we pass only one argument to the script and it's the path to a json file, + # let's parse it to get our arguments. + model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1])) + else: + model_args, data_args, training_args = parser.parse_args_into_dataclasses() + model_args.max_length = training_args.max_length + main(model_args, data_args, training_args) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/utils.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..2fcb8dabd4108fe8ccd2549ac90501d3ed914076 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/sft/utils.py @@ -0,0 +1,219 @@ +import os +from enum import Enum + +import packaging.version +import torch +import transformers +from datasets import DatasetDict, load_dataset, load_from_disk +from datasets.builder import DatasetGenerationError +from transformers import ( + AutoModelForCausalLM, + AutoTokenizer, + BitsAndBytesConfig, +) + +from peft import LoraConfig + + +DEFAULT_CHATML_CHAT_TEMPLATE = "{% for message in messages %}\n{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% if loop.last and add_generation_prompt %}{{'<|im_start|>assistant\n' }}{% endif %}{% endfor %}" +DEFAULT_ZEPHYR_CHAT_TEMPLATE = "{% for message in messages %}\n{% if message['role'] == 'user' %}\n{{ '<|user|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'system' %}\n{{ '<|system|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'assistant' %}\n{{ '<|assistant|>\n' + message['content'] + eos_token }}\n{% endif %}\n{% if loop.last and add_generation_prompt %}\n{{ '<|assistant|>' }}\n{% endif %}\n{% endfor %}" + + +class ZephyrSpecialTokens(str, Enum): + user = "<|user|>" + assistant = "<|assistant|>" + system = "<|system|>" + eos_token = "" + bos_token = "" + pad_token = "" + + @classmethod + def list(cls): + return [c.value for c in cls] + + +class ChatmlSpecialTokens(str, Enum): + user = "<|im_start|>user" + assistant = "<|im_start|>assistant" + system = "<|im_start|>system" + eos_token = "<|im_end|>" + bos_token = "" + pad_token = "" + + @classmethod + def list(cls): + return [c.value for c in cls] + + +def create_datasets(tokenizer, data_args, training_args, apply_chat_template=False): + def preprocess(samples): + batch = [] + for conversation in samples["messages"]: + batch.append(tokenizer.apply_chat_template(conversation, tokenize=False)) + return {"content": batch} + + raw_datasets = DatasetDict() + for split in data_args.splits.split(","): + try: + # Try first if dataset on a Hub repo + dataset = load_dataset(data_args.dataset_name, split=split) + except DatasetGenerationError: + # If not, check local dataset + dataset = load_from_disk(os.path.join(data_args.dataset_name, split)) + + if "train" in split: + raw_datasets["train"] = dataset + elif "test" in split: + raw_datasets["test"] = dataset + else: + raise ValueError(f"Split type {split} not recognized as one of test or train.") + + if apply_chat_template: + raw_datasets = raw_datasets.map( + preprocess, + batched=True, + remove_columns=raw_datasets["train"].column_names, + ) + + train_data = raw_datasets["train"] + valid_data = raw_datasets["test"] + print(f"Size of the train set: {len(train_data)}. Size of the validation set: {len(valid_data)}") + print(f"A sample of train dataset: {train_data[0]}") + + return train_data, valid_data + + +def create_and_prepare_model(args, data_args, training_args): + if args.use_unsloth: + from unsloth import FastLanguageModel + bnb_config = None + quant_storage_dtype = None + + if ( + torch.distributed.is_available() + and torch.distributed.is_initialized() + and torch.distributed.get_world_size() > 1 + and args.use_unsloth + ): + raise NotImplementedError("Unsloth is not supported in distributed training") + + if args.use_4bit_quantization and args.use_8bit_quantization: + raise ValueError("You configured 4bit and 8bit quantization at the same time, please choose only one of them.") + elif args.use_4bit_quantization: + compute_dtype = getattr(torch, args.bnb_4bit_compute_dtype) + quant_storage_dtype = getattr(torch, args.bnb_4bit_quant_storage_dtype) + + bnb_config = BitsAndBytesConfig( + load_in_4bit=args.use_4bit_quantization, + bnb_4bit_quant_type=args.bnb_4bit_quant_type, + bnb_4bit_compute_dtype=compute_dtype, + bnb_4bit_use_double_quant=args.use_nested_quant, + bnb_4bit_quant_storage=quant_storage_dtype, + ) + + if compute_dtype == torch.float16 and args.use_4bit_quantization: + major, _ = torch.cuda.get_device_capability() + if major >= 8: + print("=" * 80) + print("Your GPU supports bfloat16, you can accelerate training with the argument --bf16") + print("=" * 80) + elif args.use_8bit_quantization: + bnb_config = BitsAndBytesConfig(load_in_8bit=args.use_8bit_quantization) + + if args.use_unsloth: + if torch.xpu.is_available(): + raise NotImplementedError("XPU hasn't supported unsloth yet") + # Load model + model, _ = FastLanguageModel.from_pretrained( + model_name=args.model_name_or_path, + max_seq_length=training_args.max_length, + dtype=None, + load_in_4bit=args.use_4bit_quantization, + ) + else: + dtype = quant_storage_dtype if quant_storage_dtype and quant_storage_dtype.is_floating_point else torch.float32 + + # Prepare model loading arguments + model_kwargs = { + "trust_remote_code": True, + "dtype": dtype, + } + if args.use_flash_attn: + if torch.xpu.is_available(): + print("XPU hasn't supported flash_attn yet, use eager implementation instead.") + model_kwargs["attn_implementation"] = "eager" + else: + model_kwargs["attn_implementation"] = "flash_attention_2" + + # Only add quantization_config if bnb_config is not None + if bnb_config is not None: + model_kwargs["quantization_config"] = bnb_config + + model = AutoModelForCausalLM.from_pretrained(args.model_name_or_path, **model_kwargs) + + peft_config = None + chat_template = None + if args.use_peft_lora and not args.use_unsloth: + peft_config = LoraConfig( + lora_alpha=args.lora_alpha, + lora_dropout=args.lora_dropout, + r=args.lora_r, + bias="none", + task_type="CAUSAL_LM", + target_modules=args.lora_target_modules.split(",") + if args.lora_target_modules != "all-linear" + else args.lora_target_modules, + ) + + special_tokens = None + chat_template = None + if args.chat_template_format == "chatml": + special_tokens = ChatmlSpecialTokens + chat_template = DEFAULT_CHATML_CHAT_TEMPLATE + elif args.chat_template_format == "zephyr": + special_tokens = ZephyrSpecialTokens + chat_template = DEFAULT_ZEPHYR_CHAT_TEMPLATE + + if special_tokens is not None: + tokenizer = AutoTokenizer.from_pretrained( + args.model_name_or_path, + pad_token=special_tokens.pad_token.value, + bos_token=special_tokens.bos_token.value, + eos_token=special_tokens.eos_token.value, + additional_special_tokens=special_tokens.list(), + trust_remote_code=True, + ) + tokenizer.chat_template = chat_template + + # make embedding resizing configurable? + # Transformers 4.46.0+ defaults uses mean_resizing by default, which fails with QLoRA + FSDP because the + # embedding could be on meta device, therefore, we set mean_resizing=False in that case (i.e. the status quo + # ante). See https://github.com/huggingface/accelerate/issues/1620. + uses_transformers_4_46 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("4.46.0") + uses_fsdp = os.environ.get("ACCELERATE_USE_FSDP", "false").lower() == "true" + # Check if the model is quantized + is_quantized = (bnb_config is not None) or (getattr(model, "hf_quantizer", None) is not None) + if is_quantized and uses_fsdp and uses_transformers_4_46: + model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8, mean_resizing=False) + else: + model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8) + else: + tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, trust_remote_code=True) + tokenizer.pad_token = tokenizer.eos_token + + if args.use_unsloth: + # Do model patching and add fast LoRA weights + model = FastLanguageModel.get_peft_model( + model, + lora_alpha=args.lora_alpha, + lora_dropout=args.lora_dropout, + r=args.lora_r, + target_modules=args.lora_target_modules.split(",") + if args.lora_target_modules != "all-linear" + else args.lora_target_modules, + use_gradient_checkpointing=training_args.gradient_checkpointing, + random_state=training_args.seed, + max_seq_length=training_args.max_length, + ) + + return model, peft_config, tokenizer diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/shira_finetuning/README.md b/tasks/tasksmith-c488fc138ba1/environment/source/examples/shira_finetuning/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d8a30ec8863adcedfc4a4215e872c4caff92226a --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/shira_finetuning/README.md @@ -0,0 +1,73 @@ +# Sparse High Rank Adapters + +## Introduction +Sparse High Rank Adapters or [SHiRA](https://huggingface.co/papers/2406.13175) is an alternate type of adapter and has been found to have significant advantages over the low rank adapters. Specifically, SHiRA achieves better accuracy than LoRA for a variety of vision and language tasks. It also offers simpler and higher quality multi-adapter fusion by significantly reducing concept loss, a common problem faced by low rank adapters. SHiRA directly finetunes a small number of the base model's parameters to finetune the model on any adaptation task. + +## Quick start +```python +import torch +from peft import ShiraConfig, get_peft_model +from transformers import AutoTokenizer, AutoModelForCausalLM +from trl import SFTConfig, SFTTrainer +from datasets import load_dataset + +model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m", dtype=torch.bfloat16, device_map="auto") +tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m") +dataset = load_dataset("imdb", split="train[:1%]") +shira_config = ShiraConfig( + r=32, +) +peft_model = get_peft_model(model, shira_config) +training_args = SFTConfig(dataset_text_field="text", max_length=128) +trainer = SFTTrainer( + model=peft_model, + train_dataset=dataset, + processing_class=tokenizer, +) +trainer.train() +peft_model.save_pretrained("shira-opt-350m") +``` + +For more options and a more detailed example code, you can refer to shira finetuning script. +Run the script simply by running: +```bash +python3 examples/shira_finetuning/shira_finetuning.py --base_model facebook/opt-350m +``` + +If you want to run DDP by [accelerate](https://huggingface.co/docs/accelerate/en/index), please run `accelerate config` to set your ddp config, and run: +```bash +accelerate launch examples/shira_finetuning/shira_finetuning.py --base_model facebook/opt-350m +``` +please add `--device_map cpu` if you want to run finetune on CPU. + +If you want to train SHiRA with a custom sparse mask function which requires custom keyword arguments, please see the definition of `custom_random_mask_function_with_custom_kwargs` function provided in the `shira_fintuning.py` script. You can run this code using the `--use_custom_random_mask_function_with_custom_kwargs` argument. Without this argument, SHiRA defaults to a random sparse mask. Please run the code as follows. : +```bash +python3 examples/shira_finetuning/shira_finetuning.py --base_model facebook/opt-350m --use_custom_random_mask_function_with_custom_kwargs + +``` + + +## Use the model +You can load and use the model as any other 🤗 PEFT model +```python +from peft import PeftModel +from transformers import AutoTokenizer, AutoModelForCausalLM +model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m") +tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m") +shira_model = PeftModel.from_pretrained(model, "shira-opt-350m") +``` + +## Citation +``` +@inproceedings{NEURIPS2024_18c0102c, + author = {Bhardwaj, Kartikeya and Pandey, Nilesh Prasad and Priyadarshi, Sweta and Ganapathy, Viswanath and Kadambi, Shreya and Esteves, Rafael and Borse, Shubhankar and Whatmough, Paul and Garrepalli, Risheek and Van Baalen, Mart and Teague, Harris and Nagel, Markus}, + booktitle = {Advances in Neural Information Processing Systems}, + editor = {A. Globerson and L. Mackey and D. Belgrave and A. Fan and U. Paquet and J. Tomczak and C. Zhang}, + pages = {13685--13715}, + publisher = {Curran Associates, Inc.}, + title = {Sparse High Rank Adapters}, + url = {https://proceedings.neurips.cc/paper_files/paper/2024/file/18c0102cb7f1a02c14f0929089b2e576-Paper-Conference.pdf}, + volume = {37}, + year = {2024} +} +``` diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/shira_finetuning/shira_finetuning.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/shira_finetuning/shira_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..b6478fc61b16f1a40ab70c09eb37d1d07df18d9c --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/shira_finetuning/shira_finetuning.py @@ -0,0 +1,217 @@ +# Copyright 2025-present the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import os +from typing import Optional + +import torch +import transformers +from datasets import load_dataset +from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed + +from peft import ( + PeftModel, + ShiraConfig, + get_peft_model, +) + + +def train( + base_model: str = "path/to/model", + data_path: str = "yahma/alpaca-cleaned", + output_dir: str = "shira", + batch_size: int = 16, + num_epochs: int = 1, + learning_rate: float = 3e-4, + cutoff_len: int = 256, + val_set_size: int = 16, + eval_step: int = 100, + save_step: int = 100, + device_map: str = "auto", + shira_r: int = 32, + shira_target_modules: Optional[list[str]] = None, + dtype: str = "float16", + seed: Optional[int] = None, + use_custom_random_mask_function_with_custom_kwargs: Optional[bool] = False, +): + # Set device_map to the right place when enabling DDP. + world_size = int(os.environ.get("WORLD_SIZE", "0")) or int(os.environ.get("PMI_SIZE", "0")) + if world_size > 1 and device_map != "cpu": + from accelerate import Accelerator + + device_map = {"": Accelerator().process_index} + # Set seed + if seed is not None: + set_seed(seed) + model_kwargs = {"dtype": getattr(torch, dtype), "device_map": device_map} + model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs) + + tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True) + # For some tokenizer with no pad token like llama + if tokenizer.pad_token is None: + tokenizer.pad_token = tokenizer.eos_token + + def tokenize(prompt, add_eos_token=True): + result = tokenizer( + prompt, + truncation=True, + max_length=cutoff_len, + padding=False, + return_tensors=None, + ) + if ( + result["input_ids"][-1] != tokenizer.eos_token_id + and len(result["input_ids"]) < cutoff_len + and add_eos_token + ): + result["input_ids"].append(tokenizer.eos_token_id) + result["attention_mask"].append(1) + + result["labels"] = result["input_ids"].copy() + + return result + + def generate_and_tokenize_prompt(example): + full_prompt = generate_prompt(example) + tokenized_full_prompt = tokenize(full_prompt) + return tokenized_full_prompt + + def custom_random_mask_function_with_custom_kwargs(custom_arg): + def mask_fn(base_layer, r): + """ + This mask function is similar to the random_mask provided in src/peft/tuners/shira/mask_functions.py except the seed is derived from custom_kwargs. + Please use this as an example to create your own custom sparse masks that may use custom_kwargs. Remember, for a pretrained weight with shape m, n, + mask_fn must return only one mask (shape: m, n) which must be binary 0 or 1 with num_shira_parameters = r(m+n) for linear layers. Device and dtype + of mask must be same as base layer's weight's device and dtype. + """ + new_seed = custom_arg + shape = base_layer.weight.shape + num_shira_weights = r * (shape[0] + shape[1]) + random_generator = torch.Generator() + random_generator.manual_seed(new_seed) + + idx = (torch.randperm(base_layer.weight.numel(), generator=random_generator)[:num_shira_weights]).to( + base_layer.weight.device + ) + val = torch.ones_like(idx.type(base_layer.weight.dtype)) + mask = torch.zeros_like(base_layer.weight.view(1, -1)) + mask = mask.scatter_(1, idx.unsqueeze(0), val.unsqueeze(0)).view(shape) + + return mask + + return mask_fn + + mask_type = "random" if not use_custom_random_mask_function_with_custom_kwargs else "custom" + config = ShiraConfig( + r=shira_r, + mask_type=mask_type, + target_modules=shira_target_modules, + task_type="CAUSAL_LM", + ) + if use_custom_random_mask_function_with_custom_kwargs: + custom_arg = 120 + custom_mask_fn = custom_random_mask_function_with_custom_kwargs(custom_arg) + config.mask_fn = custom_mask_fn + + model = get_peft_model(model, config) + + data = load_dataset(data_path) + + train_val = data["train"].train_test_split(test_size=val_set_size, shuffle=True, seed=42) + train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt) + val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt) + + trainer = transformers.Trainer( + model=model, + train_dataset=train_data, + eval_dataset=val_data, + args=transformers.TrainingArguments( + per_device_train_batch_size=batch_size, + warmup_steps=100, + num_train_epochs=num_epochs, + learning_rate=learning_rate, + logging_steps=100, + optim="adamw_torch", + eval_strategy="steps", + save_strategy="steps", + eval_steps=eval_step, + save_steps=save_step, + output_dir=output_dir, + save_total_limit=3, + load_best_model_at_end=True, + ddp_find_unused_parameters=False if world_size > 1 else None, + ), + data_collator=transformers.DataCollatorForSeq2Seq( + tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True + ), + ) + trainer.train() + model.save_pretrained(output_dir) + + # Delete the model and load it again from the checkpoint. + del model + model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs) + model = PeftModel.from_pretrained(model, output_dir) + + +def generate_prompt(example): + return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request. + ### Instruction: + {example["instruction"]} + ### Response: + {example["output"]}""" + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("--base_model", type=str, default="path/to/model") + parser.add_argument("--data_path", type=str, default="yahma/alpaca-cleaned") + parser.add_argument("--output_dir", type=str, default="shira") + parser.add_argument("--batch_size", type=int, default=16) + parser.add_argument("--num_epochs", type=int, default=1) + parser.add_argument("--learning_rate", type=float, default=3e-4) + parser.add_argument("--cutoff_len", type=int, default=256) + parser.add_argument("--val_set_size", type=int, default=16) + parser.add_argument("--eval_step", type=int, default=100) + parser.add_argument("--save_step", type=int, default=100) + parser.add_argument("--device_map", type=str, default="auto") + parser.add_argument("--shira_r", type=int, default=32) + parser.add_argument("--shira_target_modules", type=str, default=None) + parser.add_argument("--dtype", type=str, default="float16") + parser.add_argument("--seed", type=int, default=None) + parser.add_argument("--use_custom_random_mask_function_with_custom_kwargs", action="store_true") + + args = parser.parse_args() + + train( + base_model=args.base_model, + data_path=args.data_path, + output_dir=args.output_dir, + batch_size=args.batch_size, + num_epochs=args.num_epochs, + learning_rate=args.learning_rate, + cutoff_len=args.cutoff_len, + val_set_size=args.val_set_size, + eval_step=args.eval_step, + save_step=args.save_step, + device_map=args.device_map, + shira_r=args.shira_r, + shira_target_modules=args.shira_target_modules, + dtype=args.dtype, + seed=args.seed, + use_custom_random_mask_function_with_custom_kwargs=args.use_custom_random_mask_function_with_custom_kwargs, + ) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/stable_diffusion/convert_sd_adapter_to_peft.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/stable_diffusion/convert_sd_adapter_to_peft.py new file mode 100644 index 0000000000000000000000000000000000000000..b692ba5d06fdf3b04be58f929ad946413c393357 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/stable_diffusion/convert_sd_adapter_to_peft.py @@ -0,0 +1,517 @@ +import argparse +import json +import logging +import os +from collections import Counter +from dataclasses import dataclass +from operator import attrgetter +from typing import Optional, Union + +import safetensors +import torch +from diffusers import UNet2DConditionModel +from torch import nn +from transformers import CLIPTextModel + +from peft import LoHaConfig, LoKrConfig, LoraConfig, PeftType, get_peft_model, set_peft_model_state_dict +from peft.tuners.lokr.layer import factorization + + +logger = logging.getLogger(__name__) + + +# Default kohya_ss LoRA replacement modules +# https://github.com/kohya-ss/sd-scripts/blob/c924c47f374ac1b6e33e71f82948eb1853e2243f/networks/lora.py#L661 +UNET_TARGET_REPLACE_MODULE = ["Transformer2DModel", "Attention"] +UNET_TARGET_REPLACE_MODULE_CONV2D_3X3 = ["ResnetBlock2D", "Downsample2D", "Upsample2D"] +TEXT_ENCODER_TARGET_REPLACE_MODULE = ["CLIPAttention", "CLIPMLP"] +PREFIX_UNET = "lora_unet" +PREFIX_TEXT_ENCODER = "lora_te" + + +@dataclass +class LoRAInfo: + kohya_key: str + peft_key: str + alpha: Optional[float] = None + rank: Optional[int] = None + lora_A: Optional[torch.Tensor] = None + lora_B: Optional[torch.Tensor] = None + + def peft_state_dict(self) -> dict[str, torch.Tensor]: + if self.lora_A is None or self.lora_B is None: + raise ValueError("At least one of lora_A or lora_B is None, they must both be provided") + return { + f"base_model.model.{self.peft_key}.lora_A.weight": self.lora_A, + f"base_model.model.{self.peft_key}.lora_B.weight": self.lora_B, + } + + +@dataclass +class LoHaInfo: + kohya_key: str + peft_key: str + alpha: Optional[float] = None + rank: Optional[int] = None + hada_w1_a: Optional[torch.Tensor] = None + hada_w1_b: Optional[torch.Tensor] = None + hada_w2_a: Optional[torch.Tensor] = None + hada_w2_b: Optional[torch.Tensor] = None + hada_t1: Optional[torch.Tensor] = None + hada_t2: Optional[torch.Tensor] = None + + def peft_state_dict(self) -> dict[str, torch.Tensor]: + if self.hada_w1_a is None or self.hada_w1_b is None or self.hada_w2_a is None or self.hada_w2_b is None: + raise ValueError( + "At least one of hada_w1_a, hada_w1_b, hada_w2_a, hada_w2_b is missing, they all must be provided" + ) + state_dict = { + f"base_model.model.{self.peft_key}.hada_w1_a": self.hada_w1_a, + f"base_model.model.{self.peft_key}.hada_w1_b": self.hada_w1_b, + f"base_model.model.{self.peft_key}.hada_w2_a": self.hada_w2_a, + f"base_model.model.{self.peft_key}.hada_w2_b": self.hada_w2_b, + } + if not ( + (self.hada_t1 is None and self.hada_t2 is None) or (self.hada_t1 is not None and self.hada_t2 is not None) + ): + raise ValueError("hada_t1 and hada_t2 must be either both present or not present at the same time") + if self.hada_t1 is not None and self.hada_t2 is not None: + state_dict[f"base_model.model.{self.peft_key}.hada_t1"] = self.hada_t1 + state_dict[f"base_model.model.{self.peft_key}.hada_t2"] = self.hada_t2 + return state_dict + + +@dataclass +class LoKrInfo: + kohya_key: str + peft_key: str + alpha: Optional[float] = None + rank: Optional[int] = None + lokr_w1: Optional[torch.Tensor] = None + lokr_w1_a: Optional[torch.Tensor] = None + lokr_w1_b: Optional[torch.Tensor] = None + lokr_w2: Optional[torch.Tensor] = None + lokr_w2_a: Optional[torch.Tensor] = None + lokr_w2_b: Optional[torch.Tensor] = None + lokr_t2: Optional[torch.Tensor] = None + + def peft_state_dict(self) -> dict[str, torch.Tensor]: + if (self.lokr_w1 is None) and ((self.lokr_w1_a is None) or (self.lokr_w1_b is None)): + raise ValueError("Either lokr_w1 or both lokr_w1_a and lokr_w1_b should be provided") + + if (self.lokr_w2 is None) and ((self.lokr_w2_a is None) or (self.lokr_w2_b is None)): + raise ValueError("Either lokr_w2 or both lokr_w2_a and lokr_w2_b should be provided") + + state_dict = {} + + if self.lokr_w1 is not None: + state_dict[f"base_model.model.{self.peft_key}.lokr_w1"] = self.lokr_w1 + elif self.lokr_w1_a is not None: + state_dict[f"base_model.model.{self.peft_key}.lokr_w1_a"] = self.lokr_w1_a + state_dict[f"base_model.model.{self.peft_key}.lokr_w1_b"] = self.lokr_w1_b + + if self.lokr_w2 is not None: + state_dict[f"base_model.model.{self.peft_key}.lokr_w2"] = self.lokr_w2 + elif self.lokr_w2_a is not None: + state_dict[f"base_model.model.{self.peft_key}.lokr_w2_a"] = self.lokr_w2_a + state_dict[f"base_model.model.{self.peft_key}.lokr_w2_b"] = self.lokr_w2_b + + if self.lokr_t2 is not None: + state_dict[f"base_model.model.{self.peft_key}.lokr_t2"] = self.lokr_t2 + + return state_dict + + +def construct_peft_loraconfig(info: dict[str, LoRAInfo], **kwargs) -> LoraConfig: + """Constructs LoraConfig from data extracted from adapter checkpoint + + Args: + info (Dict[str, LoRAInfo]): Information extracted from adapter checkpoint + + Returns: + LoraConfig: config for constructing LoRA + """ + + # Unpack all ranks and alphas + ranks = {key: val.rank for key, val in info.items()} + alphas = {x[0]: x[1].alpha or x[1].rank for x in info.items()} + + # Determine which modules needs to be transformed + target_modules = sorted(info.keys()) + + # Determine most common rank and alpha + r = int(Counter(ranks.values()).most_common(1)[0][0]) + lora_alpha = Counter(alphas.values()).most_common(1)[0][0] + + # Determine which modules have different rank and alpha + rank_pattern = dict(sorted(filter(lambda x: x[1] != r, ranks.items()), key=lambda x: x[0])) + alpha_pattern = dict(sorted(filter(lambda x: x[1] != lora_alpha, alphas.items()), key=lambda x: x[0])) + + config = LoraConfig( + r=r, + lora_alpha=lora_alpha, + target_modules=target_modules, + lora_dropout=0.0, + bias="none", + init_lora_weights=False, + rank_pattern=rank_pattern, + alpha_pattern=alpha_pattern, + ) + + return config + + +def construct_peft_lohaconfig(info: dict[str, LoHaInfo], **kwargs) -> LoHaConfig: + """Constructs LoHaConfig from data extracted from adapter checkpoint + + Args: + info (Dict[str, LoHaInfo]): Information extracted from adapter checkpoint + + Returns: + LoHaConfig: config for constructing LoHA + """ + + # Unpack all ranks and alphas + ranks = {x[0]: x[1].rank for x in info.items()} + alphas = {x[0]: x[1].alpha or x[1].rank for x in info.items()} + + # Determine which modules needs to be transformed + target_modules = sorted(info.keys()) + + # Determine most common rank and alpha + r = int(Counter(ranks.values()).most_common(1)[0][0]) + alpha = Counter(alphas.values()).most_common(1)[0][0] + + # Determine which modules have different rank and alpha + rank_pattern = dict(sorted(filter(lambda x: x[1] != r, ranks.items()), key=lambda x: x[0])) + alpha_pattern = dict(sorted(filter(lambda x: x[1] != alpha, alphas.items()), key=lambda x: x[0])) + + # Determine whether any of modules have effective conv2d decomposition + use_effective_conv2d = any((val.hada_t1 is not None) or (val.hada_t2 is not None) for val in info.values()) + + config = LoHaConfig( + r=r, + alpha=alpha, + target_modules=target_modules, + rank_dropout=0.0, + module_dropout=0.0, + init_weights=False, + rank_pattern=rank_pattern, + alpha_pattern=alpha_pattern, + use_effective_conv2d=use_effective_conv2d, + ) + + return config + + +def construct_peft_lokrconfig(info: dict[str, LoKrInfo], decompose_factor: int = -1, **kwargs) -> LoKrConfig: + """Constructs LoKrConfig from data extracted from adapter checkpoint + + Args: + info (Dict[str, LoKrInfo]): Information extracted from adapter checkpoint + + Returns: + LoKrConfig: config for constructing LoKr + """ + + # Unpack all ranks and alphas + ranks = {x[0]: x[1].rank for x in info.items()} + alphas = {x[0]: x[1].alpha or x[1].rank for x in info.items()} + + # Determine which modules needs to be transformed + target_modules = sorted(info.keys()) + + # Determine most common rank and alpha + r = int(Counter(ranks.values()).most_common(1)[0][0]) + alpha = Counter(alphas.values()).most_common(1)[0][0] + + # Determine which modules have different rank and alpha + rank_pattern = dict(sorted(filter(lambda x: x[1] != r, ranks.items()), key=lambda x: x[0])) + alpha_pattern = dict(sorted(filter(lambda x: x[1] != alpha, alphas.items()), key=lambda x: x[0])) + + # Determine whether any of modules have effective conv2d decomposition + use_effective_conv2d = any((val.lokr_t2 is not None) for val in info.values()) + + # decompose_both should be enabled if any w1 matrix in any layer is decomposed into 2 + decompose_both = any((val.lokr_w1_a is not None and val.lokr_w1_b is not None) for val in info.values()) + + # Determining decompose factor is a bit tricky (but it is most often -1) + # Check that decompose_factor is equal to provided + for val in info.values(): + # Determine shape of first matrix + if val.lokr_w1 is not None: + w1_shape = tuple(val.lokr_w1.shape) + else: + w1_shape = (val.lokr_w1_a.shape[0], val.lokr_w1_b.shape[1]) + + # Determine shape of second matrix + if val.lokr_w2 is not None: + w2_shape = tuple(val.lokr_w2.shape[:2]) + elif val.lokr_t2 is not None: + w2_shape = (val.lokr_w2_a.shape[1], val.lokr_w2_b.shape[1]) + else: + # We may iterate over Conv2d layer, for which second item in shape is multiplied by ksize^2 + w2_shape = (val.lokr_w2_a.shape[0], val.lokr_w2_b.shape[1]) + + # We need to check, whether decompose_factor is really -1 or not + shape = (w1_shape[0], w2_shape[0]) + if factorization(shape[0] * shape[1], factor=-1) != shape: + raise ValueError("Cannot infer decompose_factor, probably it is not equal to -1") + + config = LoKrConfig( + r=r, + alpha=alpha, + target_modules=target_modules, + rank_dropout=0.0, + module_dropout=0.0, + init_weights=False, + rank_pattern=rank_pattern, + alpha_pattern=alpha_pattern, + use_effective_conv2d=use_effective_conv2d, + decompose_both=decompose_both, + decompose_factor=decompose_factor, + ) + + return config + + +def combine_peft_state_dict(info: dict[str, Union[LoRAInfo, LoHaInfo]]) -> dict[str, torch.Tensor]: + result = {} + for key_info in info.values(): + result.update(key_info.peft_state_dict()) + return result + + +def detect_adapter_type(keys: list[str]) -> PeftType: + # Detect type of adapter by keys + # Inspired by this: + # https://github.com/bmaltais/kohya_ss/blob/ed4e3b0239a40506de9a17e550e6cf2d0b867a4f/tools/lycoris_utils.py#L312 + for key in keys: + if "alpha" in key: + continue + elif any(x in key for x in ["lora_down", "lora_up"]): + # LoRA + return PeftType.LORA + elif any(x in key for x in ["hada_w1", "hada_w2", "hada_t1", "hada_t2"]): + # LoHa may have the following keys: + # hada_w1_a, hada_w1_b, hada_w2_a, hada_w2_b, hada_t1, hada_t2 + return PeftType.LOHA + elif any(x in key for x in ["lokr_w1", "lokr_w2", "lokr_t1", "lokr_t2"]): + # LoKr may have the following keys: + # lokr_w1, lokr_w2, lokr_w1_a, lokr_w1_b, lokr_w2_a, lokr_w2_b, lokr_t1, lokr_t2 + return PeftType.LOKR + elif "diff" in key: + raise ValueError("Currently full diff adapters are not implemented") + else: + raise ValueError("Unknown adapter type, probably not implemented") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + parser.add_argument("--sd_checkpoint", default=None, type=str, required=True, help="SD checkpoint to use") + + parser.add_argument( + "--adapter_path", + default=None, + type=str, + required=True, + help="Path to downloaded adapter to convert", + ) + + parser.add_argument("--dump_path", default=None, type=str, required=True, help="Path to the output peft adapter.") + + parser.add_argument("--half", action="store_true", help="Save weights in half precision.") + parser.add_argument( + "--loha_conv2d_weights_fix", + action="store_true", + help="""LoHa checkpoints trained with lycoris-lora<=1.9.0 contain a bug described in this PR https://github.com/KohakuBlueleaf/LyCORIS/pull/115. + This option fixes this bug during weight conversion (replaces hada_t2 with hada_t1 for Conv2d 3x3 layers). + The output results may differ from webui, but in general, they should be better in terms of quality. + This option should be set to True in case the provided checkpoint has been trained with lycoris-lora version for which the mentioned PR wasn't merged. + This option should be set to False in case the provided checkpoint has been trained with lycoris-lora version for which the mentioned PR is merged or full compatibility with webui outputs is required.""", + ) + args = parser.parse_args() + + # Load all models that we need to add adapter to + text_encoder = CLIPTextModel.from_pretrained(args.sd_checkpoint, subfolder="text_encoder") + unet = UNet2DConditionModel.from_pretrained(args.sd_checkpoint, subfolder="unet") + + # Construct possible mapping from kohya keys to peft keys + models_keys = {} + for model, model_key, model_name in [ + (text_encoder, PREFIX_TEXT_ENCODER, "text_encoder"), + (unet, PREFIX_UNET, "unet"), + ]: + models_keys.update( + { + f"{model_key}.{peft_key}".replace(".", "_"): peft_key + for peft_key in (x[0] for x in model.named_modules()) + } + ) + + # Store conversion info (model_type -> peft_key -> LoRAInfo | LoHaInfo | LoKrInfo) + adapter_info: dict[str, dict[str, Union[LoRAInfo, LoHaInfo, LoKrInfo]]] = { + "text_encoder": {}, + "unet": {}, + } + + # Store decompose_factor for LoKr + decompose_factor = -1 + + # Open adapter checkpoint + with safetensors.safe_open(args.adapter_path, framework="pt", device="cpu") as f: + # Extract information about adapter structure + metadata = f.metadata() + + # It may be difficult to determine rank for LoKr adapters + # If checkpoint was trained with large rank it may not be utilized during weights creation at all + # So we need to get it from checkpoint metadata (along with decompose_factor) + rank, conv_rank = None, None + if metadata is not None: + rank = metadata.get("ss_network_dim", None) + rank = int(rank) if rank else None + if "ss_network_args" in metadata: + network_args = json.loads(metadata["ss_network_args"]) + conv_rank = network_args.get("conv_dim", None) + conv_rank = int(conv_rank) if conv_rank else rank + decompose_factor = network_args.get("factor", -1) + decompose_factor = int(decompose_factor) + + # Detect adapter type based on keys + adapter_type = detect_adapter_type(f.keys()) + adapter_info_cls = { + PeftType.LORA: LoRAInfo, + PeftType.LOHA: LoHaInfo, + PeftType.LOKR: LoKrInfo, + }[adapter_type] + + # Iterate through available info and unpack all the values + for key in f.keys(): + kohya_key, kohya_type = key.split(".")[:2] + + # Find which model this key belongs to + if kohya_key.startswith(PREFIX_TEXT_ENCODER): + model_type, model = "text_encoder", text_encoder + elif kohya_key.startswith(PREFIX_UNET): + model_type, model = "unet", unet + else: + raise ValueError(f"Cannot determine model for key: {key}") + + # Find corresponding peft key + if kohya_key not in models_keys: + raise ValueError(f"Cannot find corresponding key for diffusers/transformers model: {kohya_key}") + peft_key = models_keys[kohya_key] + + # Retrieve corresponding layer of model + layer = attrgetter(peft_key)(model) + + # Create a corresponding adapter info + if peft_key not in adapter_info[model_type]: + adapter_info[model_type][peft_key] = adapter_info_cls(kohya_key=kohya_key, peft_key=peft_key) + + tensor = f.get_tensor(key) + if kohya_type == "alpha": + adapter_info[model_type][peft_key].alpha = tensor.item() + elif kohya_type == "lora_down": + adapter_info[model_type][peft_key].lora_A = tensor + adapter_info[model_type][peft_key].rank = tensor.shape[0] + elif kohya_type == "lora_up": + adapter_info[model_type][peft_key].lora_B = tensor + adapter_info[model_type][peft_key].rank = tensor.shape[1] + elif kohya_type == "hada_w1_a": + adapter_info[model_type][peft_key].hada_w1_a = tensor + elif kohya_type == "hada_w1_b": + adapter_info[model_type][peft_key].hada_w1_b = tensor + adapter_info[model_type][peft_key].rank = tensor.shape[0] + elif kohya_type == "hada_w2_a": + adapter_info[model_type][peft_key].hada_w2_a = tensor + elif kohya_type == "hada_w2_b": + adapter_info[model_type][peft_key].hada_w2_b = tensor + adapter_info[model_type][peft_key].rank = tensor.shape[0] + elif kohya_type in {"hada_t1", "hada_t2"}: + if args.loha_conv2d_weights_fix: + if kohya_type == "hada_t1": + # This code block fixes a bug that exists for some LoHa checkpoints + # that resulted in accidentally using hada_t1 weight instead of hada_t2, see + # https://github.com/KohakuBlueleaf/LyCORIS/pull/115 + adapter_info[model_type][peft_key].hada_t1 = tensor + adapter_info[model_type][peft_key].hada_t2 = tensor + adapter_info[model_type][peft_key].rank = tensor.shape[0] + else: + if kohya_type == "hada_t1": + adapter_info[model_type][peft_key].hada_t1 = tensor + adapter_info[model_type][peft_key].rank = tensor.shape[0] + elif kohya_type == "hada_t2": + adapter_info[model_type][peft_key].hada_t2 = tensor + adapter_info[model_type][peft_key].rank = tensor.shape[0] + elif kohya_type == "lokr_t2": + adapter_info[model_type][peft_key].lokr_t2 = tensor + adapter_info[model_type][peft_key].rank = tensor.shape[0] + elif kohya_type == "lokr_w1": + adapter_info[model_type][peft_key].lokr_w1 = tensor + if isinstance(layer, nn.Linear) or ( + isinstance(layer, nn.Conv2d) and tuple(layer.weight.shape[2:]) == (1, 1) + ): + adapter_info[model_type][peft_key].rank = rank + elif isinstance(layer, nn.Conv2d): + adapter_info[model_type][peft_key].rank = conv_rank + elif kohya_type == "lokr_w2": + adapter_info[model_type][peft_key].lokr_w2 = tensor + if isinstance(layer, nn.Linear) or ( + isinstance(layer, nn.Conv2d) and tuple(layer.weight.shape[2:]) == (1, 1) + ): + adapter_info[model_type][peft_key].rank = rank + elif isinstance(layer, nn.Conv2d): + adapter_info[model_type][peft_key].rank = conv_rank + elif kohya_type == "lokr_w1_a": + adapter_info[model_type][peft_key].lokr_w1_a = tensor + adapter_info[model_type][peft_key].rank = tensor.shape[1] + elif kohya_type == "lokr_w1_b": + adapter_info[model_type][peft_key].lokr_w1_b = tensor + adapter_info[model_type][peft_key].rank = tensor.shape[0] + elif kohya_type == "lokr_w2_a": + adapter_info[model_type][peft_key].lokr_w2_a = tensor + elif kohya_type == "lokr_w2_b": + adapter_info[model_type][peft_key].lokr_w2_b = tensor + else: + raise ValueError(f"Unknown weight name in key: {key} - {kohya_type}") + + # Get function which will create adapter config based on extracted info + construct_config_fn = { + PeftType.LORA: construct_peft_loraconfig, + PeftType.LOHA: construct_peft_lohaconfig, + PeftType.LOKR: construct_peft_lokrconfig, + }[adapter_type] + + # Process each model sequentially + for model, model_name in [(text_encoder, "text_encoder"), (unet, "unet")]: + # Skip model if no data was provided + if len(adapter_info[model_name]) == 0: + continue + + config = construct_config_fn(adapter_info[model_name], decompose_factor=decompose_factor) + + # Output warning for LoHa with use_effective_conv2d + if ( + isinstance(config, LoHaConfig) + and getattr(config, "use_effective_conv2d", False) + and args.loha_conv2d_weights_fix is False + ): + logger.warning( + 'lycoris-lora<=1.9.0 LoHa implementation contains a bug, which can be fixed with "--loha_conv2d_weights_fix".\n' + "For more info, please refer to https://github.com/huggingface/peft/pull/1021 and https://github.com/KohakuBlueleaf/LyCORIS/pull/115" + ) + + model = get_peft_model(model, config) + missing_keys, unexpected_keys = set_peft_model_state_dict( + model, combine_peft_state_dict(adapter_info[model_name]) + ) + if len(unexpected_keys) > 0: + raise ValueError(f"Unexpected keys {unexpected_keys} found during conversion") + + if args.half: + model.to(torch.float16) + + # Save model to disk + model.save_pretrained(os.path.join(args.dump_path, model_name)) diff --git a/tasks/tasksmith-c488fc138ba1/environment/source/examples/stable_diffusion/inc_flux_lora_hpu.py b/tasks/tasksmith-c488fc138ba1/environment/source/examples/stable_diffusion/inc_flux_lora_hpu.py new file mode 100644 index 0000000000000000000000000000000000000000..5c0b24928100c3756a3c7148a740dfeb48cbe9f2 --- /dev/null +++ b/tasks/tasksmith-c488fc138ba1/environment/source/examples/stable_diffusion/inc_flux_lora_hpu.py @@ -0,0 +1,67 @@ +""" +This exampe demonstrates loading of LoRA adapter (via PEFT) into an FP8 INC-quantized FLUX model. + +More info on Intel Neural Compressor (INC) FP8 quantization is available at: +https://github.com/intel/neural-compressor/tree/master/examples/helloworld/fp8_example + +Requirements: +pip install optimum-habana sentencepiece neural-compressor[pt] peft +""" + +import importlib + +import torch +from neural_compressor.torch.quantization import FP8Config, convert, finalize_calibration, prepare + + +# Checks if HPU device is available +# Adapted from https://github.com/huggingface/accelerate/blob/b451956fd69a135efc283aadaa478f0d33fcbe6a/src/accelerate/utils/imports.py#L435 +def is_hpu_available(): + if ( + importlib.util.find_spec("habana_frameworks") is None + or importlib.util.find_spec("habana_frameworks.torch") is None + ): + return False + + import habana_frameworks.torch # noqa: F401 + + return hasattr(torch, "hpu") and torch.hpu.is_available() + + +# Ensure HPU device is available before proceeding +if is_hpu_available(): + from optimum.habana.diffusers import GaudiFluxPipeline +else: + raise RuntimeError("HPU device not found. This code requires Intel Gaudi device to run.") + +# Example: FLUX model inference on HPU via optimum-habana pipeline +hpu_configs = { + "use_habana": True, + "use_hpu_graphs": True, + "sdp_on_bf16": True, + "gaudi_config": "Habana/stable-diffusion", +} +pipe = GaudiFluxPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", torch_dtype=torch.bfloat16, **hpu_configs) +prompt = "A picture of sks dog in a bucket" + +# Quantize FLUX transformer to FP8 using INC (Intel Neural Compressor) +quant_configs = { + "mode": "AUTO", + "observer": "maxabs", + "scale_method": "maxabs_hw", + "allowlist": {"types": [], "names": []}, + "blocklist": {"types": [], "names": []}, + "dump_stats_path": "/tmp/hqt_output/measure", +} +config = FP8Config(**quant_configs) +pipe.transformer = prepare(pipe.transformer, config) +pipe(prompt) +finalize_calibration(pipe.transformer) +pipe.transformer = convert(pipe.transformer) + +# Load LoRA weights with PEFT +pipe.load_lora_weights("dsocek/lora-flux-dog", adapter_name="user_lora") + +# Run inference +image = pipe(prompt).images[0] +image.save("dog.png")