Introducción
En este laboratorio, aprenderemos a equilibrar la complejidad del modelo y la puntuación validada cruzada al encontrar una precisión decente dentro de 1 desviación estándar de la mejor puntuación de precisión mientras minimizamos el número de componentes PCA. Utilizaremos el conjunto de datos de dígitos de scikit-learn y una tubería que consta de PCA y LinearSVC.
Consejos sobre la VM
Una vez que se haya iniciado 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.
Importar bibliotecas
Comenzaremos importando las bibliotecas necesarias para este laboratorio.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC
Definir funciones
Definiremos dos funciones que se utilizarán más adelante en el laboratorio.
def lower_bound(cv_results):
"""
Calcular el límite inferior dentro de 1 desviación estándar
de la mejor `mean_test_scores`.
Parámetros
----------
cv_results : dict de ndarrays de numpy(masked)
Ver atributo cv_results_ de `GridSearchCV`
Devuelve
-------
float
Límite inferior dentro de 1 desviación estándar de la
mejor `mean_test_score`.
"""
best_score_idx = np.argmax(cv_results["mean_test_score"])
return (
cv_results["mean_test_score"][best_score_idx]
- cv_results["std_test_score"][best_score_idx]
)
def best_low_complexity(cv_results):
"""
Equilibrar la complejidad del modelo con la puntuación validada cruzada.
Parámetros
----------
cv_results : dict de ndarrays de numpy(masked)
Ver atributo cv_results_ de `GridSearchCV`.
Devuelve
------
int
Índice de un modelo que tiene el menor número de componentes PCA
mientras que su puntuación de prueba está dentro de 1 desviación estándar de la mejor
`mean_test_score`.
"""
threshold = lower_bound(cv_results)
candidate_idx = np.flatnonzero(cv_results["mean_test_score"] >= threshold)
best_idx = candidate_idx[
cv_results["param_reduce_dim__n_components"][candidate_idx].argmin()
]
return best_idx
Cargar datos y definir tubería
Cargaremos el conjunto de datos de dígitos de scikit-learn y definiremos una tubería que consta de PCA y LinearSVC.
pipe = Pipeline(
[
("reduce_dim", PCA(random_state=42)),
("classify", LinearSVC(random_state=42, C=0.01, dual="auto")),
]
)
X, y = load_digits(return_X_y=True)
Definir parámetros para GridSearchCV
Definiremos los parámetros para GridSearchCV.
param_grid = {"reduce_dim__n_components": [6, 8, 10, 12, 14]}
Definir objeto GridSearchCV
Definiremos el objeto GridSearchCV y ajustaremos el modelo.
grid = GridSearchCV(
pipe,
cv=10,
n_jobs=1,
param_grid=param_grid,
scoring="accuracy",
refit=best_low_complexity,
)
grid.fit(X, y)
Visualizar resultados
Visualizaremos los resultados trazando la precisión en función del número de componentes PCA.
n_components = grid.cv_results_["param_reduce_dim__n_components"]
test_scores = grid.cv_results_["mean_test_score"]
plt.figure()
plt.bar(n_components, test_scores, width=1.3, color="b")
lower = lower_bound(grid.cv_results_)
plt.axhline(np.max(test_scores), linestyle="--", color="y", label="Mejor puntuación")
plt.axhline(lower, linestyle="--", color=".5", label="Mejor puntuación - 1 desv. estándar")
plt.title("Equilibrar la complejidad del modelo y la puntuación validada cruzada")
plt.xlabel("Número de componentes PCA utilizados")
plt.ylabel("Precisión de clasificación de dígitos")
plt.xticks(n_components.tolist())
plt.ylim((0, 1.0))
plt.legend(loc="upper left")
best_index_ = grid.best_index_
print("El best_index_ es %d" % best_index_)
print("El número de componentes PCA seleccionados es %d" % n_components[best_index_])
print(
"La puntuación de precisión correspondiente es %.2f"
% grid.cv_results_["mean_test_score"][best_index_]
)
plt.show()
Resumen
En este laboratorio, aprendimos cómo equilibrar la complejidad del modelo y la puntuación validada cruzada utilizando PCA y LinearSVC. Utilizamos GridSearchCV para encontrar el mejor número de componentes PCA mientras maximizábamos la puntuación de precisión dentro de 1 desviación estándar de la mejor puntuación. También visualizamos los resultados para entender mejor el compromiso entre la complejidad del modelo y la precisión.