Crea una arquitectura personalizada

Una AutoClass infiere, automáticamente, la arquitectura del modelo y descarga la configuración y los pesos del modelo preentrenado. Normalmente, recomendamos usar una AutoClass para producir un código agnóstico a puntos de guardado o checkpoints. Sin embargo, los usuarios que quieran más control sobre los parámetros específicos de los modelos pueden crear su propio modelo 🤗 Transformers personalizado a partir de varias clases base. Esto puede ser particularmente útil para alguien que esté interesado en estudiar, entrenar o experimentar con modelos 🤗 Transformers. En esta guía vamos a profundizar en la creación de modelos personalizados sin usar AutoClass. Aprenderemos a:

• Cargar y personalizar una configuración para un modelo.
• Crear una arquitectura para un modelo.
• Crear tokenizadores rápidos y lentos para textos.
• Crear un extractor de propiedades para tareas de audio o imágenes.
• Crear un procesador para tareas multimodales.

Configuración

Una configuración es un conjunto de atributos específicos de un modelo. Cada configuración de modelo tiene atributos diferentes. Por ejemplo, todos los modelos de PLN tienen los atributos hidden_size, num_attention_heads, num_hidden_layers y vocab_size en común. Estos atributos especifican el número de cabezas de atención o de capas ocultas con las que se construyen los modelos.

Puedes echarle un vistazo a DistilBERT y sus atributos accediendo a DistilBertConfig:

>>> from transformers import DistilBertConfig

>>> config = DistilBertConfig()
>>> print(config)
DistilBertConfig {
  "activation": "gelu",
  "attention_dropout": 0.1,
  "dim": 768,
  "dropout": 0.1,
  "hidden_dim": 3072,
  "initializer_range": 0.02,
  "max_position_embeddings": 512,
  "model_type": "distilbert",
  "n_heads": 12,
  "n_layers": 6,
  "pad_token_id": 0,
  "qa_dropout": 0.1,
  "seq_classif_dropout": 0.2,
  "sinusoidal_pos_embds": false,
  "transformers_version": "4.16.2",
  "vocab_size": 30522
}

DistilBertConfig muestra todos los atributos por defecto que se han usado para construir un modelo DistilBertModel base. Todos ellos son personalizables, lo que deja espacio para poder experimentar. Por ejemplo, puedes personalizar un modelo predeterminado para:

• Probar una función de activación diferente, usando el parámetro activation.
• Usar un valor de abandono (también conocido como dropout) más alto para las probabilidades de las capas de atención, usando el parámetro attention_dropout.

>>> my_config = DistilBertConfig(activation="relu", attention_dropout=0.4)
>>> print(my_config)
DistilBertConfig {
  "activation": "relu",
  "attention_dropout": 0.4,
  "dim": 768,
  "dropout": 0.1,
  "hidden_dim": 3072,
  "initializer_range": 0.02,
  "max_position_embeddings": 512,
  "model_type": "distilbert",
  "n_heads": 12,
  "n_layers": 6,
  "pad_token_id": 0,
  "qa_dropout": 0.1,
  "seq_classif_dropout": 0.2,
  "sinusoidal_pos_embds": false,
  "transformers_version": "4.16.2",
  "vocab_size": 30522
}

Los atributos de los modelos preentrenados pueden ser modificados con la función from_pretrained():

>>> my_config = DistilBertConfig.from_pretrained("distilbert/distilbert-base-uncased", activation="relu", attention_dropout=0.4)

Cuando estés satisfecho con la configuración de tu modelo, puedes guardarlo con la función save_pretrained(). Tu configuración se guardará en un archivo JSON dentro del directorio que le especifiques como parámetro.

>>> my_config.save_pretrained(save_directory="./your_model_save_path")

Para volver a usar el archivo de configuración, puedes cargarlo usando from_pretrained():

>>> my_config = DistilBertConfig.from_pretrained("./your_model_save_path/my_config.json")

Modelo

El siguiente paso será crear un modelo. El modelo, al que a veces también nos referimos como arquitectura, es el encargado de definir cada capa y qué operaciones se realizan. Los atributos como num_hidden_layers de la configuración se usan para definir la arquitectura. Todos los modelos comparten una clase base, PreTrainedModel, y algunos métodos comunes que se pueden usar para redimensionar los embeddings o para recortar cabezas de auto-atención (también llamadas self-attention heads). Además, todos los modelos son subclases de torch.nn.Module, tf.keras.Model o flax.linen.Module, lo que significa que son compatibles con su respectivo framework.

>>> from transformers import DistilBertModel

>>> my_config = DistilBertConfig.from_pretrained("./your_model_save_path/my_config.json")
>>> model = DistilBertModel(my_config)

>>> model = DistilBertModel.from_pretrained("distilbert/distilbert-base-uncased")

>>> model = DistilBertModel.from_pretrained("distilbert/distilbert-base-uncased", config=my_config)

>>> from transformers import TFDistilBertModel

>>> my_config = DistilBertConfig.from_pretrained("./your_model_save_path/my_config.json")
>>> tf_model = TFDistilBertModel(my_config)

>>> tf_model = TFDistilBertModel.from_pretrained("distilbert/distilbert-base-uncased")

>>> tf_model = TFDistilBertModel.from_pretrained("distilbert/distilbert-base-uncased", config=my_config)

Cabezas de modelo

En este punto del tutorial, tenemos un modelo DistilBERT base que devuelve los hidden states o estados ocultos. Los hidden states se pasan como parámetros de entrada a la cabeza del modelo para producir la salida. 🤗 Transformers ofrece una cabeza de modelo diferente para cada tarea, siempre y cuando el modelo sea compatible para la tarea (por ejemplo, no puedes usar DistilBERT para una tarea secuencia a secuencia como la traducción).

>>> from transformers import DistilBertForSequenceClassification

>>> model = DistilBertForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")

>>> from transformers import DistilBertForQuestionAnswering

>>> model = DistilBertForQuestionAnswering.from_pretrained("distilbert/distilbert-base-uncased")

>>> from transformers import TFDistilBertForSequenceClassification

>>> tf_model = TFDistilBertForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")

>>> from transformers import TFDistilBertForQuestionAnswering

>>> tf_model = TFDistilBertForQuestionAnswering.from_pretrained("distilbert/distilbert-base-uncased")

Tokenizer

La ultima clase base que debes conocer antes de usar un modelo con datos textuales es la clase tokenizer, que convierte el texto bruto en tensores. Hay dos tipos de tokenizers que puedes usar con 🤗 Transformers:

• PreTrainedTokenizer: una implementación de un tokenizer hecha en Python.
• PreTrainedTokenizerFast: un tokenizer de nuestra librería 🤗 Tokenizer, basada en Rust. Este tipo de tokenizer es bastante más rápido, especialmente durante la tokenización por lotes, gracias a estar implementado en Rust. Esta rápida tokenización también ofrece métodos adicionales como el offset mapping, que relaciona los tokens con sus palabras o caracteres originales.

Ambos tokenizers son compatibles con los métodos comunes, como los de encodificación y decodificación, los métodos para añadir tokens y aquellos que manejan tokens especiales.

Si has entrenado tu propio tokenizer, puedes crear uno desde tu archivo de “vocabulario”:

>>> from transformers import DistilBertTokenizer

>>> my_tokenizer = DistilBertTokenizer(vocab_file="my_vocab_file.txt", do_lower_case=False, padding_side="left")

Es importante recordar que los vocabularios que provienen de un tokenizer personalizado serán diferentes a los vocabularios generados por el tokenizer de un modelo preentrenado. Debes usar el vocabulario de un tokenizer preentrenado si vas a usar un modelo preentrenado, de lo contrario las entradas no tendrán sentido. Crea un tokenizer con el vocabulario de un modelo preentrenado usando la clase DistilBertTokenizer:

>>> from transformers import DistilBertTokenizer

>>> slow_tokenizer = DistilBertTokenizer.from_pretrained("distilbert/distilbert-base-uncased")

Crea un tokenizer rápido con la clase DistilBertTokenizerFast:

>>> from transformers import DistilBertTokenizerFast

>>> fast_tokenizer = DistilBertTokenizerFast.from_pretrained("distilbert/distilbert-base-uncased")

Extractor de Características

Un extractor de características procesa entradas de audio e imagen. Hereda de la clase base FeatureExtractionMixin y también puede heredar de la clase ImageFeatureExtractionMixin para el procesamiento de características de las imágenes o de la clase SequenceFeatureExtractor para el procesamiento de entradas de audio.

Dependiendo de si trabajas en una tarea de audio o de video, puedes crear un extractor de características asociado al modelo que estés usando. Por ejemplo, podrías crear un ViTFeatureExtractor por defecto si estás usando ViT para clasificación de imágenes:

>>> from transformers import ViTFeatureExtractor

>>> vit_extractor = ViTFeatureExtractor()
>>> print(vit_extractor)
ViTFeatureExtractor {
  "do_normalize": true,
  "do_resize": true,
  "feature_extractor_type": "ViTFeatureExtractor",
  "image_mean": [
    0.5,
    0.5,
    0.5
  ],
  "image_std": [
    0.5,
    0.5,
    0.5
  ],
  "resample": 2,
  "size": 224
}

Puedes modificar cualquier parámetro de ViTFeatureExtractor para crear tu extractor de características personalizado:

>>> from transformers import ViTFeatureExtractor

>>> my_vit_extractor = ViTFeatureExtractor(resample="PIL.Image.BOX", do_normalize=False, image_mean=[0.3, 0.3, 0.3])
>>> print(my_vit_extractor)
ViTFeatureExtractor {
  "do_normalize": false,
  "do_resize": true,
  "feature_extractor_type": "ViTFeatureExtractor",
  "image_mean": [
    0.3,
    0.3,
    0.3
  ],
  "image_std": [
    0.5,
    0.5,
    0.5
  ],
  "resample": "PIL.Image.BOX",
  "size": 224
}

Para las entradas de audio, puedes crear un Wav2Vec2FeatureExtractor y personalizar los parámetros de una forma similar:

>>> from transformers import Wav2Vec2FeatureExtractor

>>> w2v2_extractor = Wav2Vec2FeatureExtractor()
>>> print(w2v2_extractor)
Wav2Vec2FeatureExtractor {
  "do_normalize": true,
  "feature_extractor_type": "Wav2Vec2FeatureExtractor",
  "feature_size": 1,
  "padding_side": "right",
  "padding_value": 0.0,
  "return_attention_mask": false,
  "sampling_rate": 16000
}

Procesador

Para modelos que son compatibles con tareas multimodales, 🤗 Transformers ofrece una clase procesador que agrupa un extractor de características y un tokenizer en el mismo objeto. Por ejemplo, probemos a usar el procesador Wav2Vec2Processor para una tarea de reconocimiento de voz (ASR). Un ASR transcribe el audio a texto, por lo que necesitaremos un extractor de características y un tokenizer.

Crea un extractor de características para manejar la entrada de audio:

>>> from transformers import Wav2Vec2FeatureExtractor

>>> feature_extractor = Wav2Vec2FeatureExtractor(padding_value=1.0, do_normalize=True)

Crea un tokenizer para manejar la entrada de texto:

>>> from transformers import Wav2Vec2CTCTokenizer

>>> tokenizer = Wav2Vec2CTCTokenizer(vocab_file="my_vocab_file.txt")

Puedes combinar el extractor de características y el tokenizer en el Wav2Vec2Processor:

>>> from transformers import Wav2Vec2Processor

>>> processor = Wav2Vec2Processor(feature_extractor=feature_extractor, tokenizer=tokenizer)

Con dos clases base (la configuración y el modelo) y una clase de preprocesamiento adicional (tokenizer, extractor de características o procesador), puedes crear cualquiera de los modelos compatibles con 🤗 Transformers. Cada una de estas clases son configurables, permitiéndote usar sus atributos específicos. Puedes crear un modelo para entrenarlo de una forma fácil, o modificar un modelo preentrenado disponible para especializarlo.