sft init save

cua_lite/train/collators.py

@@ -0,0 +1,125 @@
+from dataclasses import dataclass
+from typing import Any
+
+from transformers import ProcessorMixin
+from transformers.data.data_collator import DataCollatorMixin
+
+
+def insert_images_into_messages(messages, images):
+    # Use an iterator to avoid manual index management; this is more Pythonic
+    images_iter = iter(images)
+    
+    for message in messages:
+        # Skip messages that are not from the user
+        if message["role"] != "user":
+            continue
+            
+        # 1. Normalization Logic
+        # (Convert string content to list format if necessary)
+        if isinstance(message["content"], str):
+            message["content"] = [{"type": "text", "text": message["content"]}]
+            # Strings cannot contain image placeholders, so skip the rest of the loop
+            continue 
+
+        # 2. Image Injection Logic
+        for item in message["content"]:
+            if item.get("type") == "image":
+                try:
+                    # Get the next image and update the dictionary in-place
+                    item["image"] = next(images_iter)
+                except StopIteration:
+                    raise ValueError("Not enough images provided for the placeholders in messages.")
+
+    # 3. Validation: Check for surplus images
+    # If the iterator still has items, it means too many images were provided
+    if next(images_iter, None) is not None:
+        raise ValueError(f"Too many images provided. Total provided: {len(images)}")
+
+    return messages
+
+def phantomize_images_in_messages(messages):
+    for message in messages:
+        if message["role"] == "user":
+            if isinstance(message["content"], list):
+                for i in range(len(message["content"])):
+                    if message["content"][i]["type"] == "image":
+                        message["content"][i] = {"type": "image"}
+    return messages
+
+@dataclass
+class DataCollatorForVisionLanguageModeling(DataCollatorMixin):
+    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]:
+        assert "messages" in examples[0]
+        assert all(example["messages"][-1]["role"] == "assistant" for example in examples)
+        if "images" in examples[0]:
+            # merge images into messages
+            for example in examples:
+                insert_images_into_messages(example["messages"], example["images"])
+                example.pop("images")
+
+        apply_chat_template_kwargs = dict(
+            tokenize=True,
+            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_dict=True,
+            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
+        )
+        
+        output = self.processor.apply_chat_template(
+            [example["messages"] for example in examples],
+            **apply_chat_template_kwargs,
+        )
+
+        labels = output["input_ids"].clone()
+
+        # mask labels not belonging to the last turn response
+        if self.completion_only_loss:
+            # TODO: remove redundant image processing
+            non_completion_output = self.processor.apply_chat_template(
+                [example["messages"][:-1] for example in examples],
+                add_generation_prompt=True,
+                **apply_chat_template_kwargs,
+            )
+            for i in labels.size(0):
+                labels[i, :sum(non_completion_output["attention_mask"][i])] = -100
+
+        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
+
+
+if __name__ == "__main__":
+    from datasets import load_dataset
+    from transformers import AutoProcessor
+
+    from cua_lite.utils import resolve_with_base_env
+    from trl.trainer import sft_trainer
+
+    dataset_path = "HuggingFaceH4/llava-instruct-mix-vsft"
+    dataset_path = resolve_with_base_env(dataset_path, "BASE_DATASETS_DIR")
+    dataset = load_dataset(dataset_path)
+
+    processor_path = "Qwen/Qwen3-VL-2B-Thinking"
+    processor_path = resolve_with_base_env(processor_path, "BASE_MODELS_DIR")
+    processor = AutoProcessor.from_pretrained(processor_path)
+
+    collator = DataCollatorForVisionLanguageModeling(processor=processor, completion_only_loss=True)
+    output = collator([dataset["train"][0], dataset["train"][1]])
+
+    trl_collator = sft_trainer.DataCollatorForVisionLanguageModeling(processor=processor)
+    trl_output = collator([dataset["train"][0], dataset["train"][1]])
+    breakpoint()

cua_lite/train/sft.py

@@ -58,8 +58,7 @@ import os
 
 import torch
 from datasets import load_dataset
-from transformers import AutoModelForImageTextToText
-
+from transformers import AutoModelForImageTextToText, AutoProcessor
 from trl import (
     ModelConfig,
     ScriptArguments,
@@ -71,6 +70,8 @@ from trl import (
     get_quantization_config,
 )
 
+from cua_lite.train.collators import DataCollatorForVisionLanguageModeling
+
 
 # Enable logging in a Hugging Face Space
 os.environ.setdefault("TRACKIO_SPACE_ID", "trl-trackio")
@@ -98,6 +99,9 @@ if __name__ == "__main__":
     model = AutoModelForImageTextToText.from_pretrained(
         model_args.model_name_or_path, trust_remote_code=model_args.trust_remote_code, **model_kwargs
     )
+    processor = AutoProcessor.from_pretrained(
+        model_args.model_name_or_path, trust_remote_code=model_args.trust_remote_code
+    )
 
     ################
     # Dataset
@@ -107,9 +111,16 @@ if __name__ == "__main__":
     ################
     # Training
     ################
+    data_collator = DataCollatorForVisionLanguageModeling(
+        processor=processor,
+        max_length=training_args.max_length,
+        completion_only_loss=training_args.completion_only_loss,
+        pad_to_multiple_of=training_args.pad_to_multiple_of,
+    )
     trainer = SFTTrainer(
         model=model,
         args=training_args,
+        data_collator=data_collator,
         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),

cua_lite/utils/__init__.py

@@ -0,0 +1 @@
+from cua_lite.utils.utils import *

cua_lite/utils/utils.py

@@ -0,0 +1,23 @@
+import os
+
+def resolve_with_base_env(path: str, env_name: str) -> str:
+    """
+    If `env_name` is set and `path` is NOT absolute, NOT a URL/scheme,
+    and does not already exist locally, prepend the `env_name` directory.
+
+    If the resulting path does not exist, return the base environment directory instead.
+    Otherwise return `path` unchanged.
+    """
+    base = os.getenv(env_name, "").strip()
+    if not base:
+        return path
+    if os.path.isabs(path):
+        return path
+    if os.path.exists(path):
+        return path
+
+    candidate = os.path.join(base.rstrip("/"), path.lstrip("/"))
+    if os.path.exists(candidate):
+        return candidate
+    else:
+        raise FileNotFoundError