Add files using upload-large-folder tool

.gitattributes

@@ -97,3 +97,18 @@ LTA_openwebtext_dualt/mini_owt_logdirichlet/cache/owt_llmclean_qwen36_35b_articl
 LTA_openwebtext_dualt/mini_owt_logdirichlet/cache/owt_llmclean_qwen36_35b_articlefull_300k_snapshot_rev8_docs600000_shards32/part-029.jsonl filter=lfs diff=lfs merge=lfs -text
 LTA_openwebtext_dualt/mini_owt_logdirichlet/cache/owt_llmclean_qwen36_35b_articlefull_300k_snapshot_rev8_docs600000_shards32/part-019.jsonl filter=lfs diff=lfs merge=lfs -text
 LTA_openwebtext_dualt/mini_owt_logdirichlet/cache/owt_llmclean_qwen36_35b_articlefull_full_rev8/audit.jsonl filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/safetensors/_safetensors_rust.abi3.so filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/tokenizers/tokenizers.abi3.so filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/linalg/_umath_linalg.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/core/_multiarray_umath.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/core/_simd.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/core/_multiarray_tests.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node1_gpu1_port8009.log filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node0_gpu4_port8012.log filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node0_gpu7_port8015.log filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node1_gpu5_port8013.log filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node1_gpu0_port8008.log filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node0_gpu1_port8009.log filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node0_gpu3_port8011.log filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node1_gpu4_port8012.log filter=lfs diff=lfs merge=lfs -text
+LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_gpu1_port8009.log filter=lfs diff=lfs merge=lfs -text

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/core/_multiarray_tests.cpython-312-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b2cbb7419ffc2f712987aabaf518a3b1d9de8406093f79dcb1d712a34ab6057
+size 175912

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/core/_multiarray_umath.cpython-312-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a650810a8735cbdb988f74729973740a337645dd1585fef696e73e2dbc65beb
+size 7463681

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/core/_simd.cpython-312-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9402bc6bcb8a8da62816a3106415a756f8de526f8a0ec9d9cf21ff453865f5da
+size 3535232

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/core/tests/data/numpy_2_0_array.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:561d36b5dc82ca96bc35be10cdd5619c30225c43b6590adcc1cbce7430c5179c
+size 718

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/numpy/linalg/_umath_linalg.cpython-312-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8822e772d743d405983f1b9c6b34b704dd297780890dc245454f1081adf50a4c
+size 216793

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/safetensors/_safetensors_rust.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87da8f4733e6ecf840a5d8e2b1de888cad012c23755118919567ec480a7d7e02
+size 1216632

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/tokenizers/tokenizers.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c116fcf1e80d461ce0a35c332974f25949e8359416f50b3d53371810d2ce1ccc
+size 10074176

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/idefics2/__init__.py

@@ -0,0 +1,30 @@
+# Copyright 2024 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 ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+    from .configuration_idefics2 import *
+    from .image_processing_idefics2 import *
+    from .image_processing_pil_idefics2 import *
+    from .modeling_idefics2 import *
+    from .processing_idefics2 import *
+else:
+    import sys
+
+    _file = globals()["__file__"]
+    sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/idefics2/configuration_idefics2.py

@@ -0,0 +1,165 @@
+# Copyright 2024 The HuggingFace Inc. 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.
+"""Idefics2 model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring, logging
+from ..auto import CONFIG_MAPPING, AutoConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+@auto_docstring(checkpoint="HuggingFaceM4/idefics2-8b")
+@strict
+class Idefics2VisionConfig(PreTrainedConfig):
+    r"""
+    Example:
+
+    ```python
+    >>> from transformers.models.idefics2.modeling_idefics2 import Idefics2VisionTransformer
+    >>> from transformers.models.idefics2.configuration_idefics2 import Idefics2VisionConfig
+
+    >>> # Initializing a Idefics2VisionConfig with google/siglip-base-patch16-224 style configuration
+    >>> configuration = Idefics2VisionConfig()
+
+    >>> # Initializing a Idefics2VisionTransformer (with random weights) from the google/siglip-base-patch16-224 style configuration
+    >>> model = Idefics2VisionTransformer(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "idefics2_vision"
+    base_config_key = "vision_config"
+
+    hidden_size: int = 768
+    intermediate_size: int = 3072
+    num_hidden_layers: int = 12
+    num_attention_heads: int = 12
+    num_channels: int = 3
+    image_size: int | list[int] | tuple[int, int] = 224
+    patch_size: int | list[int] | tuple[int, int] = 32
+    hidden_act: str = "gelu_pytorch_tanh"
+    layer_norm_eps: float = 1e-6
+    attention_dropout: float | int = 0.0
+    initializer_range: float = 0.02
+
+
+@auto_docstring(checkpoint="HuggingFaceM4/idefics2-8b")
+@strict
+class Idefics2PerceiverConfig(PreTrainedConfig):
+    r"""
+    resampler_n_latents (`int`, *optional*, defaults to 64):
+        Number of latent embeddings to resample ("compress") the input sequence to (usually < 128).
+    resampler_depth (`int`, *optional*, defaults to 3):
+        Depth of the Perceiver Resampler (Transformer w/ cross attention). Should be shallow (<= 3).
+    resampler_n_heads (`int`, *optional*, defaults to 16):
+        Number of heads in each Transformer block (for multi-headed self-attention).
+    resampler_head_dim (`int`, *optional*, defaults to 96):
+        Dimensionality of each head projection in the Transformer block.
+    """
+
+    model_type = "idefics2_perceiver"
+
+    hidden_act: str = "silu"
+    hidden_size: int = 4096
+    rms_norm_eps: float = 1e-06
+    resampler_n_latents: int = 64
+    resampler_depth: int = 3
+    resampler_n_heads: int = 16
+    resampler_head_dim: int = 96
+    num_key_value_heads: int = 4
+    attention_dropout: float | int = 0.0
+    initializer_range: float = 0.02
+
+    def validate_architecture(self):
+        """Part of `@strict`-powered validation. Validates the architecture of the config."""
+        if self.num_key_value_heads > self.resampler_n_heads:
+            raise ValueError(
+                f"num_key_value_heads={self.num_key_value_heads} must be less than or equal to"
+                f" resampler_n_heads={self.resampler_n_heads}"
+            )
+
+
+@auto_docstring(checkpoint="HuggingFaceM4/idefics2-8b")
+@strict
+class Idefics2Config(PreTrainedConfig):
+    r"""
+    perceiver_config (`IdeficsPerceiverConfig` or `dict`, *optional*):
+        Custom perceiver config or dict
+
+    Example:
+    ```python
+    >>> from transformers import Idefics2Model, Idefics2Config
+    >>> # Initializing configuration
+    >>> configuration = Idefics2Config()
+    >>> # Initializing a model from the configuration
+    >>> model = Idefics2Model(configuration)
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "idefics2"
+    sub_configs = {
+        "text_config": AutoConfig,
+        "perceiver_config": Idefics2PerceiverConfig,
+        "vision_config": Idefics2VisionConfig,
+    }
+
+    use_cache: bool = True
+    image_token_id: int = 32_001
+    tie_word_embeddings: bool = False
+    vision_config: dict | PreTrainedConfig | None = None
+    perceiver_config: dict | PreTrainedConfig | None = None
+    text_config: dict | PreTrainedConfig | None = None
+
+    def __post_init__(self, **kwargs):
+        if self.perceiver_config is None:
+            self.perceiver_config = Idefics2PerceiverConfig()
+            logger.info("perciver_config is None, using default perceiver config")
+        elif isinstance(self.perceiver_config, dict):
+            self.perceiver_config = Idefics2PerceiverConfig(**self.perceiver_config)
+
+        if self.vision_config is None:
+            self.vision_config = Idefics2VisionConfig()
+            logger.info("vision_config is None, using default vision config")
+        elif isinstance(self.vision_config, dict):
+            self.vision_config = Idefics2VisionConfig(**self.vision_config)
+
+        if isinstance(self.text_config, dict):
+            self.text_config["model_type"] = self.text_config.get("model_type", "mistral")
+            self.text_config = CONFIG_MAPPING[self.text_config["model_type"]](**self.text_config)
+        elif self.text_config is None:
+            logger.info("text_config is None, using default text config")
+            self.text_config = CONFIG_MAPPING["mistral"](
+                max_position_embeddings=4096 * 8,
+                rms_norm_eps=1e-5,
+                # None in the original configuration_mistral, we set it to the unk_token_id
+                pad_token_id=0,
+            )
+
+        if self.text_config.hidden_size != self.perceiver_config.hidden_size:
+            self.perceiver_config.hidden_size = self.text_config.hidden_size
+            self.perceiver_config.rms_norm_eps = self.text_config.rms_norm_eps
+            logger.warning_once(
+                "Perceiver config has a different `hidden_size` than text config, which means default values were used. "
+                "In your model's config on the hub, add `hidden_size` and `rms_norm_eps` keys under the `perceiver_config` dict. "
+            )
+
+        super().__post_init__(**kwargs)
+
+
+__all__ = ["Idefics2Config", "Idefics2PerceiverConfig", "Idefics2VisionConfig"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/idefics2/image_processing_idefics2.py

@@ -0,0 +1,289 @@
+# Copyright 2025 The HuggingFace Inc. 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.
+"""Image processor class for Idefics2."""
+
+import numpy as np
+import torch
+
+from ...image_processing_backends import TorchvisionBackend
+from ...image_processing_utils import BatchFeature
+from ...image_transforms import group_images_by_shape, reorder_images
+from ...image_utils import (
+    IMAGENET_STANDARD_MEAN,
+    IMAGENET_STANDARD_STD,
+    ImageInput,
+    PILImageResampling,
+    SizeDict,
+    make_nested_list_of_images,
+)
+from ...processing_utils import ImagesKwargs, Unpack
+from ...utils import TensorType, auto_docstring, is_vision_available
+
+
+if is_vision_available():
+    from PIL import Image
+
+from torchvision.transforms.v2 import functional as tvF
+
+
+def get_resize_output_image_size(image, size: SizeDict) -> tuple[int, int]:
+    """
+    Get the output size of the image after resizing given a dictionary specifying the max and min sizes.
+    Images are always channels-first (CHW).
+    """
+    height, width = image.shape[-2:]
+
+    min_len = size.shortest_edge
+    max_len = size.longest_edge
+    aspect_ratio = width / height
+
+    if width >= height and width > max_len:
+        width = max_len
+        height = int(width / aspect_ratio)
+    elif height > width and height > max_len:
+        height = max_len
+        width = int(height * aspect_ratio)
+    height = max(height, min_len)
+    width = max(width, min_len)
+    return height, width
+
+
+def convert_to_rgb(image: ImageInput) -> ImageInput:
+    """
+    Converts an image to RGB format. Only converts if the image is of type PIL.Image.Image, otherwise returns the image
+    as is.
+    """
+    if not is_vision_available() or not isinstance(image, Image.Image):
+        return image
+
+    if image.mode == "RGB":
+        return image
+
+    image_rgba = image.convert("RGBA")
+    background = Image.new("RGBA", image_rgba.size, (255, 255, 255))
+    alpha_composite = Image.alpha_composite(background, image_rgba)
+    alpha_composite = alpha_composite.convert("RGB")
+    return alpha_composite
+
+
+class Idefics2ImageProcessorKwargs(ImagesKwargs, total=False):
+    r"""
+    do_image_splitting (`bool`, *optional*, defaults to `self.do_image_splitting`):
+        Whether to split the image into a sequence 4 equal sub-images concatenated with the original image.
+    """
+
+    do_image_splitting: bool
+
+
+def get_max_height_width(images_list: list[list["torch.Tensor|np.ndarray"]]) -> tuple[int, int]:
+    """
+    Get the maximum height and width across all images in a batch.
+    """
+    image_sizes = []
+    for images in images_list:
+        for image in images:
+            image_sizes.append(image.shape[-2:])
+
+    max_height = max(size[0] for size in image_sizes)
+    max_width = max(size[1] for size in image_sizes)
+    return (max_height, max_width)
+
+
+def make_pixel_mask(image: "torch.Tensor", output_size: tuple[int, int]) -> "torch.Tensor":
+    """
+    Make a pixel mask for the image, where 1 indicates a valid pixel and 0 indicates padding.
+    """
+    input_height, input_width = image.shape[-2:]
+    mask = torch.zeros(output_size, dtype=torch.int64, device=image.device)
+    mask[:input_height, :input_width] = 1
+    return mask
+
+
+@auto_docstring
+class Idefics2ImageProcessor(TorchvisionBackend):
+    valid_kwargs = Idefics2ImageProcessorKwargs
+    resample = PILImageResampling.BILINEAR
+    image_mean = IMAGENET_STANDARD_MEAN
+    image_std = IMAGENET_STANDARD_STD
+    do_resize = True
+    do_rescale = True
+    do_normalize = True
+    do_pad = True
+    do_convert_rgb = True
+    do_image_splitting = False
+    default_to_square = False
+    size = {"shortest_edge": 378, "longest_edge": 980}
+    model_input_names = ["pixel_values", "pixel_attention_mask"]
+
+    def __init__(self, **kwargs: Unpack[Idefics2ImageProcessorKwargs]):
+        super().__init__(**kwargs)
+
+    @auto_docstring
+    def preprocess(self, images: ImageInput, **kwargs: Unpack[Idefics2ImageProcessorKwargs]) -> BatchFeature:
+        return super().preprocess(images, **kwargs)
+
+    def convert_to_rgb(self, image: ImageInput) -> ImageInput:
+        """Convert an image to RGB format."""
+        return convert_to_rgb(image)
+
+    def resize(
+        self,
+        image: "torch.Tensor",
+        size: SizeDict,
+        resample: "PILImageResampling | tvF.InterpolationMode | int | None" = None,
+        **kwargs,
+    ) -> "torch.Tensor":
+        """Resize using Idefics2 shortest_edge/longest_edge logic."""
+        if size.shortest_edge and size.longest_edge:
+            new_size = get_resize_output_image_size(image, size)
+        elif size.height and size.width:
+            new_size = (size.height, size.width)
+        else:
+            raise ValueError("Size must contain 'height' and 'width' keys or 'shortest_edge' and 'longest_edge' keys.")
+
+        return super().resize(image, SizeDict(height=new_size[0], width=new_size[1]), resample=resample, **kwargs)
+
+    def _prepare_images_structure(self, images: ImageInput, expected_ndims: int = 3) -> ImageInput:
+        """Prepare a nested images structure for processing."""
+        images = self.fetch_images(images)
+        return make_nested_list_of_images(images, expected_ndims=expected_ndims)
+
+    def split_images(self, images: "torch.Tensor") -> list[list["torch.Tensor"]]:
+        """
+        Split a batch of images into 4 equal sub-images, and concatenate that sequence with the original image.
+        """
+        height, width = images.shape[-2:]
+
+        mid_width = width // 2
+        mid_height = height // 2
+
+        batch_split_images = [
+            images[..., :mid_height, :mid_width],
+            images[..., :mid_height, mid_width:],
+            images[..., mid_height:, :mid_width],
+            images[..., mid_height:, mid_width:],
+            images,
+        ]
+
+        batch_split_images = [[image[i] for image in batch_split_images] for i in range(len(batch_split_images[0]))]
+        return batch_split_images
+
+    def pad(
+        self, image: "torch.Tensor", padded_size: tuple[int, int], fill: int = 0
+    ) -> tuple["torch.Tensor", "torch.Tensor"]:
+        """
+        Pad an image to the specified size and create the corresponding pixel mask.
+        """
+        original_size = image.shape[-2:]
+        padding_bottom = padded_size[0] - original_size[0]
+        padding_right = padded_size[1] - original_size[1]
+
+        if padding_bottom < 0 or padding_right < 0:
+            raise ValueError(
+                f"Padding dimensions are negative. Please make sure that the padded size is larger than the "
+                f"original size. Got padded size: {padded_size}, original size: {original_size}."
+            )
+
+        if original_size != padded_size:
+            padding = (0, 0, padding_right, padding_bottom)
+            image = tvF.pad(image, padding, fill=fill, padding_mode="constant")
+
+        pixel_mask = torch.zeros(padded_size, dtype=torch.int64, device=image.device)
+        pixel_mask[: original_size[0], : original_size[1]] = 1
+
+        return image, pixel_mask
+
+    def _preprocess(
+        self,
+        images: list[list["torch.Tensor"]],
+        do_resize: bool,
+        size: SizeDict,
+        resample: "PILImageResampling | tvF.InterpolationMode | int | None",
+        do_rescale: bool,
+        rescale_factor: float,
+        do_normalize: bool,
+        image_mean: float | list[float] | None,
+        image_std: float | list[float] | None,
+        do_pad: bool | None,
+        do_image_splitting: bool | None,
+        disable_grouping: bool | None,
+        return_tensors: str | TensorType | None,
+        **kwargs,
+    ) -> BatchFeature:
+        grouped_images, grouped_images_index = group_images_by_shape(
+            images, disable_grouping=disable_grouping, is_nested=True
+        )
+        split_images_grouped = {}
+        for shape, stacked_images in grouped_images.items():
+            if do_image_splitting:
+                stacked_images = self.split_images(stacked_images)
+            split_images_grouped[shape] = stacked_images
+        split_images = reorder_images(split_images_grouped, grouped_images_index, is_nested=True)
+        if do_image_splitting:
+            for i, group_images in enumerate(split_images):
+                split_images[i] = [image for sublist in group_images for image in sublist]
+
+        grouped_images, grouped_images_index = group_images_by_shape(
+            split_images, disable_grouping=disable_grouping, is_nested=True
+        )
+        resized_images_grouped = {}
+        for shape, stacked_images in grouped_images.items():
+            if do_resize:
+                stacked_images = self.resize(stacked_images, size, resample=resample)
+            resized_images_grouped[shape] = stacked_images
+        resized_images = reorder_images(resized_images_grouped, grouped_images_index, is_nested=True)
+
+        grouped_images, grouped_images_index = group_images_by_shape(
+            resized_images, disable_grouping=disable_grouping, is_nested=True
+        )
+        processed_images_grouped = {}
+        for shape, stacked_images in grouped_images.items():
+            stacked_images = self.rescale_and_normalize(
+                stacked_images, do_rescale, rescale_factor, do_normalize, image_mean, image_std
+            )
+            processed_images_grouped[shape] = stacked_images
+        processed_images = reorder_images(processed_images_grouped, grouped_images_index, is_nested=True)
+
+        if do_pad:
+            max_num_images = max(len(images_) for images_ in processed_images)
+            max_height, max_width = get_max_height_width(processed_images)
+
+            processed_images_padded = torch.zeros(
+                len(processed_images),
+                max_num_images,
+                *(processed_images[0][0].shape[0], max_height, max_width),
+                device=processed_images[0][0].device,
+            )
+            pixel_attention_masks = torch.zeros(
+                len(processed_images),
+                max_num_images,
+                *(max_height, max_width),
+                device=processed_images[0][0].device,
+            )
+            for i, images in enumerate(processed_images):
+                for j, image in enumerate(images):
+                    processed_images_padded[i, j], pixel_attention_masks[i, j] = self.pad(
+                        image, (max_height, max_width)
+                    )
+            processed_images = processed_images_padded
+        if do_pad:
+            data = {"pixel_values": processed_images, "pixel_attention_mask": pixel_attention_masks}
+        elif return_tensors == "pt":
+            data = {"pixel_values": torch.stack([torch.stack(images) for images in processed_images])}
+        else:
+            data = {"pixel_values": processed_images}
+        return BatchFeature(data=data, tensor_type=return_tensors)
+
+
+__all__ = ["Idefics2ImageProcessor"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/idefics2/processing_idefics2.py

@@ -0,0 +1,190 @@
+# Copyright 2024 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.
+"""
+Processor class for IDEFICS2.
+"""
+
+import re
+from itertools import accumulate
+from typing import TYPE_CHECKING, Union
+
+from ...feature_extraction_utils import BatchFeature
+from ...image_utils import ImageInput, is_valid_image, load_image
+from ...processing_utils import (
+    ProcessingKwargs,
+    ProcessorMixin,
+    Unpack,
+)
+from ...tokenization_utils_base import AddedToken, TextInput
+from ...utils import auto_docstring, logging
+
+
+if TYPE_CHECKING:
+    from ...tokenization_utils_base import PreTokenizedInput
+
+
+logger = logging.get_logger(__name__)
+
+
+def is_url(val) -> bool:
+    return isinstance(val, str) and val.startswith("http")
+
+
+def is_image_or_image_url(elem):
+    return is_url(elem) or is_valid_image(elem)
+
+
+class Idefics2ProcessorKwargs(ProcessingKwargs, total=False):
+    _defaults = {
+        "text_kwargs": {
+            "add_special_tokens": True,
+            "padding": False,
+            "is_split_into_words": False,
+        },
+    }
+
+
+@auto_docstring
+class Idefics2Processor(ProcessorMixin):
+    def __init__(
+        self, image_processor, tokenizer=None, image_seq_len: int = 64, chat_template: str | None = None, **kwargs
+    ):
+        r"""
+        image_seq_len (`int`, *optional*, defaults to 64):
+            The length of the image sequence i.e. the number of <image> tokens per image in the input.
+            This parameter is used to build the string from the input prompt and image tokens and should match the
+            config.perceiver_config.resampler_n_latents value for the model used.
+        """
+        if not hasattr(tokenizer, "image_token"):
+            self.fake_image_token = AddedToken("<fake_token_around_image>", normalized=False, special=True).content
+            self.image_token = AddedToken("<image>", normalized=False, special=True).content
+            tokens_to_add = {"additional_special_tokens": [self.fake_image_token, self.image_token]}
+            tokenizer.add_special_tokens(tokens_to_add)
+            self.image_token_id = tokenizer.convert_tokens_to_ids(self.image_token)
+        else:
+            self.fake_image_token = tokenizer.image_boundary_token
+            self.image_token = tokenizer.image_token
+            self.image_token_id = tokenizer.image_token_id
+
+        self.end_of_utterance_token = AddedToken("<end_of_utterance>", normalized=False, special=True)
+        tokenizer.add_special_tokens({"additional_special_tokens": [self.end_of_utterance_token]})
+        self.image_seq_len = image_seq_len
+
+        super().__init__(image_processor, tokenizer, chat_template=chat_template)
+
+    def _extract_images_from_prompts(self, prompts):
+        prompt_images = []
+        for prompt in prompts:
+            images = []
+            for elem in prompt:
+                if is_valid_image(elem):
+                    images.append(elem)
+                elif is_url(elem):
+                    images.append(load_image(elem))
+            prompt_images.append(images)
+        return prompt_images
+
+    @auto_docstring
+    def __call__(
+        self,
+        images: ImageInput | list[ImageInput] | list[list[ImageInput]] = None,
+        text: Union[TextInput, "PreTokenizedInput", list[TextInput], list["PreTokenizedInput"]] = None,
+        **kwargs: Unpack[Idefics2ProcessorKwargs],
+    ) -> BatchFeature:
+        if text is None and images is None:
+            raise ValueError("You must provide either `text` or `images`.")
+
+        output_kwargs = self._merge_kwargs(
+            Idefics2ProcessorKwargs,
+            tokenizer_init_kwargs=self.tokenizer.init_kwargs,
+            **kwargs,
+        )
+        return_tensors = output_kwargs["text_kwargs"].pop("return_tensors", None)
+
+        n_images_in_text = []
+        inputs = {}
+
+        if text is not None:
+            if isinstance(text, str):
+                text = [text]
+            elif not isinstance(text, list) and not isinstance(text[0], str):
+                raise ValueError("Invalid input text. Please provide a string, or a list of strings")
+
+            # Replace the image token with fake tokens around the expanded image token sequence of length `image_seq_len`
+            fake_image_token = self.fake_image_token
+            image_token = self.image_token
+            image_str = f"{fake_image_token}{image_token * self.image_seq_len}{fake_image_token}"
+
+            if self.image_processor.do_image_splitting:
+                # A single image token is split into 4 patches + 1 original image
+                image_str = image_str * 5
+
+            prompt_strings = []
+            closing_fake_pattern = re.compile(rf"{re.escape(fake_image_token)}(?=[^\s<])")
+            for sample in text:
+                n_images_in_text.append(sample.count(image_token))
+                sample = sample.replace(image_token, image_str)
+                # Remove any double fake tokens if images are adjacent
+                sample = sample.replace(f"{fake_image_token}{fake_image_token}", f"{fake_image_token}")
+                # Ensure words attached directly after the closing fake token remain word-boundary aligned
+                sample = closing_fake_pattern.sub(f"{fake_image_token} ", sample)
+                prompt_strings.append(sample)
+
+            text_inputs = self.tokenizer(prompt_strings, **output_kwargs["text_kwargs"])
+            self._check_special_mm_tokens(prompt_strings, text_inputs, modalities=["image"])
+            inputs.update(text_inputs)
+
+        if images is not None:
+            if is_image_or_image_url(images):
+                images = [[images]]
+            elif isinstance(images, (list, tuple)) and is_image_or_image_url(images[0]):
+                if text is not None:
+                    if sum(n_images_in_text) != len(images):
+                        raise ValueError(
+                            f"The total number of {image_token} tokens in the prompts should be the same as the number of images passed."
+                            f" Found {sum(n_images_in_text)} {image_token} tokens and {len(images)} images."
+                        )
+                    # Reorganize the images to match the prompts
+                    cumsum_images_in_text = [0] + list(accumulate(n_images_in_text))
+                    images = [
+                        images[cumsum_images_in_text[i] : cumsum_images_in_text[i + 1]]
+                        for i in range(len(n_images_in_text))
+                    ]
+                else:
+                    images = [images]
+
+            elif (
+                not isinstance(images, (list, tuple))
+                and not isinstance(images[0], (list, tuple))
+                and not is_image_or_image_url(images[0][0])
+            ):
+                raise ValueError(
+                    "Invalid input images. Please provide a single image or a list of images or a list of list of images."
+                )
+
+            n_images_in_images = [len(sample) for sample in images]
+            if text is not None and not n_images_in_images == n_images_in_text:
+                raise ValueError(
+                    f"The number of images in the text {n_images_in_text} and images  {n_images_in_images} should be the same."
+                )
+
+            # Load images if they are URLs
+            images = [[load_image(im) for im in sample] for sample in images]
+            image_inputs = self.image_processor(images, **output_kwargs["images_kwargs"])
+            inputs.update(image_inputs)
+
+        return BatchFeature(inputs, tensor_type=return_tensors)
+
+
+__all__ = ["Idefics2Processor"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_gpu1_port8009.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28a1ca4f5290c9e274abd9b5d6af4e69822f46dd480b1d672247ec800047c65c
+size 286284882

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node0_gpu1_port8009.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df7799f5216af3beaf4d455fe39a759728e1d60a3348d65d35e08f32688b82fb
+size 138081174

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node0_gpu3_port8011.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a3ffd903a683b72d7d0b0fbdaf55f2df0171b46aef80721903bd5fdfddcb2bc
+size 138161892

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node0_gpu4_port8012.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b9ef0d56ca4a49bdc85f86012361f889b9d6ad2ad4bc116f46d889a61b04756
+size 137943247

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node0_gpu7_port8015.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bb1dd2ef3fb2995640d48e80183cc337a97dcd10d2fc076ca0a6fa003c09a93
+size 138093972

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node1_gpu0_port8008.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e1ae526462e71683846c129e2ce8484c321f00a2002f5420d280943d0032688
+size 137849373

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node1_gpu1_port8009.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41a4b4a714a682f5020818de50b4cf9dd80155d453718acd9d4d97c9644d5949
+size 138234178

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node1_gpu4_port8012.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3708a36b80b8e42e884261f128a595a8e5d05985800638ffae29ed32f8b6b923
+size 139000169

LTA_openwebtext_dualt/mini_owt_logdirichlet/logs/vllm_qwen36_35b_a3b_node1_gpu5_port8013.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd3bdae47bc876c36b7c0f6da22464333e6613a0cab14f040f08380be92dd5d0
+size 138856982