Clasificación de texto semi-supervisada

Introducción

En este laboratorio, aprenderá a realizar la clasificación semi-supervisada en un conjunto de datos de texto utilizando scikit-learn. El aprendizaje semi-supervisado es un tipo de aprendizaje automático en el que un modelo se entrena con datos etiquetados y no etiquetados. Este laboratorio cubrirá cómo utilizar los algoritmos de Autoentrenamiento y Propagación de Etiquetas para la clasificación de texto semi-supervisada. Utilizaremos el conjunto de datos 20 newsgroups para entrenar y probar nuestros modelos.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Cargar el conjunto de datos

Utilizaremos el conjunto de datos 20 newsgroups, que contiene alrededor de 18.000 publicaciones de grupos de noticias sobre 20 temas. En este paso, cargaremos el conjunto de datos y mostraremos algunas información básica sobre él.

import numpy as np
from sklearn.datasets import fetch_20newsgroups

## Cargar el conjunto de datos con las primeras cinco categorías
data = fetch_20newsgroups(
    subset="train",
    categories=[
        "alt.atheism",
        "comp.graphics",
        "comp.os.ms-windows.misc",
        "comp.sys.ibm.pc.hardware",
        "comp.sys.mac.hardware",
    ],
)

## Mostrar información sobre el conjunto de datos
print("%d documentos" % len(data.filenames))
print("%d categorías" % len(data.target_names))

Crear el pipeline para el aprendizaje supervisado

En este paso, crearemos un pipeline para el aprendizaje supervisado. El pipeline consistirá en un CountVectorizer para convertir los datos de texto en una matriz de conteos de tokens, un TfidfTransformer para aplicar la normalización de frecuencia de término-inversa de frecuencia de documento a la matriz de conteos y un SGDClassifier para entrenar el modelo.

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.linear_model import SGDClassifier
from sklearn.pipeline import Pipeline

## Parámetros para el SGDClassifier
sdg_params = dict(alpha=1e-5, penalty="l2", loss="log_loss")

## Parámetros para el CountVectorizer
vectorizer_params = dict(ngram_range=(1, 2), min_df=5, max_df=0.8)

## Crear el pipeline
pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("clf", SGDClassifier(**sdg_params)),
    ]
)

Entrenar y evaluar el modelo supervisado

En este paso, dividiremos el conjunto de datos en conjuntos de entrenamiento y prueba, y luego entrenaremos y evaluaremos el pipeline del modelo supervisado que creamos en el Paso 2.

from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score

## Dividir el conjunto de datos en conjuntos de entrenamiento y prueba
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(X, y)

## Entrenar y evaluar el pipeline del modelo supervisado
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print(
    "Micro-averaged F1 score on test set: %0.3f"
    % f1_score(y_test, y_pred, average="micro")
)

Crear el pipeline para el Autoentrenamiento

En este paso, crearemos un pipeline para el aprendizaje semi-supervisado utilizando el Autoentrenamiento. El pipeline será similar al pipeline supervisado, pero utilizaremos el SelfTrainingClassifier en lugar del SGDClassifier.

from sklearn.semi_supervised import SelfTrainingClassifier

## Crear el pipeline de Autoentrenamiento
st_pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("clf", SelfTrainingClassifier(SGDClassifier(**sdg_params), verbose=True)),
    ]
)

Entrenar y evaluar el modelo de Autoentrenamiento

En este paso, utilizaremos el Autoentrenamiento en el 20% de los datos etiquetados. Seleccionaremos al azar el 20% de los datos etiquetados, entrenaremos el modelo con esos datos y luego usaremos el modelo para predecir las etiquetas para el resto de los datos no etiquetados.

import numpy as np

## Seleccionar el 20% de los datos de entrenamiento
y_mask = np.random.rand(len(y_train)) < 0.2
X_20, y_20 = map(
    list, zip(*((x, y) for x, y, m in zip(X_train, y_train, y_mask) if m))
)

## Establecer el subconjunto no enmascarado como no etiquetado
y_train[~y_mask] = -1

## Entrenar y evaluar el pipeline de Autoentrenamiento
st_pipeline.fit(X_train, y_train)
y_pred = st_pipeline.predict(X_test)
print(
    "Micro-averaged F1 score on test set: %0.3f"
    % f1_score(y_test, y_pred, average="micro")
)

Crear el pipeline para LabelSpreading

En este paso, crearemos un pipeline para el aprendizaje semi-supervisado utilizando LabelSpreading. El pipeline será similar al pipeline supervisado, pero utilizaremos el algoritmo LabelSpreading en lugar del SGDClassifier.

from sklearn.semi_supervised import LabelSpreading
from sklearn.preprocessing import FunctionTransformer

## Crear el pipeline de LabelSpreading
ls_pipeline = Pipeline(
    [
        ("vect", CountVectorizer(**vectorizer_params)),
        ("tfidf", TfidfTransformer()),
        ("toarray", FunctionTransformer(lambda x: x.toarray())),
        ("clf", LabelSpreading()),
    ]
)

Entrenar y evaluar el modelo de LabelSpreading

En este paso, utilizaremos LabelSpreading en el 20% de los datos etiquetados. Seleccionaremos al azar el 20% de los datos etiquetados, entrenaremos el modelo con esos datos y luego usaremos el modelo para predecir las etiquetas para el resto de los datos no etiquetados.

## Entrenar y evaluar el pipeline de LabelSpreading
ls_pipeline.fit(X_train, y_train)
y_pred = ls_pipeline.predict(X_test)
print(
    "Micro-averaged F1 score on test set: %0.3f"
    % f1_score(y_test, y_pred, average="micro")
)

Resumen

En este laboratorio, aprendimos cómo realizar la clasificación semi-supervisada en un conjunto de datos de texto utilizando scikit-learn. Utilizamos los algoritmos de Autoentrenamiento y LabelSpreading para entrenar y probar nuestros modelos. El aprendizaje semi-supervisado puede ser útil cuando hay una cantidad limitada de datos etiquetados disponibles y puede ayudar a mejorar el rendimiento de un modelo al incorporar datos no etiquetados.