Click here to view the next lesson.

Capítulo 3: Entrenamiento y Ajuste Fino de Transformadores

3.4 Ejercicios Prácticos

Esta sección proporciona ejercicios prácticos para fortalecer tu comprensión del entrenamiento y ajuste fino de modelos transformer. Estos ejercicios cubren preprocesamiento de datos, técnicas de ajuste fino y métricas de evaluación. Cada ejercicio incluye una solución con ejemplos detallados de código para guiar tu implementación.

Ejercicio 1: Preprocesamiento de Datos para Clasificación

Tarea: Preprocesar datos de texto para clasificación binaria usando un tokenizador, incluyendo tokenización, relleno y truncamiento.

Instrucciones:

Usar el tokenizador BERT para tokenizar una lista de muestras de texto.
Asegurar que todas las secuencias estén rellenadas y truncadas a una longitud fija.
Mostrar los IDs de entrada tokenizados y máscaras de atención.

Solución:

from transformers import BertTokenizer

# Initialize the BERT tokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")

# Sample text data
texts = ["Transformers are amazing!", "They are used in many NLP tasks."]

# Tokenize the text with padding and truncation
tokenized = tokenizer(texts, padding="max_length", truncation=True, max_length=10, return_tensors="pt")

# Display tokenized output
print("Input IDs:", tokenized["input_ids"])
print("Attention Masks:", tokenized["attention_mask"])

Salida Esperada:

Input IDs: [[ 101 19081  2024  6429   999  102    0    0    0    0]
            [ 101 2027  2024  2109  1999  2116 17953  4703  1012  102]]
Attention Masks: [[1 1 1 1 1 1 0 0 0 0]
                  [1 1 1 1 1 1 1 1 1 1]]

Ejercicio 2: Ajuste Fino de un Modelo Usando LoRA

Tarea: Utilizar LoRA para realizar el ajuste fino de un modelo BERT para análisis de sentimientos en el conjunto de datos IMDB.

Instrucciones:

Instalar las bibliotecas necesarias.
Cargar y preprocesar el conjunto de datos IMDB.
Aplicar LoRA al modelo BERT.
Realizar el ajuste fino del modelo durante dos épocas.

Solución:

from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
from peft import get_peft_model, LoraConfig, TaskType

# Load and preprocess the dataset
dataset = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

def preprocess_function(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=256)

tokenized_datasets = dataset.map(preprocess_function, batched=True)

# Apply LoRA to the model
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2)
lora_config = LoraConfig(
    task_type=TaskType.SEQ_CLS, r=8, lora_alpha=32, lora_dropout=0.1
)
lora_model = get_peft_model(model, lora_config)

# Define training arguments
training_args = TrainingArguments(
    output_dir="./lora_results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    num_train_epochs=2
)

# Fine-tune the model
trainer = Trainer(
    model=lora_model,
    args=training_args,
    train_dataset=tokenized_datasets["train"].shuffle(seed=42).select(range(2000)),
    eval_dataset=tokenized_datasets["test"].shuffle(seed=42).select(range(500))
)
trainer.train()

Ejercicio 3: Evaluar un Modelo Usando BLEU

Tarea: Evaluar la salida de un modelo de traducción automática usando la métrica BLEU.

Instrucciones:

Definir una traducción de referencia y una traducción candidata.
Calcular la puntuación BLEU usando NLTK.

Solución:

from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction

# Reference and candidate translations
reference = ["The cat is on the mat".split()]
candidate = "The cat is on the mat".split()

# Calculate BLEU score
bleu_score = sentence_bleu(reference, candidate, smoothing_function=SmoothingFunction().method1)

print(f"BLEU Score: {bleu_score:.2f}")

Salida Esperada:

BLEU Score: 1.00

Ejercicio 4: Evaluar un Modelo de Resumen Usando ROUGE

Tarea: Evaluar la salida de un modelo de resumen usando la métrica ROUGE.

Instrucciones:

Definir un resumen de referencia y un resumen candidato.
Calcular las puntuaciones ROUGE-1, ROUGE-2 y ROUGE-L.

Solución:

from rouge_score import rouge_scorer

# Reference and candidate summaries
reference = "The cat is on the mat."
candidate = "The cat lies on the mat."

# Initialize ROUGE scorer
scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)

# Calculate ROUGE scores
scores = scorer.score(reference, candidate)

# Display results
print("ROUGE Scores:")
for key, value in scores.items():
    print(f"{key}: Precision: {value.precision:.3f}, Recall: {value.recall:.3f}, F1: {value.fmeasure:.3f}")

Salida Esperada:

ROUGE Scores:
rouge1: Precision: 0.833, Recall: 0.833, F1: 0.833
rouge2: Precision: 0.750, Recall: 0.750, F1: 0.750
rougeL: Precision: 0.833, Recall: 0.833, F1: 0.833

Ejercicio 5: Evaluar la Generación de Texto Usando BERTScore

Tarea: Evaluar la similitud semántica entre el texto generado y una referencia usando BERTScore.

Instrucciones:

Definir un texto de referencia y un texto candidato.
Calcular BERTScore usando un modelo BERT preentrenado.

Solución:

from bert_score import score

# Reference and candidate texts
references = ["The cat is on the mat."]
candidates = ["The cat lies on the mat."]

# Compute BERTScore
P, R, F1 = score(candidates, references, lang="en", model_type="bert-base-uncased")

# Display results
print(f"BERTScore Precision: {P.mean():.3f}")
print(f"BERTScore Recall: {R.mean():.3f}")
print(f"BERTScore F1: {F1.mean():.3f}")

Salida Esperada:

BERTScore Precision: 0.987
BERTScore Recall: 0.992
BERTScore F1: 0.989

Estos ejercicios demuestran los pasos clave en el preprocesamiento de datos, el ajuste fino usando LoRA y la evaluación de modelos transformer con métricas BLEU, ROUGE y BERTScore. Completar estos ejercicios proporcionará experiencia práctica y profundizará tu comprensión de las técnicas de entrenamiento y evaluación para modelos de PLN basados en transformers.

3.4 Ejercicios Prácticos

Ejercicio 1: Preprocesamiento de Datos para Clasificación

Tarea: Preprocesar datos de texto para clasificación binaria usando un tokenizador, incluyendo tokenización, relleno y truncamiento.

Instrucciones:

Usar el tokenizador BERT para tokenizar una lista de muestras de texto.
Asegurar que todas las secuencias estén rellenadas y truncadas a una longitud fija.
Mostrar los IDs de entrada tokenizados y máscaras de atención.

Solución:

from transformers import BertTokenizer

# Initialize the BERT tokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")

# Sample text data
texts = ["Transformers are amazing!", "They are used in many NLP tasks."]

# Tokenize the text with padding and truncation
tokenized = tokenizer(texts, padding="max_length", truncation=True, max_length=10, return_tensors="pt")

# Display tokenized output
print("Input IDs:", tokenized["input_ids"])
print("Attention Masks:", tokenized["attention_mask"])

Salida Esperada:

Input IDs: [[ 101 19081  2024  6429   999  102    0    0    0    0]
            [ 101 2027  2024  2109  1999  2116 17953  4703  1012  102]]
Attention Masks: [[1 1 1 1 1 1 0 0 0 0]
                  [1 1 1 1 1 1 1 1 1 1]]

Ejercicio 2: Ajuste Fino de un Modelo Usando LoRA

Tarea: Utilizar LoRA para realizar el ajuste fino de un modelo BERT para análisis de sentimientos en el conjunto de datos IMDB.

Instrucciones:

Instalar las bibliotecas necesarias.
Cargar y preprocesar el conjunto de datos IMDB.
Aplicar LoRA al modelo BERT.
Realizar el ajuste fino del modelo durante dos épocas.

Solución:

from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
from peft import get_peft_model, LoraConfig, TaskType

# Load and preprocess the dataset
dataset = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

def preprocess_function(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=256)

tokenized_datasets = dataset.map(preprocess_function, batched=True)

# Apply LoRA to the model
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2)
lora_config = LoraConfig(
    task_type=TaskType.SEQ_CLS, r=8, lora_alpha=32, lora_dropout=0.1
)
lora_model = get_peft_model(model, lora_config)

# Define training arguments
training_args = TrainingArguments(
    output_dir="./lora_results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    num_train_epochs=2
)

# Fine-tune the model
trainer = Trainer(
    model=lora_model,
    args=training_args,
    train_dataset=tokenized_datasets["train"].shuffle(seed=42).select(range(2000)),
    eval_dataset=tokenized_datasets["test"].shuffle(seed=42).select(range(500))
)
trainer.train()

Ejercicio 3: Evaluar un Modelo Usando BLEU

Tarea: Evaluar la salida de un modelo de traducción automática usando la métrica BLEU.

Instrucciones:

Definir una traducción de referencia y una traducción candidata.
Calcular la puntuación BLEU usando NLTK.

Solución:

from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction

# Reference and candidate translations
reference = ["The cat is on the mat".split()]
candidate = "The cat is on the mat".split()

# Calculate BLEU score
bleu_score = sentence_bleu(reference, candidate, smoothing_function=SmoothingFunction().method1)

print(f"BLEU Score: {bleu_score:.2f}")

Salida Esperada:

BLEU Score: 1.00

Ejercicio 4: Evaluar un Modelo de Resumen Usando ROUGE

Tarea: Evaluar la salida de un modelo de resumen usando la métrica ROUGE.

Instrucciones:

Definir un resumen de referencia y un resumen candidato.
Calcular las puntuaciones ROUGE-1, ROUGE-2 y ROUGE-L.

Solución:

from rouge_score import rouge_scorer

# Reference and candidate summaries
reference = "The cat is on the mat."
candidate = "The cat lies on the mat."

# Initialize ROUGE scorer
scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)

# Calculate ROUGE scores
scores = scorer.score(reference, candidate)

# Display results
print("ROUGE Scores:")
for key, value in scores.items():
    print(f"{key}: Precision: {value.precision:.3f}, Recall: {value.recall:.3f}, F1: {value.fmeasure:.3f}")

Salida Esperada:

ROUGE Scores:
rouge1: Precision: 0.833, Recall: 0.833, F1: 0.833
rouge2: Precision: 0.750, Recall: 0.750, F1: 0.750
rougeL: Precision: 0.833, Recall: 0.833, F1: 0.833

Ejercicio 5: Evaluar la Generación de Texto Usando BERTScore

Tarea: Evaluar la similitud semántica entre el texto generado y una referencia usando BERTScore.

Instrucciones:

Definir un texto de referencia y un texto candidato.
Calcular BERTScore usando un modelo BERT preentrenado.

Solución:

from bert_score import score

# Reference and candidate texts
references = ["The cat is on the mat."]
candidates = ["The cat lies on the mat."]

# Compute BERTScore
P, R, F1 = score(candidates, references, lang="en", model_type="bert-base-uncased")

# Display results
print(f"BERTScore Precision: {P.mean():.3f}")
print(f"BERTScore Recall: {R.mean():.3f}")
print(f"BERTScore F1: {F1.mean():.3f}")

Salida Esperada:

BERTScore Precision: 0.987
BERTScore Recall: 0.992
BERTScore F1: 0.989

3.4 Ejercicios Prácticos

Ejercicio 1: Preprocesamiento de Datos para Clasificación

Tarea: Preprocesar datos de texto para clasificación binaria usando un tokenizador, incluyendo tokenización, relleno y truncamiento.

Instrucciones:

Usar el tokenizador BERT para tokenizar una lista de muestras de texto.
Asegurar que todas las secuencias estén rellenadas y truncadas a una longitud fija.
Mostrar los IDs de entrada tokenizados y máscaras de atención.

Solución:

from transformers import BertTokenizer

# Initialize the BERT tokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")

# Sample text data
texts = ["Transformers are amazing!", "They are used in many NLP tasks."]

# Tokenize the text with padding and truncation
tokenized = tokenizer(texts, padding="max_length", truncation=True, max_length=10, return_tensors="pt")

# Display tokenized output
print("Input IDs:", tokenized["input_ids"])
print("Attention Masks:", tokenized["attention_mask"])

Salida Esperada:

Input IDs: [[ 101 19081  2024  6429   999  102    0    0    0    0]
            [ 101 2027  2024  2109  1999  2116 17953  4703  1012  102]]
Attention Masks: [[1 1 1 1 1 1 0 0 0 0]
                  [1 1 1 1 1 1 1 1 1 1]]

Ejercicio 2: Ajuste Fino de un Modelo Usando LoRA

Tarea: Utilizar LoRA para realizar el ajuste fino de un modelo BERT para análisis de sentimientos en el conjunto de datos IMDB.

Instrucciones:

Instalar las bibliotecas necesarias.
Cargar y preprocesar el conjunto de datos IMDB.
Aplicar LoRA al modelo BERT.
Realizar el ajuste fino del modelo durante dos épocas.

Solución:

from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
from peft import get_peft_model, LoraConfig, TaskType

# Load and preprocess the dataset
dataset = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

def preprocess_function(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=256)

tokenized_datasets = dataset.map(preprocess_function, batched=True)

# Apply LoRA to the model
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2)
lora_config = LoraConfig(
    task_type=TaskType.SEQ_CLS, r=8, lora_alpha=32, lora_dropout=0.1
)
lora_model = get_peft_model(model, lora_config)

# Define training arguments
training_args = TrainingArguments(
    output_dir="./lora_results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    num_train_epochs=2
)

# Fine-tune the model
trainer = Trainer(
    model=lora_model,
    args=training_args,
    train_dataset=tokenized_datasets["train"].shuffle(seed=42).select(range(2000)),
    eval_dataset=tokenized_datasets["test"].shuffle(seed=42).select(range(500))
)
trainer.train()

Ejercicio 3: Evaluar un Modelo Usando BLEU

Tarea: Evaluar la salida de un modelo de traducción automática usando la métrica BLEU.

Instrucciones:

Definir una traducción de referencia y una traducción candidata.
Calcular la puntuación BLEU usando NLTK.

Solución:

from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction

# Reference and candidate translations
reference = ["The cat is on the mat".split()]
candidate = "The cat is on the mat".split()

# Calculate BLEU score
bleu_score = sentence_bleu(reference, candidate, smoothing_function=SmoothingFunction().method1)

print(f"BLEU Score: {bleu_score:.2f}")

Salida Esperada:

BLEU Score: 1.00

Ejercicio 4: Evaluar un Modelo de Resumen Usando ROUGE

Tarea: Evaluar la salida de un modelo de resumen usando la métrica ROUGE.

Instrucciones:

Definir un resumen de referencia y un resumen candidato.
Calcular las puntuaciones ROUGE-1, ROUGE-2 y ROUGE-L.

Solución:

from rouge_score import rouge_scorer

# Reference and candidate summaries
reference = "The cat is on the mat."
candidate = "The cat lies on the mat."

# Initialize ROUGE scorer
scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)

# Calculate ROUGE scores
scores = scorer.score(reference, candidate)

# Display results
print("ROUGE Scores:")
for key, value in scores.items():
    print(f"{key}: Precision: {value.precision:.3f}, Recall: {value.recall:.3f}, F1: {value.fmeasure:.3f}")

Salida Esperada:

ROUGE Scores:
rouge1: Precision: 0.833, Recall: 0.833, F1: 0.833
rouge2: Precision: 0.750, Recall: 0.750, F1: 0.750
rougeL: Precision: 0.833, Recall: 0.833, F1: 0.833

Ejercicio 5: Evaluar la Generación de Texto Usando BERTScore

Tarea: Evaluar la similitud semántica entre el texto generado y una referencia usando BERTScore.

Instrucciones:

Definir un texto de referencia y un texto candidato.
Calcular BERTScore usando un modelo BERT preentrenado.

Solución:

from bert_score import score

# Reference and candidate texts
references = ["The cat is on the mat."]
candidates = ["The cat lies on the mat."]

# Compute BERTScore
P, R, F1 = score(candidates, references, lang="en", model_type="bert-base-uncased")

# Display results
print(f"BERTScore Precision: {P.mean():.3f}")
print(f"BERTScore Recall: {R.mean():.3f}")
print(f"BERTScore F1: {F1.mean():.3f}")

Salida Esperada:

BERTScore Precision: 0.987
BERTScore Recall: 0.992
BERTScore F1: 0.989

3.4 Ejercicios Prácticos

Ejercicio 1: Preprocesamiento de Datos para Clasificación

Tarea: Preprocesar datos de texto para clasificación binaria usando un tokenizador, incluyendo tokenización, relleno y truncamiento.

Instrucciones:

Usar el tokenizador BERT para tokenizar una lista de muestras de texto.
Asegurar que todas las secuencias estén rellenadas y truncadas a una longitud fija.
Mostrar los IDs de entrada tokenizados y máscaras de atención.

Solución:

from transformers import BertTokenizer

# Initialize the BERT tokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")

# Sample text data
texts = ["Transformers are amazing!", "They are used in many NLP tasks."]

# Tokenize the text with padding and truncation
tokenized = tokenizer(texts, padding="max_length", truncation=True, max_length=10, return_tensors="pt")

# Display tokenized output
print("Input IDs:", tokenized["input_ids"])
print("Attention Masks:", tokenized["attention_mask"])

Salida Esperada:

Input IDs: [[ 101 19081  2024  6429   999  102    0    0    0    0]
            [ 101 2027  2024  2109  1999  2116 17953  4703  1012  102]]
Attention Masks: [[1 1 1 1 1 1 0 0 0 0]
                  [1 1 1 1 1 1 1 1 1 1]]

Ejercicio 2: Ajuste Fino de un Modelo Usando LoRA

Tarea: Utilizar LoRA para realizar el ajuste fino de un modelo BERT para análisis de sentimientos en el conjunto de datos IMDB.

Instrucciones:

Instalar las bibliotecas necesarias.
Cargar y preprocesar el conjunto de datos IMDB.
Aplicar LoRA al modelo BERT.
Realizar el ajuste fino del modelo durante dos épocas.

Solución:

from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
from peft import get_peft_model, LoraConfig, TaskType

# Load and preprocess the dataset
dataset = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

def preprocess_function(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=256)

tokenized_datasets = dataset.map(preprocess_function, batched=True)

# Apply LoRA to the model
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2)
lora_config = LoraConfig(
    task_type=TaskType.SEQ_CLS, r=8, lora_alpha=32, lora_dropout=0.1
)
lora_model = get_peft_model(model, lora_config)

# Define training arguments
training_args = TrainingArguments(
    output_dir="./lora_results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    num_train_epochs=2
)

# Fine-tune the model
trainer = Trainer(
    model=lora_model,
    args=training_args,
    train_dataset=tokenized_datasets["train"].shuffle(seed=42).select(range(2000)),
    eval_dataset=tokenized_datasets["test"].shuffle(seed=42).select(range(500))
)
trainer.train()

Ejercicio 3: Evaluar un Modelo Usando BLEU

Tarea: Evaluar la salida de un modelo de traducción automática usando la métrica BLEU.

Instrucciones:

Definir una traducción de referencia y una traducción candidata.
Calcular la puntuación BLEU usando NLTK.

Solución:

from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction

# Reference and candidate translations
reference = ["The cat is on the mat".split()]
candidate = "The cat is on the mat".split()

# Calculate BLEU score
bleu_score = sentence_bleu(reference, candidate, smoothing_function=SmoothingFunction().method1)

print(f"BLEU Score: {bleu_score:.2f}")

Salida Esperada:

BLEU Score: 1.00

Ejercicio 4: Evaluar un Modelo de Resumen Usando ROUGE

Tarea: Evaluar la salida de un modelo de resumen usando la métrica ROUGE.

Instrucciones:

Definir un resumen de referencia y un resumen candidato.
Calcular las puntuaciones ROUGE-1, ROUGE-2 y ROUGE-L.

Solución:

from rouge_score import rouge_scorer

# Reference and candidate summaries
reference = "The cat is on the mat."
candidate = "The cat lies on the mat."

# Initialize ROUGE scorer
scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)

# Calculate ROUGE scores
scores = scorer.score(reference, candidate)

# Display results
print("ROUGE Scores:")
for key, value in scores.items():
    print(f"{key}: Precision: {value.precision:.3f}, Recall: {value.recall:.3f}, F1: {value.fmeasure:.3f}")

Salida Esperada:

ROUGE Scores:
rouge1: Precision: 0.833, Recall: 0.833, F1: 0.833
rouge2: Precision: 0.750, Recall: 0.750, F1: 0.750
rougeL: Precision: 0.833, Recall: 0.833, F1: 0.833

Ejercicio 5: Evaluar la Generación de Texto Usando BERTScore

Tarea: Evaluar la similitud semántica entre el texto generado y una referencia usando BERTScore.

Instrucciones:

Definir un texto de referencia y un texto candidato.
Calcular BERTScore usando un modelo BERT preentrenado.

Solución:

from bert_score import score

# Reference and candidate texts
references = ["The cat is on the mat."]
candidates = ["The cat lies on the mat."]

# Compute BERTScore
P, R, F1 = score(candidates, references, lang="en", model_type="bert-base-uncased")

# Display results
print(f"BERTScore Precision: {P.mean():.3f}")
print(f"BERTScore Recall: {R.mean():.3f}")
print(f"BERTScore F1: {F1.mean():.3f}")

Salida Esperada:

BERTScore Precision: 0.987
BERTScore Recall: 0.992
BERTScore F1: 0.989

Compra este libro