# Importation des utilitaires

Cette page présente les utilitaires de `transformers` permettant l’importation paresseuse et rapide des objets. Bien que nous visons un minimum de dépendances, certains modèles ont des exigences spécifiques qui ne peuvent être contournées. Nous ne souhaitons pas que tous les utilisateurs de `transformers` soient obligés d’installer ces dépendances pour utiliser d’autres modèles ; nous les qualifions donc de dépendances optionnelles plutôt que de dépendances obligatoires.

Le kit d'outils transformers n'est pas conçu pour générer une erreur lors de l'importation d'un modèle ayant une dépendance spécifique ; à la place, un objet pour lequel une dépendance est manquante générera une erreur lors de l'appel de n'importe quelle méthode sur cet objet. Par exemple, si `torchvision` n'est pas installé, les processeurs d'images rapides ne seront pas disponibles.

Cet objet est toujours importable :

```python
>>> from transformers import DetrImageProcessor
>>> print(DetrImageProcessor)
<class 'transformers.models.detr.image_processing_detr.DetrImageProcessor'>
```

Cependant, les méthodes de cet objet vérifient leurs dépendances facultatives lors de leur appel. Par exemple, si `torchvision` n'est pas disponible, cet appel lève une `ImportError` :

```python
>>> DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
ImportError:
DetrImageProcessor requires the Torchvision library but it was not found in your environment. Check out the instructions on the
installation page: https://pytorch.org/get-started/locally/ and follow the ones that match your environment.
Please note that you may need to restart your runtime after installation.
```

Voici comment spécifier des dépendances d'objets spécifiques.

## Spécifier les dépendances d'objets

### Basé sur le nom de fichier

Tous les objets situés sous un nom de fichier donné ont une dépendance automatique à l'outil lié au nom de fichier

**PyTorch** : tous les fichiers commençant par `modeling_` ont une dépendance automatique à PyTorch

**Tokenizers** : tous les fichiers commençant par `tokenization_` et se terminant par `_fast` ont une dépendance automatique à `tokenizers`

**Vision** : tous les fichiers commençant par `image_processing_` ont une dépendance automatique au groupe de dépendances `vision` ; à l'heure actuelle, ce groupe ne contient que la dépendance `pillow`.

**Vision + Torch + Torchvision** : tous les fichiers commençant par `image_processing_` et se terminant par `_fast` ont une dépendance automatique à `vision`, `torch` et `torchvision`.

Toutes ces dépendances automatiques s'ajoutent aux dépendances explicites détaillées ci-dessous.

### Dépendances d'objets explicites

Nous ajoutons une méthode nommée `requires` qui sert à spécifier explicitement les dépendances d'un objet donné. À titre d'exemple, la classe `Trainer` possède deux dépendances obligatoires : `torch` et `accelerate`. Voici comment nous spécifions ces dépendances requises :

```python
from .utils.import_utils import requires

@requires(backends=("torch", "accelerate"))
class Trainer:
    ...
```

Les backends qui peuvent être ajoutés ici sont tous les backends disponibles dans le module `import_utils.py`.

De plus, des versions spécifiques peuvent être indiquées pour chaque backend. Par exemple, voici comment spécifier une exigence sur torch>=2.6 pour la classe `Trainer` :

```python
from .utils.import_utils import requires

@requires(backends=("torch>=2.6", "accelerate"))
class Trainer:
    ...
```

Vous pouvez spécifier les opérateurs suivants : `==`, `>`, `>=`, `<`, `<=`, `!=`.

## Méthodes[[transformers.utils.import_utils.define_import_structure]]

#### transformers.utils.import_utils.define_import_structure[[transformers.utils.import_utils.define_import_structure]]

```python
transformers.utils.import_utils.define_import_structure(module_path: str, prefix: str | None = None)
```

Cette méthode prend un module_path en entrée et crée une structure d’importation digeste par un _LazyModule.

Voici un exemple de structure d'importation de la sortie au niveau src.transformers.models :

{ frozenset({'tokenizers'}): { 'albert.tokenization_albert_fast': {'AlbertTokenizer'} }, frozenset(): { 'albert.configuration_albert': {'AlbertConfig'}, 'align.processing_align': {'AlignProcessor'}, 'align.configuration_align': {'AlignConfig', 'AlignTextConfig', 'AlignVisionConfig'}, 'altclip.configuration_altclip': {'AltCLIPConfig', 'AltCLIPTextConfig', 'AltCLIPVisionConfig'}, 'altclip.processing_altclip': {'AltCLIPProcessor'} } }

La structure d'importation est un dict défini avec des frozensets comme clés, et des dicts de chaînes vers des ensembles d'objets.

Si `prefix` n'est pas None, ce préfixe sera ajouté à toutes les clés du dictionnaire renvoyé.

#### transformers.utils.import_utils.requires[[transformers.utils.import_utils.requires]]

```python
transformers.utils.import_utils.requires(backends = ())
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/import_utils.py#L2974)

Ce décorateur permet deux choses :
- Attacher un tuple `__backends` à un objet pour déterminer les backends nécessaires à son exécution correcte sans l'instantier
- La chaîne '@requires' est utilisée pour importer dynamiquement des objets

#### transformers.requires_backends[[transformers.requires_backends]]

```python
transformers.requires_backends(obj, backends)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/import_utils.py#L2394)

**Paramètres :**

obj : objet à vérifier

backends : liste ou tuple des backends à vérifier.

Méthode qui lève automatiquement une exception si les backends spécifiés ne sont pas disponibles. Elle est souvent utilisée lors de la

initialisation afin de garantir que les dépendances requises sont installées :

```py
requires_backends(self, ["torch"])
```

Les backends doivent être définis dans `BACKEND_MAPPING`, défini dans `transformers.utils.import_utils`.