Remove deprecated objects

docs/source/en/model_doc/led.md

@@ -181,11 +181,6 @@ print(tokenizer.decode(output[0], skip_special_tokens=True))
 [[autodoc]] LEDForConditionalGeneration
     - forward
 
-## LEDForSequenceClassification
-
-[[autodoc]] LEDForSequenceClassification
-    - forward
-
 ## LEDForQuestionAnswering
 
 [[autodoc]] LEDForQuestionAnswering

src/transformers/__init__.py

@@ -133,7 +133,6 @@
         "is_wandb_available",
     ],
     "loss": [],
-    "modelcard": ["ModelCard"],
     "pipelines": [
         "AnyToAnyPipeline",
         "AudioClassificationPipeline",
@@ -615,8 +614,7 @@
     from .masking_utils import AttentionMaskInterface as AttentionMaskInterface
     from .model_debugging_utils import model_addition_debugger_context as model_addition_debugger_context
 
-    # Model Cards
-    from .modelcard import ModelCard as ModelCard
+    # Models
     from .modeling_layers import GradientCheckpointingLayer as GradientCheckpointingLayer
     from .modeling_rope_utils import ROPE_INIT_FUNCTIONS as ROPE_INIT_FUNCTIONS
     from .modeling_rope_utils import RopeParameters as RopeParameters

src/transformers/modelcard.py

@@ -13,10 +13,7 @@
 # limitations under the License.
 """Configuration base class and utilities."""
 
-import copy
-import json
 import os
-import warnings
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -47,8 +44,6 @@
 )
 from .training_args import ParallelMode
 from .utils import (
-    MODEL_CARD_NAME,
-    cached_file,
     is_datasets_available,
     is_tokenizers_available,
     is_torch_available,
@@ -76,179 +71,6 @@
 logger = logging.get_logger(__name__)
 
 
-class ModelCard:
-    r"""
-    Structured Model Card class. Store model card as well as methods for loading/downloading/saving model cards.
-
-    Please read the following paper for details and explanation on the sections: "Model Cards for Model Reporting" by
-    Margaret Mitchell, Simone Wu, Andrew Zaldivar, Parker Barnes, Lucy Vasserman, Ben Hutchinson, Elena Spitzer,
-    Inioluwa Deborah Raji and Timnit Gebru for the proposal behind model cards. Link: https://huggingface.co/papers/1810.03993
-
-    Note: A model card can be loaded and saved to disk.
-    """
-
-    def __init__(self, **kwargs):
-        warnings.warn(
-            "The class `ModelCard` is deprecated and will be removed in version 5 of Transformers", FutureWarning
-        )
-        # Recommended attributes from https://huggingface.co/papers/1810.03993 (see papers)
-        self.model_details = kwargs.pop("model_details", {})
-        self.intended_use = kwargs.pop("intended_use", {})
-        self.factors = kwargs.pop("factors", {})
-        self.metrics = kwargs.pop("metrics", {})
-        self.evaluation_data = kwargs.pop("evaluation_data", {})
-        self.training_data = kwargs.pop("training_data", {})
-        self.quantitative_analyses = kwargs.pop("quantitative_analyses", {})
-        self.ethical_considerations = kwargs.pop("ethical_considerations", {})
-        self.caveats_and_recommendations = kwargs.pop("caveats_and_recommendations", {})
-
-        # Open additional attributes
-        for key, value in kwargs.items():
-            try:
-                setattr(self, key, value)
-            except AttributeError as err:
-                logger.error(f"Can't set {key} with value {value} for {self}")
-                raise err
-
-    def save_pretrained(self, save_directory_or_file):
-        """Save a model card object to the directory or file `save_directory_or_file`."""
-        if os.path.isdir(save_directory_or_file):
-            # If we save using the predefined names, we can load using `from_pretrained`
-            output_model_card_file = os.path.join(save_directory_or_file, MODEL_CARD_NAME)
-        else:
-            output_model_card_file = save_directory_or_file
-
-        self.to_json_file(output_model_card_file)
-        logger.info(f"Model card saved in {output_model_card_file}")
-
-    @classmethod
-    def from_pretrained(cls, pretrained_model_name_or_path, **kwargs):
-        r"""
-        Instantiate a [`ModelCard`] from a pre-trained model model card.
-
-        Parameters:
-            pretrained_model_name_or_path: either:
-
-                - a string, the *model id* of a pretrained model card hosted inside a model repo on huggingface.co.
-                - a path to a *directory* containing a model card file saved using the [`~ModelCard.save_pretrained`]
-                  method, e.g.: `./my_model_directory/`.
-                - a path or url to a saved model card JSON *file*, e.g.: `./my_model_directory/modelcard.json`.
-
-            cache_dir: (*optional*) string:
-                Path to a directory in which a downloaded pre-trained model card should be cached if the standard cache
-                should not be used.
-
-            kwargs: (*optional*) dict: key/value pairs with which to update the ModelCard object after loading.
-
-                - The values in kwargs of any keys which are model card attributes will be used to override the loaded
-                  values.
-                - Behavior concerning key/value pairs whose keys are *not* model card attributes is controlled by the
-                  *return_unused_kwargs* keyword parameter.
-
-            proxies: (*optional*) dict, default None:
-                A dictionary of proxy servers to use by protocol or endpoint, e.g.: {'http': 'foo.bar:3128',
-                'http://hostname': 'foo.bar:4012'}. The proxies are used on each request.
-
-            return_unused_kwargs: (*optional*) bool:
-
-                - If False, then this function returns just the final model card object.
-                - If True, then this functions returns a tuple *(model card, unused_kwargs)* where *unused_kwargs* is a
-                  dictionary consisting of the key/value pairs whose keys are not model card attributes: ie the part of
-                  kwargs which has not been used to update *ModelCard* and is otherwise ignored.
-
-        Examples:
-
-        ```python
-        # Download model card from huggingface.co and cache.
-        modelcard = ModelCard.from_pretrained("google-bert/bert-base-uncased")
-        # Model card was saved using *save_pretrained('./test/saved_model/')*
-        modelcard = ModelCard.from_pretrained("./test/saved_model/")
-        modelcard = ModelCard.from_pretrained("./test/saved_model/modelcard.json")
-        modelcard = ModelCard.from_pretrained("google-bert/bert-base-uncased", output_attentions=True, foo=False)
-        ```"""
-        cache_dir = kwargs.pop("cache_dir", None)
-        proxies = kwargs.pop("proxies", None)
-        return_unused_kwargs = kwargs.pop("return_unused_kwargs", False)
-        from_pipeline = kwargs.pop("_from_pipeline", None)
-
-        user_agent = {"file_type": "model_card"}
-        if from_pipeline is not None:
-            user_agent["using_pipeline"] = from_pipeline
-
-        is_local = os.path.isdir(pretrained_model_name_or_path)
-        if os.path.isfile(pretrained_model_name_or_path):
-            resolved_model_card_file = pretrained_model_name_or_path
-            is_local = True
-        else:
-            try:
-                # Load from URL or cache if already cached
-                resolved_model_card_file = cached_file(
-                    pretrained_model_name_or_path,
-                    filename=MODEL_CARD_NAME,
-                    cache_dir=cache_dir,
-                    proxies=proxies,
-                    user_agent=user_agent,
-                )
-                if is_local:
-                    logger.info(f"loading model card file {resolved_model_card_file}")
-                else:
-                    logger.info(f"loading model card file {MODEL_CARD_NAME} from cache at {resolved_model_card_file}")
-                # Load model card
-                modelcard = cls.from_json_file(resolved_model_card_file)
-
-            except (OSError, json.JSONDecodeError):
-                # We fall back on creating an empty model card
-                modelcard = cls()
-
-        # Update model card with kwargs if needed
-        to_remove = []
-        for key, value in kwargs.items():
-            if hasattr(modelcard, key):
-                setattr(modelcard, key, value)
-                to_remove.append(key)
-        for key in to_remove:
-            kwargs.pop(key, None)
-
-        logger.info(f"Model card: {modelcard}")
-        if return_unused_kwargs:
-            return modelcard, kwargs
-        else:
-            return modelcard
-
-    @classmethod
-    def from_dict(cls, json_object):
-        """Constructs a `ModelCard` from a Python dictionary of parameters."""
-        return cls(**json_object)
-
-    @classmethod
-    def from_json_file(cls, json_file):
-        """Constructs a `ModelCard` from a json file of parameters."""
-        with open(json_file, encoding="utf-8") as reader:
-            text = reader.read()
-        dict_obj = json.loads(text)
-        return cls(**dict_obj)
-
-    def __eq__(self, other):
-        return self.__dict__ == other.__dict__
-
-    def __repr__(self):
-        return str(self.to_json_string())
-
-    def to_dict(self):
-        """Serializes this instance to a Python dictionary."""
-        output = copy.deepcopy(self.__dict__)
-        return output
-
-    def to_json_string(self):
-        """Serializes this instance to a JSON string."""
-        return json.dumps(self.to_dict(), indent=2, sort_keys=True) + "\n"
-
-    def to_json_file(self, json_file_path):
-        """Save this instance to a json file."""
-        with open(json_file_path, "w", encoding="utf-8") as writer:
-            writer.write(self.to_json_string())
-
-
 AUTOGENERATED_TRAINER_COMMENT = """
 <!-- This model card has been generated automatically according to the information the Trainer had access to. You
 should probably proofread and complete it, then remove this comment. -->

src/transformers/modeling_outputs.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import warnings
 from dataclasses import dataclass
 
 import torch
@@ -1705,12 +1704,3 @@ class MaskedImageModelingOutput(ModelOutput):
     reconstruction: torch.FloatTensor | None = None
     hidden_states: tuple[torch.FloatTensor, ...] | None = None
     attentions: tuple[torch.FloatTensor, ...] | None = None
-
-    @property
-    def logits(self):
-        warnings.warn(
-            "logits attribute is deprecated and will be removed in version 5 of Transformers."
-            " Please use the reconstruction attribute to retrieve the final output instead.",
-            FutureWarning,
-        )
-        return self.reconstruction

src/transformers/models/auto/modeling_auto.py

@@ -1280,7 +1280,6 @@ class _BaseModelWithGenerate(PreTrainedModel, GenerationMixin):
         ("layoutlm", "LayoutLMForSequenceClassification"),
         ("layoutlmv2", "LayoutLMv2ForSequenceClassification"),
         ("layoutlmv3", "LayoutLMv3ForSequenceClassification"),
-        ("led", "LEDForSequenceClassification"),
         ("lilt", "LiltForSequenceClassification"),
         ("llama", "LlamaForSequenceClassification"),
         ("longformer", "LongformerForSequenceClassification"),

src/transformers/models/blip/modeling_blip.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 """PyTorch BLIP model."""
 
-import warnings
 from dataclasses import dataclass
 from typing import Any
 
@@ -84,15 +83,6 @@ class BlipForConditionalGenerationModelOutput(ModelOutput):
     hidden_states: tuple[torch.FloatTensor, ...] | None = None
     attentions: tuple[torch.FloatTensor, ...] | None = None
 
-    @property
-    def decoder_logits(self):
-        warnings.warn(
-            "`decoder_logits` attribute is deprecated and will be removed in version 5 of Transformers."
-            " Please use the `logits` attribute to retrieve the final output instead.",
-            FutureWarning,
-        )
-        return self.logits
-
 
 @dataclass
 @auto_docstring(