Framework split for Spanish version of doc quicktour.mdx

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:
 
+<frameworkcontent>
+<pt>
 ```bash
 pip install torch
-===PT-TF-SPLIT===
+```
+</pt>
+<tf>
+```bash
 pip install tensorflow
 ```
+</tf>
+</frameworkcontent>
 
 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,20 +144,32 @@ El [`pipeline`] puede adaptarse a cualquier modelo del [Model Hub](https://huggi
 >>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
 ```
 
+<frameworkcontent>
+<pt>
 Usa [`AutoModelForSequenceClassification`] y ['AutoTokenizer'] para cargar un modelo preentrenado y un tokenizador asociado (más en un `AutoClass` debajo):
 
 ```py
 >>> from transformers import AutoTokenizer, AutoModelForSequenceClassification
 
 >>> model = AutoModelForSequenceClassification.from_pretrained(model_name)
 >>> tokenizer = AutoTokenizer.from_pretrained(model_name)
->>> # ===PT-TF-SPLIT===
+```
+
+</pt>
+
+<tf>
+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)
 ```
 
+</tf>
+</frameworkcontent>
+
 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
 
 <Youtube id="AhChOFRegn4"/>
 
-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:
 
+<frameworkcontent>
+<pt>
 ```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===
+```
+</pt>
+<tf>
+```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",
 ... )
 ```
+</tf>
+</frameworkcontent>
 
 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`]:
+<frameworkcontent>
+<pt>
+🤗 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)
 ```
 
 <Tip>
@@ -243,12 +266,10 @@ Ve el [task summary](./task_summary) para revisar qué clase del [`AutoModel`] d
 
 </Tip>
 
-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=<SoftmaxBackward0>)
+```
+</pt>
+<tf>
+🤗 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)
+```
+
+<Tip>
+  Ve el [task summary](./task_summary) para revisar qué clase del [`AutoModel`]
+  deberías usar para cada tarea.
+</Tip>
+
+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)
 ```
+</tf>
+</frameworkcontent>
 
 <Tip>
 
@@ -289,36 +336,58 @@ Los outputs del modelo también se comportan como tuplas o diccionarios (e.g., p
 
 ### Guarda un modelo
 
+<frameworkcontent>
+<pt>
 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")
+```
+
+</pt>
+
+<tf>
+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")
 ```
+</tf>
+</frameworkcontent>
 
 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:
 
+<frameworkcontent>
+<pt>
 ```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===
+```
+</pt>
+<tf>
+```py
 >>> from transformers import TFAutoModel
 
 >>> tokenizer = AutoTokenizer.from_pretrained(pt_save_directory)
 >>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(pt_save_directory, from_pt=True)
 ```
+</tf>
+</frameworkcontent>