Click here to view the next lesson.

Capítulo 4: Implementación y escalado de modelos de transformadores

4.4 Ejercicios Prácticos

Esta sección proporciona ejercicios prácticos para reforzar tu comprensión sobre el despliegue y escalamiento de modelos transformer usando ONNX, TensorFlow Lite, FastAPI y Hugging Face Spaces. Cada ejercicio incluye una solución con ejemplos detallados de código para guiar tu implementación.

Ejercicio 1: Convertir un Modelo Transformer a ONNX

Tarea: Convertir un modelo transformer de Hugging Face al formato ONNX y realizar inferencia usando ONNXRuntime.

Instrucciones:

Cargar un modelo transformer preentrenado.
Convertir el modelo a ONNX.
Usar ONNXRuntime para inferencia.

Solución:

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import onnx
import onnxruntime as ort

# Step 1: Load the model and tokenizer
model_name = "bert-base-uncased"
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Step 2: Export the model to ONNX
dummy_input = tokenizer("This is a test input.", return_tensors="pt")
torch.onnx.export(
    model,
    args=(dummy_input["input_ids"], dummy_input["attention_mask"]),
    f="bert_model.onnx",
    input_names=["input_ids", "attention_mask"],
    output_names=["output"],
    dynamic_axes={"input_ids": {0: "batch_size"}, "attention_mask": {0: "batch_size"}},
    opset_version=11
)

# Step 3: Perform inference with ONNXRuntime
onnx_session = ort.InferenceSession("bert_model.onnx")
inputs = tokenizer("This is a great day!", return_tensors="np")
onnx_outputs = onnx_session.run(None, {
    "input_ids": inputs["input_ids"],
    "attention_mask": inputs["attention_mask"]
})
print("ONNX Inference Result:", onnx_outputs[0])

Ejercicio 2: Desplegar un Modelo Transformer con TensorFlow Lite

Tarea: Convertir un modelo transformer de Hugging Face a formato TensorFlow Lite y realizar inferencia.

Instrucciones:

Cargar un modelo TensorFlow.
Convertirlo al formato TensorFlow Lite.
Usar el intérprete de TensorFlow Lite para inferencia.

Solución:

from transformers import TFAutoModelForSequenceClassification, AutoTokenizer
import tensorflow as tf

# Step 1: Load the model and tokenizer
model_name = "bert-base-uncased"
model = TFAutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Step 2: Save the model and convert it to TFLite
model.save("saved_model")
converter = tf.lite.TFLiteConverter.from_saved_model("saved_model")
tflite_model = converter.convert()
with open("bert_model.tflite", "wb") as f:
    f.write(tflite_model)

# Step 3: Perform inference with TensorFlow Lite
interpreter = tf.lite.Interpreter(model_path="bert_model.tflite")
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

inputs = tokenizer("TensorFlow Lite is efficient!", return_tensors="np")
interpreter.set_tensor(input_details[0]['index'], inputs["input_ids"].astype('int32'))
interpreter.invoke()
output_data = interpreter.get_tensor(output_details[0]['index'])
print("TFLite Inference Result:", output_data)

Ejercicio 3: Crear una API con FastAPI

Tarea: Construir una aplicación FastAPI para análisis de sentimientos usando un modelo preentrenado.

Instrucciones:

Configurar una aplicación FastAPI.
Cargar un pipeline de análisis de sentimientos de Hugging Face.
Crear un endpoint para analizar el sentimiento del texto de entrada.

Solución:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from transformers import pipeline

# Step 1: Initialize FastAPI and define input schema
class TextInput(BaseModel):
    text: str

app = FastAPI()
model_pipeline = pipeline("sentiment-analysis")

# Step 2: Define the API endpoint
@app.post("/analyze_sentiment")
def analyze_sentiment(input: TextInput):
    try:
        result = model_pipeline(input.text)
        return {"text": input.text, "sentiment": result[0]}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# Step 3: Run the server using `uvicorn`
# Command: uvicorn app:app --reload

Prueba de la API:

curl -X POST "http://127.0.0.1:8000/analyze_sentiment" \
-H "Content-Type: application/json" \
-d '{"text": "Transformers are incredible!"}'

Respuesta:

{
  "text": "Transformers are incredible!",
  "sentiment": {
    "label": "POSITIVE",
    "score": 0.9998
  }
}

Ejercicio 4: Desplegar una Aplicación Gradio en Hugging Face Spaces

Tarea: Crear y desplegar una aplicación Gradio para resumir textos.

Instrucciones:

Crear una aplicación Gradio para resumir textos.
Desplegarla en Hugging Face Spaces.

Solución:

import gradio as gr
from transformers import pipeline

# Step 1: Load the summarization pipeline
summarizer = pipeline("summarization", model="t5-small")

# Step 2: Define the Gradio function
def summarize_text(input_text):
    summary = summarizer(input_text, max_length=50, min_length=20, do_sample=False)
    return summary[0]["summary_text"]

# Step 3: Create the Gradio interface
interface = gr.Interface(
    fn=summarize_text,
    inputs="text",
    outputs="text",
    title="Text Summarizer",
    description="Provide a text and get a summarized version."
)

# Step 4: Launch the app locally
interface.launch()

Para Desplegar en Hugging Face Spaces:

Sube este código a un repositorio de GitHub.
Vincula el repositorio a un Space de Hugging Face.
Tu aplicación estará alojada en: https://huggingface.co/spaces/<your_space_name>.

Estos ejercicios proporcionaron experiencia práctica en el despliegue de modelos transformer utilizando ONNX, TensorFlow Lite, FastAPI y Hugging Face Spaces. Al completar estas tareas, has adquirido conocimientos prácticos en la optimización de modelos, creación de APIs y despliegue de aplicaciones interactivas. Experimenta más con estas herramientas para construir soluciones de PLN escalables para casos de uso del mundo real.

4.4 Ejercicios Prácticos

Ejercicio 1: Convertir un Modelo Transformer a ONNX

Tarea: Convertir un modelo transformer de Hugging Face al formato ONNX y realizar inferencia usando ONNXRuntime.

Instrucciones:

Cargar un modelo transformer preentrenado.
Convertir el modelo a ONNX.
Usar ONNXRuntime para inferencia.

Solución:

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import onnx
import onnxruntime as ort

# Step 1: Load the model and tokenizer
model_name = "bert-base-uncased"
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Step 2: Export the model to ONNX
dummy_input = tokenizer("This is a test input.", return_tensors="pt")
torch.onnx.export(
    model,
    args=(dummy_input["input_ids"], dummy_input["attention_mask"]),
    f="bert_model.onnx",
    input_names=["input_ids", "attention_mask"],
    output_names=["output"],
    dynamic_axes={"input_ids": {0: "batch_size"}, "attention_mask": {0: "batch_size"}},
    opset_version=11
)

# Step 3: Perform inference with ONNXRuntime
onnx_session = ort.InferenceSession("bert_model.onnx")
inputs = tokenizer("This is a great day!", return_tensors="np")
onnx_outputs = onnx_session.run(None, {
    "input_ids": inputs["input_ids"],
    "attention_mask": inputs["attention_mask"]
})
print("ONNX Inference Result:", onnx_outputs[0])

Ejercicio 2: Desplegar un Modelo Transformer con TensorFlow Lite

Tarea: Convertir un modelo transformer de Hugging Face a formato TensorFlow Lite y realizar inferencia.

Instrucciones:

Cargar un modelo TensorFlow.
Convertirlo al formato TensorFlow Lite.
Usar el intérprete de TensorFlow Lite para inferencia.

Solución:

from transformers import TFAutoModelForSequenceClassification, AutoTokenizer
import tensorflow as tf

# Step 1: Load the model and tokenizer
model_name = "bert-base-uncased"
model = TFAutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Step 2: Save the model and convert it to TFLite
model.save("saved_model")
converter = tf.lite.TFLiteConverter.from_saved_model("saved_model")
tflite_model = converter.convert()
with open("bert_model.tflite", "wb") as f:
    f.write(tflite_model)

# Step 3: Perform inference with TensorFlow Lite
interpreter = tf.lite.Interpreter(model_path="bert_model.tflite")
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

inputs = tokenizer("TensorFlow Lite is efficient!", return_tensors="np")
interpreter.set_tensor(input_details[0]['index'], inputs["input_ids"].astype('int32'))
interpreter.invoke()
output_data = interpreter.get_tensor(output_details[0]['index'])
print("TFLite Inference Result:", output_data)

Ejercicio 3: Crear una API con FastAPI

Tarea: Construir una aplicación FastAPI para análisis de sentimientos usando un modelo preentrenado.

Instrucciones:

Configurar una aplicación FastAPI.
Cargar un pipeline de análisis de sentimientos de Hugging Face.
Crear un endpoint para analizar el sentimiento del texto de entrada.

Solución:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from transformers import pipeline

# Step 1: Initialize FastAPI and define input schema
class TextInput(BaseModel):
    text: str

app = FastAPI()
model_pipeline = pipeline("sentiment-analysis")

# Step 2: Define the API endpoint
@app.post("/analyze_sentiment")
def analyze_sentiment(input: TextInput):
    try:
        result = model_pipeline(input.text)
        return {"text": input.text, "sentiment": result[0]}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# Step 3: Run the server using `uvicorn`
# Command: uvicorn app:app --reload

Prueba de la API:

curl -X POST "http://127.0.0.1:8000/analyze_sentiment" \
-H "Content-Type: application/json" \
-d '{"text": "Transformers are incredible!"}'

Respuesta:

{
  "text": "Transformers are incredible!",
  "sentiment": {
    "label": "POSITIVE",
    "score": 0.9998
  }
}

Ejercicio 4: Desplegar una Aplicación Gradio en Hugging Face Spaces

Tarea: Crear y desplegar una aplicación Gradio para resumir textos.

Instrucciones:

Crear una aplicación Gradio para resumir textos.
Desplegarla en Hugging Face Spaces.

Solución:

import gradio as gr
from transformers import pipeline

# Step 1: Load the summarization pipeline
summarizer = pipeline("summarization", model="t5-small")

# Step 2: Define the Gradio function
def summarize_text(input_text):
    summary = summarizer(input_text, max_length=50, min_length=20, do_sample=False)
    return summary[0]["summary_text"]

# Step 3: Create the Gradio interface
interface = gr.Interface(
    fn=summarize_text,
    inputs="text",
    outputs="text",
    title="Text Summarizer",
    description="Provide a text and get a summarized version."
)

# Step 4: Launch the app locally
interface.launch()

Para Desplegar en Hugging Face Spaces:

Sube este código a un repositorio de GitHub.
Vincula el repositorio a un Space de Hugging Face.
Tu aplicación estará alojada en: https://huggingface.co/spaces/<your_space_name>.

4.4 Ejercicios Prácticos

Ejercicio 1: Convertir un Modelo Transformer a ONNX

Tarea: Convertir un modelo transformer de Hugging Face al formato ONNX y realizar inferencia usando ONNXRuntime.

Instrucciones:

Cargar un modelo transformer preentrenado.
Convertir el modelo a ONNX.
Usar ONNXRuntime para inferencia.

Solución:

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import onnx
import onnxruntime as ort

# Step 1: Load the model and tokenizer
model_name = "bert-base-uncased"
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Step 2: Export the model to ONNX
dummy_input = tokenizer("This is a test input.", return_tensors="pt")
torch.onnx.export(
    model,
    args=(dummy_input["input_ids"], dummy_input["attention_mask"]),
    f="bert_model.onnx",
    input_names=["input_ids", "attention_mask"],
    output_names=["output"],
    dynamic_axes={"input_ids": {0: "batch_size"}, "attention_mask": {0: "batch_size"}},
    opset_version=11
)

# Step 3: Perform inference with ONNXRuntime
onnx_session = ort.InferenceSession("bert_model.onnx")
inputs = tokenizer("This is a great day!", return_tensors="np")
onnx_outputs = onnx_session.run(None, {
    "input_ids": inputs["input_ids"],
    "attention_mask": inputs["attention_mask"]
})
print("ONNX Inference Result:", onnx_outputs[0])

Ejercicio 2: Desplegar un Modelo Transformer con TensorFlow Lite

Tarea: Convertir un modelo transformer de Hugging Face a formato TensorFlow Lite y realizar inferencia.

Instrucciones:

Cargar un modelo TensorFlow.
Convertirlo al formato TensorFlow Lite.
Usar el intérprete de TensorFlow Lite para inferencia.

Solución:

from transformers import TFAutoModelForSequenceClassification, AutoTokenizer
import tensorflow as tf

# Step 1: Load the model and tokenizer
model_name = "bert-base-uncased"
model = TFAutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Step 2: Save the model and convert it to TFLite
model.save("saved_model")
converter = tf.lite.TFLiteConverter.from_saved_model("saved_model")
tflite_model = converter.convert()
with open("bert_model.tflite", "wb") as f:
    f.write(tflite_model)

# Step 3: Perform inference with TensorFlow Lite
interpreter = tf.lite.Interpreter(model_path="bert_model.tflite")
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

inputs = tokenizer("TensorFlow Lite is efficient!", return_tensors="np")
interpreter.set_tensor(input_details[0]['index'], inputs["input_ids"].astype('int32'))
interpreter.invoke()
output_data = interpreter.get_tensor(output_details[0]['index'])
print("TFLite Inference Result:", output_data)

Ejercicio 3: Crear una API con FastAPI

Tarea: Construir una aplicación FastAPI para análisis de sentimientos usando un modelo preentrenado.

Instrucciones:

Configurar una aplicación FastAPI.
Cargar un pipeline de análisis de sentimientos de Hugging Face.
Crear un endpoint para analizar el sentimiento del texto de entrada.

Solución:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from transformers import pipeline

# Step 1: Initialize FastAPI and define input schema
class TextInput(BaseModel):
    text: str

app = FastAPI()
model_pipeline = pipeline("sentiment-analysis")

# Step 2: Define the API endpoint
@app.post("/analyze_sentiment")
def analyze_sentiment(input: TextInput):
    try:
        result = model_pipeline(input.text)
        return {"text": input.text, "sentiment": result[0]}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# Step 3: Run the server using `uvicorn`
# Command: uvicorn app:app --reload

Prueba de la API:

curl -X POST "http://127.0.0.1:8000/analyze_sentiment" \
-H "Content-Type: application/json" \
-d '{"text": "Transformers are incredible!"}'

Respuesta:

{
  "text": "Transformers are incredible!",
  "sentiment": {
    "label": "POSITIVE",
    "score": 0.9998
  }
}

Ejercicio 4: Desplegar una Aplicación Gradio en Hugging Face Spaces

Tarea: Crear y desplegar una aplicación Gradio para resumir textos.

Instrucciones:

Crear una aplicación Gradio para resumir textos.
Desplegarla en Hugging Face Spaces.

Solución:

import gradio as gr
from transformers import pipeline

# Step 1: Load the summarization pipeline
summarizer = pipeline("summarization", model="t5-small")

# Step 2: Define the Gradio function
def summarize_text(input_text):
    summary = summarizer(input_text, max_length=50, min_length=20, do_sample=False)
    return summary[0]["summary_text"]

# Step 3: Create the Gradio interface
interface = gr.Interface(
    fn=summarize_text,
    inputs="text",
    outputs="text",
    title="Text Summarizer",
    description="Provide a text and get a summarized version."
)

# Step 4: Launch the app locally
interface.launch()

Para Desplegar en Hugging Face Spaces:

Sube este código a un repositorio de GitHub.
Vincula el repositorio a un Space de Hugging Face.
Tu aplicación estará alojada en: https://huggingface.co/spaces/<your_space_name>.

4.4 Ejercicios Prácticos

Ejercicio 1: Convertir un Modelo Transformer a ONNX

Tarea: Convertir un modelo transformer de Hugging Face al formato ONNX y realizar inferencia usando ONNXRuntime.

Instrucciones:

Cargar un modelo transformer preentrenado.
Convertir el modelo a ONNX.
Usar ONNXRuntime para inferencia.

Solución:

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import onnx
import onnxruntime as ort

# Step 1: Load the model and tokenizer
model_name = "bert-base-uncased"
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Step 2: Export the model to ONNX
dummy_input = tokenizer("This is a test input.", return_tensors="pt")
torch.onnx.export(
    model,
    args=(dummy_input["input_ids"], dummy_input["attention_mask"]),
    f="bert_model.onnx",
    input_names=["input_ids", "attention_mask"],
    output_names=["output"],
    dynamic_axes={"input_ids": {0: "batch_size"}, "attention_mask": {0: "batch_size"}},
    opset_version=11
)

# Step 3: Perform inference with ONNXRuntime
onnx_session = ort.InferenceSession("bert_model.onnx")
inputs = tokenizer("This is a great day!", return_tensors="np")
onnx_outputs = onnx_session.run(None, {
    "input_ids": inputs["input_ids"],
    "attention_mask": inputs["attention_mask"]
})
print("ONNX Inference Result:", onnx_outputs[0])

Ejercicio 2: Desplegar un Modelo Transformer con TensorFlow Lite

Tarea: Convertir un modelo transformer de Hugging Face a formato TensorFlow Lite y realizar inferencia.

Instrucciones:

Cargar un modelo TensorFlow.
Convertirlo al formato TensorFlow Lite.
Usar el intérprete de TensorFlow Lite para inferencia.

Solución:

from transformers import TFAutoModelForSequenceClassification, AutoTokenizer
import tensorflow as tf

# Step 1: Load the model and tokenizer
model_name = "bert-base-uncased"
model = TFAutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Step 2: Save the model and convert it to TFLite
model.save("saved_model")
converter = tf.lite.TFLiteConverter.from_saved_model("saved_model")
tflite_model = converter.convert()
with open("bert_model.tflite", "wb") as f:
    f.write(tflite_model)

# Step 3: Perform inference with TensorFlow Lite
interpreter = tf.lite.Interpreter(model_path="bert_model.tflite")
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

inputs = tokenizer("TensorFlow Lite is efficient!", return_tensors="np")
interpreter.set_tensor(input_details[0]['index'], inputs["input_ids"].astype('int32'))
interpreter.invoke()
output_data = interpreter.get_tensor(output_details[0]['index'])
print("TFLite Inference Result:", output_data)

Ejercicio 3: Crear una API con FastAPI

Tarea: Construir una aplicación FastAPI para análisis de sentimientos usando un modelo preentrenado.

Instrucciones:

Configurar una aplicación FastAPI.
Cargar un pipeline de análisis de sentimientos de Hugging Face.
Crear un endpoint para analizar el sentimiento del texto de entrada.

Solución:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from transformers import pipeline

# Step 1: Initialize FastAPI and define input schema
class TextInput(BaseModel):
    text: str

app = FastAPI()
model_pipeline = pipeline("sentiment-analysis")

# Step 2: Define the API endpoint
@app.post("/analyze_sentiment")
def analyze_sentiment(input: TextInput):
    try:
        result = model_pipeline(input.text)
        return {"text": input.text, "sentiment": result[0]}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# Step 3: Run the server using `uvicorn`
# Command: uvicorn app:app --reload

Prueba de la API:

curl -X POST "http://127.0.0.1:8000/analyze_sentiment" \
-H "Content-Type: application/json" \
-d '{"text": "Transformers are incredible!"}'

Respuesta:

{
  "text": "Transformers are incredible!",
  "sentiment": {
    "label": "POSITIVE",
    "score": 0.9998
  }
}

Ejercicio 4: Desplegar una Aplicación Gradio en Hugging Face Spaces

Tarea: Crear y desplegar una aplicación Gradio para resumir textos.

Instrucciones:

Crear una aplicación Gradio para resumir textos.
Desplegarla en Hugging Face Spaces.

Solución:

import gradio as gr
from transformers import pipeline

# Step 1: Load the summarization pipeline
summarizer = pipeline("summarization", model="t5-small")

# Step 2: Define the Gradio function
def summarize_text(input_text):
    summary = summarizer(input_text, max_length=50, min_length=20, do_sample=False)
    return summary[0]["summary_text"]

# Step 3: Create the Gradio interface
interface = gr.Interface(
    fn=summarize_text,
    inputs="text",
    outputs="text",
    title="Text Summarizer",
    description="Provide a text and get a summarized version."
)

# Step 4: Launch the app locally
interface.launch()

Para Desplegar en Hugging Face Spaces:

Sube este código a un repositorio de GitHub.
Vincula el repositorio a un Space de Hugging Face.
Tu aplicación estará alojada en: https://huggingface.co/spaces/<your_space_name>.

Compra este libro