# Utilidades para procesadores de imágenes

Esta página enumera todas las funciones utilitarias utilizadas por los procesadores de imágenes, principalmente las transformaciones funcionales empleadas para procesar las imágenes.

La mayoría de esos parámetros solo son útiles si estás estudiando el código de los procesadores de imágenes de la biblioteca.

## Transformaciones de imagen[[transformers.image_transforms.center_crop]]

#### transformers.image_transforms.center_crop[[transformers.image_transforms.center_crop]]

```python
transformers.image_transforms.center_crop(image: ndarray, size: tuple, data_format: str | transformers.image_utils.ChannelDimension | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L448)

**Parámetros:**

image (`np.ndarray`) : La imagen que se recortará.

size (`tuple[int, int]`) : El tamaño objetivo para la imagen recortada.

data_format (`str` o `ChannelDimension`, *opcional*) : El formato de la dimensión de canales para la imagen de salida. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). Si no se establece, se utilizará el formato inferido de la imagen de entrada.

input_data_format (`str` o `ChannelDimension`, *opcional*) : El formato de la dimensión de canales para la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). Si no se establece, se utilizará el formato inferido de la imagen de entrada.

**Devuelve:** `np.ndarray`

La imagen recortada.

Recorta la `image` al `size` especificado mediante un recorte centrado. Tenga en cuenta que si la imagen es demasiado pequeña para recortarla al tamaño indicado, se rellenará (de modo que el resultado devuelto siempre tendrá el tamaño `size`).

#### transformers.image_transforms.center_to_corners_format[[transformers.image_transforms.center_to_corners_format]]

```python
transformers.image_transforms.center_to_corners_format(bboxes_center: TensorType)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L553)

Convierte las cajas delimitadoras del formato de centro al formato de esquinas.

formato center: contiene la coordenada del centro de la caja y sus dimensiones de ancho y alto (center_x, center_y, width, height) formato corners: contiene las coordenadas de las esquinas superior izquierda e inferior derecha de la caja (top_left_x, top_left_y, bottom_right_x, bottom_right_y)

#### transformers.image_transforms.corners_to_center_format[[transformers.image_transforms.corners_to_center_format]]

```python
transformers.image_transforms.corners_to_center_format(bboxes_corners: TensorType)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L596)

Convierte las cajas delimitadoras del formato de esquinas al formato de centro.

formato corners: contiene las coordenadas de las esquinas superior izquierda e inferior derecha de la caja (top_left_x, top_left_y, bottom_right_x, bottom_right_y) formato center: contiene la coordenada del centro de la caja y sus dimensiones de ancho y alto (center_x, center_y, width, height)

#### transformers.image_transforms.id_to_rgb[[transformers.image_transforms.id_to_rgb]]

```python
transformers.image_transforms.id_to_rgb(id_map)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L643)

Convierte un ID único en un color RGB.

#### transformers.image_transforms.normalize[[transformers.image_transforms.normalize]]

```python
transformers.image_transforms.normalize(image: ndarray, mean: float | collections.abc.Collection[float], std: float | collections.abc.Collection[float], data_format: transformers.image_utils.ChannelDimension | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L387)

**Parámetros:**

image (`np.ndarray`) : La imagen a normalizar.

mean (`float` o `Collection[float]`) : La media a utilizar para la normalización.

std (`float` o `Collection[float]`) : La desviación estándar a utilizar para la normalización.

data_format (`ChannelDimension`, *opcional*) : El formato de la dimensión de canal de la imagen de salida. Si no se establece, se utilizará el formato inferido a partir de la entrada.

input_data_format (`ChannelDimension`, *opcional*) : El formato de la dimensión de canal de la imagen de entrada. Si no se establece, se utilizará el formato inferido a partir de la entrada.

Normaliza `image` utilizando la media y la desviación estándar especificadas por `mean` y `std`.

image = (image - mean) / std

#### transformers.image_transforms.pad[[transformers.image_transforms.pad]]

```python
transformers.image_transforms.pad(image: ndarray, padding: int | tuple[int, int] | collections.abc.Iterable[tuple[int, int]], mode: PaddingMode = <PaddingMode.CONSTANT: 'constant'>, constant_values: float | collections.abc.Iterable[float] = 0.0, data_format: str | transformers.image_utils.ChannelDimension | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L673)

**Parámetros:**

image (`np.ndarray`) : La imagen que se debe rellenar.

padding (`int` o `tuple[int, int]` o `Iterable[tuple[int, int]]`) : Relleno que se aplica a los bordes de los ejes de altura y ancho. Puede tener uno de tres formatos: - `((before_height, after_height), (before_width, after_width))` anchos de relleno únicos para cada eje. - `((before, after),)` genera el mismo relleno antes y después para la altura y el ancho. - `(pad,)` o int es un atajo para before = after = ancho de relleno para todos los ejes.

mode (`PaddingMode`) : El modo de relleno a utilizar. Puede ser uno de los siguientes: - `"constant"`: rellena con un valor constante. - `"reflect"`: rellena con la reflexión del vector reflejado en los primeros y últimos valores del vector a lo largo de cada eje. - `"replicate"`: rellena con la replicación del último valor en el borde del array a lo largo de cada eje. - `"symmetric"`: rellena con la reflexión del vector reflejado a lo largo del borde del array.

constant_values (`float` o `Iterable[float]`, *opcional*) : El valor a utilizar para el relleno si `mode` es `"constant"`.

data_format (`str` o `ChannelDimension`, *opcional*) : El formato de la dimensión de canales para la imagen de salida. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). Si no se establece, se usará el mismo que el de la imagen de entrada.

input_data_format (`str` o `ChannelDimension`, *opcional*) : El formato de la dimensión de canales para la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). Si no se establece, se utilizará el formato inferido de la imagen de entrada.

**Devuelve:** `np.ndarray`

La imagen rellena.

Rellena la `image` con el `padding` (altura, ancho) y el `mode` especificados.

#### transformers.image_transforms.rgb_to_id[[transformers.image_transforms.rgb_to_id]]

```python
transformers.image_transforms.rgb_to_id(color)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L632)

Convierte un color RGB en un ID único.

#### transformers.image_transforms.rescale[[transformers.image_transforms.rescale]]

```python
transformers.image_transforms.rescale(image: ndarray, scale: float, data_format: transformers.image_utils.ChannelDimension | None = None, dtype: dtype = <class 'numpy.float32'>, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L92)

**Parámetros:**

image (`np.ndarray`) : La imagen que se debe reescalar.

scale (`float`) : La escala a utilizar para reescalar la imagen.

data_format (`ChannelDimension`, *opcional*) : El formato de la dimensión de canal de la imagen. Si no se proporciona, será el mismo que el de la imagen de entrada.

dtype (`np.dtype`, *opcional*, valor predeterminado `np.float32`) : El dtype de la imagen de salida. El valor predeterminado es `np.float32`. Se utiliza para la compatibilidad hacia atrás con los extractores de características.

input_data_format (`ChannelDimension`, *opcional*) : El formato de la dimensión de canal de la imagen de entrada. Si no se proporciona, se inferirá a partir de la imagen de entrada.

**Devuelve:** `np.ndarray`

La imagen reescalada.

Escala `image` por `scale`.

#### transformers.image_transforms.resize[[transformers.image_transforms.resize]]

```python
transformers.image_transforms.resize(image: ndarray, size: tuple, resample: typing.Optional[ForwardRef('PILImageResampling')] = None, reducing_gap: int | None = None, data_format: transformers.image_utils.ChannelDimension | None = None, return_numpy: bool = True, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L316)

**Parámetros:**

image (`np.ndarray`) : La imagen que se debe redimensionar.

size (`tuple[int, int]`) : El tamaño que se usará para redimensionar la imagen.

resample (`int`, *opcional*, valor predeterminado `PILImageResampling.BILINEAR`) : El filtro que se usa para el muestreo.

reducing_gap (`int`, *opcional*) : Aplica una optimización redimensionando la imagen en dos pasos. A mayor `reducing_gap`, más se acerca el resultado al muestreo equitativo. Consulta la documentación correspondiente de Pillow para más detalles.

data_format (`ChannelDimension`, *opcional*) : El formato de la dimensión de canal de la imagen de salida. Si no se establece, se utilizará el formato inferido a partir de la entrada.

return_numpy (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver la imagen redimensionada como un array de numpy. Si es False, se devuelve un objeto `PIL.Image.Image`.

input_data_format (`ChannelDimension`, *opcional*) : El formato de la dimensión de canal de la imagen de entrada. Si no se establece, se utilizará el formato inferido a partir de la entrada.

**Devuelve:** `np.ndarray`

La imagen redimensionada.

Redimensiona `image` a `(height, width)` especificado por `size` usando la biblioteca PIL.

#### transformers.image_transforms.to_pil_image[[transformers.image_transforms.to_pil_image]]

```python
transformers.image_transforms.to_pil_image(image: typing.Union[numpy.ndarray, ForwardRef('PIL.Image.Image'), ForwardRef('torch.Tensor')], do_rescale: bool | None = None, image_mode: str | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_transforms.py#L157)

**Parámetros:**

image (`PIL.Image.Image` o `numpy.ndarray` o `torch.Tensor`) : La imagen que se convertirá al formato `PIL.Image`.

do_rescale (`bool`, *opcional*) : Indica si se debe aplicar el factor de escala (para que los valores de píxeles sean enteros entre 0 y 255). El valor predeterminado será `True` si el tipo de imagen es de punto flotante y la conversión a `int` provocaría una pérdida de precisión, y `False` en caso contrario.

image_mode (`str`, *opcional*) : El modo a utilizar para la imagen PIL. Si no se establece, se usará el modo predeterminado para el tipo de imagen de entrada.

input_data_format (`ChannelDimension`, *opcional*) : El formato de la dimensión de canal de la imagen de entrada. Si no se establece, se utilizará el formato inferido a partir de la entrada.

**Devuelve:** `PIL.Image.Image`

La imagen convertida.

Converts `image` to a PIL Image. Optionally rescales it and puts the channel dimension back as the last axis if needed.

## ImageProcessingMixin[[transformers.ImageProcessingMixin]]

#### transformers.ImageProcessingMixin[[transformers.ImageProcessingMixin]]

```python
transformers.ImageProcessingMixin(**kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L61)

Esta es una mezcla de procesador de imágenes que se utiliza para proporcionar funcionalidad de guardado/carga para extractores de características secuenciales y de imágenes.

#### fetch_images[[transformers.ImageProcessingMixin.fetch_images]]

```python
fetch_images(image_url_or_urls: str | list[str] | list[list[str]])
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L489)

Convierte una URL o una lista de URLs en los objetos `PIL.Image` correspondientes.

Si se pasa una única url, el valor devuelto será un único objeto. Si se pasa una lista, se devuelve una lista de objetos.

#### from_dict[[transformers.ImageProcessingMixin.from_dict]]

```python
from_dict(image_processor_dict: dict, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L366)

**Parámetros:**

image_processor_dict (`dict[str, Any]`) : Diccionario que se utilizará para instanciar el objeto de procesador de imágenes. Dicho diccionario puede obtenerse de un punto de control preentrenado mediante el método [to_dict()](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin.to_dict).

kwargs (`dict[str, Any]`) : Parámetros adicionales a partir de los cuales se inicializa el objeto de procesador de imágenes.

**Devuelve:** [ImageProcessingMixin](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin)

El objeto de procesador de imágenes instanciado a partir de esos parámetros.

Instancia un tipo de [ImageProcessingMixin](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin) a partir de un diccionario de Python de parámetros.

#### from_json_file[[transformers.ImageProcessingMixin.from_json_file]]

```python
from_json_file(json_file: str | os.PathLike)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L419)

**Parámetros:**

json_file (`str` o `os.PathLike`) : Ruta al archivo JSON que contiene los parámetros.

**Devuelve:** Un procesador de imágenes de tipo [ImageProcessingMixin](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin)

El objeto image_processor instanciado a partir de ese archivo JSON.

Instancia un procesador de imágenes de tipo [ImageProcessingMixin](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin) a partir de la ruta a un archivo JSON de parámetros.

#### from_pretrained[[transformers.ImageProcessingMixin.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L84)

**Parámetros:**

pretrained_model_name_or_path (`str` or `os.PathLike`) : This can be either:  - a string, the *model id* of a pretrained image_processor hosted inside a model repo on huggingface.co. - a path to a *directory* containing a image processor file saved using the [save_pretrained()](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin.save_pretrained) method, e.g., `./my_model_directory/`. - a path to a saved image processor JSON *file*, e.g., `./my_model_directory/preprocessor_config.json`.

cache_dir (`str` o `os.PathLike`, *opcional*) : Ruta a un directorio en el que se debe almacenar en caché el procesador de imágenes de un modelo preentrenado descargado si no se debe usar la caché estándar.

force_download (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe forzar la (re)descarga de los archivos del procesador de imágenes y sobrescribir las versiones en caché si existen.

proxies (`dict[str, str]`, *opcional*) : Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, p. ej., `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` Los proxies se utilizan en cada solicitud.

token (`str` o `bool`, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True`, o no se especifica, se usará el token generado al ejecutar `hf auth login` (almacenado en `~/.huggingface`).

revision (`str`, *opcional*, valor predeterminado `"main"`) : La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta o un id de commit, ya que utilizamos un sistema basado en git para almacenar modelos y otros artefactos en huggingface.co, por lo que `revision` puede ser cualquier identificador permitido por git. Para probar una pull request que hayas realizado en el Hub, puedes pasar `revision="refs/pr/<pr_number>"`.

return_unused_kwargs (`bool`, *opcional*, valor predeterminado `False`) : Si es `False`, esta función devuelve únicamente el objeto de procesador de imágenes final. Si es `True`, esta función devuelve una `Tuple(image_processor, unused_kwargs)` donde *unused_kwargs* es un diccionario que consiste en pares clave/valor cuyas claves no son atributos del procesador de imágenes: es decir, la parte de `kwargs` que no se ha utilizado para actualizar `image_processor` y que se ignora de lo contrario.

subfolder (`str`, *opcional*, valor predeterminado `""`) : Si los archivos relevantes se encuentran en una subcarpeta del repositorio del modelo en huggingface.co, puede especificar aquí el nombre de la carpeta.

kwargs (`dict[str, Any]`, *opcional*) : Los valores en kwargs de cualquier clave que sea un atributo del procesador de imágenes se utilizarán para sobrescribir los valores cargados. El comportamiento respecto a los pares clave/valor cuyas claves *no* son atributos del procesador de imágenes se controla mediante el parámetro de palabra clave `return_unused_kwargs`.

**Devuelve:**

Un procesador de imágenes de tipo [ImageProcessingMixin](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin).

Instanciar un tipo de [ImageProcessingMixin](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin) desde un procesador de imágenes.

Ejemplos:

```python
# We can't instantiate directly the base class *ImageProcessingMixin* so let's show the examples on a
# derived class: *CLIPImageProcessor*
image_processor = CLIPImageProcessor.from_pretrained(
    "openai/clip-vit-base-patch32"
)  # Download image_processing_config from huggingface.co and cache.
image_processor = CLIPImageProcessor.from_pretrained(
    "./test/saved_model/"
)  # E.g. image processor (or model) was saved using *save_pretrained('./test/saved_model/')*
image_processor = CLIPImageProcessor.from_pretrained("./test/saved_model/preprocessor_config.json")
image_processor = CLIPImageProcessor.from_pretrained(
    "openai/clip-vit-base-patch32", do_normalize=False, foo=False
)
assert image_processor.do_normalize is False
image_processor, unused_kwargs = CLIPImageProcessor.from_pretrained(
    "openai/clip-vit-base-patch32", do_normalize=False, foo=False, return_unused_kwargs=True
)
assert image_processor.do_normalize is False
assert unused_kwargs == {"foo": False}
```

#### get_image_processor_dict[[transformers.ImageProcessingMixin.get_image_processor_dict]]

```python
get_image_processor_dict(pretrained_model_name_or_path: str | os.PathLike, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L238)

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike`) : El identificador del punto de control preentrenado del que queremos obtener el diccionario de parámetros.

subfolder (`str`, *opcional*, valor predeterminado `""`) : Si los archivos relevantes se encuentran en una subcarpeta del repositorio del modelo en huggingface.co, puede especificar aquí el nombre de la carpeta.

image_processor_filename (`str`, *opcional*, valor predeterminado `"config.json"`) : El nombre del archivo en el directorio del modelo que se usará para la configuración del procesador de imágenes.

**Devuelve:** `tuple[Dict, Dict]`

El diccionario (o diccionarios) que se utilizará para instanciar el objeto de procesador de imágenes.

A partir de `pretrained_model_name_or_path`, se resuelve en un diccionario de parámetros, que se utilizará para instanciar un procesador de imágenes de tipo `~image_processor_utils.ImageProcessingMixin` mediante `from_dict`.

#### push_to_hub[[transformers.ImageProcessingMixin.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

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

**Parámetros:**

repo_id (`str`) : El nombre del repositorio al que deseas enviar tu procesador de imágenes. Debe incluir el nombre de tu organización cuando se envía a una organización determinada.

commit_message (`str`, *opcional*) : Mensaje para el commit al hacer push. El valor predeterminado es `"Upload image processor"`.

commit_description (`str`, *opcional*) : La descripción del commit que se creará

private (`bool`, *opcional*) : Si se debe hacer el repositorio privado. Si es `None` (valor predeterminado), el repositorio será público a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si el repositorio ya existe.

token (`bool` o `str`, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True` (valor predeterminado), se usará el token generado al ejecutar `hf auth login` (guardado en `~/.huggingface`).

revision (`str`, *opcional*) : Rama a la que se enviarán los archivos subidos.

create_pr (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe crear una PR con los archivos subidos o realizar el commit directamente.

max_shard_size (`int` o `str`, *opcional*, valor predeterminado `"50GB"`) : Solo aplicable a modelos. El tamaño máximo de un checkpoint antes de que se divida en fragmentos. Los fragmentos del checkpoint tendrán cada uno un tamaño inferior a este valor. Si se expresa como una cadena, debe consistir en dígitos seguidos de una unidad (como `"5MB"`).

tags (`list[str]`, *opcional*) : Lista de etiquetas para publicar en el Hub.

Sube el archivo del procesador de imágenes al 🤗 Model Hub.

Ejemplos:

```python
from transformers import AutoImageProcessor

image processor = AutoImageProcessor.from_pretrained("google-bert/bert-base-cased")

# Push the image processor to your namespace with the name "my-finetuned-bert".
image processor.push_to_hub("my-finetuned-bert")

# Push the image processor to an organization with the name "my-finetuned-bert".
image processor.push_to_hub("huggingface/my-finetuned-bert")
```

#### register_for_auto_class[[transformers.ImageProcessingMixin.register_for_auto_class]]

```python
register_for_auto_class(auto_class = 'AutoImageProcessor')
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L467)

**Parámetros:**

auto_class (`str` o `type`, *opcional*, valor predeterminado `"AutoImageProcessor "`) : La clase auto con la que registrar este nuevo procesador de imágenes.

Registra esta clase con una clase auto dada. Esto solo debe usarse para procesadores de imágenes personalizados, ya que los de la biblioteca ya están mapeados con `AutoImageProcessor `.

#### save_pretrained[[transformers.ImageProcessingMixin.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, push_to_hub: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L190)

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Directorio donde se guardará el archivo JSON del procesador de imágenes (se creará si no existe).

push_to_hub (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe subir el modelo al Hugging Face model hub después de guardarlo. Puede especificar el repositorio al que desea subirlo con `repo_id` (por defecto, se usará el nombre de `save_directory` en su espacio de nombres).

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan al método [push_to_hub()](/docs/transformers/main/es/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Guarde un objeto de procesador de imágenes en el directorio `save_directory` para que pueda recargarse mediante el método de clase [from_pretrained()](/docs/transformers/main/es/internal/image_processing_utils#transformers.ImageProcessingMixin.from_pretrained).

#### to_dict[[transformers.ImageProcessingMixin.to_dict]]

```python
to_dict()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L407)

**Devuelve:** `dict[str, Any]`

Diccionario de todos los atributos que componen esta instancia de procesador de imágenes.

Serializa esta instancia en un diccionario de Python.

#### to_json_file[[transformers.ImageProcessingMixin.to_json_file]]

```python
to_json_file(json_file_path: str | os.PathLike)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L453)

**Parámetros:**

json_file_path (`str` o `os.PathLike`) : Ruta al archivo JSON en el que se guardarán los parámetros de esta instancia de image_processor.

Guarde esta instancia en un archivo JSON.

#### to_json_string[[transformers.ImageProcessingMixin.to_json_string]]

```python
to_json_string()
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L438)

**Devuelve:** `str`

Cadena que contiene todos los atributos que componen esta instancia de feature_extractor en formato JSON.

Serializa esta instancia en una cadena JSON.