# Extrator de recursos

Um feature extractor é responsável por preparar os recursos de entrada para modelos de áudio. Isso inclui a extração de recursos de sequências, por exemplo, o pré-processamento de arquivos de áudio para gerar recursos de Log-Mel Spectrogram, e a conversão para tensores NumPy e PyTorch.

## FeatureExtractionMixin[[transformers.FeatureExtractionMixin]]

#### transformers.FeatureExtractionMixin[[transformers.FeatureExtractionMixin]]

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

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

Este é um mixin de extração de recursos usado para fornecer funcionalidade de salvamento/carregamento para extratores de recursos sequenciais e de áudio.

#### from_pretrained[[transformers.FeatureExtractionMixin.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/feature_extraction_utils.py#L286)

**Parâmetros:**

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

cache_dir (`str` ou `os.PathLike`, *opcional*) : Caminho para um diretório em que um extrator de recursos de 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 extrator de recursos e substituir 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 extrator de recursos. Se `True`, esta função retorna uma `Tuple(feature_extractor, unused_kwargs)`, onde *unused_kwargs* é um dicionário composto por pares de chave/valor cujas chaves não são atributos do extrator de recursos: ou seja, a parte de `kwargs` que não foi usada para atualizar `feature_extractor` e é, de outra forma, ignorada.

kwargs (`dict[str, Any]`, *opcional*) : Os valores em kwargs de quaisquer chaves que sejam atributos do extrator de recursos 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 extrator de recursos é controlado pelo parâmetro de palavra-chave `return_unused_kwargs`.

**Retorna:**

Um extrator de recursos do tipo [FeatureExtractionMixin](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin).

Instancie um tipo de [FeatureExtractionMixin](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin) a partir de um extrator de recursos, *por exemplo*, uma classe derivada de [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor).

Exemplos:

```python
# We can't instantiate directly the base class *FeatureExtractionMixin* nor *SequenceFeatureExtractor* so let's show the examples on a
# derived class: *Wav2Vec2FeatureExtractor*
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
    "facebook/wav2vec2-base-960h"
)  # Download feature_extraction_config from huggingface.co and cache.
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
    "./test/saved_model/"
)  # E.g. feature_extractor (or model) was saved using *save_pretrained('./test/saved_model/')*
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained("./test/saved_model/preprocessor_config.json")
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
    "facebook/wav2vec2-base-960h", return_attention_mask=False, foo=False
)
assert feature_extractor.return_attention_mask is False
feature_extractor, unused_kwargs = Wav2Vec2FeatureExtractor.from_pretrained(
    "facebook/wav2vec2-base-960h", return_attention_mask=False, foo=False, return_unused_kwargs=True
)
assert feature_extractor.return_attention_mask is False
assert unused_kwargs == {"foo": False}
```

#### save_pretrained[[transformers.FeatureExtractionMixin.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/feature_extraction_utils.py#L390)

**Parâmetros:**

save_directory (`str` ou `os.PathLike`) : Diretório onde o arquivo JSON do extrator de recursos 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 feature_extractor no diretório `save_directory`, para que ele possa ser recarregado usando o método de classe [from_pretrained()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained).

## SequenceFeatureExtractor[[transformers.SequenceFeatureExtractor]]

#### transformers.SequenceFeatureExtractor[[transformers.SequenceFeatureExtractor]]

```python
transformers.SequenceFeatureExtractor(feature_size: int, sampling_rate: int, padding_value: float, **kwargs)
```

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

**Parâmetros:**

feature_size (`int`) : A dimensão dos recursos das características extraídas.

sampling_rate (`int`) : A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz).

padding_value (`float`) : O valor usado para preencher os valores/vetores de padding.

Esta é uma classe geral de extração de recursos para reconhecimento de fala.

#### pad[[transformers.SequenceFeatureExtractor.pad]]

```python
pad(processed_features: transformers.feature_extraction_utils.BatchFeature | list[transformers.feature_extraction_utils.BatchFeature] | dict[str, transformers.feature_extraction_utils.BatchFeature] | dict[str, list[transformers.feature_extraction_utils.BatchFeature]] | list[dict[str, transformers.feature_extraction_utils.BatchFeature]], padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, truncation: bool = False, pad_to_multiple_of: int | None = None, return_attention_mask: bool | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None)
```

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

**Parâmetros:**

processed_features ([BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature), lista de [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature), `dict[str, list[float]]`, `dict[str, list[list[float]]` ou `list[dict[str, list[float]]]`) : Entradas processadas. Pode representar uma única entrada ([BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature) ou `dict[str, list[float]]`) ou um lote de valores/vetores de entrada (lista de [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature), *dict[str, list[list[float]]]* ou *list[dict[str, list[float]]]*), permitindo o uso deste método tanto durante o pré-processamento quanto em uma função de colagem de um Dataloader do PyTorch. Em vez de `list[float]`, você pode ter tensores (arrays numpy ou tensores do PyTorch); consulte a observação acima sobre o tipo de retorno.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `True`) : Selecione uma estratégia para aplicar padding às sequências retornadas (de acordo com o lado de padding e o índice de padding do modelo) entre:  - `True` ou `'longest'`: Aplica padding até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Aplica padding até um comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode retornar um lote com sequências de comprimentos diferentes).

max_length (`int`, *opcional*) : Comprimento máximo da lista retornada e, opcionalmente, o comprimento do padding (veja acima).

truncation (`bool`) : Ativa a truncagem para cortar sequências de entrada com comprimento maior que `max_length` para `max_length`.

pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Isso é especialmente útil para permitir o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta) ou em TPUs, que se beneficiam de ter comprimentos de sequência que sejam múltiplos de 128.

return_attention_mask (`bool`, *opcional*) : Se deve retornar a attention mask. Se mantido o valor padrão, a attention mask será retornada de acordo com o padrão do feature_extractor específico.  [O que são attention masks?](../glossary#attention-mask)

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de lista de inteiros do Python. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy.

Preencha os valores de entrada / vetores de entrada ou um lote de valores de entrada / vetores de entrada até o comprimento predefinido ou até o comprimento máximo da sequência no lote.

Os valores de padding do lado (esquerda/direita) são definidos no nível do extrator de recursos (com `self.padding_side`, `self.padding_value`)

Se as `processed_features` passadas forem um dicionário de arrays numpy ou tensores PyTorch, o resultado usará o mesmo tipo, a menos que você forneça um tipo de tensor diferente com `return_tensors`. No caso de tensores PyTorch, no entanto, você perderá o dispositivo específico dos seus tensores.

## BatchFeature[[transformers.BatchFeature]]

#### transformers.BatchFeature[[transformers.BatchFeature]]

```python
transformers.BatchFeature(data: dict[str, typing.Any] | None = None, tensor_type: None | str | transformers.utils.generic.TensorType = None, skip_tensor_conversion: list[str] | set[str] | None = None)
```

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

**Parâmetros:**

data (`dict`, *opcional*) : Dicionário de listas/arrays/tensors retornados pelos métodos __call__/pad ('input_values', 'attention_mask', etc.).

tensor_type (`Union[None, str, TensorType]`, *opcional*) : Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.

skip_tensor_conversion (`list[str]` ou `set[str]`, *opcional*) : Lista ou conjunto de chaves que não devem ser convertidas em tensores, mesmo quando `tensor_type` for especificado.

Contém a saída dos métodos [pad()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) e `__call__` específicos do extrator de recursos.

Esta classe é derivada de um dicionário python e pode ser usada como um dicionário.

#### convert_to_tensors[[transformers.BatchFeature.convert_to_tensors]]

```python
convert_to_tensors(tensor_type: str | transformers.utils.generic.TensorType | None = None, skip_tensor_conversion: list[str] | set[str] | None = None)
```

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

**Parâmetros:**

tensor_type (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : O tipo de tensores a ser usado. Se for `str`, deve ser um dos valores da enumeração [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType). Se for `None`, nenhuma modificação é feita.

skip_tensor_conversion (`list[str]` ou `set[str]`, *opcional*) : Lista ou conjunto de chaves que não devem ser convertidas em tensores, mesmo quando `tensor_type` for especificado.

Converta o conteúdo interno em tensores.

Observação: Valores que não possuem uma estrutura semelhante a um array (por exemplo, strings, dicts, listas de strings) são automaticamente ignorados e não serão convertidos em tensors. Arrays irregulares (listas de arrays com comprimentos diferentes) ainda são tentados, embora possam gerar erros durante a conversão.

#### para[[transformers.BatchFeature.to]]

```python
to(*args, **kwargs)
```

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

**Parâmetros:**

args (`Tuple`) : Será passado para a função `to(...)` dos tensores.

kwargs (`Dict`, *opcional*) : Será passado para a função `to(...)` dos tensores. Para habilitar a transferência de dados assíncrona, defina a flag `non_blocking` em `kwargs` (padrão: `False`).

**Retorna:** [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature)

A mesma instância após a modificação.

Envie todos os valores para o dispositivo chamando `v.to(*args, **kwargs)` (somente PyTorch). Isso deve suportar o cast em diferentes `dtypes` e o envio do `BatchFeature` para um `device` diferente.

## ImageFeatureExtractionMixin[[transformers.ImageFeatureExtractionMixin]]

#### transformers.ImageFeatureExtractionMixin[[transformers.ImageFeatureExtractionMixin]]

```python
transformers.ImageFeatureExtractionMixin()
```

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

Mixin que contém utilitários para preparar recursos de imagem.

#### center_crop[[transformers.ImageFeatureExtractionMixin.center_crop]]

```python
center_crop(image, size)
```

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

**Parâmetros:**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor` de forma (n_channels, height, width) ou (height, width, n_channels)) : A imagem a ser redimensionada.

size (`int` ou `tuple[int, int]`) : O tamanho para o qual recortar a imagem.

**Retorna:** `new_image`

Uma imagem centralizada recortada `PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor` de forma: (n_channels, height, width).

Realiza o recorte da `image` para o tamanho especificado usando um recorte central. Observe que, se a imagem for pequena demais para ser recortada para o tamanho fornecido, ela será preenchida (de modo que o resultado retornado tenha o tamanho solicitado).

#### convert_rgb[[transformers.ImageFeatureExtractionMixin.convert_rgb]]

```python
convert_rgb(image)
```

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

**Parâmetros:**

image (`PIL.Image.Image`) : A imagem a ser convertida.

Converte `PIL.Image.Image` para o formato RGB.

#### expand_dims[[transformers.ImageFeatureExtractionMixin.expand_dims]]

```python
expand_dims(image)
```

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

**Parâmetros:**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : A imagem a ser expandida.

Expande a `image` bidimensional para 3 dimensões.

#### flip_channel_order[[transformers.ImageFeatureExtractionMixin.flip_channel_order]]

```python
flip_channel_order(image)
```

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

**Parâmetros:**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : A imagem cujos canais de cor devem ser invertidos. Se for `np.ndarray` ou `torch.Tensor`, a dimensão dos canais deve vir primeiro.

Inverte a ordem dos canais de `image` de RGB para BGR, ou vice-versa. Observe que isso acionará a conversão de `image` para um array NumPy, caso seja uma Imagem PIL.

#### normalizar[[transformers.ImageFeatureExtractionMixin.normalize]]

```python
normalize(image, mean, std, rescale = False)
```

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

**Parâmetros:**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : A imagem a ser normalizada.

mean (`list[float]` ou `np.ndarray` ou `torch.Tensor`) : A média (por canal) a ser usada para normalização.

std (`list[float]` ou `np.ndarray` ou `torch.Tensor`) : O desvio padrão (por canal) a ser usado para normalização.

rescale (`bool`, *opcional*, padrão `False`) : Indica se a imagem deve ser reescalada para ficar entre 0 e 1. Se uma imagem PIL for fornecida, o reescalamento ocorrerá automaticamente.

Normalizes `image` with `mean` and `std`. Note that this will trigger a conversion of `image` to a NumPy array if it's a PIL Image.

#### rescale[[transformers.ImageFeatureExtractionMixin.rescale]]

```python
rescale(image: ndarray, scale: float | int)
```

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

Redimensiona uma imagem numpy pelo fator de escala

#### resize[[transformers.ImageFeatureExtractionMixin.resize]]

```python
resize(image, size, resample = None, default_to_square = True, max_size = None)
```

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

**Parâmetros:**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : A imagem a ser redimensionada.

size (`int` ou `tuple[int, int]`) : O tamanho a ser usado para redimensionar a imagem. Se `size` for uma sequência como (h, w), o tamanho de saída será ajustado a esse valor. Se `size` for um int e `default_to_square` for `True`, a imagem será redimensionada para (size, size). Se `size` for um int e `default_to_square` for `False`, a aresta menor da imagem será ajustada a esse número. Ou seja, se a altura > largura, a imagem será reescalada para (size * height / width, size).

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

default_to_square (`bool`, *opcional*, padrão `True`) : Como converter `size` quando ele é um único int. Se definido como `True`, o `size` será convertido para um quadrado (`size`,`size`). Se definido como `False`, replicará o [`torchvision.transforms.Resize`](https://pytorch.org/vision/stable/transforms.html#torchvision.transforms.Resize) com suporte para redimensionar apenas a menor aresta e fornecer um `max_size` opcional.

max_size (`int`, *opcional*, padrão `None`) : O valor máximo permitido para a aresta mais longa da imagem redimensionada: se a aresta mais longa da imagem for maior que `max_size` após o redimensionamento de acordo com `size`, a imagem será redimensionada novamente para que a aresta mais longa seja igual a `max_size`. Como resultado, `size` pode ser anulado, ou seja, a aresta menor pode ficar menor que `size`. Usado apenas se `default_to_square` for `False`.

**Retorna:** `image`

Uma `PIL.Image.Image` redimensionada.

Redimensiona `image`. Força a conversão da entrada para PIL.Image.

#### girar[[transformers.ImageFeatureExtractionMixin.rotate]]

```python
rotate(image, angle, resample = None, expand = 0, center = None, translate = None, fillcolor = None)
```

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

**Parâmetros:**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : A imagem a ser rotacionada. Se for `np.ndarray` ou `torch.Tensor`, será convertida para `PIL.Image.Image` antes da rotação.

**Retorna:** `image`

Uma imagem `PIL.Image.Image` rotacionada.

Retorna uma cópia rotacionada de `image`. Este método retorna uma cópia de `image`, rotacionada o número de graus especificado no sentido anti-horário em torno do seu centro.

#### to_numpy_array[[transformers.ImageFeatureExtractionMixin.to_numpy_array]]

```python
to_numpy_array(image, rescale = None, channel_first = True)
```

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

**Parâmetros:**

image (`PIL.Image.Image` ou `np.ndarray` ou `torch.Tensor`) : A imagem a ser convertida em um array NumPy.

rescale (`bool`, *opcional*) : Se deve ou não aplicar o fator de escala (para tornar os valores de pixels em floats entre 0. e 1.). O padrão será `True` se a imagem for uma imagem PIL ou um array/tensor de inteiros, `False` caso contrário.

channel_first (`bool`, *opcional*, padrão `True`) : Indica se as dimensões da imagem devem ser permutadas para colocar a dimensão de canal primeiro.

Converte `image` em um array numpy. Opcionalmente, reescala e coloca a dimensão de canal como a primeira dimensão.

#### to_pil_image[[transformers.ImageFeatureExtractionMixin.to_pil_image]]

```python
to_pil_image(image, rescale = None)
```

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

**Parâmetros:**

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

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, `False` caso contrário.

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