diff --git a/docs/source_es/quicktour.mdx b/docs/source_es/quicktour.mdx index 38b624f84d01..8b400867099e 100644 --- a/docs/source_es/quicktour.mdx +++ b/docs/source_es/quicktour.mdx @@ -62,11 +62,18 @@ En el siguiente ejemplo, usarás el [`pipeline`] para análisis de sentimiento. Instala las siguientes dependencias si aún no lo has hecho: + + ```bash pip install torch -===PT-TF-SPLIT=== +``` + + +```bash pip install tensorflow ``` + + Importa [`pipeline`] y especifica la tarea que deseas completar: @@ -96,7 +103,7 @@ label: NEGATIVE, with score: 0.5309 El [`pipeline`] también puede iterar sobre un dataset entero. Comienza instalando la biblioteca [🤗 Datasets](https://huggingface.co/docs/datasets/): ```bash -pip install datasets +pip install datasets ``` Crea un [`pipeline`] con la tarea que deseas resolver y el modelo que quieres usar. Coloca el parámetro `device` a `0` para poner los tensores en un dispositivo CUDA: @@ -137,6 +144,8 @@ El [`pipeline`] puede adaptarse a cualquier modelo del [Model Hub](https://huggi >>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment" ``` + + Usa [`AutoModelForSequenceClassification`] y ['AutoTokenizer'] para cargar un modelo preentrenado y un tokenizador asociado (más en un `AutoClass` debajo): ```py @@ -144,13 +153,23 @@ Usa [`AutoModelForSequenceClassification`] y ['AutoTokenizer'] para cargar un mo >>> model = AutoModelForSequenceClassification.from_pretrained(model_name) >>> tokenizer = AutoTokenizer.from_pretrained(model_name) ->>> # ===PT-TF-SPLIT=== +``` + + + + +Usa [`TFAutoModelForSequenceClassification`] y ['AutoTokenizer'] para cargar un modelo preentrenado y un tokenizador asociado (más en un `TFAutoClass` debajo): + +```py >>> from transformers import AutoTokenizer, TFAutoModelForSequenceClassification >>> model = TFAutoModelForSequenceClassification.from_pretrained(model_name) >>> tokenizer = AutoTokenizer.from_pretrained(model_name) ``` + + + Después puedes especificar el modelo y el tokenizador en el [`pipeline`], y aplicar el `classifier` en tu texto objetivo: ```py @@ -165,7 +184,7 @@ Si no pudieras encontrar el modelo para tu caso respectivo de uso necesitarás a -Debajo del capó, las clases [`AutoModelForSequenceClassification`] y [`AutoTokenizer`] trabajan juntas para dar poder al [`pipeline`]. Una [AutoClass](./model_doc/auto) es un atajo que automáticamente recupera la arquitectura de un modelo preentrenado con su nombre o el path. Sólo necesitarás seleccionar el `AutoClass` apropiado para tu tarea y tu tokenizador asociado con [`AutoTokenizer`]. +Debajo del capó, las clases [`AutoModelForSequenceClassification`] y [`AutoTokenizer`] trabajan juntas para dar poder al [`pipeline`]. Una [AutoClass](./model_doc/auto) es un atajo que automáticamente recupera la arquitectura de un modelo preentrenado con su nombre o el path. Sólo necesitarás seleccionar el `AutoClass` apropiado para tu tarea y tu tokenizador asociado con [`AutoTokenizer`]. Regresemos a nuestro ejemplo y veamos cómo puedes usar el `AutoClass` para reproducir los resultados del [`pipeline`]. @@ -201,6 +220,8 @@ El tokenizador devolverá un diccionario conteniendo: Como con el [`pipeline`], el tokenizador aceptará una lista de inputs. Además, el tokenizador también puede rellenar (pad, en inglés) y truncar el texto para devolver un lote (batch, en inglés) de longitud uniforme: + + ```py >>> pt_batch = tokenizer( ... ["We are very happy to show you the 🤗 Transformers library.", "We hope you don't hate it."], @@ -209,7 +230,10 @@ Como con el [`pipeline`], el tokenizador aceptará una lista de inputs. Además, ... max_length=512, ... return_tensors="pt", ... ) ->>> # ===PT-TF-SPLIT=== +``` + + +```py >>> tf_batch = tokenizer( ... ["We are very happy to show you the 🤗 Transformers library.", "We hope you don't hate it."], ... padding=True, @@ -218,23 +242,22 @@ Como con el [`pipeline`], el tokenizador aceptará una lista de inputs. Además, ... return_tensors="tf", ... ) ``` + + Lee el tutorial de [preprocessing](./preprocessing) para más detalles acerca de la tokenización. ### AutoModel -🤗 Transformers provee una forma simple y unificada de cargar tus instancias preentrenadas. Esto significa que puedes cargar un [`AutoModel`] como cargarías un [`AutoTokenizer`]. La única diferencia es seleccionar el [`AutoModel`] correcto para la tarea. Ya que estás clasificando texto, o secuencias, carga [`AutoModelForSequenceClassification`]. El equivalente en TensorFlow es simplemente [`TFAutoModelForSequenceClassification`]: + + +🤗 Transformers provee una forma simple y unificada de cargar tus instancias preentrenadas. Esto significa que puedes cargar un [`AutoModel`] como cargarías un [`AutoTokenizer`]. La única diferencia es seleccionar el [`AutoModel`] correcto para la tarea. Ya que estás clasificando texto, o secuencias, carga [`AutoModelForSequenceClassification`]: ```py >>> from transformers import AutoModelForSequenceClassification >>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment" >>> pt_model = AutoModelForSequenceClassification.from_pretrained(model_name) ->>> # ===PT-TF-SPLIT=== ->>> from transformers import TFAutoModelForSequenceClassification - ->>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment" ->>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(model_name) ``` @@ -243,12 +266,10 @@ Ve el [task summary](./task_summary) para revisar qué clase del [`AutoModel`] d -Ahora puedes pasar tu lote (batch) preprocesado de inputs directamente al modelo. Si estás utilizando un modelo de PyTorch, desempaca el diccionario añadiendo `**`. Para modelos de TensorFlow, pasa las llaves de los diccionarios directamente a los tensores: +Ahora puedes pasar tu lote (batch) preprocesado de inputs directamente al modelo. Solo tienes que desempacar el diccionario añadiendo `**`: ```py >>> pt_outputs = pt_model(**pt_batch) ->>> # ===PT-TF-SPLIT=== ->>> tf_outputs = tf_model(tf_batch) ``` El modelo producirá las activaciones finales en el atributo `logits`. Aplica la función softmax a `logits` para obtener las probabilidades: @@ -260,16 +281,42 @@ El modelo producirá las activaciones finales en el atributo `logits`. Aplica la >>> print(pt_predictions) tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725], [0.2084, 0.1826, 0.1969, 0.1755, 0.2365]], grad_fn=) +``` + + +🤗 Transformers provee una forma simple y unificada de cargar tus instancias preentrenadas. Esto significa que puedes cargar un [`TFAutoModel`] como cargarías un [`AutoTokenizer`]. La única diferencia es seleccionar el [`TFAutoModel`] correcto para la tarea. Ya que estás clasificando texto, o secuencias, carga [`TFAutoModelForSequenceClassification`]: + +```py +>>> from transformers import TFAutoModelForSequenceClassification ->>> # ===PT-TF-SPLIT=== +>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment" +>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(model_name) +``` + + + Ve el [task summary](./task_summary) para revisar qué clase del [`AutoModel`] + deberías usar para cada tarea. + + +Ahora puedes pasar tu lote preprocesado de inputs directamente al modelo pasando las llaves del diccionario directamente a los tensores: + +```py +>>> tf_outputs = tf_model(tf_batch) +``` + +El modelo producirá las activaciones finales en el atributo `logits`. Aplica la función softmax a `logits` para obtener las probabilidades: + +```py >>> import tensorflow as tf >>> tf_predictions = tf.nn.softmax(tf_outputs.logits, axis=-1) ->>> print(tf_predictions) +>>> print(tf.math.round(tf_predictions * 10**4) / 10**4) tf.Tensor( -[[0.00206 0.00177 0.01155 0.21209 0.77253] - [0.20842 0.18262 0.19693 0.1755 0.23652]], shape=(2, 5), dtype=float32) +[[0.0021 0.0018 0.0116 0.2121 0.7725] + [0.2084 0.1826 0.1969 0.1755 0.2365]], shape=(2, 5), dtype=float32) ``` + + @@ -289,36 +336,58 @@ Los outputs del modelo también se comportan como tuplas o diccionarios (e.g., p ### Guarda un modelo + + Una vez que tu modelo esté fine-tuned puedes guardarlo con tu tokenizador usando [`PreTrainedModel.save_pretrained`]: ```py >>> pt_save_directory = "./pt_save_pretrained" >>> tokenizer.save_pretrained(pt_save_directory) # doctest: +IGNORE_RESULT >>> pt_model.save_pretrained(pt_save_directory) ->>> # ===PT-TF-SPLIT=== +``` + +Cuando quieras usar el modelo otra vez cárgalo con [`PreTrainedModel.from_pretrained`]: + +```py +>>> pt_model = AutoModelForSequenceClassification.from_pretrained("./pt_save_pretrained") +``` + + + + +Una vez que tu modelo esté fine-tuned puedes guardarlo con tu tokenizador usando [`TFPreTrainedModel.save_pretrained`]: + +```py >>> tf_save_directory = "./tf_save_pretrained" >>> tokenizer.save_pretrained(tf_save_directory) # doctest: +IGNORE_RESULT >>> tf_model.save_pretrained(tf_save_directory) ``` -Cuando quieras usar el modelo otra vez cárgalo con [`PreTrainedModel.from_pretrained`]: +Cuando quieras usar el modelo otra vez cárgalo con [`TFPreTrainedModel.from_pretrained`]: ```py ->>> pt_model = AutoModelForSequenceClassification.from_pretrained("./pt_save_pretrained") ->>> # ===PT-TF-SPLIT=== >>> tf_model = TFAutoModelForSequenceClassification.from_pretrained("./tf_save_pretrained") ``` + + Una característica particularmente cool de 🤗 Transformers es la habilidad de guardar el modelo y cargarlo como un modelo de PyTorch o TensorFlow. El parámetro `from_pt` o `from_tf` puede convertir el modelo de un framework al otro: + + ```py >>> from transformers import AutoModel >>> tokenizer = AutoTokenizer.from_pretrained(tf_save_directory) >>> pt_model = AutoModelForSequenceClassification.from_pretrained(tf_save_directory, from_tf=True) ->>> # ===PT-TF-SPLIT=== +``` + + +```py >>> from transformers import TFAutoModel >>> tokenizer = AutoTokenizer.from_pretrained(pt_save_directory) >>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(pt_save_directory, from_pt=True) ``` + +