Entrenamiento de nuestro modelo de clasificación optimizado

Como nota interesante, una vez que has terminado el entrenamiento y se ha generado tu best model nada te prohibe, abrirlo y seguirlo entrenando un par de iteraciones más.

Adjunto mi código para que se den una idea:

 # Checkpoint Callback
    checkpoint_cb = ModelCheckpoint("models/best_model.h5", verbose=1, save_best_only=True, monitor="val_acc")

    if not exists("models/best_model.h5"):
        print("Entrenando por primera vez")
        print("*" * 64)
        print("Creando arquitectura")
        md = architecture(base_filtros=32, w_regularized=1e-4, shape=x_train[0].shape, num_classes=num_clases)
        print("*" * 64)
        print("Empezando a entrenar")
        md.compile(optimizer=Adam(), loss="categorical_crossentropy", metrics=["acc"])
        history = md.fit(datagen.flow(x_train, y_train, batch_size=128),
                         callbacks=[checkpoint_cb],
                         steps_per_epoch=x_train.shape[0] // 128,
                         epochs=50,
                         verbose=2,
                         validation_data=(x_valid, y_valid))
        plot_results(history, "acc", "resultado_tuneado.png")

    else:
        print("Abriendo modelo y continuando entrenamiento")
        md = load_model("models/best_model.h5")
        history = md.fit(datagen.flow(x_train, y_train, batch_size=128),
                         callbacks=[checkpoint_cb],
                         steps_per_epoch=x_train.shape[0] // 128,
                         epochs=20,
                         verbose=2,
                         validation_data=(x_valid, y_valid))

        plot_results(history, "acc", "resultado_tuneado_2.png") 

El número de lotes que se crearán en `datagen.flow()` depende del tamaño del conjunto de datos, el tamaño del lote especificado y el número de pasos por época. Si no se establece un `steps_per_epoch` explícitamente, Keras continuará generando lotes hasta que se agoten todos los datos. Es importante definir `steps_per_epoch` o proporcionar un tamaño de datos que se ajuste a tu modelo para controlar este comportamiento.

Para entrenar un modelo de clasificación optimizado con redes neuronales convolucionales (CNN), se pueden aplicar varias estrategias de optimización, como el uso de técnicas de \*\*regularización\*\*, \*\*data augmentation\*\*, y \*\*callbacks\*\* como \*\*EarlyStopping\*\* y \*\*ModelCheckpoint\*\* para controlar el entrenamiento y mejorar el rendimiento del modelo. A continuación, te guiaré a través de un ejemplo paso a paso para entrenar un modelo optimizado utilizando el conjunto de datos \*\*Fashion MNIST\*\*. \### Paso 1: Cargar y preprocesar los datos Vamos a usar el conjunto de datos \*\*Fashion MNIST\*\*, que contiene imágenes de 28x28 píxeles en escala de grises de diferentes artículos de ropa. ```python import tensorflow as tf from tensorflow.keras.datasets import fashion\_mnist from tensorflow.keras.utils import to\_categorical \# Cargar los datos (x\_train, y\_train), (x\_test, y\_test) = fashion\_mnist.load\_data() \# Redimensionar las imágenes para que tengan una dimensión de canal x\_train = x\_train.reshape(-1, 28, 28, 1) x\_test = x\_test.reshape(-1, 28, 28, 1) \# Normalizar los valores de los píxeles entre 0 y 1 x\_train = x\_train.astype('float32') / 255 x\_test = x\_test.astype('float32') / 255 \# Convertir las etiquetas a formato one-hot y\_train = to\_categorical(y\_train, 10) y\_test = to\_categorical(y\_test, 10) ``` \### Paso 2: Crear el modelo CNN Este es el modelo básico con capas de convolución, activación, max pooling, y regularización mediante \*\*Dropout\*\* y \*\*Batch Normalization\*\*. ```python from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, BatchNormalization \# Definir el modelo model = Sequential() \# Primera capa de convolución model.add(Conv2D(32, (3, 3), padding='same', activation='relu', input\_shape=(28, 28, 1))) model.add(BatchNormalization()) model.add(MaxPooling2D(pool\_size=(2, 2))) model.add(Dropout(0.25)) \# Segunda capa de convolución model.add(Conv2D(64, (3, 3), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool\_size=(2, 2))) model.add(Dropout(0.25)) \# Aplanar y capas completamente conectadas model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) \# Capa de salida model.add(Dense(10, activation='softmax')) \# Resumen del modelo model.summary() ``` \### Paso 3: Compilar el modelo Elegimos un optimizador adecuado y configuramos una función de pérdida y métricas de evaluación. ```python model.compile(optimizer='adam', loss='categorical\_crossentropy', metrics=\['accuracy']) ``` \### Paso 4: Callbacks (EarlyStopping y ModelCheckpoint) Utilizaremos \*\*EarlyStopping\*\* para detener el entrenamiento si el rendimiento en los datos de validación deja de mejorar, y \*\*ModelCheckpoint\*\* para guardar el mejor modelo. ```python from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint \# Guardar el mejor modelo checkpoint = ModelCheckpoint('mejor\_modelo.h5', monitor='val\_accuracy', save\_best\_only=True, verbose=1) \# Detener el entrenamiento si no mejora la precisión de validación early\_stopping = EarlyStopping(monitor='val\_accuracy', patience=5, verbose=1) \# Lista de callbacks callbacks = \[checkpoint, early\_stopping] ``` \### Paso 5: Entrenamiento con Data Augmentation El \*\*Data Augmentation\*\* genera nuevas imágenes a partir de las existentes mediante transformaciones aleatorias, lo que mejora la capacidad de generalización del modelo. ```python from tensorflow.keras.preprocessing.image import ImageDataGenerator \# Crear un generador de datos con augmentación datagen = ImageDataGenerator(rotation\_range=20, width\_shift\_range=0.2, height\_shift\_range=0.2, horizontal\_flip=True) \# Ajustar el generador a los datos de entrenamiento datagen.fit(x\_train) \# Entrenar el modelo history = model.fit(datagen.flow(x\_train, y\_train, batch\_size=32), epochs=50, validation\_data=(x\_test, y\_test), callbacks=callbacks) ``` \### Paso 6: Evaluar el modelo Finalmente, evaluamos el rendimiento del mejor modelo guardado en el conjunto de datos de prueba. ```python \# Cargar el mejor modelo guardado mejor\_modelo = tf.keras.models.load\_model('mejor\_modelo.h5') \# Evaluar el modelo en los datos de prueba score = mejor\_modelo.evaluate(x\_test, y\_test, verbose=0) print(f'Pérdida en test: {score\[0]}') print(f'Precisión en test: {score\[1]}') ``` \### Explicación de los Componentes Clave: 1\. \*\*Batch Normalization\*\*: Acelera el entrenamiento y mejora la estabilidad al normalizar las entradas a cada capa. 2\. \*\*Dropout\*\*: Reduce el sobreajuste al apagar aleatoriamente neuronas durante el entrenamiento. 3\. \*\*EarlyStopping\*\*: Detiene el entrenamiento si el modelo deja de mejorar después de un número fijo de épocas. 4\. \*\*ModelCheckpoint\*\*: Guarda el modelo con mejor rendimiento durante el entrenamiento. 5\. \*\*Data Augmentation\*\*: Mejora la capacidad del modelo para generalizar al modificar las imágenes de entrenamiento. Con este enfoque, tienes un modelo optimizado para la clasificación de imágenes, que debería generalizar mejor en datos no vistos y tener un entrenamiento más eficiente.

Epoch 1/20
384/391 ━━━━━━━━━━━━━━━━━━━━ 0s 99ms/step - accuracy: 0.1996 - loss: 2.1047
391/391 ━━━━━━━━━━━━━━━━━━━━ 46s 105ms/step - accuracy: 0.2010 - loss: 2.1013 - val_accuracy: 0.3720 - val_loss: 1.6851
Epoch 2/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.3685 - loss: 1.6976 - val_accuracy: 0.4526 - val_loss: 1.5051
Epoch 3/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.4288 - loss: 1.5673 - val_accuracy: 0.4945 - val_loss: 1.4209
Epoch 4/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 93ms/step - accuracy: 0.4615 - loss: 1.4908 - val_accuracy: 0.5006 - val_loss: 1.3773
Epoch 5/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.4906 - loss: 1.4152 - val_accuracy: 0.5245 - val_loss: 1.3175
Epoch 6/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 92ms/step - accuracy: 0.5102 - loss: 1.3676 - val_accuracy: 0.5637 - val_loss: 1.2155
Epoch 7/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5174 - loss: 1.3467 - val_accuracy: 0.5705 - val_loss: 1.1890
Epoch 8/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5394 - loss: 1.2960 - val_accuracy: 0.5858 - val_loss: 1.1732
Epoch 9/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 92ms/step - accuracy: 0.5484 - loss: 1.2656 - val_accuracy: 0.5985 - val_loss: 1.1295
Epoch 10/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5630 - loss: 1.2347 - val_accuracy: 0.5931 - val_loss: 1.1346
Epoch 11/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5690 - loss: 1.2147 - val_accuracy: 0.6115 - val_loss: 1.0975
Epoch 12/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.5773 - loss: 1.1939 - val_accuracy: 0.6341 - val_loss: 1.0285
Epoch 13/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.5855 - loss: 1.1819 - val_accuracy: 0.6211 - val_loss: 1.0559
Epoch 14/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5829 - loss: 1.1710 - val_accuracy: 0.6284 - val_loss: 1.0315
Epoch 15/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5975 - loss: 1.1436 - val_accuracy: 0.6196 - val_loss: 1.0725
Epoch 16/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.6034 - loss: 1.1338 - val_accuracy: 0.6098 - val_loss: 1.1229
Epoch 17/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 93ms/step - accuracy: 0.6082 - loss: 1.1112 - val_accuracy: 0.6426 - val_loss: 1.0291
Epoch 18/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.6121 - loss: 1.1037 - val_accuracy: 0.6594 - val_loss: 0.9613
Epoch 19/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.6172 - loss: 1.0911 - val_accuracy: 0.6101 - val_loss: 1.1146
Epoch 20/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.6174 - loss: 1.0960 - val_accuracy: 0.6443 - val_loss: 0.9951

313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.6421 - loss: 1.0004
[0.9950822591781616, 0.6442999839782715]