# Importar utilidades

Esta página describe las utilidades de `transformers` para habilitar la importación de objetos de forma diferida y rápida. Aunque nos esforzamos por mantener al mínimo las dependencias, algunos modelos tienen requisitos de dependencias específicas que no se pueden evitar. No queremos que todos los usuarios de `transformers` tengan que instalar esas dependencias para usar otros modelos, por lo que las marcamos como dependencias suaves en lugar de dependencias duras.

El kit de herramientas transformers no está diseñado para fallar al importar un modelo que tiene una dependencia específica; en su lugar, un objeto para el que falta una dependencia fallará al llamar a cualquiera de sus métodos. Por ejemplo, si `torchvision` no está instalado, los procesadores de imágenes rápidos no estarán disponibles.

Este objeto aún es importable:

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

Sin embargo, los métodos de ese objeto comprueban sus dependencias opcionales cuando se invocan. Por ejemplo, si `torchvision` no está disponible, esta llamada genera un `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.
```

Veamos cómo especificar dependencias de objetos específicos.

## Especificación de dependencias de objetos

### Basado en el nombre de archivo

Todos los objetos bajo un nombre de archivo dado tienen una dependencia automática con la herramienta vinculada a ese nombre de archivo

**PyTorch**: Todos los archivos que comienzan con `modeling_` tienen una dependencia automática de PyTorch

**Tokenizers**: Todos los archivos que comienzan con `tokenization_` y terminan con `_fast` tienen una dependencia automática de `tokenizers`

**Vision**: Todos los archivos que comienzan con `image_processing_` tienen una dependencia automática con el grupo de dependencias `vision`; en el momento de la redacción, este solo contiene la dependencia `pillow`.

**Vision + Torch + Torchvision**: Todos los archivos que comienzan con `image_processing_` y terminan con `_fast` tienen una dependencia automática de `vision`, `torch` y `torchvision`.

Todas estas dependencias automáticas se añaden además de las dependencias explícitas que se detallan a continuación.

### Dependencias de objetos explícitas

Añadimos un método llamado `requires` que se utiliza para especificar explícitamente las dependencias de un objeto dado. Como ejemplo, la clase `Trainer` tiene dos dependencias obligatorias: `torch` y `accelerate`. A continuación se muestra cómo especificamos estas dependencias requeridas:

```python
from .utils.import_utils import requires

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

Los backends que se pueden agregar aquí son todos los backends disponibles en el módulo `import_utils.py`.

Además, se pueden especificar versiones concretas en cada backend. Por ejemplo, así se especifica un requisito de torch>=2.6 en la clase `Trainer`:

```python
from .utils.import_utils import requires

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

Puede especificar los siguientes operadores: `==`, `>`, `>=`, `<`, `<=`, `!=`.

## Métodos[[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)
```

Este método toma un module_path como entrada y crea una estructura de importación digerible por un _LazyModule.

A continuación se muestra un ejemplo de la estructura de importación de la salida a nivel de 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 estructura de importación es un diccionario definido con conjuntos inmutables como claves y diccionarios de cadenas a conjuntos de objetos.

Si `prefix` no es None, se añadirá ese prefijo a todas las claves del diccionario devuelto.

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

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

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

Este decorador permite dos cosas:
- Adjuntar una tupla `__backends` a un objeto para ver cuáles son los backends necesarios para que se ejecute correctamente sin instanciarlo
- La cadena '@requires' se utiliza para importar objetos de forma dinámica

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

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

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

**Parámetros:**

obj : objeto a verificar

backends : lista o tupla de backends a verificar.

Método que lanza automáticamente una excepción en caso de que los backends especificados no estén disponibles. Se utiliza a menudo durante la clase

inicialización para asegurarse de que las dependencias requeridas están instaladas:

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

Los backends deben definirse en `BACKEND_MAPPING`, definido en `transformers.utils.import_utils`.

