Tutorial práctico de aprendizaje automático (9): generalización del modelo

Generalización

La generalización de modelos se refiere a la capacidad de un modelo de aprendizaje automático para adaptarse a datos nuevos e invisibles. En el aprendizaje automático, generalmente dividimos el conjunto de datos existente en un conjunto de entrenamiento y un conjunto de prueba, usamos el conjunto de entrenamiento para entrenar el modelo y luego usamos el conjunto de prueba para evaluar el rendimiento del modelo. Un modelo que funciona bien en el conjunto de entrenamiento puede no necesariamente funcionar bien en el conjunto de prueba o en aplicaciones reales. Por lo tanto, debemos asegurarnos de que el modelo tenga buenas capacidades de generalización para garantizar su eficacia en escenarios reales.

Para mejorar la capacidad de generalización del modelo, generalmente necesitamos tomar una serie de medidas, como aumentar el tamaño del conjunto de datos, selección de características, escalado de características, regularización, validación cruzada, etc. Mediante estos métodos, se puede reducir el sobreajuste del modelo y mejorar la capacidad de predicción de nuevos datos.

En resumen, la generalización de modelos es un concepto muy importante en el aprendizaje automático. Está directamente relacionado con el efecto del modelo en aplicaciones prácticas y también es uno de los indicadores importantes para evaluar algoritmos y modelos de aprendizaje automático.

Evaluación y selección de modelos.

análisis de errores

La predicción de la máquina es como lanzar un dardo: cuanto más cerca esté del blanco, más precisa será la predicción. Los errores se pueden dividir en dos categorías: sesgo y varianza. La siguiente figura se puede utilizar para representar vívidamente:

Con respecto a la tarea de aprendizaje, si la función asumida no es lo suficientemente buena, pueden ocurrir dos problemas en los resultados de ajuste:

• Subajuste (subajuste): hay muy pocos parámetros, la función de hipótesis es demasiado libre y demasiado simple, e incluso el conjunto de muestras no está bien ajustado, la predicción se sesga fácilmente hacia un lado y la desviación es grande.
• Sobreajuste (sobreajuste): hay demasiados parámetros, la función asumida es demasiado libre y no es resistente a la interferencia. Se ajusta muy bien al conjunto de muestras, pero la función asumida está demasiado deformada y la predicción va de izquierda a derecha. con una gran variación.

El subajuste y el sobreajuste se pueden ilustrar vívidamente en la siguiente figura:

Al cambiar la complejidad del modelo y el tamaño del conjunto de entrenamiento, el gráfico de función del error del conjunto de entrenamiento y el conjunto de prueba (el error al cambiar la complejidad del modelo): Cambiar el

conjunto de datos Error de tiempo

Es relativamente sencillo resolver el ajuste insuficiente, simplemente agregue parámetros o características. El problema es el ajuste excesivo.
Las soluciones al sobreajuste incluyen:

• Reduzca los parámetros de este modelo o cambie a un modelo más simple.
• Regularización.
• Aumentar el conjunto de entrenamiento, reducir los componentes de ruido, etc.

error de generalización

$\theta$ representa el hiperparámetro,$j_{}$$\{$ $yo$$\}$ representa el modelo entrenado$Cuanto\; menor\; sea\; el\; error\; para\; datos\; desconocidos\; después\; del\; parámetro\; \theta$ , mayor será la capacidad de generalización,$j_{tes}$$\{$ $yo$$\}$ representa el error del modelo en la máquina de prueba: cuanto menor sea el error, mayor será la capacidad de generalización.

Esperamos que nuestro modelo pueda generalizarse, es decir, que también pueda funcionar en situaciones desconocidas y no entrenadas. El error de generalización se refiere a la función de costo del modelo al procesar datos desconocidos: $j_{}$$\{$ $yo$$\}$
valor, que puede cuantificar la capacidad de generalización del modelo.
Sin embargo, cuando entrenamos y probamos el modelo, no hay datos desconocidos. Mejoraremos el modelo en función de su rendimiento en el conjunto de entrenamiento y luego realizaremos capacitación y pruebas. Pero el cálculo final en el conjunto de prueba es:$j_{tes}$$\{$ $yo$$\}$ El conjunto de prueba se ha optimizado y su estimación del error de generalización es obviamente demasiado optimista y demasiado baja. En otras palabras, el efecto de poner el modelo en aplicación real será mucho peor de lo esperado.
Para resolver este problema, la gente ha propuesto el método de validación cruzada.

Validación cruzada

Pasos de validación cruzada

1. El conjunto de entrenamiento se divide a su vez en conjuntos de subentrenamiento y conjuntos de validación cruzada. Oculte el conjunto de prueba y no lo use todavía. (El conjunto de prueba es una simulación de datos desconocidos)
2. Utilice varios modelos para entrenar en el conjunto de subentrenamiento y mida el $j_{cv}$$\{$ $yo$$\}$
3. Seleccione $j_{cv}$$\{$ $yo$$\}$ El modelo más pequeño se considera el mejor. Combine el conjunto de subentrenamiento y el conjunto de validación cruzada en un conjunto de entrenamiento para entrenar el modelo final.

Un método mejorado de validación cruzada es la validación cruzada K-fold (Figura 6): el conjunto de entrenamiento se divide en muchos bloques pequeños, y un bloque pequeño se toma como conjunto de validación cruzada en cada caso, y las partes restantes se fusionados como conjuntos de subentrenamiento., encuentre $j_{cv}$$\{$ $yo$$\}$ , calcula cada situación y encuentra el$j_{cv}$$\{$ $yo$$\}$ , el modelo con el promedio más pequeño se considera el mejor modelo. Al final, el mejor modelo todavía se entrena en todo el conjunto de entrenamiento y el error de generalización se estima en el conjunto de prueba.

La ventaja de la validación cruzada K-fold es garantizar aún más que el conjunto de validación cruzada no sea especial y que la estimación del error de generalización sea más precisa.

KFold dividido

En sklearn, podemos usar la clase KFold para implementar la validación cruzada de k veces.
Al realizar una validación cruzada de k veces, el objeto KFold divide aleatoriamente el conjunto de datos original en k subconjuntos de tamaño aproximado, cada subconjunto se denomina "pliegue". Por ejemplo, una matriz de 10 elementos, si k = 5, se dividirá en 5 conjuntos de datos, cada conjunto de datos plegados es 2 y los 5 conjuntos de datos plegados se utilizarán como una máquina de prueba, por lo que habrá 5 combinaciones. .

from sklearn.model_selection import KFold
import numpy as np

# 创建一个包含10个元素的数组作为样本数据
X = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
# 定义K值
k = 5

# 创建KFold对象，并指定n_splits参数为K
kf = KFold(n_splits=k)

# 遍历KFold对象中的每一组训练集和测试集
for train_index, test_index in kf.split(X):
    print("train_index:", train_index, "test_index:", test_index)

El resultado es el siguiente:

train_index: [2 3 4 5 6 7 8 9] test_index: [0 1]
train_index: [0 1 4 5 6 7 8 9] test_index: [2 3]
train_index: [0 1 2 3 6 7 8 9] test_index: [4 5]
train_index: [0 1 2 3 4 5 8 9] test_index: [6 7]
train_index: [0 1 2 3 4 5 6 7] test_index: [8 9]

El valor de veces también determina el número de puntuaciones finalmente verificadas utilizando el conjunto de datos cv.

cross_val_score combate real

La función cross_val_score es uno de los métodos rápidos de la biblioteca Scikit-learn para evaluar el rendimiento del modelo. Calcula una puntuación del modelo basada en validación cruzada y devuelve la puntuación de rendimiento de la prueba para cada pliegue. A diferencia de KFold, cross_val_score no necesita mostrar conjuntos de datos divididos. Solo necesita proporcionar un modelo y un conjunto de datos para la evaluación, y la función manejará automáticamente el proceso de validación cruzada, haciendo que el código sea más limpio y más fácil de entender.

Conjuntos de datos y modelos

load_digits es una función en la biblioteca Scikit-learn para cargar un conjunto de datos de imágenes de dígitos escritos a mano. Este conjunto de datos contiene 1797 imágenes de dígitos escritos a mano de un tamaño de 8x8 píxeles, cada imagen correspondiente a una etiqueta numérica del 0 al 9.

from sklearn.datasets import load_digits

digits = load_digits()
import matplotlib.pyplot as plt

fig, axes = plt.subplots(nrows=1, ncols=5, figsize=(10, 3))

for i, ax in enumerate(axes):
    ax.imshow(digits.images[i], cmap='gray')
    ax.set_title(digits.target[i])

plt.show()

El KNeighborsClassifier en la biblioteca Scikit-learn implementa el algoritmo k-vecino más cercano, en el que los hiperparámetros k y p afectan el rendimiento del modelo.

• n_neighbors (es decir, k): especifique el número de vecinos más cercanos que se considerarán. De forma predeterminada, es 5, lo que significa que al predecir una nueva muestra, se utilizarán las etiquetas de los 5 puntos de datos más cercanos en el conjunto de datos, y la etiqueta con más entre los 5 es la etiqueta de los datos actuales.
• p: métrica utilizada para calcular la distancia. De forma predeterminada, se usa la distancia de Minkowski y p es 2, lo que significa que se usa la distancia euclidiana. Diferentes valores de p corresponden a diferentes métodos de medición de distancia. Por ejemplo, p = 1 representa la distancia de Manhattan y p = 3 puede utilizar un método de medición de distancia de Manhattan más complejo.

Obtenga el mejor k,p utilizando el conjunto de datos y el conjunto de pruebas

Divida el conjunto de datos en un conjunto de entrenamiento y un conjunto de prueba, luego k varía de 1 a 11, p de 1 a 6, pruebe la puntuación del conjunto de entrenamiento y obtenga los mejores k y p.

import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

digits = datasets.load_digits()
x = digits.data
y = digits.target

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.4, random_state=666)

best_score, best_p, best_k = 0, 0, 0 
for k in range(2, 11):
    for  p in range(1, 6):
        knn_clf = KNeighborsClassifier(weights="distance", n_neighbors=k, p=p)
        knn_clf.fit(x_train, y_train)
        score = knn_clf.score(x_test, y_test)
        if score > best_score:
            best_score, best_p, best_k = score, p, k

print("Best K=", best_k)
print("Best P=", best_p)
print("Best score=", best_score)

Resultado de salida:

Best K= 3
Best P= 4
Best score= 0.9860917941585535

Obtenga k,p óptimo mediante validación cruzada

El método de validación cruzada utilizado por la función cross_val_score de forma predeterminada es la validación cruzada triple, que divide el conjunto de datos en 3 partes iguales, 2 de las cuales se utilizan para entrenamiento y 1 para prueba. En cada iteración de pliegue, el conjunto de pruebas se utiliza para obtener la puntuación de la métrica de rendimiento y luego se promedian y devuelven los resultados de todos los pliegues.

Cabe señalar que cross_val_score también tiene un parámetro llamado cv, que se puede usar para especificar el número de pliegues para la validación cruzada, es decir, el valor k. Por ejemplo, cv=5 significa validación cruzada quíntuple, dividiendo el conjunto de datos en 5 partes iguales, 4 partes para entrenamiento y 1 parte para prueba. Para problemas de clasificación y problemas de regresión, generalmente se elige una validación cruzada de 3, 5 o 10 veces. En general, cuanto mayor sea el número de pliegues en la validación cruzada, más confiables serán los resultados de la evaluación del modelo, pero el costo computacional también aumenta.

En resumen, cuando el parámetro cv no se establece explícitamente, cross_val_score utiliza validación cruzada triple de forma predeterminada, es decir, el valor k predeterminado es 3.

best_score, best_p, best_k = 0, 0, 0 
for k in range(2, 11):
    for  p in range(1, 6):
        knn_clf = KNeighborsClassifier(weights="distance", n_neighbors=k, p=p)
        scores = cross_val_score(knn_clf, x_train, y_train)
        score = np.mean(scores)
        if score > best_score:
            best_score, best_p, best_k = score, p, k

print("Best K=", best_k)
print("Best P=", best_p)
print("Best score=", best_score)

producción

Best K= 2
Best P= 2
Best score= 0.9823599874006478

Comparando el primer caso encontramos que los hiperparámetros óptimos obtenidos son diferentes, aunque la puntuación será ligeramente menor, el segundo caso es generalmente más creíble. Sin embargo, esta puntuación solo muestra que este conjunto de parámetros es óptimo y no se refiere a la precisión del modelo en el conjunto de prueba, así que veamos la precisión a continuación.

best_knn_clf = KNeighborsClassifier(weights='distance', n_neighbors=2, p=2)
best_knn_clf.fit(x_train, y_train)
best_knn_clf.score(x_test, y_test)

Resultado de salida: 0.980528511821975, esta es la precisión del modelo.

Regularización

principio

Para comprender qué es la regularización, primero debemos comprender la ecuación de la figura anterior. Cuando hay muy pocas características y datos para entrenar, a menudo ocurre un desajuste, que corresponde a las coordenadas de la izquierda; y el objetivo que queremos lograr son a menudo las coordenadas en el medio, donde se usan características y datos apropiados para el entrenamiento; pero A menudo, en la vida real, hay muchos factores que afectan los resultados, es decir, habrá muchos valores de características, por lo que al entrenar el modelo, a menudo se producirá un sobreajuste, como se muestra en la figura anterior.
Tomando la fórmula de la imagen como ejemplo, el modelo que obtenemos a menudo es:

$i_{}+i_{}X+i_{}{X}^2+i_{}{X}^3+i_{}{X}^4$

Para obtener la gráfica de las coordenadas intermedias, definitivamente esperamos que θ3 y θ4 sean lo más pequeños posible, porque cuanto más pequeños son estos dos elementos, más cerca están de 0 y se puede obtener la gráfica del medio.
Para la función de pérdida:
$$\left(\frac{}{2m\_\_}\right[\sum _{yo=1}\left(h_{}\right(x^{yo})-y^{yo}{)}^2])$$
En regresión lineal, el valor mínimo de la función de pérdida
$$mín\left(\frac{}{2m\_\_}\right[\sum _{yo=1}\left(h_{}\right(x^{yo})-y^{yo}{)}^2])$$
y calcularθ \thetavalor$\theta \; .$
Si se suma un número a la función de pérdida para encontrar el valor mínimo, entonces este número debe estar más cerca de 0 y el mínimo debe ser menor.
Entonces, ¿qué se suma a este valor? Esperamos que$A\; medida\; que\; \theta$ se acerca a 0, cuanto menor sea el impacto en la función de pérdida, mejor, es decir, las características se reducen.
Generalizando la fórmula:
$$\frac{}{2m\_\_}\left[\sum _{yo=1}\right(h_{}\left(x^{yo}\right)-y^{yo}{)}^2])+yo\sum _{j=1}{i}_j^{}$$

Para encontrar el valor mínimo de la función de pérdida, de modo que el valor θ se acerque a 0, esto logra nuestro objetivo.
Es equivalente a agregar un término de penalización (término λ) a la función de pérdida original.
Este es un método para evitar el sobreajuste. Generalmente se llama regularización L2, también llamada regresión de cresta.

Podemos pensar que después de agregar el término regular L2, la longitud estimada del parámetro se vuelve más corta, lo que matemáticamente se denomina contracción de características.

Introducción al método de contracción: se refiere a tener en cuenta el tamaño de los coeficientes durante el proceso de entrenamiento y resolución de parámetros. Al establecer el coeficiente de penalización, los coeficientes de las características con menor influencia se atenúan a 0 y solo se retienen las características importantes. , reduciendo así la complejidad del modelo y evitando el sobreajuste. Los métodos de reducción más utilizados incluyen Lasso (regularización L1) y Regresión Ridge (regularización L2).
Fórmula de lazo (regularización L1):
$$\frac{}{2m\_\_}\left[\sum _{yo=1}\right(h_{}\left(x^{yo}\right)-y^{yo}{)}^2]+yo\sum _{j=1}|\theta {\_}_{}|$$

La lógica anterior puede verse como una aplicación del método multiplicador de Lagrange.

Los objetivos principales del uso del método de contracción incluyen dos:

1. Por un lado, debido a que el modelo puede considerar muchas características innecesarias, que son ruido para el modelo, la contracción puede reducir la complejidad del modelo al eliminar el ruido;
2. Por otro lado, si hay multicolinealidad en las características del modelo (correlación entre variables), puede conducir a múltiples soluciones para el modelo, y una solución de un modelo de múltiples soluciones a menudo no puede reflejar la verdadera situación del modelo. características asociadas y mejorar la estabilidad del modelo.

gráficos correspondientes

Podemos simplificar la ecuación para la regularización L2:
$j=j_{}+yo{\sum }_{}{w}^2$
J0 representa la función de pérdida original. Suponemos que el término de regularización es: Supongamos
que 2 características w tienen dos valores w1 y w2
$l=\lambda (w_1^{}+w_2^{})$
También podríamos recordar la ecuación de un círculo:
$(x-un{)}^2+(y-segundo{)}^2=r^{2donde}$
(a, b) son las coordenadas del centro del círculo y r es el radio. Entonces, la unidad que pasa por el origen de las coordenadas se puede escribir como:
Igual que el término de regularización L2. Al mismo tiempo, la tarea del aprendizaje automático es encontrar el valor mínimo de la función de pérdida a través de algunos métodos (como como descenso de gradiente).
En este momento, nuestra tarea es encontrar la solución que minimice J0 bajo la restricción L (método del multiplicador de Lagrange).

El proceso de resolución de J0 puede dibujar contornos. Al mismo tiempo, la función regularizada L2 L también se puede dibujar en el plano bidimensional de w1w2. Como se muestra en la siguiente figura:

L se representa como un círculo negro en la figura. A medida que el método de descenso de gradiente continúa acercándose, se cruza con el círculo por primera vez y es difícil que esta intersección aparezca en el eje de coordenadas.

Esto muestra que la regularización L2 no es fácil para obtener una matriz dispersa. Al mismo tiempo, para encontrar el valor mínimo de la función de pérdida, w1 y w2 están infinitamente cerca de 0 para evitar un ajuste excesivo.

Regresión de Ridege

Este es el
caso de prueba de regularización L2:

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(42)
x = np.random.uniform(-3.0, 3.0, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x + 3 + np.random.normal(0, 1, size=100)

plt.scatter(x, y)
plt.show()

Utilice 20 términos para ajustar (simulando sobreajuste)

from sklearn.linear_model import LinearRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

def PolynomiaRegression(degree):
    return Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('std_scale', StandardScaler()),
        ('lin_reg', LinearRegression()),
    ])


np.random.seed(666)
x_train, x_test, y_train, y_test = train_test_split(X, y)

poly_reg = PolynomiaRegression(degree=20)
poly_reg.fit(x_train, y_train)

y_poly_predict = poly_reg.predict(x_test)
print(mean_squared_error(y_test, y_poly_predict))
# 167.9401085999025
import matplotlib.pyplot as plt
x_plot = np.linspace(-3, 3, 100).reshape(100, 1)
y_plot = poly_reg.predict(x_plot)

plt.scatter(x, y)
plt.plot(x_plot[:,0], y_plot, color='r')
plt.axis([-3, 3, 0, 6])
plt.show()

Encapsule una función para generar un conjunto de prueba y probar el modelo.

def plot_model(model):
    x_plot = np.linspace(-3, 3, 100).reshape(100, 1)
    y_plot = model.predict(x_plot)

    plt.scatter(x, y)
    plt.plot(x_plot[:,0], y_plot, color='r')
    plt.axis([-3, 3, 0, 6])
    plt.show()

Utilice la regresión de crestas:

from sklearn.linear_model import Ridge
def RidgeRegression(degree, alpha):
    return Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('std_scale', StandardScaler()),
        ('lin_reg', Ridge(alpha=alpha)),
    ])

ridege1_reg = RidgeRegression(20, alpha=0.0001)
ridege1_reg.fit(x_train, y_train)

y1_predict = ridege1_reg.predict(x_test)
print(mean_squared_error(y_test, y1_predict))
# 跟之前的136.相比小了很多
plot_model(ridege1_reg)

Error de salida: 1.3233492754136291

Ajustar $a$ =1

ridege2_reg = RidgeRegression(20, alpha=1)
ridege2_reg.fit(x_train, y_train)

y2_predict = ridege2_reg.predict(x_test)
print(mean_squared_error(y_test, y2_predict))
plot_model(ridege2_reg)

Salida: 1.1888759304218461

ajustar $un$ =100

ridege2_reg = RidgeRegression(20, alpha=100)
ridege2_reg.fit(x_train, y_train)

y2_predict = ridege2_reg.predict(x_test)
print(mean_squared_error(y_test, y2_predict))
# 1.3196456113086197
plot_model(ridege2_reg)

Salida: 1.3196456113086197

ajustar alfa \alpha=$1000000$

ridege2_reg = RidgeRegression(20, alpha=1000000)
ridege2_reg.fit(x_train, y_train)

y2_predict = ridege2_reg.predict(x_test)
print(mean_squared_error(y_test, y2_predict))
# 1.8404103153255003
plot_model(ridege2_reg)

Salida: 1.8404103153255003

A partir de los valores alfa anteriores, podemos ver que podemos realizar una búsqueda más detallada entre 1 y 100 y encontrar la curva relativamente suave más adecuada para ajustar. Esta es la regularidad L2.

Regularización LASSO

encapsulación

#%%

import numpy as np
import matplotlib.pyplot as plt
from skimage.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
np.random.seed(42)
x = np.random.uniform(-3.0, 3.0, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x + 3 + np.random.normal(0, 1, size=100)
np.random.seed(666)
x_train, x_test, y_train, y_test = train_test_split(X, y)

plt.scatter(x, y)
plt.show()

#%%

from sklearn.linear_model import Lasso
def plot_model(model):
    x_plot = np.linspace(-3, 3, 100).reshape(100, 1)
    y_plot = model.predict(x_plot)

    plt.scatter(x, y)
    plt.plot(x_plot[:,0], y_plot, color='r')
    plt.axis([-3, 3, 0, 6])
    plt.show()
def LassoRegression(degree, alpha):
    return Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('std_scale', StandardScaler()),
        ('lin_reg', Lasso(alpha=alpha)),
    ])
def TestRegression(degree, alpha):
    lasso1_reg = LassoRegression(degree, alpha) 
    #这里相比Ridge的alpha小了很多，这是因为在Ridge中是平方项
    lasso1_reg.fit(x_train, y_train)
    
    y1_predict = lasso1_reg.predict(x_test)
    print(mean_squared_error(y_test, y1_predict))
    # 1.149608084325997
    plot_model(lasso1_reg)

Usando regresión de lazo:
ajustando $\alpha$ = 0,01

TestRegression(20,0.01)

Salida: 1.149608084325997

Ajustar $\alpha$ = 0,1

TestRegression(20,0.1)

Salida: 1.1213911351818648

ajustar $a$ =1

TestRegression(20,1)

Salida: 1.8408939659515595

Explicar Ridge y LASSO

Al comparar las dos figuras, se encuentra que es más probable que el modelo ajustado por LASSO sea una línea recta, mientras que es más probable que el modelo ajustado por Ridge sea una curva. Esto se debe a que las dos regularidades son esencialmente diferentes. Ridge tiende a hacer que la
suma de todo sea lo más pequeña posible, mientras que Lasso tiende a hacer que parte
del valor se convierta en 0, por lo que puede usarse para la selección de características. Por eso se llama Selección El motivo de la operación.