Este proyecto tiene como objetivo entrenar un modelo de Clasificación de Texto utilizando XLM-RoBERTa, un modelo preentrenado de transformers multilingües, para clasificar noticias como falsas (label = 0) o verdaderas (label = 1). El modelo se entrena utilizando un conjunto de datos etiquetado de noticias y se evalúa en un conjunto de validación para determinar su capacidad para predecir correctamente las clases de las noticias.
En primer lugar, se carga el conjunto de datos desde un archivo CSV. Este dataset contiene las noticias y sus respectivas etiquetas (falsas o verdaderas). El archivo CSV se lee usando pandas, una librería de Python para manipular datos en formato de tabla (DataFrame).
df = pd.read_csv(dataset_path, on_bad_lines='skip')
Parámetro on_bad_lines='skip': Este parámetro se utiliza para evitar que el código se caiga si hay líneas mal formadas en el archivo CSV. Simplemente las omite.
El conjunto de datos se divide en dos subconjuntos: uno para entrenamiento y otro para validación. train_test_split de scikit-learn se utiliza para esta tarea.
test_size=0.2: Indica que el 20% de los datos se usarán para validación, mientras que el 80% restante se destinará al entrenamiento.stratify=df['label'].tolist(): Asegura que las proporciones de las clases (falsas y verdaderas) sean iguales en ambos subconjuntos (estratificación).train_texts, val_texts, train_labels, val_labels = train_test_split(
df['text'].tolist(),a
df['label'].tolist(),
test_size=0.2,
random_state=42,
stratify=df['label'].tolist()
)
El modelo XLM-RoBERTa requiere que los textos se conviertan en tokens, es decir, en una representación numérica que el modelo pueda procesar. Utilizamos el tokenizador de Hugging Face's Transformers.
train_encodings = tokenizer(train_texts, truncation=True, padding=True, max_length=256)
val_encodings = tokenizer(val_texts, truncation=True, padding=True, max_length=256)
truncation=True: Si un texto es más largo que el máximo de 256 tokens, se trunca.padding=True: Si un texto es más corto, se rellena con un token especial para asegurarse de que todos los textos tengan la misma longitud.max_length=256: Limita la longitud de los textos a 256 tokens.Para que el modelo pueda trabajar con el conjunto de datos, se crea una clase personalizada FakeNewsDataset que hereda de torch.utils.data.Dataset. Esta clase estructura los datos para que el modelo pueda acceder a ellos durante el entrenamiento y la evaluación.
class FakeNewsDataset(torch.utils.data.Dataset):
def __init__(self, encodings, labels):
self.encodings = encodings
self.labels = labels
def __len__(self):
return len(self.labels)
def __getitem__(self, idx):
item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
item['label'] = torch.tensor(self.labels[idx])
return item
__len__(): Devuelve la longitud del conjunto de datos (número de muestras).__getitem__(): Devuelve un diccionario con los datos de una muestra. Las claves son los nombres de las columnas de los tensores (input_ids, attention_mask), y se agrega también la etiqueta (label).AdvancedXLMRClassifier
El modelo XLM-RoBERTa es un modelo preentrenado de transformers, por lo que no es necesario entrenarlo desde cero. Sin embargo, creamos una clase personalizada que extiende el modelo base de XLM-RoBERTa para añadir una capa de clasificación adicional.
Se congelan las primeras capas del modelo base para evitar que sus parámetros se actualicen durante el entrenamiento. Esto es útil para aprovechar las representaciones preentrenadas del modelo sin tener que ajustarlas completamente.
for param in self.xlm_roberta.roberta.embeddings.parameters():
param.requires_grad = False
for param in self.xlm_roberta.roberta.encoder.layer[:5].parameters():
param.requires_grad = False
self.xlm_roberta.roberta.embeddings.parameters(): Congela los parámetros de la capa de embeddings (representaciones de palabras).self.xlm_roberta.roberta.encoder.layer[:5].parameters(): Congela las primeras 5 capas del encoder.Después de la capa de XLM-RoBERTa, añadimos una red neuronal adicional (MLP) con varias capas Linear, BatchNorm1d, ReLU y Dropout para mejorar el rendimiento del modelo.
self.classifier = nn.Sequential(
nn.Dropout(0.5),
nn.Linear(self.xlm_roberta.config.hidden_size, 512),
nn.BatchNorm1d(512),
nn.ReLU(),
nn.Dropout(0.4),
nn.Linear(512, 256),
nn.BatchNorm1d(256),
nn.ReLU(),
nn.Dropout(0.3),
nn.Linear(256, num_labels)
)
Dropout: Regularización para prevenir el sobreajuste, que apaga aleatoriamente ciertas neuronas durante el entrenamiento.Linear: Capa totalmente conectada que reduce la dimensión del espacio de características.BatchNorm1d: Normalización de las activaciones para estabilizar el entrenamiento.ReLU: Función de activación no lineal para introducir no linealidad.El método forward es el que define cómo pasan los datos a través del modelo. Primero, obtiene las salidas de XLM-RoBERTa, luego toma el [CLS] token (el token que representa la secuencia completa) y lo pasa a través de las capas adicionales de la red neuronal.
outputs = self.xlm_roberta.roberta(input_ids=input_ids, attention_mask=attention_mask, return_dict=True)
pooled_output = outputs.last_hidden_state[:, 0, :]
logits = self.classifier(pooled_output)
last_hidden_state[:, 0, :]: Selecciona el [CLS] token de la secuencia (el primer token) como representación de toda la secuencia.self.classifier(pooled_output): Pasa el token [CLS] por la red de clasificación.Se define la función compute_metrics para evaluar el rendimiento del modelo usando métricas como precisión, recall, F1 score y accuracy. Además, se experimenta con diferentes umbrales de decisión para las predicciones (0.4, 0.45, 0.5).
def compute_metrics(eval_pred):
logits, labels = eval_pred
predictions = torch.softmax(torch.tensor(logits), dim=-1)
thresholds = [0.4, 0.45, 0.5]
best_f1 = 0
best_threshold = 0.45
best_metrics = {}
for threshold in thresholds:
binary_predictions = (predictions[:, 1] > threshold).int()
precision, recall, f1, _ = precision_recall_fscore_support(labels, binary_predictions, average='binary')
if f1 > best_f1:
best_f1 = f1
best_threshold = threshold
best_metrics = {
"accuracy": accuracy_score(labels, binary_predictions),
"f1": f1,
"precision": precision,
"recall": recall
}
return best_metrics
El Trainer es el encargado de gestionar el ciclo completo de entrenamiento y evaluación. Se le pasa el modelo, los datos, y los parámetros de entrenamiento. También se configura el early stopping para detener el entrenamiento si la métrica de evaluación no mejora después de un número definido de épocas.
trainer = Trainer(
model=model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=val_dataset,
data_collator=data_collator,
compute_metrics=compute
_metrics,
callbacks=[early_stopping]
)
trainer.train()
early_stopping es una función de callback que detiene el entrenamiento si la métrica F1 no mejora después de 3 épocas consecutivas.
Una vez entrenado el modelo, se guarda tanto el modelo como el tokenizador para su reutilización posterior:
model.save_pretrained('./results')
tokenizer.save_pretrained('./results')
Se evalúa el modelo en el conjunto de validación usando la función evaluate del Trainer, que devuelve las métricas de rendimiento.
results = trainer.evaluate()
print("Resultados de evaluación:", results)
Este código utiliza técnicas avanzadas como fine-tuning de un modelo preentrenado de XLM-RoBERTa, congelación de capas, early stopping, y cálculo de métricas personalizadas para clasificar noticias como verdaderas o falsas. El modelo es afinado para este conjunto de datos específico, y su rendimiento se evalúa con precisión, recall, F1 score y accuracy.
Este enfoque proporciona una solución eficiente y efectiva para el problema de clasificación de texto en problemas de desinformación, utilizando modelos de lenguaje de última generación.