Efecto del umbral variable en el autoentrenamiento

Introducción

Esta práctica ilustra el efecto de variar el umbral en el autoentrenamiento. Se carga el conjunto de datos breast_cancer y se eliminan las etiquetas de modo que solo 50 de las 569 muestras tengan etiquetas. Se ajusta un SelfTrainingClassifier en este conjunto de datos, con umbrales variables.

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.

En ocasiones, 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

Importar bibliotecas

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.svm import SVC
from sklearn.model_selection import StratifiedKFold
from sklearn.semi_supervised import SelfTrainingClassifier
from sklearn.metrics import accuracy_score
from sklearn.utils import shuffle

En primer lugar, importaremos las bibliotecas necesarias para esta práctica.

Cargar datos

X, y = datasets.load_breast_cancer(return_X_y=True)
X, y = shuffle(X, y, random_state=42)
y_true = y.copy()
y[50:] = -1
total_samples = y.shape[0]

Se carga y mezcla el conjunto de datos breast_cancer. Luego copiamos las etiquetas reales a y_true y eliminamos todas las etiquetas excepto las primeras 50 muestras de y. Esto se utilizará para simular un escenario de aprendizaje semi-supervisado.

Definir clasificador

base_classifier = SVC(probability=True, gamma=0.001, random_state=42)

Definimos nuestro clasificador base como una Máquina de Vectores de Soporte (SVM) con un valor bajo de gamma de 0.001.

Definir valores de umbral

x_values = np.arange(0.4, 1.05, 0.05)
x_values = np.append(x_values, 0.99999)

Definimos una matriz de valores de umbral que van desde 0.4 hasta 1, con pasos de 0.05. Luego agregamos un valor de umbral muy alto de 0.99999 para asegurarnos de incluir un valor de umbral que no resultará en ninguna muestra autoetiquetada.

Definir arrays para los resultados

scores = np.empty((x_values.shape[0], n_splits))
amount_labeled = np.empty((x_values.shape[0], n_splits))
amount_iterations = np.empty((x_values.shape[0], n_splits))

Definimos arrays para almacenar los resultados de nuestro experimento.

Autoentrenamiento con umbral variable

for i, threshold in enumerate(x_values):
    self_training_clf = SelfTrainingClassifier(base_classifier, threshold=threshold)

    skfolds = StratifiedKFold(n_splits=n_splits)
    for fold, (train_index, test_index) in enumerate(skfolds.split(X, y)):
        X_train = X[train_index]
        y_train = y[train_index]
        X_test = X[test_index]
        y_test = y[test_index]
        y_test_true = y_true[test_index]

        self_training_clf.fit(X_train, y_train)

        amount_labeled[i, fold] = (
            total_samples
            - np.unique(self_training_clf.labeled_iter_, return_counts=True)[1][0]
        )

        amount_iterations[i, fold] = np.max(self_training_clf.labeled_iter_)

        y_pred = self_training_clf.predict(X_test)
        scores[i, fold] = accuracy_score(y_test_true, y_pred)

Realizamos autoentrenamiento con umbrales variables, utilizando nuestro clasificador base y la clase SelfTrainingClassifier de scikit-learn. Utilizamos validación cruzada estratificada k-fold para dividir nuestros datos en conjuntos de entrenamiento y prueba. Luego ajustamos el clasificador de autoentrenamiento en el conjunto de entrenamiento y calculamos la precisión del clasificador en el conjunto de prueba. También almacenamos la cantidad de muestras etiquetadas y el número de iteración para cada pliegue.

Visualizar resultados

ax1 = plt.subplot(211)
ax1.errorbar(
    x_values, scores.mean(axis=1), yerr=scores.std(axis=1), capsize=2, color="b"
)
ax1.set_ylabel("Precisión", color="b")
ax1.tick_params("y", colors="b")

ax2 = ax1.twinx()
ax2.errorbar(
    x_values,
    amount_labeled.mean(axis=1),
    yerr=amount_labeled.std(axis=1),
    capsize=2,
    color="g",
)
ax2.set_ylim(bottom=0)
ax2.set_ylabel("Cantidad de muestras etiquetadas", color="g")
ax2.tick_params("y", colors="g")

ax3 = plt.subplot(212, sharex=ax1)
ax3.errorbar(
    x_values,
    amount_iterations.mean(axis=1),
    yerr=amount_iterations.std(axis=1),
    capsize=2,
    color="b",
)
ax3.set_ylim(bottom=0)
ax3.set_ylabel("Cantidad de iteraciones")
ax3.set_xlabel("Umbral")

plt.show()

Graficamos los resultados de nuestro experimento utilizando Matplotlib. La gráfica superior muestra la cantidad de muestras etiquetadas que tiene disponible el clasificador al final del ajuste, y la precisión del clasificador. La gráfica inferior muestra la última iteración en la que se etiquetó una muestra.

Resumen

En este laboratorio, aprendimos cómo realizar autoentrenamiento con valores de umbral variables utilizando scikit-learn. Vimos que el valor óptimo de umbral se encuentra entre umbrales muy bajos y muy altos, y que elegir un valor de umbral adecuado puede resultar en mejoras significativas en la precisión.