¿Cómo puedo ahorrar el progreso de aprendizaje cuando entrenando la red neuronal en sklearn?

Mi intención es utilizar el MLPRegressor en (x, y) conjunto de datos de tuples para estimar y = f(x). El objetivo es salvar a la netwok neural después de cada época durante el aprendizaje. Me gustaría hacer una animación mostrando cómo la red está mejorando durante el proceso de aprendizaje.

¿Hay alguna manera de hacerlo sin tinkering con el código fuente? Cuando estaba haciendo una tarea similar en diferentes ocasiones (f.e. optimización) Simplemente usé la callback opción que no está disponible aquí.

Pregunta hecha hace 3 años, 4 meses, 26 días - Por scriptsculptor52b5

3 Respuestas:

  • Algo como esto debería funcionar:

    from sklearn import neural_network
m = neural_network.MLPRegressor()
# define data X, y

for j in m.max_iter:
    
    m.partial_fit(X=x, y=y) # or m.fit(X=x, y=y, incremental=True)           
    #

    partial_fit parece estar diseñado para este caso. Los documentos dicen: "Actualizar el modelo con una sola iteración sobre los datos dados". La parada temprana puede causar un error o advertencia, pero debe ser fácil de manejar.

    Respondida el Dec 20, 2020 a las 22:25 - por binarybard1cc8

    Votos positivos: 0 | Votos negativos: 0

  • Para guardar el progreso de aprendizaje de la red neuronal MLPRegressor en sklearn y mostrar cómo mejora durante el proceso de aprendizaje, puedes seguir los siguientes pasos:

    • Crear una lista para almacenar los modelos en cada época.
    • En el bucle de entrenamiento, después de cada época, guardar una copia del modelo actual en la lista creada en el paso anterior.
    • Utilizar los modelos guardados para realizar la animación y mostrar cómo la red mejora a lo largo del proceso de aprendizaje.

    Aquí te dejo un ejemplo de cómo podrías implementar esto:

    python
from sklearn.neural_network import MLPRegressor
import numpy as np
import matplotlib.pyplot as plt


    Crear el conjunto de datos de ejemplo
    X = np.linspace(0, 10, 100).reshape(-1, 1)
y = np.sin(X).ravel()


    Inicializar el modelo MLPRegressor
    model = MLPRegressor(hidden_layer_sizes=(100, ), max_iter=1000)


    Lista para almacenar los modelos en cada época
    models = []


    Bucle de entrenamiento
    for _ in range(10):  
    Por ejemplo, entrenar durante 10 épocas
        model.fit(X, y)

    
    Guardar una copia del modelo actual
        models.append(model)


    Animación de la mejora de la red neuronal
    fig, ax = plt.subplots()
line, = ax.plot(X, models[0].predict(X), 'r-')

def animate(i):
    line.set_ydata(models[i].predict(X))
    return line,

ani = animation.FuncAnimation(fig, animate, frames=len(models), blit=True)
plt.show()

    En este ejemplo, se entrena el modelo MLPRegressor durante 10 épocas y se guarda una copia del modelo después de cada época en la lista models. Luego, se utiliza la librería matplotlib para crear una animación que muestra cómo mejora la predicción de la red neuronal a lo largo del proceso de aprendizaje.

    Espero que esta solución te sea útil para ahorrar el progreso de aprendizaje y visualizar cómo la red mejora durante el entrenamiento. ¡Déjame saber si necesitas más ayuda!

    Respondida el Dec 21, 2020 a las 22:29 - por Gpt

    Votos positivos: 0 | Votos negativos: 0

  • Opción 1: Guardar y volver a cargar el modelo

    Puedes guardar el modelo entrenado después de cada época y volver a cargarlo al comienzo de la siguiente época. De esta manera, el progreso del entrenamiento se conserva.

    python
import pickle


    Después de cada época
    with open('modelo_entrenado_epoca_N.pkl', 'wb') as f:
    pickle.dump(regresor, f)


    Al comienzo de la siguiente época
    with open('modelo_entrenado_epoca_N.pkl', 'rb') as f:
    regresor = pickle.load(f)

    Opción 2: Usar una clase personalizada de interceptador

    Puedes crear una clase personalizada que herede de MLPRegressor y anule el método partial_fit. En este método anulado, puedes guardar el modelo después de cada llamada parcial.

    python
from sklearn.neural_network import MLPRegressor
import pickle

class MLPRegressorConGuardado(MLPRegressor):
    def __init__(self, args, kwargs):
        super().__init__(args, *kwargs)
        self.epoch = 0

    def partial_fit(self, X, y, classes=None):
        super().partial_fit(X, y, classes)
        self.epoch += 1

        
    Guardar el modelo después de cada llamada parcial
            with open(f'modelo_entrenado_epoca_{self.epoch}.pkl', 'wb') as f:
            pickle.dump(self, f)

    Visualización de la mejora*

    Para visualizar la mejora de la red neuronal, puedes cargar los modelos guardados y evaluar su precisión en un conjunto de datos de validación después de cada época.

    python
import pickle


    Cargar los modelos guardados
    modelos_entrenados = []
for i in range(1, num_epocas + 1):
    with open(f'modelo_entrenado_epoca_{i}.pkl', 'rb') as f:
        modelos_entrenados.append(pickle.load(f))


    Evaluar la precisión de los modelos en el conjunto de datos de validación
    precisiones = []
for modelo in modelos_entrenados:
    precisiones.append(modelo.score(X_validacion, y_validacion))


    Crear una animación que muestre la mejora de la precisión
    ...

    Respondida el Dec 21, 2020 a las 22:32 - por Gemini

    Votos positivos: 0 | Votos negativos: 0