# Extracción de características

Un extractor de características se encarga de preparar las características de entrada para los modelos de audio. Esto incluye la extracción de características de secuencias, por ejemplo, el preprocesamiento de archivos de audio para generar características de Espectrograma Log-Mel, y la conversión a tensores de NumPy y PyTorch.

## FeatureExtractionMixin[[transformers.FeatureExtractionMixin]]

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

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

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

Esta es una mezcla de extracción de características que se utiliza para proporcionar funcionalidad de guardado/carga para extractores de características secuenciales y de audio.

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

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

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike`) : Puede ser cualquiera de las siguientes opciones: - una cadena, el *model id* de un feature_extractor preentrenado alojado en un repositorio de modelos en huggingface.co. - una ruta a un *directorio* que contiene un archivo de feature extractor guardado mediante el método [save_pretrained()](/docs/transformers/main/es/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained), por ejemplo, `./my_model_directory/`. - una ruta a un *archivo* JSON de feature extractor guardado, por ejemplo, `./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 extractor de características 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 extractor de características 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 solo el objeto final de extracción de características. Si es `True`, esta función devuelve una `Tuple(feature_extractor, unused_kwargs)` donde *unused_kwargs* es un diccionario que consiste en pares clave/valor cuyas claves no son atributos del extractor de características: es decir, la parte de `kwargs` que no se ha utilizado para actualizar `feature_extractor` y que se ignora de lo contrario.

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

**Devuelve:**

Un extractor de características de tipo [FeatureExtractionMixin](/docs/transformers/main/es/main_classes/feature_extractor#transformers.FeatureExtractionMixin).

Instancie un tipo de [FeatureExtractionMixin](/docs/transformers/main/es/main_classes/feature_extractor#transformers.FeatureExtractionMixin) a partir de un extractor de características, *por ejemplo*, una clase derivada de [SequenceFeatureExtractor](/docs/transformers/main/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor).

Ejemplos:

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

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

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Directorio donde se guardará el archivo JSON del feature extractor (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 feature_extractor en el directorio `save_directory` para que pueda recargarse mediante el método de clase [from_pretrained()](/docs/transformers/main/es/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)
```

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

**Parámetros:**

feature_size (`int`) : La dimensión de las características de las características extraídas.

sampling_rate (`int`) : La tasa de muestreo a la que se deben digitalizar los archivos de audio, expresada en hercios (Hz).

padding_value (`float`) : El valor que se utiliza para rellenar los valores / vectores de relleno.

Esta es una clase general de extracción de características para el reconocimiento de voz.

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

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

**Parámetros:**

processed_features ([BatchFeature](/docs/transformers/main/es/main_classes/feature_extractor#transformers.BatchFeature), lista de [BatchFeature](/docs/transformers/main/es/main_classes/feature_extractor#transformers.BatchFeature), `dict[str, list[float]]`, `dict[str, list[list[float]]` o `list[dict[str, list[float]]]`) : Entradas procesadas. Puede representar una sola entrada ([BatchFeature](/docs/transformers/main/es/main_classes/feature_extractor#transformers.BatchFeature) o `dict[str, list[float]]`) o un lote de valores / vectores de entrada (lista de [BatchFeature](/docs/transformers/main/es/main_classes/feature_extractor#transformers.BatchFeature), *dict[str, list[list[float]]]* o *list[dict[str, list[float]]]*), por lo que puede utilizar este método tanto durante el preprocesamiento como en una función de collate de un Dataloader de PyTorch. En lugar de `list[float]`, puede tener tensores (arrays de numpy o tensores de PyTorch); consulte la nota anterior sobre el tipo de retorno.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `True`) : Selecciona una estrategia para rellenar las secuencias devueltas (según el lado de relleno y el índice de relleno del modelo) entre:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede devolver un lote con secuencias de longitudes diferentes).

max_length (`int`, *opcional*) : Longitud máxima de la lista devuelta y, opcionalmente, longitud de relleno (ver arriba).

truncation (`bool`) : Activa la truncación para recortar las secuencias de entrada más largas que `max_length` hasta `max_length`.

pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Esto resulta especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta), o en TPUs, que se benefician de que las longitudes de secuencia sean un múltiplo de 128.

return_attention_mask (`bool`, *opcional*) : Indica si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del feature_extractor específico.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy.

Rellena los valores de entrada / vectores de entrada o un lote de valores de entrada / vectores de entrada hasta una longitud predefinida o hasta la longitud de secuencia máxima del lote.

Los valores de relleno (izquierda/derecha) se definen a nivel del extractor de características (con `self.padding_side`, `self.padding_value`)

Si las `processed_features` pasadas son un diccionario de arrays de numpy o tensores de PyTorch, el resultado usará el mismo tipo, a menos que proporciones un tipo de tensor diferente con `return_tensors`. En el caso de los tensores de PyTorch, sin embargo, se perderá el dispositivo específico de tus 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)
```

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

**Parámetros:**

data (`dict`, *opcional*) : Diccionario de listas/arrays/tensores devueltos por los métodos __call__/pad ('input_values', 'attention_mask', etc.).

tensor_type (`Union[None, str, TensorType]`, *opcional*) : Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.

skip_tensor_conversion (`list[str]` o `set[str]`, *opcional*) : Lista o conjunto de claves que no deben convertirse en tensores, incluso cuando se especifica `tensor_type`.

Contiene la salida de los métodos [pad()](/docs/transformers/main/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) y `__call__` específicos del extractor de características.

Esta clase se deriva de un diccionario de Python y puede usarse como un diccionario.

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

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

**Parámetros:**

tensor_type (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : El tipo de tensores a utilizar. Si es `str`, debe ser uno de los valores de la enumeración [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType). Si es `None`, no se realiza ninguna modificación.

skip_tensor_conversion (`list[str]` o `set[str]`, *opcional*) : Lista o conjunto de claves que no deben convertirse en tensores, incluso cuando se especifica `tensor_type`.

Convierte el contenido interno en tensores.

Nota: Los valores que no tienen una estructura similar a un array (p. ej., cadenas, diccionarios, listas de cadenas) se omiten automáticamente y no se convierten en tensores. Se intenta convertir los arrays irregulares (listas de arrays con longitudes diferentes), aunque pueden generar errores durante la conversión.

#### a[[transformers.BatchFeature.to]]

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

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

**Parámetros:**

args (`Tuple`) : Se pasará a la función `to(...)` de los tensores.

kwargs (`Dict`, *opcional*) : Se pasará a la función `to(...)` de los tensores. Para habilitar la transferencia de datos asíncrona, establezca la bandera `non_blocking` en `kwargs` (el valor predeterminado es `False`).

**Devuelve:** [BatchFeature](/docs/transformers/main/es/main_classes/feature_extractor#transformers.BatchFeature)

La misma instancia después de la modificación.

Envíe todos los valores al dispositivo llamando a `v.to(*args, **kwargs)` (solo PyTorch). Esto debería admitir el cambio a distintos `dtypes` y enviar el `BatchFeature` a un `device` diferente.

## ImageFeatureExtractionMixin[[transformers.ImageFeatureExtractionMixin]]

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

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

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

Mixin que contiene utilidades para preparar características de imagen.

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

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

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

**Parámetros:**

image (`PIL.Image.Image` o `np.ndarray` o `torch.Tensor` de forma (n_channels, height, width) o (height, width, n_channels)) : La imagen que se debe redimensionar.

size (`int` o `tuple[int, int]`) : El tamaño al que recortar la imagen.

**Devuelve:** `new_image`

Un `PIL.Image.Image` o `np.ndarray` o `torch.Tensor` recortado al centro con forma: (n_channels, height, width).

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

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

```python
convert_rgb(image)
```

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

**Parámetros:**

image (`PIL.Image.Image`) : La imagen a convertir.

Convierte `PIL.Image.Image` al formato RGB.

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

```python
expand_dims(image)
```

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

**Parámetros:**

image (`PIL.Image.Image` o `np.ndarray` o `torch.Tensor`) : La imagen que se va a expandir.

Expande la `image` de 2 dimensiones a 3 dimensiones.

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

```python
flip_channel_order(image)
```

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

**Parámetros:**

image (`PIL.Image.Image` o `np.ndarray` o `torch.Tensor`) : La imagen cuyos canales de color se deben invertir. Si es `np.ndarray` o `torch.Tensor`, la dimensión de canal debe ser la primera.

Flips the channel order of `image` from RGB to BGR, or vice versa. Note that this will trigger a conversion of `image` to a NumPy array if it's a PIL Image.

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

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

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

**Parámetros:**

image (`PIL.Image.Image` o `np.ndarray` o `torch.Tensor`) : La imagen que se va a normalizar.

mean (`list[float]` o `np.ndarray` o `torch.Tensor`) : La media (por canal) que se utilizará para la normalización.

std (`list[float]` o `np.ndarray` o `torch.Tensor`) : La desviación estándar (por canal) que se utilizará para la normalización.

rescale (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe reescalar la imagen para que esté entre 0 y 1. Si se proporciona una imagen PIL, el reescalado se realizará automáticamente.

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

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

Escalar una imagen de numpy por una cantidad de escala

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

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

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

**Parámetros:**

image (`PIL.Image.Image` o `np.ndarray` o `torch.Tensor`) : La imagen que se debe redimensionar.

size (`int` o `tuple[int, int]`) : El tamaño a utilizar para redimensionar la imagen. Si `size` es una secuencia como (h, w), el tamaño de salida se ajustará a este. Si `size` es un int y `default_to_square` es `True`, la imagen se redimensionará a (size, size). Si `size` es un int y `default_to_square` es `False`, el lado más corto de la imagen se ajustará a este número. Es decir, si la altura > el ancho, la imagen se reescalará a (size * height / width, size).

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

default_to_square (`bool`, *opcional*, valor predeterminado `True`) : Cómo convertir `size` cuando es un solo int. Si se establece en `True`, `size` se convertirá en un cuadrado (`size`,`size`). Si se establece en `False`, replicará [`torchvision.transforms.Resize`](https://pytorch.org/vision/stable/transforms.html#torchvision.transforms.Resize) con soporte para redimensionar solo el borde más pequeño y proporcionando un `max_size` opcional.

max_size (`int`, *opcional*, valor predeterminado `None`) : El valor máximo permitido para el lado más largo de la imagen redimensionada: si el lado más largo de la imagen es mayor que `max_size` después de ser redimensionada según `size`, la imagen se redimensiona nuevamente para que el lado más largo sea igual a `max_size`. Como resultado, `size` podría verse anulado, es decir, el lado más corto podría ser más corto que `size`. Solo se utiliza si `default_to_square` es `False`.

**Devuelve:** `image`

Una `PIL.Image.Image` redimensionada.

Redimensiona `image`. Fuerza la conversión de la entrada a PIL.Image.

#### rotar[[transformers.ImageFeatureExtractionMixin.rotate]]

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

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

**Parámetros:**

image (`PIL.Image.Image` o `np.ndarray` o `torch.Tensor`) : La imagen que se va a rotar. Si es `np.ndarray` o `torch.Tensor`, se convertirá a `PIL.Image.Image` antes de rotarla.

**Devuelve:** `image`

Una `PIL.Image.Image` rotada.

Devuelve una copia rotada de `image`. Este método devuelve una copia de `image`, rotada el número de grados indicado en sentido antihorario alrededor de su centro.

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

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

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

**Parámetros:**

image (`PIL.Image.Image` o `np.ndarray` o `torch.Tensor`) : La imagen que se convertirá en un array de NumPy.

rescale (`bool`, *opcional*) : Indica si se debe aplicar el factor de escalado (para convertir los valores de píxeles en flotantes entre 0. y 1.). El valor predeterminado será `True` si la imagen es una imagen PIL o un array/tensor de enteros, y `False` en caso contrario.

channel_first (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben permutar las dimensiones de la imagen para colocar la dimensión de canal al principio.

Convierte `image` en un array de numpy. Opcionalmente, lo reescala y coloca la dimensión de canal como la primera dimensión.

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

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

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

**Parámetros:**

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

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 `False` en caso contrario.

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