# Utilitários para processadores de imagem

Esta página lista todas as funções utilitárias usadas pelos processadores de imagem, principalmente as transformações funcionais usadas para processar as imagens.

A maioria delas só é útil se você estiver estudando o código dos processadores de imagem na biblioteca.

## Transformações de Imagem[[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)
```

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

**Parâmetros:**

image (`np.ndarray`) : A imagem a ser recortada.

size (`tuple[int, int]`) : O tamanho alvo para a imagem recortada.

data_format (`str` ou `ChannelDimension`, *opcional*) : O formato da dimensão de canal para a imagem de saída. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). Se não for definido, será usado o formato inferido da imagem de entrada.

input_data_format (`str` ou `ChannelDimension`, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). Se não for definido, será utilizado o formato inferido da imagem de entrada.

**Retorna:** `np.ndarray`

A imagem recortada.

Recorta a `image` para o `size` especificado usando um recorte central. Observe que, se a imagem for pequena demais para ser recortada para o tamanho fornecido, ela será preenchida (portanto, o resultado retornado sempre terá o tamanho `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)
```

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

Converte caixas delimitadoras do formato de centro para o formato de cantos.

formato center: contém a coordenada do centro da caixa e suas dimensões de largura e altura (center_x, center_y, width, height) formato corners: contém as coordenadas dos cantos superior esquerdo e inferior direito da caixa (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)
```

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

Converte caixas delimitadoras do formato de cantos para o formato de centro.

formato corners: contém as coordenadas dos cantos superior esquerdo e inferior direito da caixa (top_left_x, top_left_y, bottom_right_x, bottom_right_y) formato center: contém a coordenada do centro da caixa e suas dimensões de largura e altura (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)
```

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

Converte um ID exclusivo em uma cor 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)
```

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

**Parâmetros:**

image (`np.ndarray`) : A imagem a ser normalizada.

mean (`float` ou `Collection[float]`) : A média a ser usada para a normalização.

std (`float` ou `Collection[float]`) : O desvio padrão a ser usado para a normalização.

data_format (`ChannelDimension`, *opcional*) : O formato da dimensão de canal da imagem de saída. Se não for definido, usará o formato inferido a partir da entrada.

input_data_format (`ChannelDimension`, *opcional*) : O formato da dimensão de canal da imagem de entrada. Se não for definido, será usado o formato inferido a partir da entrada.

Normaliza `image` usando a média e o desvio padrão especificados por `mean` e `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)
```

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

**Parâmetros:**

image (`np.ndarray`) : A imagem a ser preenchida.

padding (`int` ou `tuple[int, int]` ou `Iterable[tuple[int, int]]`) : Preenchimento a ser aplicado às bordas dos eixos de altura e largura. Pode ser um dos três formatos: - `((before_height, after_height), (before_width, after_width))` larguras de preenchimento únicas para cada eixo. - `((before, after),)` gera o mesmo preenchimento antes e depois para altura e largura. - `(pad,)` ou int é um atalho para before = after = largura de preenchimento para todos os eixos.

mode (`PaddingMode`) : O modo de preenchimento a ser usado. Pode ser um dos seguintes: - `"constant"`: preenche com um valor constante. - `"reflect"`: preenche com a reflexão do vetor espelhado nos primeiros e últimos valores do vetor ao longo de cada eixo. - `"replicate"`: preenche com a replicação do último valor na borda da matriz ao longo de cada eixo. - `"symmetric"`: preenche com a reflexão do vetor espelhado na borda da matriz.

constant_values (`float` ou `Iterable[float]`, *opcional*) : O valor a ser usado para o preenchimento se `mode` for `"constant"`.

data_format (`str` ou `ChannelDimension`, *opcional*) : O formato da dimensão de canal para a imagem de saída. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). Se não for definido, usará o mesmo formato da imagem de entrada.

input_data_format (`str` ou `ChannelDimension`, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). Se não for definido, será utilizado o formato inferido da imagem de entrada.

**Retorna:** `np.ndarray`

A imagem com preenchimento.

Preenche a `image` com o `padding` (altura, largura) e o `mode` especificados.

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

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

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

Converte a cor RGB em um ID exclusivo.

#### 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)
```

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

**Parâmetros:**

image (`np.ndarray`) : A imagem a ser redimensionada.

scale (`float`) : A escala a ser usada para redimensionar a imagem.

data_format (`ChannelDimension`, *opcional*) : O formato da dimensão de canal da imagem. Se não for fornecido, será o mesmo da imagem de entrada.

dtype (`np.dtype`, *opcional*, padrão `np.float32`) : O dtype da imagem de saída. O padrão é `np.float32`. Usado para compatibilidade reversa com extratores de recursos.

input_data_format (`ChannelDimension`, *opcional*) : O formato da dimensão de canal da imagem de entrada. Se não for fornecido, ele será inferido a partir da imagem de entrada.

**Retorna:** `np.ndarray`

A imagem redimensionada.

Redimensiona `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)
```

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

**Parâmetros:**

image (`np.ndarray`) : A imagem a ser redimensionada.

size (`tuple[int, int]`) : O tamanho a ser usado para redimensionar a imagem.

resample (`int`, *opcional*, padrão `PILImageResampling.BILINEAR`) : O filtro a ser usado para o reamostragem.

reducing_gap (`int`, *opcional*) : Aplica otimização redimensionando a imagem em duas etapas. Quanto maior o `reducing_gap`, mais próximo o resultado fica do reamostragem justa. Consulte a documentação correspondente do Pillow para mais detalhes.

data_format (`ChannelDimension`, *opcional*) : O formato da dimensão de canal da imagem de saída. Se não for definido, usará o formato inferido a partir da entrada.

return_numpy (`bool`, *opcional*, padrão `True`) : Indica se a imagem redimensionada deve ser retornada como um array numpy. Se False, um objeto `PIL.Image.Image` é retornado.

input_data_format (`ChannelDimension`, *opcional*) : O formato da dimensão de canal da imagem de entrada. Se não for definido, será usado o formato inferido a partir da entrada.

**Retorna:** `np.ndarray`

A imagem redimensionada.

Redimensiona `image` para `(height, width)` especificado por `size` usando a 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)
```

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

**Parâmetros:**

image (`PIL.Image.Image` ou `numpy.ndarray` ou `torch.Tensor`) : A imagem a ser convertida para o formato `PIL.Image`.

do_rescale (`bool`, *opcional*) : Se deve ou não aplicar o fator de escala (para tornar os valores de pixels inteiros entre 0 e 255). O valor padrão será `True` se o tipo da imagem for de ponto flutuante e a conversão para `int` resultasse em perda de precisão, e `False` caso contrário.

image_mode (`str`, *opcional*) : O modo a ser usado para a imagem PIL. Se não for definido, será utilizado o modo padrão para o tipo de imagem de entrada.

input_data_format (`ChannelDimension`, *opcional*) : O formato da dimensão de canal da imagem de entrada. Se não for definido, será usado o formato inferido a partir da entrada.

**Retorna:** `PIL.Image.Image`

A imagem 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)
```

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

Este é um mixin de processador de imagem usado para fornecer funcionalidade de salvamento/carregamento para extratores de recursos sequenciais e de imagem.

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

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

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

Converte uma única URL ou uma lista de URLs nos objetos `PIL.Image` correspondentes.

Se uma única url for passada, o valor retornado será um único objeto. Se uma lista for passada, uma lista de objetos é retornada.

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

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

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

**Parâmetros:**

image_processor_dict (`dict[str, Any]`) : Dicionário que será usado para instanciar o objeto de processador de imagem. Esse dicionário pode ser obtido de um checkpoint pré-treinado utilizando o método [to_dict()](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin.to_dict).

kwargs (`dict[str, Any]`) : Parâmetros adicionais a partir dos quais inicializar o objeto de processador de imagem.

**Retorna:** [ImageProcessingMixin](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin)

O objeto de processador de imagem instanciado a partir desses parâmetros.

Instancia um tipo de [ImageProcessingMixin](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin) a partir de um dicionário Python de parâmetros.

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

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

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

**Parâmetros:**

json_file (`str` ou `os.PathLike`) : Caminho para o arquivo JSON contendo os parâmetros.

**Retorna:** Um processador de imagem do tipo [ImageProcessingMixin](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin)

O objeto image_processor instanciado a partir desse arquivo JSON.

Instancia um processador de imagens do tipo [ImageProcessingMixin](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin) a partir do caminho para um arquivo 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)
```

[Origem](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/pt/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` ou `os.PathLike`, *opcional*) : Caminho para um diretório em que o processador de imagem de um modelo pré-treinado baixado deve ser armazenado em cache, caso o cache padrão não deva ser usado.

force_download (`bool`, *opcional*, padrão `False`) : Indica se deve forçar o (re)download dos arquivos do processador de imagem e sobrescrever as versões em cache, caso existam.

proxies (`dict[str, str]`, *opcional*) : Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` Os proxies são usados em cada solicitação.

token (`str` ou `bool`, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, ou não especificado, usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`).

revision (`str`, *opcional*, padrão `"main"`) : A versão específica do modelo a ser usada. Pode ser o nome de um branch, o nome de uma tag ou um id de commit, pois usamos um sistema baseado em git para armazenar modelos e outros artefatos no huggingface.co, portanto `revision` pode ser qualquer identificador permitido pelo git.     Para testar um pull request que você fez no Hub, você pode passar `revision="refs/pr/<pr_number>"`.

return_unused_kwargs (`bool`, *opcional*, padrão `False`) : Se `False`, esta função retorna apenas o objeto final do processador de imagem. Se `True`, esta função retorna uma `Tuple(image_processor, unused_kwargs)`, onde *unused_kwargs* é um dicionário composto pelos pares de chave/valor cujas chaves não são atributos do processador de imagem: ou seja, a parte de `kwargs` que não foi usada para atualizar `image_processor` e é, de outra forma, ignorada.

subfolder (`str`, *opcional*, padrão `""`) : Caso os arquivos relevantes estejam localizados em uma subpasta do repositório do modelo no huggingface.co, você pode especificar o nome da pasta aqui.

kwargs (`dict[str, Any]`, *opcional*) : Os valores em kwargs de quaisquer chaves que sejam atributos do processador de imagem serão usados para substituir os valores carregados. O comportamento em relação a pares de chave/valor cujas chaves *não* são atributos do processador de imagem é controlado pelo parâmetro de palavra-chave `return_unused_kwargs`.

**Retorna:**

Um processador de imagens do tipo [ImageProcessingMixin](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin).

Instancie um tipo de [ImageProcessingMixin](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin) a partir de um processador de imagem.

Exemplos:

```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)
```

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

**Parâmetros:**

pretrained_model_name_or_path (`str` ou `os.PathLike`) : O identificador do checkpoint pré-treinado do qual queremos o dicionário de parâmetros.

subfolder (`str`, *opcional*, padrão `""`) : Caso os arquivos relevantes estejam localizados em uma subpasta do repositório do modelo no huggingface.co, você pode especificar o nome da pasta aqui.

image_processor_filename (`str`, *opcional*, padrão `"config.json"`) : O nome do arquivo no diretório do modelo a ser usado para a configuração do processador de imagem.

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

O(s) dicionário(s) que será(ão) usado(s) para instanciar o objeto de processador de imagem.

A partir de um `pretrained_model_name_or_path`, resolve para um dicionário de parâmetros, a ser usado para instanciar um processador de imagem do tipo `~image_processor_utils.ImageProcessingMixin` usando `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)
```

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

**Parâmetros:**

repo_id (`str`) : O nome do repositório para o qual você deseja enviar seu image processor. Deve conter o nome da sua organização ao enviar para uma organização específica.

commit_message (`str`, *opcional*) : Mensagem para o commit ao fazer push. O valor padrão será `"Upload image processor"`.

commit_description (`str`, *opcional*) : A descrição do commit que será criado

private (`bool`, *opcional*) : Se deve tornar o repositório privado. Se `None` (padrão), o repositório será público, a menos que o padrão da organização seja privado. Este valor é ignorado se o repositório já existir.

token (`bool` ou `str`, *opcional*) : O token a ser usado como autorização bearer HTTP para arquivos remotos. Se `True` (padrão), usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`).

revision (`str`, *opcional*) : Branch para a qual os arquivos enviados serão enviados.

create_pr (`bool`, *opcional*, padrão `False`) : Se deve ou não criar um PR com os arquivos enviados ou fazer o commit diretamente.

max_shard_size (`int` ou `str`, *opcional*, padrão `"50GB"`) : Aplicável apenas a modelos. O tamanho máximo de um checkpoint antes de ser fragmentado. Os fragmentos do checkpoint terão, então, cada um um tamanho menor que esse valor. Se expresso como string, deve conter dígitos seguidos de uma unidade (como `"5MB"`).

tags (`list[str]`, *opcional*) : Lista de tags para enviar no Hub.

Envie o arquivo do processador de imagens para o 🤗 Model Hub.

Exemplos:

```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')
```

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

**Parâmetros:**

auto_class (`str` ou `type`, *opcional*, padrão `"AutoImageProcessor "`) : A classe auto com a qual este novo processador de imagem será registrado.

Registre esta classe com uma classe auto específica. Isso deve ser usado apenas para processadores de imagem personalizados, pois os da biblioteca já estão mapeados com `AutoImageProcessor `.

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

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

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

**Parâmetros:**

save_directory (`str` ou `os.PathLike`) : Diretório onde o arquivo JSON do processador de imagem será salvo (será criado se não existir).

push_to_hub (`bool`, *opcional*, padrão `False`) : Indica se o modelo deve ser enviado para o Hugging Face model hub após ser salvo. Você pode especificar o repositório de destino com `repo_id` (por padrão, será usado o nome de `save_directory` no seu namespace).

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais passados ao método [push_to_hub()](/docs/transformers/main/pt/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Salve um objeto de processador de imagens no diretório `save_directory` para que ele possa ser recarregado usando o método de classe [from_pretrained()](/docs/transformers/main/pt/internal/image_processing_utils#transformers.ImageProcessingMixin.from_pretrained).

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

```python
to_dict()
```

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

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

Dicionário de todos os atributos que compõem esta instância de processador de imagem.

Serializa esta instância em um dicionário Python.

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

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

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

**Parâmetros:**

json_file_path (`str` ou `os.PathLike`) : Caminho para o arquivo JSON em que os parâmetros desta instância de image_processor serão salvos.

Salve esta instância em um arquivo JSON.

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

```python
to_json_string()
```

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

**Retorna:** `str`

String contendo todos os atributos que compõem esta instância de feature_extractor em formato JSON.

Serializa esta instância em uma string JSON.