transformers 5.0.0rc2__py3-none-any.whl → 5.1.0__py3-none-any.whl

transformers/utils/backbone_utils.py

@@ -1,379 +1,19 @@
-# Copyright 2023 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 warnings
 
-"""Collection of utils to be used by backbones and their components."""
+from ..backbone_utils import BackboneConfigMixin, BackboneMixin
 
-import enum
-import inspect
-from collections.abc import Iterable
-from typing import TYPE_CHECKING, Union
 
-
-if TYPE_CHECKING:
-    from ..configuration_utils import PreTrainedConfig
-
-
-class BackboneType(enum.Enum):
-    TIMM = "timm"
-    TRANSFORMERS = "transformers"
-
-
-def verify_out_features_out_indices(
-    out_features: Iterable[str] | None, out_indices: Iterable[int] | None, stage_names: Iterable[str] | None
-):
-    """
-    Verify that out_indices and out_features are valid for the given stage_names.
-    """
-    if stage_names is None:
-        raise ValueError("Stage_names must be set for transformers backbones")
-
-    if out_features is not None:
-        if not isinstance(out_features, (list,)):
-            raise ValueError(f"out_features must be a list got {type(out_features)}")
-        if any(feat not in stage_names for feat in out_features):
-            raise ValueError(f"out_features must be a subset of stage_names: {stage_names} got {out_features}")
-        if len(out_features) != len(set(out_features)):
-            raise ValueError(f"out_features must not contain any duplicates, got {out_features}")
-        if out_features != (sorted_feats := [feat for feat in stage_names if feat in out_features]):
-            raise ValueError(
-                f"out_features must be in the same order as stage_names, expected {sorted_feats} got {out_features}"
-            )
-
-    if out_indices is not None:
-        if not isinstance(out_indices, list):
-            raise ValueError(f"out_indices must be a list, got {type(out_indices)}")
-        # Convert negative indices to their positive equivalent: [-1,] -> [len(stage_names) - 1,]
-        positive_indices = tuple(idx % len(stage_names) if idx < 0 else idx for idx in out_indices)
-        if any(idx for idx in positive_indices if idx not in range(len(stage_names))):
-            raise ValueError(f"out_indices must be valid indices for stage_names {stage_names}, got {out_indices}")
-        if len(positive_indices) != len(set(positive_indices)):
-            msg = f"out_indices must not contain any duplicates, got {out_indices}"
-            msg += f"(equivalent to {positive_indices}))" if positive_indices != out_indices else ""
-            raise ValueError(msg)
-        if positive_indices != tuple(sorted(positive_indices)):
-            sorted_negative = [idx for _, idx in sorted(zip(positive_indices, out_indices), key=lambda x: x[0])]
-            raise ValueError(
-                f"out_indices must be in the same order as stage_names, expected {sorted_negative} got {out_indices}"
-            )
-
-    if out_features is not None and out_indices is not None:
-        if len(out_features) != len(out_indices):
-            raise ValueError("out_features and out_indices should have the same length if both are set")
-        if out_features != [stage_names[idx] for idx in out_indices]:
-            raise ValueError("out_features and out_indices should correspond to the same stages if both are set")
-
-
-def _align_output_features_output_indices(
-    out_features: list[str] | None,
-    out_indices: list[int] | tuple[int, ...] | None,
-    stage_names: list[str],
-):
-    """
-    Finds the corresponding `out_features` and `out_indices` for the given `stage_names`.
-
-    The logic is as follows:
-        - `out_features` not set, `out_indices` set: `out_features` is set to the `out_features` corresponding to the
-        `out_indices`.
-        - `out_indices` not set, `out_features` set: `out_indices` is set to the `out_indices` corresponding to the
-        `out_features`.
-        - `out_indices` and `out_features` not set: `out_indices` and `out_features` are set to the last stage.
-        - `out_indices` and `out_features` set: input `out_indices` and `out_features` are returned.
-
-    Args:
-        out_features (`list[str]`): The names of the features for the backbone to output.
-        out_indices (`list[int]` or `tuple[int]`): The indices of the features for the backbone to output.
-        stage_names (`list[str]`): The names of the stages of the backbone.
-    """
-    if out_indices is None and out_features is None:
-        out_indices = [len(stage_names) - 1]
-        out_features = [stage_names[-1]]
-    elif out_indices is None and out_features is not None:
-        out_indices = [stage_names.index(layer) for layer in out_features]
-    elif out_features is None and out_indices is not None:
-        out_features = [stage_names[idx] for idx in out_indices]
-    return out_features, out_indices
-
-
-def get_aligned_output_features_output_indices(
-    out_features: list[str] | None,
-    out_indices: list[int] | tuple[int] | None,
-    stage_names: list[str],
-) -> tuple[list[str], list[int]]:
-    """
-    Get the `out_features` and `out_indices` so that they are aligned.
-
-    The logic is as follows:
-        - `out_features` not set, `out_indices` set: `out_features` is set to the `out_features` corresponding to the
-        `out_indices`.
-        - `out_indices` not set, `out_features` set: `out_indices` is set to the `out_indices` corresponding to the
-        `out_features`.
-        - `out_indices` and `out_features` not set: `out_indices` and `out_features` are set to the last stage.
-        - `out_indices` and `out_features` set: they are verified to be aligned.
-
-    Args:
-        out_features (`list[str]`): The names of the features for the backbone to output.
-        out_indices (`list[int]` or `tuple[int]`): The indices of the features for the backbone to output.
-        stage_names (`list[str]`): The names of the stages of the backbone.
-    """
-    out_indices = list(out_indices) if out_indices is not None else None
-    # First verify that the out_features and out_indices are valid
-    verify_out_features_out_indices(out_features=out_features, out_indices=out_indices, stage_names=stage_names)
-    output_features, output_indices = _align_output_features_output_indices(
-        out_features=out_features, out_indices=out_indices, stage_names=stage_names
+class BackboneConfigMixin(BackboneConfigMixin):
+    warnings.warn(
+        "Importing `BackboneConfigMixin` from `utils/backbone_utils.py` is deprecated and will be removed in "
+        "Transformers v5.10. Import as `from transformers.backbone_utils import BackboneConfigMixin` instead.",
+        FutureWarning,
     )
-    # Verify that the aligned out_features and out_indices are valid
-    verify_out_features_out_indices(out_features=output_features, out_indices=output_indices, stage_names=stage_names)
-    return output_features, output_indices
-
-
-class BackboneMixin:
-    backbone_type: BackboneType | None = None
-
-    # Attribute to indicate if the backbone has attention and can return attention outputs.
-    # Should be set to `False` for conv-based models to be able to run `forward_with_filtered_kwargs`
-    has_attentions: bool = True
-
-    def _init_timm_backbone(self, config) -> None:
-        """
-        Initialize the backbone model from timm The backbone must already be loaded to self._backbone
-        """
-        if getattr(self, "_backbone", None) is None:
-            raise ValueError("self._backbone must be set before calling _init_timm_backbone")
-
-        # These will diagree with the defaults for the transformers models e.g. for resnet50
-        # the transformer model has out_features = ['stem', 'stage1', 'stage2', 'stage3', 'stage4']
-        # the timm model has out_features = ['act', 'layer1', 'layer2', 'layer3', 'layer4']
-        self.stage_names = [stage["module"] for stage in self._backbone.feature_info.info]
-        self.num_features = [stage["num_chs"] for stage in self._backbone.feature_info.info]
-
-        # In some timm versions, out_indices reflects the input type of out_indices on the `create_model` call,
-        # in later versions >= 1, it is always a tuple
-        out_indices = list(self._backbone.feature_info.out_indices)
-        out_features = self._backbone.feature_info.module_name()
-
-        # We verify the out indices and out features are valid
-        verify_out_features_out_indices(
-            out_features=out_features, out_indices=out_indices, stage_names=self.stage_names
-        )
-        self._out_features, self._out_indices = out_features, out_indices
-
-    def _init_transformers_backbone(self, config) -> None:
-        stage_names = getattr(config, "stage_names")
-        out_features = getattr(config, "out_features", None)
-        out_indices = getattr(config, "out_indices", None)
-
-        self.stage_names = stage_names
-        self._out_features, self._out_indices = get_aligned_output_features_output_indices(
-            out_features=out_features, out_indices=out_indices, stage_names=stage_names
-        )
-        # Number of channels for each stage. This is set in the transformer backbone model init
-        self.num_features = None
-
-    def _init_backbone(self, config) -> None:
-        """
-        Method to initialize the backbone. This method is called by the constructor of the base class after the
-        pretrained model weights have been loaded.
-        """
-        self.config = config
-
-        self.use_timm_backbone = getattr(config, "use_timm_backbone", False)
-        self.backbone_type = BackboneType.TIMM if self.use_timm_backbone else BackboneType.TRANSFORMERS
-
-        if self.backbone_type == BackboneType.TIMM:
-            self._init_timm_backbone(config)
-        elif self.backbone_type == BackboneType.TRANSFORMERS:
-            self._init_transformers_backbone(config)
-        else:
-            raise ValueError(f"backbone_type {self.backbone_type} not supported.")
 
-    @property
-    def out_features(self):
-        return self._out_features
 
-    @out_features.setter
-    def out_features(self, out_features: list[str]):
-        """
-        Set the out_features attribute. This will also update the out_indices attribute to match the new out_features.
-        """
-        self._out_features, self._out_indices = get_aligned_output_features_output_indices(
-            out_features=out_features, out_indices=None, stage_names=self.stage_names
-        )
-
-    @property
-    def out_indices(self):
-        return self._out_indices
-
-    @out_indices.setter
-    def out_indices(self, out_indices: tuple[int] | list[int]):
-        """
-        Set the out_indices attribute. This will also update the out_features attribute to match the new out_indices.
-        """
-        self._out_features, self._out_indices = get_aligned_output_features_output_indices(
-            out_features=None, out_indices=out_indices, stage_names=self.stage_names
-        )
-
-    @property
-    def out_feature_channels(self):
-        # the current backbones will output the number of channels for each stage
-        # even if that stage is not in the out_features list.
-        return {stage: self.num_features[i] for i, stage in enumerate(self.stage_names)}
-
-    @property
-    def channels(self):
-        return [self.out_feature_channels[name] for name in self.out_features]
-
-    def forward_with_filtered_kwargs(self, *args, **kwargs):
-        if not self.has_attentions:
-            kwargs.pop("output_attentions", None)
-        if self.backbone_type == BackboneType.TIMM:
-            signature = dict(inspect.signature(self.forward).parameters)
-            kwargs = {k: v for k, v in kwargs.items() if k in signature}
-        return self(*args, **kwargs)
-
-    def forward(
-        self,
-        pixel_values,
-        output_hidden_states: bool | None = None,
-        output_attentions: bool | None = None,
-        return_dict: bool | None = None,
-    ):
-        raise NotImplementedError("This method should be implemented by the derived class.")
-
-    def to_dict(self):
-        """
-        Serializes this instance to a Python dictionary. Override the default `to_dict()` from `PreTrainedConfig` to
-        include the `out_features` and `out_indices` attributes.
-        """
-        output = super().to_dict()
-        output["out_features"] = output.pop("_out_features")
-        output["out_indices"] = output.pop("_out_indices")
-        return output
-
-
-class BackboneConfigMixin:
-    """
-    A Mixin to support handling the `out_features` and `out_indices` attributes for the backbone configurations.
-    """
-
-    @property
-    def out_features(self):
-        return self._out_features
-
-    @out_features.setter
-    def out_features(self, out_features: list[str]):
-        """
-        Set the out_features attribute. This will also update the out_indices attribute to match the new out_features.
-        """
-        self._out_features, self._out_indices = get_aligned_output_features_output_indices(
-            out_features=out_features, out_indices=None, stage_names=self.stage_names
-        )
-
-    @property
-    def out_indices(self):
-        return self._out_indices
-
-    @out_indices.setter
-    def out_indices(self, out_indices: tuple[int, ...] | list[int]):
-        """
-        Set the out_indices attribute. This will also update the out_features attribute to match the new out_indices.
-        """
-        self._out_features, self._out_indices = get_aligned_output_features_output_indices(
-            out_features=None, out_indices=out_indices, stage_names=self.stage_names
-        )
-
-    def to_dict(self):
-        """
-        Serializes this instance to a Python dictionary. Override the default `to_dict()` from `PreTrainedConfig` to
-        include the `out_features` and `out_indices` attributes.
-        """
-        output = super().to_dict()
-        output["out_features"] = output.pop("_out_features")
-        output["out_indices"] = output.pop("_out_indices")
-        return output
-
-
-def load_backbone(config):
-    """
-    Loads the backbone model from a config object.
-
-    If the config is from the backbone model itself, then we return a backbone model with randomly initialized
-    weights.
-
-    If the config is from the parent model of the backbone model itself, then we load the pretrained backbone weights
-    if specified.
-    """
-    from transformers import AutoBackbone, AutoConfig
-
-    backbone_config = getattr(config, "backbone_config", None)
-    use_timm_backbone = getattr(config, "use_timm_backbone", None)
-    use_pretrained_backbone = getattr(config, "use_pretrained_backbone", None)
-    backbone_checkpoint = getattr(config, "backbone", None)
-    backbone_kwargs = getattr(config, "backbone_kwargs", None)
-    backbone_kwargs = {} if backbone_kwargs is None else backbone_kwargs
-
-    if backbone_kwargs and backbone_config is not None:
-        raise ValueError("You can't specify both `backbone_kwargs` and `backbone_config`.")
-
-    # If there is a backbone_config and a backbone checkpoint, and use_pretrained_backbone=False then the desired
-    # behaviour is ill-defined: do you want to load from the checkpoint's config or the backbone_config?
-    if backbone_config is not None and backbone_checkpoint is not None and use_pretrained_backbone is not None:
-        raise ValueError("Cannot specify both config.backbone_config and config.backbone")
-
-    # If any of the following are set, then the config passed in is from a model which contains a backbone.
-    if backbone_config is None and use_timm_backbone is None and backbone_checkpoint is None:
-        return AutoBackbone.from_config(config=config, **backbone_kwargs)
-
-    # config from the parent model that has a backbone
-    if use_timm_backbone:
-        if backbone_checkpoint is None:
-            raise ValueError("config.backbone must be set if use_timm_backbone is True")
-        # Because of how timm backbones were originally added to models, we need to pass in use_pretrained_backbone
-        # to determine whether to load the pretrained weights.
-        backbone = AutoBackbone.from_pretrained(
-            backbone_checkpoint,
-            use_timm_backbone=use_timm_backbone,
-            use_pretrained_backbone=use_pretrained_backbone,
-            **backbone_kwargs,
-        )
-    elif use_pretrained_backbone:
-        if backbone_checkpoint is None:
-            raise ValueError("config.backbone must be set if use_pretrained_backbone is True")
-        backbone = AutoBackbone.from_pretrained(backbone_checkpoint, **backbone_kwargs)
-    else:
-        if backbone_config is None and backbone_checkpoint is None:
-            raise ValueError("Either config.backbone_config or config.backbone must be set")
-        if backbone_config is None:
-            backbone_config = AutoConfig.from_pretrained(backbone_checkpoint, **backbone_kwargs)
-        backbone = AutoBackbone.from_config(config=backbone_config)
-    return backbone
-
-
-def verify_backbone_config_arguments(
-    use_timm_backbone: bool,
-    use_pretrained_backbone: bool,
-    backbone: str | None,
-    backbone_config: Union[dict, "PreTrainedConfig"] | None,
-    backbone_kwargs: dict | None,
-):
-    """
-    Verify that the config arguments to be passed to load_backbone are valid
-    """
-    if backbone_config is not None and backbone is not None:
-        raise ValueError("You can't specify both `backbone` and `backbone_config`.")
-
-    if backbone_config is not None and use_timm_backbone:
-        raise ValueError("You can't specify both `backbone_config` and `use_timm_backbone`.")
-
-    if backbone_kwargs is not None and backbone_kwargs and backbone_config is not None:
-        raise ValueError("You can't specify both `backbone_kwargs` and `backbone_config`.")
+class BackboneMixin(BackboneMixin):
+    warnings.warn(
+        "Importing `BackboneMixin` from `utils/backbone_utils.py` is deprecated and will be removed in "
+        "Transformers v5.10. Import as `from transformers.backbone_utils import BackboneMixin` instead.",
+        FutureWarning,
+    )

transformers/utils/doc.py

@@ -677,27 +677,6 @@ AUDIO_FRAME_CLASSIFICATION_SAMPLE = PT_SPEECH_FRAME_CLASS_SAMPLE
 AUDIO_XVECTOR_SAMPLE = PT_SPEECH_XVECTOR_SAMPLE
 
 
-IMAGE_TO_TEXT_SAMPLE = r"""
-    Example:
-
-    ```python
-    >>> from PIL import Image
-    >>> import requests
-    >>> from transformers import AutoProcessor, {model_class}
-
-    >>> processor = AutoProcessor.from_pretrained("{checkpoint}")
-    >>> model = {model_class}.from_pretrained("{checkpoint}")
-
-    >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    >>> image = Image.open(requests.get(url, stream=True).raw)
-
-    >>> inputs = processor(images=image, return_tensors="pt")
-
-    >>> outputs = model(**inputs)
-    ```
-"""
-
-
 DEPTH_ESTIMATION_SAMPLE = r"""
     Example:
 
@@ -705,10 +684,12 @@ DEPTH_ESTIMATION_SAMPLE = r"""
     >>> from transformers import AutoImageProcessor, {model_class}
     >>> import torch
     >>> from PIL import Image
-    >>> import requests
+    >>> import httpx
+        >>> from io import BytesIO
 
     >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
-    >>> image = Image.open(requests.get(url, stream=True).raw)
+    >>> with httpx.stream("GET", url) as response:
+    ...     image = Image.open(BytesIO(response.read())).convert("RGB")
 
     >>> processor = AutoImageProcessor.from_pretrained("{checkpoint}")
     >>> model = {model_class}.from_pretrained("{checkpoint}")
@@ -842,14 +823,6 @@ OBJECT_DETECTION_SAMPLE = r"""
 QUESTION_ANSWERING_SAMPLE = PT_QUESTION_ANSWERING_SAMPLE
 
 
-TEXT2TEXT_GENERATION_SAMPLE = r"""
-    Example:
-
-    ```python
-    ```
-"""
-
-
 TEXT_CLASSIFICATION_SAMPLE = PT_SEQUENCE_CLASSIFICATION_SAMPLE
 
 
@@ -883,7 +856,6 @@ IMAGE_TEXT_TO_TEXT_GENERATION_SAMPLE = r"""
 
     ```python
     >>> from PIL import Image
-    >>> import requests
     >>> from transformers import AutoProcessor, {model_class}
 
     >>> model = {model_class}.from_pretrained("{checkpoint}")
@@ -921,7 +893,6 @@ PIPELINE_TASKS_TO_SAMPLE_DOCSTRINGS = OrderedDict(
         ("audio-classification", AUDIO_CLASSIFICATION_SAMPLE),
         ("audio-xvector", AUDIO_XVECTOR_SAMPLE),
         ("image-text-to-text", IMAGE_TEXT_TO_TEXT_GENERATION_SAMPLE),
-        ("image-to-text", IMAGE_TO_TEXT_SAMPLE),
         ("visual-question-answering", VISUAL_QUESTION_ANSWERING_SAMPLE),
         ("depth-estimation", DEPTH_ESTIMATION_SAMPLE),
         ("video-classification", VIDEO_CLASSIFICATION_SAMPLE),
@@ -936,7 +907,6 @@ PIPELINE_TASKS_TO_SAMPLE_DOCSTRINGS = OrderedDict(
         ("table-question-answering", TABLE_QUESTION_ANSWERING_SAMPLE),
         ("document-question-answering", DOCUMENT_QUESTION_ANSWERING_SAMPLE),
         ("question-answering", QUESTION_ANSWERING_SAMPLE),
-        ("text2text-generation", TEXT2TEXT_GENERATION_SAMPLE),
         ("next-sentence-prediction", NEXT_SENTENCE_PREDICTION_SAMPLE),
         ("multiple-choice", MULTIPLE_CHOICE_SAMPLE),
         ("text-classification", TEXT_CLASSIFICATION_SAMPLE),
@@ -961,7 +931,6 @@ MODELS_TO_PIPELINE = OrderedDict(
         ("MODEL_FOR_AUDIO_XVECTOR_MAPPING_NAMES", "audio-xvector"),
         # Vision
         ("MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES", "image-text-to-text"),
-        ("MODEL_FOR_VISION_2_SEQ_MAPPING_NAMES", "image-to-text"),
         ("MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING_NAMES", "visual-question-answering"),
         ("MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMES", "depth-estimation"),
         ("MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING_NAMES", "video-classification"),
@@ -977,7 +946,6 @@ MODELS_TO_PIPELINE = OrderedDict(
         ("MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING_NAMES", "table-question-answering"),
         ("MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES", "document-question-answering"),
         ("MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES", "question-answering"),
-        ("MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES", "text2text-generation"),
         ("MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES", "next-sentence-prediction"),
         ("MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES", "multiple-choice"),
         ("MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES", "text-classification"),

transformers/utils/dummy_pt_objects.py

@@ -23,34 +23,6 @@ class EncoderDecoderCache(metaclass=DummyObject):
         requires_backends(self, ["torch"])
 
 
-class HQQQuantizedCache(metaclass=DummyObject):
-    _backends = ["torch"]
-
-    def __init__(self, *args, **kwargs):
-        requires_backends(self, ["torch"])
-
-
-class HybridCache(metaclass=DummyObject):
-    _backends = ["torch"]
-
-    def __init__(self, *args, **kwargs):
-        requires_backends(self, ["torch"])
-
-
-class OffloadedCache(metaclass=DummyObject):
-    _backends = ["torch"]
-
-    def __init__(self, *args, **kwargs):
-        requires_backends(self, ["torch"])
-
-
-class OffloadedStaticCache(metaclass=DummyObject):
-    _backends = ["torch"]
-
-    def __init__(self, *args, **kwargs):
-        requires_backends(self, ["torch"])
-
-
 class QuantizedCache(metaclass=DummyObject):
     _backends = ["torch"]
 
@@ -58,20 +30,6 @@ class QuantizedCache(metaclass=DummyObject):
         requires_backends(self, ["torch"])
 
 
-class QuantoQuantizedCache(metaclass=DummyObject):
-    _backends = ["torch"]
-
-    def __init__(self, *args, **kwargs):
-        requires_backends(self, ["torch"])
-
-
-class SlidingWindowCache(metaclass=DummyObject):
-    _backends = ["torch"]
-
-    def __init__(self, *args, **kwargs):
-        requires_backends(self, ["torch"])
-
-
 class StaticCache(metaclass=DummyObject):
     _backends = ["torch"]
 

transformers/utils/generic.py

@@ -179,7 +179,7 @@ def maybe_autocast(
     device_type: str,
     dtype: Optional["_dtype"] = None,
     enabled: bool = True,
-    cache_enabled: Optional[bool] = None,
+    cache_enabled: bool | None = None,
 ):
     """
     Context manager that only autocasts if:
@@ -210,6 +210,31 @@ def is_mlx_array(x):
     return False if not _is_mlx_available else _is_mlx(x)
 
 
+def is_flash_attention_requested(config=None, requested_attention_implementation: str | None = None):
+    """
+    Checks whether some flavor of flash attention is requested or not.
+
+    This is checked against one of the two arguments, i.e. either the `config` or the directly passed value
+    `requested_attention_implementation`. Otherwise, an error will be raised (ambiguity).
+
+    The different versions of flash attention are usually
+    - Implementations based on the original flash attention repo: https://github.com/Dao-AILab/flash-attention
+    - Kernels implementations such as: https://huggingface.co/kernels-community/vllm-flash-attn3
+    """
+    if config is not None and requested_attention_implementation is not None:
+        raise ValueError(
+            "Requested attention implementation is ambiguous: "
+            "Please pass either the config or the name of the attention implementation, not both."
+        )
+
+    if config is not None:
+        checked_attention_implementation = config._attn_implementation
+    else:
+        checked_attention_implementation = requested_attention_implementation
+
+    return "flash" in checked_attention_implementation
+
+
 def to_py_obj(obj):
     """
     Convert a PyTorch tensor, Numpy array or python list to a python list.
@@ -219,12 +244,11 @@ def to_py_obj(obj):
     elif isinstance(obj, (dict, UserDict)):
         return {k: to_py_obj(v) for k, v in obj.items()}
     elif isinstance(obj, (list, tuple)):
-        try:
-            arr = np.array(obj)
-            if np.issubdtype(arr.dtype, np.integer) or np.issubdtype(arr.dtype, np.floating):
-                return arr.tolist()
-        except Exception:
-            pass
+        # Only convert directly if all elements are numeric scalars
+        if all(isinstance(x, (int, float, np.number)) for x in obj):
+            return list(obj)
+
+        # Otherwise recurse element-wise
         return [to_py_obj(o) for o in obj]
 
     framework_to_py_obj = {
@@ -850,34 +874,46 @@ def check_model_inputs(func=None, *, tie_last_hidden_states=True):
     def wrapped_fn(func):
         @wraps(func)
         def wrapper(self, *args, **kwargs):
-            use_cache_arg_index = None
-            if "use_cache" in func.__code__.co_varnames:
-                use_cache_arg_index = func.__code__.co_varnames.index("use_cache") - 1  # -1 for self
-
-            if (
-                use_cache_arg_index is not None
-                and len(args) > use_cache_arg_index
-                and args[use_cache_arg_index] is not None
-            ):
-                use_cache = args[use_cache_arg_index]
-            elif kwargs.get("use_cache") is not None:
-                use_cache = kwargs["use_cache"]
-            else:
-                use_cache = getattr(self.config, "use_cache", None)
-
-            if use_cache is not None:
-                if getattr(self, "gradient_checkpointing", False) and self.training and use_cache:
-                    logger.warning_once(
-                        "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`."
-                    )
-                    use_cache = False
-
-                if use_cache_arg_index is not None and len(args) > use_cache_arg_index:
-                    args = list(args)
-                    args[use_cache_arg_index] = use_cache
-                    args = tuple(args)
+            args_with_config_defaults = [
+                "use_cache",
+                "vision_feature_layer",
+                "vision_feature_select_strategy",
+                "vision_aspect_ratio",
+            ]
+            for arg_name in args_with_config_defaults:
+                arg_index = None
+                if arg_name in func.__code__.co_varnames:
+                    arg_index = func.__code__.co_varnames.index(arg_name) - 1  # -1 for self
+
+                if arg_index is not None and len(args) > arg_index and args[arg_index] is not None:
+                    arg_value = args[arg_index]
+                elif kwargs.get(arg_name) is not None:
+                    arg_value = kwargs[arg_name]
                 else:
-                    kwargs["use_cache"] = use_cache
+                    arg_value = getattr(self.config, arg_name, None)
+
+                if arg_value is not None:
+                    # Arg-specific handling
+                    if arg_name == "use_cache":
+                        if getattr(self, "gradient_checkpointing", False) and self.training and arg_value:
+                            logger.warning_once(
+                                "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`."
+                            )
+                            arg_value = False
+                    elif arg_name == "vision_feature_select_strategy":
+                        valid_strategies = ["default", "full"]
+                        if arg_value not in valid_strategies:
+                            raise ValueError(
+                                f"`Unexpected select feature strategy: {arg_value}. "
+                                f"Please select from {valid_strategies}."
+                            )
+
+                    if arg_index is not None and len(args) > arg_index:
+                        args = list(args)
+                        args[arg_index] = arg_value
+                        args = tuple(args)
+                    else:
+                        kwargs[arg_name] = arg_value
 
             return_dict = kwargs.pop("return_dict", None)
             if return_dict is None: