diff --git a/docs/source/es/_toctree.yml b/docs/source/es/_toctree.yml index d016c8ca88ec..81a7a500b783 100644 --- a/docs/source/es/_toctree.yml +++ b/docs/source/es/_toctree.yml @@ -64,8 +64,6 @@ title: Entrenador - local: sagemaker title: Ejecutar el entrenamiento en Amazon SageMaker - - local: serialization - title: Exportar a ONNX - local: torchscript title: Exportar a TorchScript - local: community diff --git a/docs/source/es/serialization.md b/docs/source/es/serialization.md deleted file mode 100644 index 9c29ed6f0406..000000000000 --- a/docs/source/es/serialization.md +++ /dev/null @@ -1,651 +0,0 @@ - - -# Exportar modelos 🤗 Transformers - -Si necesitas implementar modelos 🤗 Transformers en entornos de producción, te -recomendamos exportarlos a un formato serializado que se pueda cargar y ejecutar -en tiempos de ejecución y hardware especializados. En esta guía, te mostraremos cómo -exportar modelos 🤗 Transformers en dos formatos ampliamente utilizados: ONNX y TorchScript. - -Una vez exportado, un modelo puede optimizarse para la inferencia a través de técnicas -como la cuantización y _pruning_. Si estás interesado en optimizar tus modelos para -que funcionen con la máxima eficiencia, consulta la -[biblioteca de 🤗 Optimum](https://github.com/huggingface/optimum). - -## ONNX - -El proyecto [ONNX (Open Neural Network eXchange)](http://onnx.ai) es un -estándar abierto que define un conjunto común de operadores y un formato -de archivo común para representar modelos de aprendizaje profundo en una -amplia variedad de _frameworks_, incluidos PyTorch y TensorFlow. Cuando un modelo -se exporta al formato ONNX, estos operadores se usan para construir un -grafo computacional (a menudo llamado _representación intermedia_) que -representa el flujo de datos a través de la red neuronal. - -Al exponer un grafo con operadores y tipos de datos estandarizados, ONNX facilita -el cambio entre frameworks. Por ejemplo, un modelo entrenado en PyTorch se puede -exportar a formato ONNX y luego importar en TensorFlow (y viceversa). - -🤗 Transformers proporciona un paquete llamado `transformers.onnx`, el cual permite convertir -los checkpoints de un modelo en un grafo ONNX aprovechando los objetos de configuración. -Estos objetos de configuración están hechos a la medida de diferentes arquitecturas de modelos -y están diseñados para ser fácilmente extensibles a otras arquitecturas. - -Las configuraciones a la medida incluyen las siguientes arquitecturas: - - - -- ALBERT -- BART -- BEiT -- BERT -- BigBird -- BigBird-Pegasus -- Blenderbot -- BlenderbotSmall -- BLOOM -- CamemBERT -- CLIP -- CodeGen -- ConvBERT -- ConvNeXT -- ConvNeXTV2 -- Data2VecText -- Data2VecVision -- DeBERTa -- DeBERTa-v2 -- DeiT -- DETR -- DistilBERT -- ELECTRA -- FlauBERT -- GPT Neo -- GPT-J -- I-BERT -- LayoutLM -- LayoutLMv3 -- LeViT -- LongT5 -- M2M100 -- Marian -- mBART -- MobileBERT -- MobileViT -- MT5 -- OpenAI GPT-2 -- Perceiver -- PLBart -- ResNet -- RoBERTa -- RoFormer -- SqueezeBERT -- T5 -- ViT -- XLM -- XLM-RoBERTa -- XLM-RoBERTa-XL -- YOLOS - -En las próximas dos secciones, te mostraremos cómo: - -* Exportar un modelo compatible utilizando el paquete `transformers.onnx`. -* Exportar un modelo personalizado para una arquitectura no compatible. - -### Exportar un model a ONNX - -Para exportar un modelo 🤗 Transformers a ONNX, tienes que instalar primero algunas -dependencias extra: - -```bash -pip install transformers[onnx] -``` - -El paquete `transformers.onnx` puede ser usado luego como un módulo de Python: - -```bash -python -m transformers.onnx --help - -usage: Hugging Face Transformers ONNX exporter [-h] -m MODEL [--feature {causal-lm, ...}] [--opset OPSET] [--atol ATOL] output - -positional arguments: - output Path indicating where to store generated ONNX model. - -optional arguments: - -h, --help show this help message and exit - -m MODEL, --model MODEL - Model ID on huggingface.co or path on disk to load model from. - --feature {causal-lm, ...} - The type of features to export the model with. - --opset OPSET ONNX opset version to export the model with. - --atol ATOL Absolute difference tolerence when validating the model. -``` - -Exportar un checkpoint usando una configuración a la medida se puede hacer de la siguiente manera: - -```bash -python -m transformers.onnx --model=distilbert/distilbert-base-uncased onnx/ -``` - -que debería mostrar los siguientes registros: - -```bash -Validating ONNX model... - -[✓] ONNX model output names match reference model ({'last_hidden_state'}) - - Validating ONNX Model output "last_hidden_state": - -[✓] (2, 8, 768) matches (2, 8, 768) - -[✓] all values close (atol: 1e-05) -All good, model saved at: onnx/model.onnx -``` - -Esto exporta un grafo ONNX del checkpoint definido por el argumento `--model`. -En este ejemplo, es un modelo `distilbert/distilbert-base-uncased`, pero puede ser cualquier -checkpoint en Hugging Face Hub o que esté almacenado localmente. - -El archivo `model.onnx` resultante se puede ejecutar en uno de los -[muchos aceleradores](https://onnx.ai/supported-tools.html#deployModel) -que admiten el estándar ONNX. Por ejemplo, podemos cargar y ejecutar el -modelo con [ONNX Runtime](https://onnxruntime.ai/) de la siguiente manera: - -```python ->>> from transformers import AutoTokenizer ->>> from onnxruntime import InferenceSession - ->>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased") ->>> session = InferenceSession("onnx/model.onnx") ->>> # ONNX Runtime expects NumPy arrays as input ->>> inputs = tokenizer("Using DistilBERT with ONNX Runtime!", return_tensors="np") ->>> outputs = session.run(output_names=["last_hidden_state"], input_feed=dict(inputs)) -``` - -Los nombres necesarios de salida (es decir, `["last_hidden_state"]`) se pueden obtener -echando un vistazo a la configuración ONNX de cada modelo. Por ejemplo, para DistilBERT tenemos: - -```python ->>> from transformers.models.distilbert import DistilBertConfig, DistilBertOnnxConfig - ->>> config = DistilBertConfig() ->>> onnx_config = DistilBertOnnxConfig(config) ->>> print(list(onnx_config.outputs.keys())) -["last_hidden_state"]s -``` - -El proceso es idéntico para los checkpoints de TensorFlow en Hub. -Por ejemplo, podemos exportar un checkpoint puro de TensorFlow desde -[Keras](https://huggingface.co/keras-io) de la siguiente manera: - -```bash -python -m transformers.onnx --model=keras-io/transformers-qa onnx/ -``` - -Para exportar un modelo que está almacenado localmente, deberás tener los pesos -y tokenizadores del modelo almacenados en un directorio. Por ejemplo, podemos cargar -y guardar un checkpoint de la siguiente manera: - -```python ->>> from transformers import AutoTokenizer, AutoModelForSequenceClassification - ->>> # Load tokenizer and PyTorch weights form the Hub ->>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased") ->>> pt_model = AutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased") ->>> # Save to disk ->>> tokenizer.save_pretrained("local-pt-checkpoint") ->>> pt_model.save_pretrained("local-pt-checkpoint") -``` - -Una vez que se guarda el checkpoint, podemos exportarlo a ONNX usando el argumento `--model` -del paquete `transformers.onnx` al directorio deseado: - -```bash -python -m transformers.onnx --model=local-pt-checkpoint onnx/ -``` - -### Seleccionar características para diferentes topologías de un modelo - -Cada configuración a la medida viene con un conjunto de _características_ que te permiten exportar -modelos para diferentes tipos de topologías o tareas. Como se muestra en la siguiente tabla, cada -función está asociada con una auto-clase de automóvil diferente: - -| Feature | Auto Class | -| ------------------------------------ | ------------------------------------ | -| `causal-lm`, `causal-lm-with-past` | `AutoModelForCausalLM` | -| `default`, `default-with-past` | `AutoModel` | -| `masked-lm` | `AutoModelForMaskedLM` | -| `question-answering` | `AutoModelForQuestionAnswering` | -| `seq2seq-lm`, `seq2seq-lm-with-past` | `AutoModelForSeq2SeqLM` | -| `sequence-classification` | `AutoModelForSequenceClassification` | -| `token-classification` | `AutoModelForTokenClassification` | - -Para cada configuración, puedes encontrar la lista de funciones admitidas a través de `FeaturesManager`. -Por ejemplo, para DistilBERT tenemos: - -```python ->>> from transformers.onnx.features import FeaturesManager - ->>> distilbert_features = list(FeaturesManager.get_supported_features_for_model_type("distilbert").keys()) ->>> print(distilbert_features) -["default", "masked-lm", "causal-lm", "sequence-classification", "token-classification", "question-answering"] -``` - -Le puedes pasar una de estas características al argumento `--feature` en el paquete `transformers.onnx`. -Por ejemplo, para exportar un modelo de clasificación de texto, podemos elegir un modelo ya ajustado del Hub y ejecutar: - -```bash -python -m transformers.onnx --model=distilbert/distilbert-base-uncased-finetuned-sst-2-english \ - --feature=sequence-classification onnx/ -``` - -que mostrará los siguientes registros: - -```bash -Validating ONNX model... - -[✓] ONNX model output names match reference model ({'logits'}) - - Validating ONNX Model output "logits": - -[✓] (2, 2) matches (2, 2) - -[✓] all values close (atol: 1e-05) -All good, model saved at: onnx/model.onnx -``` - -Ten en cuenta que, en este caso, los nombres de salida del modelo ajustado son `logits` en lugar de `last_hidden_state` -que vimos anteriormente con el checkpoint `distilbert/distilbert-base-uncased`. Esto es de esperarse ya que el modelo ajustado -tiene un cabezal de clasificación secuencial. - - - -Las características que tienen un sufijo 'with-past' (por ejemplo, 'causal-lm-with-past') corresponden a topologías -de modelo con estados ocultos precalculados (clave y valores en los bloques de atención) que se pueden usar para una -decodificación autorregresiva más rápida. - - - - -### Exportar un modelo para una arquitectura no compatible - -Si deseas exportar un modelo cuya arquitectura no es compatible de forma nativa -con la biblioteca, debes seguir tres pasos principales: - -1. Implementa una configuración personalizada en ONNX. -2. Exporta el modelo a ONNX. -3. Valide los resultados de PyTorch y los modelos exportados. - -En esta sección, veremos cómo se implementó la serialización de DistilBERT -para mostrar lo que implica cada paso. - -#### Implementar una configuración personalizada en ONNX - -Comencemos con el objeto de configuración de ONNX. Proporcionamos tres clases abstractas -de las que debe heredar, según el tipo de arquitectura del modelo que quieras exportar: - -* Modelos basados en el _Encoder_ inherente de [`~onnx.config.OnnxConfig`] -* Modelos basados en el _Decoder_ inherente de [`~onnx.config.OnnxConfigWithPast`] -* Modelos _Encoder-decoder_ inherente de [`~onnx.config.OnnxSeq2SeqConfigWithPast`] - - - -Una buena manera de implementar una configuración personalizada en ONNX es observar la implementación -existente en el archivo `configuration_.py` de una arquitectura similar. - - - -Dado que DistilBERT es un modelo de tipo _encoder_, su configuración se hereda de `OnnxConfig`: - -```python ->>> from typing import Mapping, OrderedDict ->>> from transformers.onnx import OnnxConfig - - ->>> class DistilBertOnnxConfig(OnnxConfig): -... @property -... def inputs(self) -> Mapping[str, Mapping[int, str]]: -... return OrderedDict( -... [ -... ("input_ids", {0: "batch", 1: "sequence"}), -... ("attention_mask", {0: "batch", 1: "sequence"}), -... ] -... ) -``` - -Cada objeto de configuración debe implementar la propiedad `inputs` y devolver un mapeo, -donde cada llave corresponde a una entrada esperada y cada valor indica el eje de esa entrada. -Para DistilBERT, podemos ver que se requieren dos entradas: `input_ids` y `attention_mask`. -Estas entradas tienen la misma forma de `(batch_size, sequence_length)`, es por lo que vemos -los mismos ejes utilizados en la configuración. - - - -Observa que la propiedad `inputs` para `DistilBertOnnxConfig` devuelve un `OrderedDict`. -Esto nos asegura que las entradas coincidan con su posición relativa dentro del método -`PreTrainedModel.forward()` al rastrear el grafo. Recomendamos usar un `OrderedDict` -para las propiedades `inputs` y `outputs` al implementar configuraciones ONNX personalizadas. - - - -Una vez que hayas implementado una configuración ONNX, puedes crear una -instancia proporcionando la configuración del modelo base de la siguiente manera: - -```python ->>> from transformers import AutoConfig - ->>> config = AutoConfig.from_pretrained("distilbert/distilbert-base-uncased") ->>> onnx_config = DistilBertOnnxConfig(config) -``` - -El objeto resultante tiene varias propiedades útiles. Por ejemplo, puedes ver el conjunto de operadores ONNX que se -utilizará durante la exportación: - -```python ->>> print(onnx_config.default_onnx_opset) -11 -``` - -También puedes ver los resultados asociados con el modelo de la siguiente manera: - -```python ->>> print(onnx_config.outputs) -OrderedDict([("last_hidden_state", {0: "batch", 1: "sequence"})]) -``` - -Observa que la propiedad de salidas sigue la misma estructura que las entradas; -devuelve un objecto `OrderedDict` de salidas nombradas y sus formas. La estructura -de salida está vinculada a la elección de la función con la que se inicializa la configuración. -Por defecto, la configuración de ONNX se inicializa con la función `default` que -corresponde a exportar un modelo cargado con la clase `AutoModel`. Si quieres exportar -una topología de modelo diferente, simplemente proporciona una característica diferente -al argumento `task` cuando inicialices la configuración de ONNX. Por ejemplo, si quisiéramos -exportar DistilBERT con un cabezal de clasificación de secuencias, podríamos usar: - -```python ->>> from transformers import AutoConfig - ->>> config = AutoConfig.from_pretrained("distilbert/distilbert-base-uncased") ->>> onnx_config_for_seq_clf = DistilBertOnnxConfig(config, task="sequence-classification") ->>> print(onnx_config_for_seq_clf.outputs) -OrderedDict([('logits', {0: 'batch'})]) -``` - - - -Todas las propiedades base y métodos asociados con [`~onnx.config.OnnxConfig`] y las -otras clases de configuración se pueden sobreescribir si es necesario. -Consulte [`BartOnnxConfig`] para ver un ejemplo avanzado. - - - -#### Exportar el modelo - -Una vez que hayas implementado la configuración de ONNX, el siguiente paso es exportar el modelo. -Aquí podemos usar la función `export()` proporcionada por el paquete `transformers.onnx`. -Esta función espera la configuración de ONNX, junto con el modelo base y el tokenizador, -y la ruta para guardar el archivo exportado: - -```python ->>> from pathlib import Path ->>> from transformers.onnx import export ->>> from transformers import AutoTokenizer, AutoModel - ->>> onnx_path = Path("model.onnx") ->>> model_ckpt = "distilbert/distilbert-base-uncased" ->>> base_model = AutoModel.from_pretrained(model_ckpt) ->>> tokenizer = AutoTokenizer.from_pretrained(model_ckpt) - ->>> onnx_inputs, onnx_outputs = export(tokenizer, base_model, onnx_config, onnx_config.default_onnx_opset, onnx_path) -``` - -Los objetos `onnx_inputs` y `onnx_outputs` devueltos por la función `export()` -son listas de llaves definidas en las propiedades `inputs` y `outputs` de la configuración. -Una vez exportado el modelo, puedes probar que el modelo está bien formado de la siguiente manera: - -```python ->>> import onnx - ->>> onnx_model = onnx.load("model.onnx") ->>> onnx.checker.check_model(onnx_model) -``` - - - -Si tu modelo tiene más de 2GB, verás que se crean muchos archivos adicionales durante la exportación. -Esto es _esperado_ porque ONNX usa [Búferes de protocolo](https://developers.google.com/protocol-buffers/) -para almacenar el modelo y éstos tienen un límite de tamaño de 2 GB. Consulta la -[documentación de ONNX](https://github.com/onnx/onnx/blob/master/docs/ExternalData.md) para obtener -instrucciones sobre cómo cargar modelos con datos externos. - - - -#### Validar los resultados del modelo - -El paso final es validar que los resultados del modelo base y exportado coincidan dentro -de cierta tolerancia absoluta. Aquí podemos usar la función `validate_model_outputs()` -proporcionada por el paquete `transformers.onnx` de la siguiente manera: - -```python ->>> from transformers.onnx import validate_model_outputs - ->>> validate_model_outputs( -... onnx_config, tokenizer, base_model, onnx_path, onnx_outputs, onnx_config.atol_for_validation -... ) -``` - -Esta función usa el método `OnnxConfig.generate_dummy_inputs()` para generar entradas para el modelo base -y exportado, y la tolerancia absoluta se puede definir en la configuración. En general, encontramos una -concordancia numérica en el rango de 1e-6 a 1e-4, aunque es probable que cualquier valor menor que 1e-3 esté bien. - -### Contribuir con una nueva configuración a 🤗 Transformers - -¡Estamos buscando expandir el conjunto de configuraciones a la medida para usar y agradecemos las contribuciones de la comunidad! -Si deseas contribuir con su colaboración a la biblioteca, deberás: - -* Implementa la configuración de ONNX en el archivo `configuration_.py` correspondiente -* Incluye la arquitectura del modelo y las características correspondientes en [`~onnx.features.FeatureManager`] -* Agrega tu arquitectura de modelo a las pruebas en `test_onnx_v2.py` - -Revisa cómo fue la contribución para la [configuración de IBERT](https://github.com/huggingface/transformers/pull/14868/files) -y así tener una idea de lo que necesito. - -## TorchScript - - - -Este es el comienzo de nuestros experimentos con TorchScript y todavía estamos explorando sus capacidades con modelos de -tamaño de entrada variable. Es un tema de interés y profundizaremos nuestro análisis en las próximas -versiones, con más ejemplos de código, una implementación más flexible y puntos de referencia que comparen códigos -basados en Python con TorchScript compilado. - - - -Según la documentación de PyTorch: "TorchScript es una forma de crear modelos serializables y optimizables a partir del -código de PyTorch". Los dos módulos de Pytorch [JIT y TRACE](https://pytorch.org/docs/stable/jit.html) permiten al -desarrollador exportar su modelo para reutilizarlo en otros programas, como los programas C++ orientados a la eficiencia. - -Hemos proporcionado una interfaz que permite exportar modelos de 🤗 Transformers a TorchScript para que puedan reutilizarse -en un entorno diferente al de un programa Python basado en PyTorch. Aquí explicamos cómo exportar y usar nuestros modelos -usando TorchScript. - -Exportar un modelo requiere de dos cosas: - -- un pase hacia adelante con entradas ficticias. -- instanciación del modelo con la indicador `torchscript`. - -Estas necesidades implican varias cosas con las que los desarrolladores deben tener cuidado. Éstas se detallan a continuación. - -### Indicador de TorchScript y pesos atados - -Este indicador es necesario porque la mayoría de los modelos de lenguaje en este repositorio tienen pesos vinculados entre su capa -de `Embedding` y su capa de `Decoding`. TorchScript no permite la exportación de modelos que tengan pesos atados, por lo que es -necesario desvincular y clonar los pesos previamente. - -Esto implica que los modelos instanciados con el indicador `torchscript` tienen su capa `Embedding` y `Decoding` separadas, -lo que significa que no deben entrenarse más adelante. El entrenamiento desincronizaría las dos capas, lo que generaría -resultados inesperados. - -Este no es el caso de los modelos que no tienen un cabezal de modelo de lenguaje, ya que no tienen pesos atados. -Estos modelos se pueden exportar de forma segura sin el indicador `torchscript`. - -### Entradas ficticias y longitudes estándar - -Las entradas ficticias se utilizan para crear un modelo de pase hacia adelante. Mientras los valores de las entradas se -propagan a través de las capas, PyTorch realiza un seguimiento de las diferentes operaciones ejecutadas en cada tensor. -Estas operaciones registradas se utilizan luego para crear el "rastro" del modelo. - -El rastro se crea en relación con las dimensiones de las entradas. Por lo tanto, está limitado por las dimensiones de la -entrada ficticia y no funcionará para ninguna otra longitud de secuencia o tamaño de lote. Al intentar con un tamaño diferente, -un error como: - -`The expanded size of the tensor (3) must match the existing size (7) at non-singleton dimension 2` - -aparecerá. Por lo tanto, se recomienda rastrear el modelo con un tamaño de entrada ficticia al menos tan grande como la -entrada más grande que se alimentará al modelo durante la inferencia. El _padding_ se puede realizar para completar los -valores que faltan. Sin embargo, como el modelo se habrá rastreado con un tamaño de entrada grande, las dimensiones de -las diferentes matrices también serán grandes, lo que dará como resultado más cálculos. - -Se recomienda tener cuidado con el número total de operaciones realizadas en cada entrada y seguir de cerca el rendimiento -al exportar modelos de longitud de secuencia variable. - -### Usar TorchScript en Python - -A continuación se muestra un ejemplo que muestra cómo guardar, cargar modelos y cómo usar el rastreo para la inferencia. - -#### Guardando un modelo - -Este fragmento muestra cómo usar TorchScript para exportar un `BertModel`. Aquí, el `BertModel` se instancia de acuerdo -con la clase `BertConfig` y luego se guarda en el disco con el nombre de archivo `traced_bert.pt` - -```python -from transformers import BertModel, BertTokenizer, BertConfig -import torch - -enc = BertTokenizer.from_pretrained("google-bert/bert-base-uncased") - -# Tokenizing input text -text = "[CLS] Who was Jim Henson ? [SEP] Jim Henson was a puppeteer [SEP]" -tokenized_text = enc.tokenize(text) - -# Masking one of the input tokens -masked_index = 8 -tokenized_text[masked_index] = "[MASK]" -indexed_tokens = enc.convert_tokens_to_ids(tokenized_text) -segments_ids = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1] - -# Creating a dummy input -tokens_tensor = torch.tensor([indexed_tokens]) -segments_tensors = torch.tensor([segments_ids]) -dummy_input = [tokens_tensor, segments_tensors] - -# Initializing the model with the torchscript flag -# Flag set to True even though it is not necessary as this model does not have an LM Head. -config = BertConfig( - vocab_size_or_config_json_file=32000, - hidden_size=768, - num_hidden_layers=12, - num_attention_heads=12, - intermediate_size=3072, - torchscript=True, -) - -# Instantiating the model -model = BertModel(config) - -# The model needs to be in evaluation mode -model.eval() - -# If you are instantiating the model with *from_pretrained* you can also easily set the TorchScript flag -model = BertModel.from_pretrained("google-bert/bert-base-uncased", torchscript=True) - -# Creating the trace -traced_model = torch.jit.trace(model, [tokens_tensor, segments_tensors]) -torch.jit.save(traced_model, "traced_bert.pt") -``` - -#### Cargar un modelo - -Este fragmento muestra cómo cargar el `BertModel` que se guardó previamente en el disco con el nombre `traced_bert.pt`. -Estamos reutilizando el `dummy_input` previamente inicializado. - -```python -loaded_model = torch.jit.load("traced_bert.pt") -loaded_model.eval() - -all_encoder_layers, pooled_output = loaded_model(*dummy_input) -``` - -#### Usar un modelo rastreado para la inferencia - -Usar el modelo rastreado para la inferencia es tan simple como usar su método `__call__`: - -```python -traced_model(tokens_tensor, segments_tensors) -``` - -### Implementar los modelos HuggingFace TorchScript en AWS mediante Neuron SDK - -AWS presentó la familia de instancias [Amazon EC2 Inf1](https://aws.amazon.com/ec2/instance-types/inf1/) para la inferencia -de aprendizaje automático de bajo costo y alto rendimiento en la nube. Las instancias Inf1 funcionan con el chip AWS -Inferentia, un acelerador de hardware personalizado, que se especializa en cargas de trabajo de inferencia de aprendizaje -profundo. [AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/#) es el kit de desarrollo para Inferentia -que admite el rastreo y la optimización de modelos de transformers para su implementación en Inf1. El SDK de Neuron proporciona: - - -1. API fácil de usar con una línea de cambio de código para rastrear y optimizar un modelo de TorchScript para la inferencia en la nube. -2. Optimizaciones de rendimiento listas para usar con un [costo-rendimiento mejorado](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/benchmark/>) -3. Soporte para modelos HuggingFace Transformers construidos con [PyTorch](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/pytorch/bert_tutorial/tutorial_pretrained_bert.html) -o [TensorFlow](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/tensorflow/huggingface_bert/huggingface_bert.html). - -#### Implicaciones - -Los modelos Transformers basados en la arquitectura -[BERT (Representaciones de _Enconder_ bidireccional de Transformers)](https://huggingface.co/docs/transformers/main/model_doc/bert), -o sus variantes, como [distilBERT](https://huggingface.co/docs/transformers/main/model_doc/distilbert) y -[roBERTa](https://huggingface.co/docs/transformers/main/model_doc/roberta), se ejecutarán mejor en Inf1 para tareas no -generativas, como la respuesta extractiva de preguntas, la clasificación de secuencias y la clasificación de tokens. -Como alternativa, las tareas de generación de texto se pueden adaptar para ejecutarse en Inf1, según este -[tutorial de AWS Neuron MarianMT](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/pytorch/transformers-marianmt.html). -Puedes encontrar más información sobre los modelos que están listos para usarse en Inferentia en la -[sección _Model Architecture Fit_ de la documentación de Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/models/models-inferentia.html#models-inferentia). - -#### Dependencias - -Usar AWS Neuron para convertir modelos requiere las siguientes dependencias y entornos: - -* Un [entorno Neuron SDK](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html#installation-guide), -que viene preconfigurado en [AWS Deep Learning AMI](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia-launching.html). - -#### Convertir un modelo a AWS Neuron - -Con el mismo script usado en [Uso de TorchScript en Python](https://huggingface.co/docs/transformers/main/es/serialization#using-torchscript-in-python) -para rastrear un "BertModel", puedes importar la extensión del _framework_ `torch.neuron` para acceder a los componentes -del SDK de Neuron a través de una API de Python. - -```python -from transformers import BertModel, BertTokenizer, BertConfig -import torch -import torch.neuron -``` -Y modificando la línea de código de rastreo de: - -```python -torch.jit.trace(model, [tokens_tensor, segments_tensors]) -``` - -con lo siguiente: - -```python -torch.neuron.trace(model, [token_tensor, segments_tensors]) -``` - -Este cambio permite a Neuron SDK rastrear el modelo y optimizarlo para ejecutarse en instancias Inf1. - -Para obtener más información sobre las funciones, las herramientas, los tutoriales de ejemplo y las últimas actualizaciones -de AWS Neuron SDK, consulte la [documentación de AWS NeuronSDK](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/index.html). diff --git a/docs/source/it/_toctree.yml b/docs/source/it/_toctree.yml index 2ba1b8ecede3..6e0371fb2470 100644 --- a/docs/source/it/_toctree.yml +++ b/docs/source/it/_toctree.yml @@ -29,8 +29,6 @@ title: Addestramento con script - local: multilingual title: Modelli multilingua per l'inferenza - - local: serialization - title: Esporta modelli Transformers - local: perf_train_cpu title: Addestramento efficiente su CPU - local: perf_train_cpu_many @@ -66,4 +64,3 @@ - local: pr_checks title: Controlli su una Pull Request title: Guide How-to - diff --git a/docs/source/it/serialization.md b/docs/source/it/serialization.md deleted file mode 100644 index 53e16d927eb9..000000000000 --- a/docs/source/it/serialization.md +++ /dev/null @@ -1,653 +0,0 @@ - - -# Esporta modelli 🤗 Transformers - -Se devi implementare 🤗 modelli Transformers in ambienti di produzione, noi -consigliamo di esportarli in un formato serializzato che può essere caricato ed eseguito -su runtime e hardware specializzati. In questa guida ti mostreremo come farlo -esporta 🤗 Modelli Transformers in due formati ampiamente utilizzati: ONNX e TorchScript. - -Una volta esportato, un modello può essere ottimizato per l'inferenza tramite tecniche come -la quantizzazione e soppressione. Se sei interessato a ottimizzare i tuoi modelli per l'esecuzione -con la massima efficienza, dai un'occhiata a [🤗 Optimum -library](https://github.com/huggingface/optimum). - -## ONNX - -Il progetto [ONNX (Open Neural Network eXchange)](http://onnx.ai) Il progetto onnx è un open -standard che definisce un insieme comune di operatori e un formato di file comune a -rappresentano modelli di deep learning in un'ampia varietà di framework, tra cui -PyTorch e TensorFlow. Quando un modello viene esportato nel formato ONNX, questi -operatori sono usati per costruire un grafico computazionale (often called an -_intermediate representation_) che rappresenta il flusso di dati attraverso la -rete neurale. - -Esponendo un grafico con operatori e tipi di dati standardizzati, ONNX rende -più facile passare da un framework all'altro. Ad esempio, un modello allenato in PyTorch può -essere esportato in formato ONNX e quindi importato in TensorFlow (e viceversa). - -🤗 Transformers fornisce un pacchetto `transformers.onnx` che ti consente di -convertire i checkpoint del modello in un grafico ONNX sfruttando gli oggetti di configurazione. -Questi oggetti di configurazione sono già pronti per una serie di architetture di modelli, -e sono progettati per essere facilmente estensibili ad altre architetture. - -Le configurazioni pronte includono le seguenti architetture: - - - -- ALBERT -- BART -- BEiT -- BERT -- BigBird -- BigBird-Pegasus -- Blenderbot -- BlenderbotSmall -- CamemBERT -- ConvBERT -- Data2VecText -- Data2VecVision -- DeiT -- DistilBERT -- ELECTRA -- FlauBERT -- GPT Neo -- GPT-J -- I-BERT -- LayoutLM -- M2M100 -- Marian -- mBART -- MobileBERT -- OpenAI GPT-2 -- Perceiver -- PLBart -- RoBERTa -- RoFormer -- SqueezeBERT -- T5 -- ViT -- XLM -- XLM-RoBERTa -- XLM-RoBERTa-XL - -Nelle prossime due sezioni, ti mostreremo come: - -* Esporta un modello supportato usando il pacchetto `transformers.onnx`. -* Esporta un modello personalizzato per un'architettura non supportata. - -### Esportazione di un modello in ONNX - -Per esportare un modello 🤗 Transformers in ONNX, dovrai prima installarne alcune -dipendenze extra: - -```bash -pip install transformers[onnx] -``` - -Il pacchetto `transformers.onnx` può essere usato come modulo Python: - -```bash -python -m transformers.onnx --help - -usage: Hugging Face Transformers ONNX exporter [-h] -m MODEL [--feature {causal-lm, ...}] [--opset OPSET] [--atol ATOL] output - -positional arguments: - output Path indicating where to store generated ONNX model. - -optional arguments: - -h, --help show this help message and exit - -m MODEL, --model MODEL - Model ID on huggingface.co or path on disk to load model from. - --feature {causal-lm, ...} - The type of features to export the model with. - --opset OPSET ONNX opset version to export the model with. - --atol ATOL Absolute difference tolerance when validating the model. -``` - -L'esportazione di un checkpoint utilizzando una configurazione già pronta può essere eseguita come segue: - -```bash -python -m transformers.onnx --model=distilbert/distilbert-base-uncased onnx/ -``` - -che dovrebbe mostrare i seguenti log: - -```bash -Validating ONNX model... - -[✓] ONNX model output names match reference model ({'last_hidden_state'}) - - Validating ONNX Model output "last_hidden_state": - -[✓] (2, 8, 768) matches (2, 8, 768) - -[✓] all values close (atol: 1e-05) -All good, model saved at: onnx/model.onnx -``` - -Questo esporta un grafico ONNX del checkpoint definito dall'argomento `--model`. -In questo esempio è `distilbert/distilbert-base-uncased`, ma può essere qualsiasi checkpoint -Hugging Face Hub o uno memorizzato localmente. - -Il file risultante `model.onnx` può quindi essere eseguito su uno dei [tanti -acceleratori](https://onnx.ai/supported-tools.html#deployModel) che supportano il -lo standard ONNX. Ad esempio, possiamo caricare ed eseguire il modello con [ONNX -Runtime](https://onnxruntime.ai/) come segue: - -```python ->>> from transformers import AutoTokenizer ->>> from onnxruntime import InferenceSession - ->>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased") ->>> session = InferenceSession("onnx/model.onnx") ->>> # ONNX Runtime expects NumPy arrays as input ->>> inputs = tokenizer("Using DistilBERT with ONNX Runtime!", return_tensors="np") ->>> outputs = session.run(output_names=["last_hidden_state"], input_feed=dict(inputs)) -``` - -I nomi di output richiesti (cioè `["last_hidden_state"]`) possono essere ottenuti -dando un'occhiata alla configurazione ONNX di ogni modello. Ad esempio, per -DistilBERT abbiamo: - -```python ->>> from transformers.models.distilbert import DistilBertConfig, DistilBertOnnxConfig - ->>> config = DistilBertConfig() ->>> onnx_config = DistilBertOnnxConfig(config) ->>> print(list(onnx_config.outputs.keys())) -["last_hidden_state"] -``` - -Il processo è identico per i checkpoint TensorFlow sull'hub. Ad esempio, noi -possiamo esportare un checkpoint TensorFlow puro da [Keras -organizzazione](https://huggingface.co/keras-io) come segue: - -```bash -python -m transformers.onnx --model=keras-io/transformers-qa onnx/ -``` - -Per esportare un modello memorizzato localmente, devi disporre dei pesi del modello -e file tokenizer memorizzati in una directory. Ad esempio, possiamo caricare e salvare un -checkpoint come segue: - -```python ->>> from transformers import AutoTokenizer, AutoModelForSequenceClassification - ->>> # Load tokenizer and PyTorch weights form the Hub ->>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased") ->>> pt_model = AutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased") ->>> # Save to disk ->>> tokenizer.save_pretrained("local-pt-checkpoint") ->>> pt_model.save_pretrained("local-pt-checkpoint") -``` - -Una volta salvato il checkpoint, possiamo esportarlo su ONNX puntando l'argomento `--model` -del pacchetto `transformers.onnx` nella directory desiderata: - -```bash -python -m transformers.onnx --model=local-pt-checkpoint onnx/ -``` - -### Selezione delle caratteristiche per diverse topologie di modello - -Ogni configurazione già pronta viene fornita con una serie di _caratteristiche_ che ti consentono di -esportare modelli per diversi tipi di topologie o attività. Come mostrato nella tabella -di seguito, ogni caratteristica è associata a una diversa Auto Class: - -| Caratteristica | Auto Class | -| ------------------------------------ | ------------------------------------ | -| `causal-lm`, `causal-lm-with-past` | `AutoModelForCausalLM` | -| `default`, `default-with-past` | `AutoModel` | -| `masked-lm` | `AutoModelForMaskedLM` | -| `question-answering` | `AutoModelForQuestionAnswering` | -| `seq2seq-lm`, `seq2seq-lm-with-past` | `AutoModelForSeq2SeqLM` | -| `sequence-classification` | `AutoModelForSequenceClassification` | -| `token-classification` | `AutoModelForTokenClassification` | - -Per ciascuna configurazione, puoi trovare l'elenco delle funzionalità supportate tramite il -`FeaturesManager`. Ad esempio, per DistilBERT abbiamo: - -```python ->>> from transformers.onnx.features import FeaturesManager - ->>> distilbert_features = list(FeaturesManager.get_supported_features_for_model_type("distilbert").keys()) ->>> print(distilbert_features) -["default", "masked-lm", "causal-lm", "sequence-classification", "token-classification", "question-answering"] -``` - -Puoi quindi passare una di queste funzionalità all'argomento `--feature` nel -pacchetto `transformers.onnx`. Ad esempio, per esportare un modello di classificazione del testo -possiamo scegliere un modello ottimizzato dall'Hub ed eseguire: - -```bash -python -m transformers.onnx --model=distilbert/distilbert-base-uncased-finetuned-sst-2-english \ - --feature=sequence-classification onnx/ -``` - -che visualizzerà i seguenti registri: - -```bash -Validating ONNX model... - -[✓] ONNX model output names match reference model ({'logits'}) - - Validating ONNX Model output "logits": - -[✓] (2, 2) matches (2, 2) - -[✓] all values close (atol: 1e-05) -All good, model saved at: onnx/model.onnx -``` - -Puoi notare che in questo caso, i nomi di output del modello ottimizzato sono -`logits` invece di `last_hidden_state` che abbiamo visto con il -checkpoint `distilbert/distilbert-base-uncased` precedente. Questo è previsto dal -modello ottimizato visto che ha una testa di e. - - - -Le caratteristiche che hanno un suffisso `wtih-past` (ad es. `causal-lm-with-past`) -corrispondono a topologie di modello con stati nascosti precalcolati (chiave e valori -nei blocchi di attenzione) che possono essere utilizzati per la decodifica autoregressiva veloce. - - - - -### Esportazione di un modello per un'architettura non supportata - -Se desideri esportare un modello la cui architettura non è nativamente supportata dalla -libreria, ci sono tre passaggi principali da seguire: - -1. Implementare una configurazione ONNX personalizzata. -2. Esportare il modello in ONNX. -3. Convalidare gli output di PyTorch e dei modelli esportati. - -In questa sezione, vedremo come DistilBERT è stato implementato per mostrare cosa è -coinvolto in ogni passaggio. - -#### Implementazione di una configurazione ONNX personalizzata - -Iniziamo con l'oggetto di configurazione ONNX. Forniamo tre classi -astratte da cui ereditare, a seconda del tipo di archittettura -del modello che desideri esportare: - -* I modelli basati su encoder ereditano da [`~onnx.config.OnnxConfig`] -* I modelli basati su decoder ereditano da [`~onnx.config.OnnxConfigWithPast`] -* I modelli encoder-decoder ereditano da[`~onnx.config.OnnxSeq2SeqConfigWithPast`] - - - -Un buon modo per implementare una configurazione ONNX personalizzata è guardare l'implementazione -esistente nel file `configuration_.py` di un'architettura simile. - - - -Poiché DistilBERT è un modello basato su encoder, la sua configurazione eredita da -`OnnxConfig`: - -```python ->>> from typing import Mapping, OrderedDict ->>> from transformers.onnx import OnnxConfig - - ->>> class DistilBertOnnxConfig(OnnxConfig): -... @property -... def inputs(self) -> Mapping[str, Mapping[int, str]]: -... return OrderedDict( -... [ -... ("input_ids", {0: "batch", 1: "sequence"}), -... ("attention_mask", {0: "batch", 1: "sequence"}), -... ] -... ) -``` - -Ogni oggetto di configurazione deve implementare la proprietà `inputs` e restituire una -mappatura, dove ogni chiave corrisponde a un input previsto e ogni valore -indica l'asse di quell'input. Per DistilBERT, possiamo vedere che sono richiesti -due input: `input_ids` e `attention_mask`. Questi inputs hanno la stessa forma di -`(batch_size, sequence_length)` per questo motivo vediamo gli stessi assi usati nella -configurazione. - - - -Puoi notare che la proprietà `inputs` per `DistilBertOnnxConfig` restituisce un -`OrdinatoDict`. Ciò garantisce che gli input corrispondano alla loro posizione -relativa all'interno del metodo `PreTrainedModel.forward()` durante il tracciamento del grafico. -Raccomandiamo di usare un `OrderedDict` per le proprietà `inputs` e `outputs` -quando si implementano configurazioni ONNX personalizzate. - - - -Dopo aver implementato una configurazione ONNX, è possibile istanziarla -fornendo alla configurazione del modello base come segue: - -```python ->>> from transformers import AutoConfig - ->>> config = AutoConfig.from_pretrained("distilbert/distilbert-base-uncased") ->>> onnx_config = DistilBertOnnxConfig(config) -``` - -L'oggetto risultante ha diverse proprietà utili. Ad esempio è possibile visualizzare il -Set operatore ONNX che verrà utilizzato durante l'esportazione: - -```python ->>> print(onnx_config.default_onnx_opset) -11 -``` - -È inoltre possibile visualizzare gli output associati al modello come segue: - -```python ->>> print(onnx_config.outputs) -OrderedDict([("last_hidden_state", {0: "batch", 1: "sequence"})]) -``` - -Puoi notare che la proprietà degli output segue la stessa struttura degli input; esso -restituisce un `OrderedDict` di output con nome e le loro forme. La struttura di output -è legato alla scelta della funzione con cui viene inizializzata la configurazione. -Per impostazione predefinita, la configurazione ONNX viene inizializzata con la funzione 'predefinita' -che corrisponde all'esportazione di un modello caricato con la classe `AutoModel`. Se tu -desideri esportare una topologia di modello diversa, è sufficiente fornire una funzionalità diversa a -l'argomento `task` quando inizializzi la configurazione ONNX. Ad esempio, se -volevamo esportare DistilBERT con una testa di classificazione per sequenze, potremmo -usare: - -```python ->>> from transformers import AutoConfig - ->>> config = AutoConfig.from_pretrained("distilbert/distilbert-base-uncased") ->>> onnx_config_for_seq_clf = DistilBertOnnxConfig(config, task="sequence-classification") ->>> print(onnx_config_for_seq_clf.outputs) -OrderedDict([('logits', {0: 'batch'})]) -``` - - - -Tutte le proprietà e i metodi di base associati a [`~onnx.config.OnnxConfig`] e le -altre classi di configurazione possono essere sovrascritte se necessario. Guarda -[`BartOnnxConfig`] per un esempio avanzato. - - - -#### Esportazione del modello - -Una volta implementata la configurazione ONNX, il passaggio successivo consiste nell'esportare il -modello. Qui possiamo usare la funzione `export()` fornita dal -pacchetto `transformers.onnx`. Questa funzione prevede la configurazione ONNX, insieme -con il modello base e il tokenizer e il percorso per salvare il file esportato: - -```python ->>> from pathlib import Path ->>> from transformers.onnx import export ->>> from transformers import AutoTokenizer, AutoModel - ->>> onnx_path = Path("model.onnx") ->>> model_ckpt = "distilbert/distilbert-base-uncased" ->>> base_model = AutoModel.from_pretrained(model_ckpt) ->>> tokenizer = AutoTokenizer.from_pretrained(model_ckpt) - ->>> onnx_inputs, onnx_outputs = export(tokenizer, base_model, onnx_config, onnx_config.default_onnx_opset, onnx_path) -``` - -Gli `onnx_inputs` e `onnx_outputs` restituiti dalla funzione `export()` sono -liste di chiavi definite nelle proprietà di `input` e `output` della -configurazione. Una volta esportato il modello, puoi verificare che il modello sia ben -formato come segue: - -```python ->>> import onnx - ->>> onnx_model = onnx.load("model.onnx") ->>> onnx.checker.check_model(onnx_model) -``` - - - -Se il tuo modello è più largo di 2 GB, vedrai che molti file aggiuntivi sono -creati durante l'esportazione. Questo è _previsto_ perché ONNX utilizza [Protocol -Buffer](https://developers.google.com/protocol-buffers/) per memorizzare il modello e -questi hanno un limite di dimensione 2 GB. Vedi la [Documentazione -ONNX](https://github.com/onnx/onnx/blob/master/docs/ExternalData.md) -per istruzioni su come caricare modelli con dati esterni. - - - -#### Convalida degli output del modello - -Il passaggio finale consiste nel convalidare gli output dal modello di base e quello esportato -corrispondere entro una soglia di tolleranza assoluta. Qui possiamo usare la -Funzione `validate_model_outputs()` fornita dal pacchetto `transformers.onnx` -come segue: - -```python ->>> from transformers.onnx import validate_model_outputs - ->>> validate_model_outputs( -... onnx_config, tokenizer, base_model, onnx_path, onnx_outputs, onnx_config.atol_for_validation -... ) -``` - -Questa funzione usa il metodo `OnnxConfig.generate_dummy_inputs()` per generare -input per il modello di base e quello esportato e la tolleranza assoluta può essere -definita nella configurazione. Generalmente troviamo una corrispondenza numerica nell'intervallo da 1e-6 -a 1e-4, anche se è probabile che qualsiasi cosa inferiore a 1e-3 vada bene. - -### Contribuire con una nuova configurazione a 🤗 Transformers - -Stiamo cercando di espandere l'insieme di configurazioni già pronte e di accettare -contributi della community! Se vuoi contribuire con la tua aggiunta -nella libreria, dovrai: - -* Implementare la configurazione ONNX nella corrispondente `configuration file -_.py` -* Includere l'architettura del modello e le funzioni corrispondenti in [`~onnx.features.FeatureManager`] -* Aggiungere la tua architettura del modello ai test in `test_onnx_v2.py` - -Scopri come stato contribuito la configurazione per [IBERT](https://github.com/huggingface/transformers/pull/14868/files) per -avere un'idea di cosa è coinvolto. - -## TorchScript - - - -Questo è l'inizio dei nostri esperimenti con TorchScript e stiamo ancora esplorando le sue capacità con -modelli con variable-input-size. È una nostra priorità e approfondiremo le nostre analisi nelle prossime versioni, -con più esempi di codici, un'implementazione più flessibile e benchmark che confrontano i codici basati su Python con quelli compilati con -TorchScript. - - - -Secondo la documentazione di Pytorch: "TorchScript è un modo per creare modelli serializzabili e ottimizzabili da codice -Pytorch". I due moduli di Pytorch [JIT e TRACE](https://pytorch.org/docs/stable/jit.html) consentono allo sviluppatore di esportare -il loro modello da riutilizzare in altri programmi, come i programmi C++ orientati all'efficienza. - -Abbiamo fornito un'interfaccia che consente l'esportazione di modelli 🤗 Transformers in TorchScript in modo che possano essere riutilizzati -in un ambiente diverso rispetto a un programma Python basato su Pytorch. Qui spieghiamo come esportare e utilizzare i nostri modelli utilizzando -TorchScript. - -Esportare un modello richiede due cose: - -- Un passaggio in avanti con input fittizzi. -- Istanziazione del modello con flag `torchscript`. - -Queste necessità implicano diverse cose a cui gli sviluppatori dovrebbero prestare attenzione. Questi dettagli mostrati sotto. - -### Flag TorchScript e pesi legati - -Questo flag è necessario perché la maggior parte dei modelli linguistici in questo repository hanno pesi legati tra il loro -strato "Embedding" e lo strato "Decoding". TorchScript non consente l'esportazione di modelli che hanno pesi -legati, quindi è necessario prima slegare e clonare i pesi. - -Ciò implica che i modelli istanziati con il flag `torchscript` hanno il loro strato `Embedding` e strato `Decoding` -separato, il che significa che non dovrebbero essere addestrati in futuro. L'allenamento de-sincronizza i due -strati, portando a risultati inaspettati. - -Questo non è il caso per i modelli che non hanno una testa del modello linguistico, poiché quelli non hanno pesi legati. Questi modelli -può essere esportato in sicurezza senza il flag `torchscript`. - -### Input fittizi e standard lengths - -Gli input fittizzi sono usati per fare un modello passaggio in avanti . Mentre i valori degli input si propagano attraverso i strati, -Pytorch tiene traccia delle diverse operazioni eseguite su ciascun tensore. Queste operazioni registrate vengono quindi utilizzate per -creare la "traccia" del modello. - -La traccia viene creata relativamente alle dimensioni degli input. È quindi vincolato dalle dimensioni dell'input -fittizio e non funzionerà per altre lunghezze di sequenza o dimensioni batch. Quando si proverà con una dimensione diversa, ci sarà errore -come: - -`La dimensione espansa del tensore (3) deve corrispondere alla dimensione esistente (7) nella dimensione non singleton 2` - -will be raised. Si consiglia pertanto di tracciare il modello con una dimensione di input fittizia grande almeno quanto il più grande -input che verrà fornito al modello durante l'inferenza. È possibile eseguire il padding per riempire i valori mancanti. Il modello -sarà tracciato con una grande dimensione di input, tuttavia, anche le dimensioni della diverse matrici saranno grandi, -risultando in più calcoli. - -Si raccomanda di prestare attenzione al numero totale di operazioni eseguite su ciascun input e di seguire da vicino le prestazioni -durante l'esportazione di modelli di sequenza-lunghezza variabili. - -### Usare TorchSscript in Python - -Di seguito è riportato un esempio, che mostra come salvare, caricare modelli e come utilizzare la traccia per l'inferenza. - -#### Salvare un modello - -Questo frammento di codice mostra come usare TorchScript per esportare un `BertModel`. Qui il `BertModel` è istanziato secondo -una classe `BertConfig` e quindi salvato su disco con il nome del file `traced_bert.pt` - -```python -from transformers import BertModel, BertTokenizer, BertConfig -import torch - -enc = BertTokenizer.from_pretrained("google-bert/bert-base-uncased") - -# Tokenizing input text -text = "[CLS] Who was Jim Henson ? [SEP] Jim Henson was a puppeteer [SEP]" -tokenized_text = enc.tokenize(text) - -# Masking one of the input tokens -masked_index = 8 -tokenized_text[masked_index] = "[MASK]" -indexed_tokens = enc.convert_tokens_to_ids(tokenized_text) -segments_ids = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1] - -# Creating a dummy input -tokens_tensor = torch.tensor([indexed_tokens]) -segments_tensors = torch.tensor([segments_ids]) -dummy_input = [tokens_tensor, segments_tensors] - -# Initializing the model with the torchscript flag -# Flag set to True even though it is not necessary as this model does not have an LM Head. -config = BertConfig( - vocab_size_or_config_json_file=32000, - hidden_size=768, - num_hidden_layers=12, - num_attention_heads=12, - intermediate_size=3072, - torchscript=True, -) - -# Instantiating the model -model = BertModel(config) - -# The model needs to be in evaluation mode -model.eval() - -# If you are instantiating the model with *from_pretrained* you can also easily set the TorchScript flag -model = BertModel.from_pretrained("google-bert/bert-base-uncased", torchscript=True) - -# Creating the trace -traced_model = torch.jit.trace(model, [tokens_tensor, segments_tensors]) -torch.jit.save(traced_model, "traced_bert.pt") -``` - -#### Caricare un modello - -Questo frammento di codice mostra come caricare il `BertModel` che era stato precedentemente salvato su disco con il nome `traced_bert.pt`. -Stiamo riutilizzando il `dummy_input` precedentemente inizializzato. - -```python -loaded_model = torch.jit.load("traced_bert.pt") -loaded_model.eval() - -all_encoder_layers, pooled_output = loaded_model(*dummy_input) -``` - -#### Utilizzare un modello tracciato per l'inferenza - -Usare il modello tracciato per l'inferenza è semplice come usare il suo metodo dunder `__call__`: - -```python -traced_model(tokens_tensor, segments_tensors) -``` - -### Implementare modelli HuggingFace TorchScript su AWS utilizzando Neuron SDK - -AWS ha introdotto [Amazon EC2 Inf1](https://aws.amazon.com/ec2/instance-types/inf1/) -famiglia di istanze per l'inferenza di machine learning a basso costo e ad alte prestazioni nel cloud. -Le istanze Inf1 sono alimentate dal chip AWS Inferentia, un acceleratore hardware personalizzato, -specializzato in carichi di lavoro di inferenza di deep learning. -[AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/#) -è l'SDK per Inferentia che supporta il tracciamento e l'ottimizzazione dei modelli transformers per -distribuzione su Inf1. L'SDK Neuron fornisce: - - -1. API di facile utilizzo con una riga di modifica del codice per tracciare e ottimizzare un modello TorchScript per l'inferenza nel cloud. -2. Ottimizzazioni delle prestazioni pronte all'uso per [miglioramento dei costi-prestazioni](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/benchmark/>) -3. Supporto per i modelli di trasformatori HuggingFace costruiti con [PyTorch](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/pytorch/bert_tutorial/tutorial_pretrained_bert.html) - o [TensorFlow](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/tensorflow/huggingface_bert/huggingface_bert.html). - -#### Implicazioni - -Modelli Transformers basati su architettura [BERT (Bidirectional Encoder Representations from Transformers)](https://huggingface.co/docs/transformers/main/model_doc/bert), -o sue varianti come [distilBERT](https://huggingface.co/docs/transformers/main/model_doc/distilbert) -e [roBERTa](https://huggingface.co/docs/transformers/main/model_doc/roberta) -funzioneranno meglio su Inf1 per attività non generative come la question answering estrattive, -Classificazione della sequenza, Classificazione dei token. In alternativa, generazione di testo -le attività possono essere adattate per essere eseguite su Inf1, secondo questo [tutorial AWS Neuron MarianMT](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/pytorch/transformers-marianmt.html). -Ulteriori informazioni sui modelli che possono essere convertiti fuori dagli schemi su Inferentia possono essere -trovati nella [sezione Model Architecture Fit della documentazione Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/models/models-inferentia.html#models-inferentia). - -#### Dipendenze - -L'utilizzo di AWS Neuron per convertire i modelli richiede le seguenti dipendenze e l'ambiente: - -* A [Neuron SDK environment](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html#installation-guide), - which comes pre-configured on [AWS Deep Learning AMI](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia-launching.html). - -#### Convertire un modello per AWS Neuron - -Usando lo stesso script come in [Usando TorchScipt in Python](https://huggingface.co/docs/transformers/main/en/serialization#using-torchscript-in-python) -per tracciare un "BertModel", importi l'estensione del framework `torch.neuron` per accedere -i componenti di Neuron SDK tramite un'API Python. - -```python -from transformers import BertModel, BertTokenizer, BertConfig -import torch -import torch.neuron -``` -E modificare solo la riga di codice di traccia - -Da: - -```python -torch.jit.trace(model, [tokens_tensor, segments_tensors]) -``` - -A: - -```python -torch.neuron.trace(model, [token_tensor, segments_tensors]) -``` - -Questa modifica consente a Neuron SDK di tracciare il modello e ottimizzarlo per l'esecuzione nelle istanze Inf1. - -Per ulteriori informazioni sulle funzionalità, gli strumenti, i tutorial di esempi e gli ultimi aggiornamenti di AWS Neuron SDK, -consultare la [documentazione AWS NeuronSDK](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/index.html). diff --git a/docs/source/ja/main_classes/onnx.md b/docs/source/ja/main_classes/onnx.md index f12427760976..aa5538a6971c 100644 --- a/docs/source/ja/main_classes/onnx.md +++ b/docs/source/ja/main_classes/onnx.md @@ -48,8 +48,3 @@ rendered properly in your Markdown viewer. 各 ONNX 構成は、次のことを可能にする一連の _機能_ に関連付けられています。 さまざまなタイプのトポロジまたはタスクのモデルをエクスポートします。 - -### FeaturesManager - -[[autodoc]] onnx.features.FeaturesManager - diff --git a/docs/source/ja/model_doc/beit.md b/docs/source/ja/model_doc/beit.md index cd92b041c8b1..e58543b023a1 100644 --- a/docs/source/ja/model_doc/beit.md +++ b/docs/source/ja/model_doc/beit.md @@ -93,12 +93,6 @@ BEiT の使用を開始するのに役立つ公式 Hugging Face およびコミ [[autodoc]] BeitConfig -## BeitFeatureExtractor - -[[autodoc]] BeitFeatureExtractor - - __call__ - - post_process_semantic_segmentation - ## BeitImageProcessor [[autodoc]] BeitImageProcessor diff --git a/docs/source/ja/model_doc/chinese_clip.md b/docs/source/ja/model_doc/chinese_clip.md index 5dac6b3589f3..c5a258c4962c 100644 --- a/docs/source/ja/model_doc/chinese_clip.md +++ b/docs/source/ja/model_doc/chinese_clip.md @@ -91,10 +91,6 @@ Chinese-CLIP モデルは、[OFA-Sys](https://huggingface.co/OFA-Sys) によっ [[autodoc]] ChineseCLIPImageProcessorFast - preprocess -## ChineseCLIPFeatureExtractor - -[[autodoc]] ChineseCLIPFeatureExtractor - ## ChineseCLIPProcessor [[autodoc]] ChineseCLIPProcessor @@ -114,4 +110,4 @@ Chinese-CLIP モデルは、[OFA-Sys](https://huggingface.co/OFA-Sys) によっ ## ChineseCLIPVisionModel [[autodoc]] ChineseCLIPVisionModel - - forward \ No newline at end of file + - forward diff --git a/docs/source/ja/model_doc/clip.md b/docs/source/ja/model_doc/clip.md index ac6cb606a52c..acfab70139f1 100644 --- a/docs/source/ja/model_doc/clip.md +++ b/docs/source/ja/model_doc/clip.md @@ -138,10 +138,6 @@ CLIP を使い始めるのに役立つ公式 Hugging Face およびコミュニ [[autodoc]] CLIPImageProcessorFast - preprocess -## CLIPFeatureExtractor - -[[autodoc]] CLIPFeatureExtractor - ## CLIPProcessor [[autodoc]] CLIPProcessor @@ -173,4 +169,3 @@ CLIP を使い始めるのに役立つ公式 Hugging Face およびコミュニ [[autodoc]] CLIPVisionModel - forward - diff --git a/docs/source/ja/model_doc/conditional_detr.md b/docs/source/ja/model_doc/conditional_detr.md index d0bb090630fa..5dad8dab09a9 100644 --- a/docs/source/ja/model_doc/conditional_detr.md +++ b/docs/source/ja/model_doc/conditional_detr.md @@ -53,15 +53,6 @@ alt="描画" width="600"/> - post_process_semantic_segmentation - post_process_panoptic_segmentation -## ConditionalDetrFeatureExtractor - -[[autodoc]] ConditionalDetrFeatureExtractor - - __call__ - - post_process_object_detection - - post_process_instance_segmentation - - post_process_semantic_segmentation - - post_process_panoptic_segmentation - ## ConditionalDetrModel [[autodoc]] ConditionalDetrModel @@ -76,5 +67,3 @@ alt="描画" width="600"/> [[autodoc]] ConditionalDetrForSegmentation - forward - - \ No newline at end of file diff --git a/docs/source/ja/model_doc/convnext.md b/docs/source/ja/model_doc/convnext.md index 46672f38cbf9..93c9edb4b2b3 100644 --- a/docs/source/ja/model_doc/convnext.md +++ b/docs/source/ja/model_doc/convnext.md @@ -55,10 +55,6 @@ ConvNeXT の使用を開始するのに役立つ公式 Hugging Face およびコ [[autodoc]] ConvNextConfig -## ConvNextFeatureExtractor - -[[autodoc]] ConvNextFeatureExtractor - ## ConvNextImageProcessor [[autodoc]] ConvNextImageProcessor @@ -79,4 +75,3 @@ ConvNeXT の使用を開始するのに役立つ公式 Hugging Face およびコ [[autodoc]] ConvNextForImageClassification - forward - diff --git a/docs/source/ja/model_doc/deformable_detr.md b/docs/source/ja/model_doc/deformable_detr.md index 3264f3d960be..251acfe971d6 100644 --- a/docs/source/ja/model_doc/deformable_detr.md +++ b/docs/source/ja/model_doc/deformable_detr.md @@ -54,12 +54,6 @@ Deformable DETR の使用を開始するのに役立つ公式 Hugging Face お - preprocess - post_process_object_detection -## DeformableDetrFeatureExtractor - -[[autodoc]] DeformableDetrFeatureExtractor - - __call__ - - post_process_object_detection - ## DeformableDetrConfig [[autodoc]] DeformableDetrConfig diff --git a/docs/source/ja/model_doc/deit.md b/docs/source/ja/model_doc/deit.md index 7be69bd9972f..18ec1737f404 100644 --- a/docs/source/ja/model_doc/deit.md +++ b/docs/source/ja/model_doc/deit.md @@ -88,11 +88,6 @@ DeiT を始めるのに役立つ公式 Hugging Face およびコミュニティ [[autodoc]] DeiTConfig -## DeiTFeatureExtractor - -[[autodoc]] DeiTFeatureExtractor - - __call__ - ## DeiTImageProcessor [[autodoc]] DeiTImageProcessor @@ -123,4 +118,3 @@ DeiT を始めるのに役立つ公式 Hugging Face およびコミュニティ [[autodoc]] DeiTForImageClassificationWithTeacher - forward - diff --git a/docs/source/ja/model_doc/detr.md b/docs/source/ja/model_doc/detr.md index bef1a8fce770..d1adb5f838b1 100644 --- a/docs/source/ja/model_doc/detr.md +++ b/docs/source/ja/model_doc/detr.md @@ -193,15 +193,6 @@ DETR の使用を開始するのに役立つ公式 Hugging Face およびコミ - post_process_instance_segmentation - post_process_panoptic_segmentation -## DetrFeatureExtractor - -[[autodoc]] DetrFeatureExtractor - - __call__ - - post_process_object_detection - - post_process_semantic_segmentation - - post_process_instance_segmentation - - post_process_panoptic_segmentation - ## DETR specific outputs [[autodoc]] models.detr.modeling_detr.DetrModelOutput diff --git a/docs/source/ko/main_classes/onnx.md b/docs/source/ko/main_classes/onnx.md index 510dab9df2f9..ba8faca5f943 100644 --- a/docs/source/ko/main_classes/onnx.md +++ b/docs/source/ko/main_classes/onnx.md @@ -43,8 +43,3 @@ rendered properly in your Markdown viewer. ## ONNX 특징[[onnx-features]] 각 ONNX 설정은 다양한 유형의 토폴로지나 작업에 대해 모델을 내보낼 수 있게(exporting) 해주는 _features_ 세트와 연관되어 있습니다. - -### FeaturesManager[[transformers.onnx.FeaturesManager]] - -[[autodoc]] onnx.features.FeaturesManager - diff --git a/docs/source/ko/model_doc/clip.md b/docs/source/ko/model_doc/clip.md index b62629fa0771..4929408e6e13 100644 --- a/docs/source/ko/model_doc/clip.md +++ b/docs/source/ko/model_doc/clip.md @@ -25,7 +25,7 @@ Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gret *최신 컴퓨터 비전 시스템은 미리 정해진 고정된 객체 카테고리 집합을 예측하도록 훈련됩니다. 이러한 제한된 형태의 지도는 다른 시각적 개념을 지정하기 위해 추가적인 라벨링된 데이터가 필요하므로 그 일반성과 사용성을 제한합니다. 이미지 원시 텍스트에서 직접 학습하는 것은 훨씬 더 광범위한 지도 소스를 활용하는 아주 좋은 대안입니다. 이미지와 캡션을 맞추는 간단한 사전 학습 작업이, 인터넷에서 수집한 4억 쌍의 이미지-텍스트 데이터셋에서 SOTA 수준의 이미지 표현을 처음부터 효율적이고 확장 가능하게 학습하는 방법임을 확인할 수 있습니다. 사전 훈련 후, 자연어는 학습된 시각적 개념을 참조하거나 새로운 개념을 설명하는 데 사용되어 모델의 하위 작업으로의 제로샷 전이를 가능하게 합니다. 해당 논문에서는 OCR, 비디오 내 행동 인식, 지리적 위치 파악, 그리고 많은 종류의 세밀한 객체 분류 등 30개 이상의 다양한 기존 컴퓨터 비전 데이터셋에 대한 벤치마킹을 통해 이 접근 방식의 성능을 연구합니다. 이 모델은 대부분의 작업에 대해 의미 있게 전이되며, 종종 데이터셋별 훈련 없이도 완전 지도 학습 기준선과 경쟁력 있는 성능을 보입니다. 예를 들어, ImageNet에서 원래 ResNet-50의 정확도를 제로샷으로 일치시키는데, 이는 ResNet-50이 훈련된 128만 개의 훈련 예제를 전혀 사용할 필요가 없었습니다. 코드 및 사전 훈련된 모델 가중치는 이 https URL에서 공개합니다.* -이 모델은 [valhalla](https://huggingface.co/valhalla)에 의해 기여되었습니다. +이 모델은 [valhalla](https://huggingface.co/valhalla)에 의해 기여되었습니다. 원본 코드는 [이곳](https://github.com/openai/CLIP)에서 확인할 수 있습니다. ## 사용 팁과 예시[[usage-tips-and-example]] @@ -34,7 +34,7 @@ CLIP은 멀티모달 비전 밒 언어 모델입니다. 이미지-텍스트 유 트랜스포머 인코더에 이미지를 입력하기 위해, 각 이미지는 고정 크기의 겹치지 않는 패치들의 시퀀스로 분할되고, 이후 선형 임베딩됩니다. [CLS]토큰이 전체 이미지의 표현으로 추가됩니다. 저자들은 또한 절대 위치 임베딩을 추가하고, 결과로 나온 벡터 시퀀스를 표준 트랜스포머 인토더에 입력합니다. [`CLIPImageProcessor`]는 모델을 위해 이미지를 리사이즈(또는 재스캐일링)하고 정규화하는데 사용될 수 있습니다. -[`CLIPTokenizer`]는 텍스트를 인코딩하는데 사용됩니다. [`CLIPProcessor`]는 [`CLIPImageProcessor`]와 [`CLIPTokenizer`]를 하나의 인스턴스로 감싸서 텍스트를 인코딩하고 이미지를 준비하는데 모두 사용됩니다. +[`CLIPTokenizer`]는 텍스트를 인코딩하는데 사용됩니다. [`CLIPProcessor`]는 [`CLIPImageProcessor`]와 [`CLIPTokenizer`]를 하나의 인스턴스로 감싸서 텍스트를 인코딩하고 이미지를 준비하는데 모두 사용됩니다. 다음 예시는 [`CLIPProcessor`]와 [`CLIPModel`]을 사용하여 이미지-텍스트 유사도 점수를 얻는 방법을 보여줍니다. @@ -175,9 +175,9 @@ model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32", dtype=torch.fl CLIP을 시작하는 데 도움이 되는 Hugging Face와 community 자료 목록(🌎로 표시됨) 입니다. -- [원격 센싱 (인공위성) 이미지와 캡션을 가지고 CLIP 미세조정하기](https://huggingface.co/blog/fine-tune-clip-rsicd): +- [원격 센싱 (인공위성) 이미지와 캡션을 가지고 CLIP 미세조정하기](https://huggingface.co/blog/fine-tune-clip-rsicd): [RSICD dataset](https://github.com/201528014227051/RSICD_optimal)을 가지고 CLIP을 미세조정 하는 방법과 데이터 증강에 대한 성능 비교에 대한 블로그 포스트 -- 이 [예시 스크립트](https://github.com/huggingface/transformers/tree/main/examples/pytorch/contrastive-image-text)는 [COCO dataset](https://cocodataset.org/#home)를 이용한 사전학습된 비전과 텍스트와 인코더를 사용해서 CLIP같은 비전-텍스트 듀얼 모델을 어떻게 학습시키는지 보여줍니다. +- 이 [예시 스크립트](https://github.com/huggingface/transformers/tree/main/examples/pytorch/contrastive-image-text)는 [COCO dataset](https://cocodataset.org/#home)를 이용한 사전학습된 비전과 텍스트와 인코더를 사용해서 CLIP같은 비전-텍스트 듀얼 모델을 어떻게 학습시키는지 보여줍니다. @@ -187,7 +187,7 @@ CLIP을 시작하는 데 도움이 되는 Hugging Face와 community 자료 목 - 사전학습된 CLIP모델과 MRR(Mean Reciprocal Rank) 점수 연산을 사용한 이미지 검색에 대한 [노트북](https://colab.research.google.com/drive/1bLVwVKpAndpEDHqjzxVPr_9nGrSbuOQd?usp=sharing). 🌎 - 이미지 검색과 유사성 점수에 대해 보여주는 [노트북](https://colab.research.google.com/github/deep-diver/image_search_with_natural_language/blob/main/notebooks/Image_Search_CLIP.ipynb). 🌎 -- Multilingual CLIP를 사용해서 이미지와 텍스트를 어떻게 같은 벡터 공간에 매핑 시키는지에 대한 [노트북](https://colab.research.google.com/drive/1xO-wC_m_GNzgjIBQ4a4znvQkvDoZJvH4?usp=sharing). 🌎 +- Multilingual CLIP를 사용해서 이미지와 텍스트를 어떻게 같은 벡터 공간에 매핑 시키는지에 대한 [노트북](https://colab.research.google.com/drive/1xO-wC_m_GNzgjIBQ4a4znvQkvDoZJvH4?usp=sharing). 🌎 - [Unsplash](https://unsplash.com)와 [TMDB](https://www.themoviedb.org/) 데이터셋을 활용한 의미론적(semantic) 이미지 검색에서 CLIP을 구동하는 방법에 대한 [노트북](https://colab.research.google.com/github/vivien000/clip-demo/blob/master/clip.ipynb#scrollTo=uzdFhRGqiWkR). 🌎 **설명 가능성** @@ -226,10 +226,6 @@ CLIP을 시작하는 데 도움이 되는 Hugging Face와 community 자료 목 [[autodoc]] CLIPImageProcessor - preprocess -## CLIPFeatureExtractor[[transformers.CLIPFeatureExtractor]] - -[[autodoc]] CLIPFeatureExtractor - ## CLIPProcessor[[transformers.CLIPProcessor]] [[autodoc]] CLIPProcessor @@ -266,4 +262,3 @@ CLIP을 시작하는 데 도움이 되는 Hugging Face와 community 자료 목 [[autodoc]] CLIPForImageClassification - forward - diff --git a/docs/source/ko/model_doc/vit.md b/docs/source/ko/model_doc/vit.md index 7cdb6fbd6c41..473020a33f7a 100644 --- a/docs/source/ko/model_doc/vit.md +++ b/docs/source/ko/model_doc/vit.md @@ -35,7 +35,7 @@ alt="drawing" width="600"/> - [DeiT](deit) (Data-efficient Image Transformers) (Facebook AI 개발). DeiT 모델은 distilled vision transformers입니다. DeiT의 저자들은 더 효율적으로 훈련된 ViT 모델도 공개했으며, 이는 [`ViTModel`] 또는 [`ViTForImageClassification`]에 바로 사용할 수 있습니다. 여기에는 3가지 크기로 4개의 변형이 제공됩니다: *facebook/deit-tiny-patch16-224*, *facebook/deit-small-patch16-224*, *facebook/deit-base-patch16-224* and *facebook/deit-base-patch16-384*. 그리고 모델에 이미지를 준비하려면 [`DeiTImageProcessor`]를 사용해야 한다는 점에 유의하십시오. -- [BEiT](beit) (BERT pre-training of Image Transformers) (Microsoft Research 개발). BEiT 모델은 BERT (masked image modeling)에 영감을 받고 VQ-VAE에 기반한 self-supervised 방법을 이용하여 supervised pre-trained vision transformers보다 더 우수한 성능을 보입니다. +- [BEiT](beit) (BERT pre-training of Image Transformers) (Microsoft Research 개발). BEiT 모델은 BERT (masked image modeling)에 영감을 받고 VQ-VAE에 기반한 self-supervised 방법을 이용하여 supervised pre-trained vision transformers보다 더 우수한 성능을 보입니다. - DINO (Vision Transformers의 self-supervised 훈련을 위한 방법) (Facebook AI 개발). DINO 방법으로 훈련된 Vision Transformer는 학습되지 않은 상태에서도 객체를 분할할 수 있는 합성곱 신경망에서는 볼 수 없는 매우 흥미로운 능력을 보여줍니다. DINO 체크포인트는 [hub](https://huggingface.co/models?other=dino)에서 찾을 수 있습니다. @@ -93,7 +93,7 @@ ViT의 추론 및 커스텀 데이터에 대한 미세 조정과 관련된 데 ⚗️ 최적화 -- [Optimum을 사용한 양자화를 통해 Vision Transformer(ViT) 가속](https://www.philschmid.de/optimizing-vision-transformer)에 대한 블로그 포스트 +- [Optimum을 사용한 양자화를 통해 Vision Transformer(ViT) 가속](https://www.philschmid.de/optimizing-vision-transformer)에 대한 블로그 포스트 ⚡️ 추론 @@ -109,10 +109,6 @@ ViT의 추론 및 커스텀 데이터에 대한 미세 조정과 관련된 데 [[autodoc]] ViTConfig -## ViTFeatureExtractor [[transformers.ViTFeatureExtractor]] - -[[autodoc]] ViTFeatureExtractor - - __call__ ## ViTImageProcessor [[transformers.ViTImageProcessor]] @@ -139,4 +135,3 @@ ViT의 추론 및 커스텀 데이터에 대한 미세 조정과 관련된 데 [[autodoc]] ViTForImageClassification - forward - diff --git a/docs/source/pt/_toctree.yml b/docs/source/pt/_toctree.yml index c525a2a4faa1..04a636414204 100644 --- a/docs/source/pt/_toctree.yml +++ b/docs/source/pt/_toctree.yml @@ -20,11 +20,9 @@ - local: create_a_model title: Criando uma arquitetura customizada - local: custom_models - title: Compartilhando modelos customizados + title: Compartilhando modelos customizados - local: run_scripts title: Treinamento a partir de um script - - local: serialization - title: Exportando modelos para ONNX - sections: - local: tasks/sequence_classification title: Classificação de texto diff --git a/docs/source/pt/serialization.md b/docs/source/pt/serialization.md deleted file mode 100644 index 9e390f07bde4..000000000000 --- a/docs/source/pt/serialization.md +++ /dev/null @@ -1,502 +0,0 @@ - - -# Exportando modelos para ONNX - -Se você precisar implantar modelos 🤗 Transformers em ambientes de produção, recomendamos -exporta-los para um formato serializado que pode ser carregado e executado em -tempos de execução e hardware. Neste guia, mostraremos como exportar modelos 🤗 Transformers -para [ONNX (Open Neural Network eXchange)](http://onnx.ai). - - - -Uma vez exportado, um modelo pode ser otimizado para inferência por meio de técnicas como -quantização e poda. Se você estiver interessado em otimizar seus modelos para serem executados com -máxima eficiência, confira a biblioteca [🤗 Optimum -](https://github.com/huggingface/optimum). - - - -ONNX é um padrão aberto que define um conjunto comum de operadores e um formato de arquivo comum -para representar modelos de aprendizado profundo em uma ampla variedade de estruturas, incluindo PyTorch e -TensorFlow. Quando um modelo é exportado para o formato ONNX, esses operadores são usados para -construir um grafo computacional (muitas vezes chamado de _representação intermediária_) que -representa o fluxo de dados através da rede neural. - -Ao expor um grafo com operadores e tipos de dados padronizados, o ONNX facilita a -alternar entre os frameworks. Por exemplo, um modelo treinado em PyTorch pode ser exportado para -formato ONNX e depois importado no TensorFlow (e vice-versa). - -🤗 Transformers fornece um pacote [`transformers.onnx`](main_classes/onnx) que permite -que você converta os checkpoints do modelo em um grafo ONNX aproveitando os objetos de configuração. -Esses objetos de configuração vêm prontos para várias arquiteturas de modelo e são -projetado para ser facilmente extensível a outras arquiteturas. - -As configurações prontas incluem as seguintes arquiteturas: - - - -- ALBERT -- BART -- BEiT -- BERT -- BigBird -- BigBird-Pegasus -- Blenderbot -- BlenderbotSmall -- BLOOM -- CamemBERT -- CLIP -- CodeGen -- Conditional DETR -- ConvBERT -- ConvNeXT -- ConvNeXTV2 -- Data2VecText -- Data2VecVision -- DeBERTa -- DeBERTa-v2 -- DeiT -- DETR -- DistilBERT -- ELECTRA -- ERNIE -- FlauBERT -- GPT Neo -- GPT-J -- GroupViT -- I-BERT -- LayoutLM -- LayoutLMv3 -- LeViT -- Longformer -- LongT5 -- M2M100 -- Marian -- mBART -- MobileBERT -- MobileViT -- MT5 -- OpenAI GPT-2 -- OWL-ViT -- Perceiver -- PLBart -- ResNet -- RoBERTa -- RoFormer -- SegFormer -- SqueezeBERT -- Swin Transformer -- T5 -- Table Transformer -- Vision Encoder decoder -- ViT -- XLM -- XLM-RoBERTa -- XLM-RoBERTa-XL -- YOLOS - -Nas próximas duas seções, mostraremos como: - -* Exportar um modelo suportado usando o pacote `transformers.onnx`. -* Exportar um modelo personalizado para uma arquitetura sem suporte. - -## Exportando um modelo para ONNX - -Para exportar um modelo 🤗 Transformers para o ONNX, primeiro você precisa instalar algumas -dependências extras: - -```bash -pip install transformers[onnx] -``` - -O pacote `transformers.onnx` pode então ser usado como um módulo Python: - -```bash -python -m transformers.onnx --help - -usage: Hugging Face Transformers ONNX exporter [-h] -m MODEL [--feature {causal-lm, ...}] [--opset OPSET] [--atol ATOL] output - -positional arguments: - output Path indicating where to store generated ONNX model. - -optional arguments: - -h, --help show this help message and exit - -m MODEL, --model MODEL - Model ID on huggingface.co or path on disk to load model from. - --feature {causal-lm, ...} - The type of features to export the model with. - --opset OPSET ONNX opset version to export the model with. - --atol ATOL Absolute difference tolerance when validating the model. -``` - -A exportação de um checkpoint usando uma configuração pronta pode ser feita da seguinte forma: - -```bash -python -m transformers.onnx --model=distilbert/distilbert-base-uncased onnx/ -``` - -Você deve ver os seguintes logs: - -```bash -Validating ONNX model... - -[✓] ONNX model output names match reference model ({'last_hidden_state'}) - - Validating ONNX Model output "last_hidden_state": - -[✓] (2, 8, 768) matches (2, 8, 768) - -[✓] all values close (atol: 1e-05) -All good, model saved at: onnx/model.onnx -``` - -Isso exporta um grafo ONNX do ponto de verificação definido pelo argumento `--model`. Nisso -Por exemplo, é `distilbert/distilbert-base-uncased`, mas pode ser qualquer checkpoint no Hugging -Face Hub ou um armazenado localmente. - -O arquivo `model.onnx` resultante pode ser executado em um dos [muitos -aceleradores](https://onnx.ai/supported-tools.html#deployModel) que suportam o ONNX -padrão. Por exemplo, podemos carregar e executar o modelo com [ONNX -Tempo de execução](https://onnxruntime.ai/) da seguinte forma: - -```python ->>> from transformers import AutoTokenizer ->>> from onnxruntime import InferenceSession - ->>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased") ->>> session = InferenceSession("onnx/model.onnx") ->>> # ONNX Runtime expects NumPy arrays as input ->>> inputs = tokenizer("Using DistilBERT with ONNX Runtime!", return_tensors="np") ->>> outputs = session.run(output_names=["last_hidden_state"], input_feed=dict(inputs)) -``` - -Os nomes de saída necessários (como `["last_hidden_state"]`) podem ser obtidos pegando uma - configuração ONNX de cada modelo. Por exemplo, para DistilBERT temos: - -```python ->>> from transformers.models.distilbert import DistilBertConfig, DistilBertOnnxConfig - ->>> config = DistilBertConfig() ->>> onnx_config = DistilBertOnnxConfig(config) ->>> print(list(onnx_config.outputs.keys())) -["last_hidden_state"] -``` - -O processo é idêntico para os checkpoints do TensorFlow no Hub. Por exemplo, podemos -exportar um checkpoint TensorFlow puro do [Keras -](https://huggingface.co/keras-io) da seguinte forma: - -```bash -python -m transformers.onnx --model=keras-io/transformers-qa onnx/ -``` - -Para exportar um modelo armazenado localmente, você precisará ter os pesos e -arquivos tokenizer armazenados em um diretório. Por exemplo, podemos carregar e salvar um checkpoint como: - -```python ->>> from transformers import AutoTokenizer, AutoModelForSequenceClassification - ->>> # Load tokenizer and PyTorch weights form the Hub ->>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased") ->>> pt_model = AutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased") ->>> # Save to disk ->>> tokenizer.save_pretrained("local-pt-checkpoint") ->>> pt_model.save_pretrained("local-pt-checkpoint") -``` - -Uma vez que o checkpoint é salvo, podemos exportá-lo para o ONNX apontando o `--model` -argumento do pacote `transformers.onnx` para o diretório desejado: - -```bash -python -m transformers.onnx --model=local-pt-checkpoint onnx/ -``` - -```python ->>> from transformers import AutoTokenizer, TFAutoModelForSequenceClassification - ->>> # Load tokenizer and TensorFlow weights from the Hub ->>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased") ->>> tf_model = TFAutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased") ->>> # Save to disk ->>> tokenizer.save_pretrained("local-tf-checkpoint") ->>> tf_model.save_pretrained("local-tf-checkpoint") -``` - -Uma vez que o checkpoint é salvo, podemos exportá-lo para o ONNX apontando o `--model` -argumento do pacote `transformers.onnx` para o diretório desejado: - -```bash -python -m transformers.onnx --model=local-tf-checkpoint onnx/ -``` - -## Selecionando features para diferentes tarefas do modelo - -Cada configuração pronta vem com um conjunto de _features_ que permitem exportar -modelos para diferentes tipos de tarefas. Conforme mostrado na tabela abaixo, cada recurso é -associado a uma `AutoClass` diferente: - -| Feature | Auto Class | -| ------------------------------------ | ------------------------------------ | -| `causal-lm`, `causal-lm-with-past` | `AutoModelForCausalLM` | -| `default`, `default-with-past` | `AutoModel` | -| `masked-lm` | `AutoModelForMaskedLM` | -| `question-answering` | `AutoModelForQuestionAnswering` | -| `seq2seq-lm`, `seq2seq-lm-with-past` | `AutoModelForSeq2SeqLM` | -| `sequence-classification` | `AutoModelForSequenceClassification` | -| `token-classification` | `AutoModelForTokenClassification` | - -Para cada configuração, você pode encontrar a lista de recursos suportados por meio do -[`~transformers.onnx.FeaturesManager`]. Por exemplo, para DistilBERT temos: - -```python ->>> from transformers.onnx.features import FeaturesManager - ->>> distilbert_features = list(FeaturesManager.get_supported_features_for_model_type("distilbert").keys()) ->>> print(distilbert_features) -["default", "masked-lm", "causal-lm", "sequence-classification", "token-classification", "question-answering"] -``` - -Você pode então passar um desses recursos para o argumento `--feature` no -pacote `transformers.onnx`. Por exemplo, para exportar um modelo de classificação de texto, podemos -escolher um modelo ajustado no Hub e executar: - -```bash -python -m transformers.onnx --model=distilbert/distilbert-base-uncased-finetuned-sst-2-english \ - --feature=sequence-classification onnx/ -``` - -Isso exibe os seguintes logs: - -```bash -Validating ONNX model... - -[✓] ONNX model output names match reference model ({'logits'}) - - Validating ONNX Model output "logits": - -[✓] (2, 2) matches (2, 2) - -[✓] all values close (atol: 1e-05) -All good, model saved at: onnx/model.onnx -``` - -Observe que, neste caso, os nomes de saída do modelo ajustado são `logits` -em vez do `last_hidden_state` que vimos com o checkpoint `distilbert/distilbert-base-uncased` -mais cedo. Isso é esperado, pois o modelo ajustado (fine-tuned) possui uma cabeça de classificação de sequência. - - - -Os recursos que têm um sufixo `with-pass` (como `causal-lm-with-pass`) correspondem a -classes de modelo com estados ocultos pré-computados (chave e valores nos blocos de atenção) -que pode ser usado para decodificação autorregressiva rápida. - - - - - -Para modelos do tipo `VisionEncoderDecoder`, as partes do codificador e do decodificador são -exportados separadamente como dois arquivos ONNX chamados `encoder_model.onnx` e `decoder_model.onnx` respectivamente. - - - -## Exportando um modelo para uma arquitetura sem suporte - -Se você deseja exportar um modelo cuja arquitetura não é suportada nativamente pela -biblioteca, há três etapas principais a seguir: - -1. Implemente uma configuração ONNX personalizada. -2. Exporte o modelo para o ONNX. -3. Valide as saídas do PyTorch e dos modelos exportados. - -Nesta seção, veremos como o DistilBERT foi implementado para mostrar o que está envolvido -em cada passo. - -### Implementando uma configuração ONNX personalizada - -Vamos começar com o objeto de configuração ONNX. Fornecemos três classes abstratas que -você deve herdar, dependendo do tipo de arquitetura de modelo que deseja exportar: - -* Modelos baseados em codificador herdam de [`~onnx.config.OnnxConfig`] -* Modelos baseados em decodificador herdam de [`~onnx.config.OnnxConfigWithPast`] -* Os modelos codificador-decodificador herdam de [`~onnx.config.OnnxSeq2SeqConfigWithPast`] - - - -Uma boa maneira de implementar uma configuração ONNX personalizada é observar as -implementação no arquivo `configuration_.py` de uma arquitetura semelhante. - - - -Como o DistilBERT é um modelo baseado em codificador, sua configuração é herdada de -`OnnxConfig`: - -```python ->>> from typing import Mapping, OrderedDict ->>> from transformers.onnx import OnnxConfig - - ->>> class DistilBertOnnxConfig(OnnxConfig): -... @property -... def inputs(self) -> Mapping[str, Mapping[int, str]]: -... return OrderedDict( -... [ -... ("input_ids", {0: "batch", 1: "sequence"}), -... ("attention_mask", {0: "batch", 1: "sequence"}), -... ] -... ) -``` - -Todo objeto de configuração deve implementar a propriedade `inputs` e retornar um mapeamento, -onde cada chave corresponde a uma entrada esperada e cada valor indica o eixo -dessa entrada. Para o DistilBERT, podemos ver que duas entradas são necessárias: `input_ids` e -`attention_mask`. Essas entradas têm a mesma forma de `(batch_size, sequence_length)` -é por isso que vemos os mesmos eixos usados na configuração. - - - -Notice that `inputs` property for `DistilBertOnnxConfig` returns an `OrderedDict`. This -ensures that the inputs are matched with their relative position within the -`PreTrainedModel.forward()` method when tracing the graph. We recommend using an -`OrderedDict` for the `inputs` and `outputs` properties when implementing custom ONNX -configurations. - -Observe que a propriedade `inputs` para `DistilBertOnnxConfig` retorna um `OrderedDict`. Este -garante que as entradas sejam combinadas com sua posição relativa dentro do -método `PreTrainedModel.forward()` ao traçar o grafo. Recomendamos o uso de um -`OrderedDict` para as propriedades `inputs` e `outputs` ao implementar configurações personalizadas ONNX. - - - -Depois de implementar uma configuração ONNX, você pode instanciá-la fornecendo a -configuração do modelo base da seguinte forma: - -```python ->>> from transformers import AutoConfig - ->>> config = AutoConfig.from_pretrained("distilbert/distilbert-base-uncased") ->>> onnx_config = DistilBertOnnxConfig(config) -``` - -O objeto resultante tem várias propriedades úteis. Por exemplo, você pode visualizar o conjunto de operadores ONNX - que será usado durante a exportação: - -```python ->>> print(onnx_config.default_onnx_opset) -11 -``` - -Você também pode visualizar as saídas associadas ao modelo da seguinte forma: - -```python ->>> print(onnx_config.outputs) -OrderedDict([("last_hidden_state", {0: "batch", 1: "sequence"})]) -``` - -Observe que a propriedade outputs segue a mesma estrutura das entradas; ele retorna um -`OrderedDict` de saídas nomeadas e suas formas. A estrutura de saída está ligada a -escolha do recurso com o qual a configuração é inicializada. Por padrão, a configuração do ONNX -é inicializada com o recurso `default` que corresponde à exportação de um -modelo carregado com a classe `AutoModel`. Se você deseja exportar um modelo para outra tarefa, -apenas forneça um recurso diferente para o argumento `task` quando você inicializar a configuração ONNX -. Por exemplo, se quisermos exportar o DistilBERT com uma sequência -de classificação, poderíamos usar: - -```python ->>> from transformers import AutoConfig - ->>> config = AutoConfig.from_pretrained("distilbert/distilbert-base-uncased") ->>> onnx_config_for_seq_clf = DistilBertOnnxConfig(config, task="sequence-classification") ->>> print(onnx_config_for_seq_clf.outputs) -OrderedDict([('logits', {0: 'batch'})]) -``` - - - -Todas as propriedades e métodos básicos associados a [`~onnx.config.OnnxConfig`] e -as outras classes de configuração podem ser substituídas se necessário. Confira [`BartOnnxConfig`] -para um exemplo avançado. - - - -### Exportando um modelo - -Depois de ter implementado a configuração do ONNX, o próximo passo é exportar o modelo. -Aqui podemos usar a função `export()` fornecida pelo pacote `transformers.onnx`. -Esta função espera a configuração do ONNX, juntamente com o modelo base e o tokenizer, -e o caminho para salvar o arquivo exportado: - -```python ->>> from pathlib import Path ->>> from transformers.onnx import export ->>> from transformers import AutoTokenizer, AutoModel - ->>> onnx_path = Path("model.onnx") ->>> model_ckpt = "distilbert/distilbert-base-uncased" ->>> base_model = AutoModel.from_pretrained(model_ckpt) ->>> tokenizer = AutoTokenizer.from_pretrained(model_ckpt) - ->>> onnx_inputs, onnx_outputs = export(tokenizer, base_model, onnx_config, onnx_config.default_onnx_opset, onnx_path) -``` - -Os `onnx_inputs` e `onnx_outputs` retornados pela função `export()` são listas de - chaves definidas nas propriedades `inputs` e `outputs` da configuração. Uma vez que o -modelo é exportado, você pode testar se o modelo está bem formado da seguinte forma: - -```python ->>> import onnx - ->>> onnx_model = onnx.load("model.onnx") ->>> onnx.checker.check_model(onnx_model) -``` - - - -Se o seu modelo for maior que 2GB, você verá que muitos arquivos adicionais são criados -durante a exportação. Isso é _esperado_ porque o ONNX usa [Protocol -Buffers](https://developers.google.com/protocol-buffers/) para armazenar o modelo e estes -têm um limite de tamanho de 2GB. Veja a [ONNX -documentação](https://github.com/onnx/onnx/blob/master/docs/ExternalData.md) para -instruções sobre como carregar modelos com dados externos. - - - -### Validando a saída dos modelos - -A etapa final é validar se as saídas do modelo base e exportado concordam -dentro de alguma tolerância absoluta. Aqui podemos usar a função `validate_model_outputs()` -fornecida pelo pacote `transformers.onnx` da seguinte forma: - -```python ->>> from transformers.onnx import validate_model_outputs - ->>> validate_model_outputs( -... onnx_config, tokenizer, base_model, onnx_path, onnx_outputs, onnx_config.atol_for_validation -... ) -``` - -Esta função usa o método [`~transformers.onnx.OnnxConfig.generate_dummy_inputs`] para -gerar entradas para o modelo base e o exportado, e a tolerância absoluta pode ser -definida na configuração. Geralmente encontramos concordância numérica em 1e-6 a 1e-4 -de alcance, embora qualquer coisa menor que 1e-3 provavelmente esteja OK. - -## Contribuindo com uma nova configuração para 🤗 Transformers - -Estamos procurando expandir o conjunto de configurações prontas e receber contribuições -da comunidade! Se você gostaria de contribuir para a biblioteca, você -precisará: - -* Implemente a configuração do ONNX no arquivo `configuration_.py` correspondente -Arquivo -* Incluir a arquitetura do modelo e recursos correspondentes em - [`~onnx.features.FeatureManager`] -* Adicione sua arquitetura de modelo aos testes em `test_onnx_v2.py` - -Confira como ficou a configuração do [IBERT -](https://github.com/huggingface/transformers/pull/14868/files) para obter uma -idéia do que está envolvido. diff --git a/docs/source/zh/main_classes/onnx.md b/docs/source/zh/main_classes/onnx.md index d35dd1c4bf8e..ef4cee5f9b48 100644 --- a/docs/source/zh/main_classes/onnx.md +++ b/docs/source/zh/main_classes/onnx.md @@ -43,8 +43,3 @@ rendered properly in your Markdown viewer. ## ONNX Features 每个ONNX配置与一组 _特性_ 相关联，使您能够为不同类型的拓扑结构或任务导出模型。 - -### FeaturesManager - -[[autodoc]] onnx.features.FeaturesManager -