Entrenamiento de un modelo de clasificación con redes convolucionales

Modifique el tamaño del bach a 64, learning rate a 8e-5, el dropout de algunas capas, obteniendo un accuracy con el set de test del 80.46%

in_shape = x_train.shape[1:]
f_size = [32, 32, 64, 64, 128, 128]#filtros en cada capa conv2D
k_size =[3, 3, 3, 3, 3, 3] #tamaño del kernel 
r_lr = 8e-5  #learning rate
r_dropout = [0.0, 0.0, 0.2, 0.2, 0.2, 0.2] #dropout en cada capa

def def_model(in_shape,n_clases,f_size,k_size,r_lr):
    model = Sequential()

    #conv1
    model.add(Conv2D(f_size[0], k_size[0], padding= 'same', kernel_regularizer=regularizers.l2(r_lr), input_shape = in_shape))
    model.add(Activation('relu'))


    #conv2
    model.add(Conv2D(f_size[1], k_size[1], padding= 'same', kernel_regularizer=regularizers.l2(r_lr)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2,2)))
    model.add(Dropout(r_dropout[1]))

    #conv3
    model.add(Conv2D(f_size[2], k_size[2], padding= 'same', kernel_regularizer=regularizers.l2(r_lr)))
    model.add(Activation('relu'))
    #model.add(MaxPooling2D(pool_size=(2,2)))
    model.add(Dropout(r_dropout[2]))

    #conv4
    model.add(Conv2D(f_size[3], k_size[3], padding= 'same', kernel_regularizer=regularizers.l2(r_lr)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2,2)))
    model.add(Dropout(r_dropout[3]))


    #conv5
    model.add(Conv2D(f_size[4], k_size[4], padding= 'same', kernel_regularizer=regularizers.l2(r_lr)))
    model.add(Activation('relu'))
    #model.add(MaxPooling2D(pool_size=(2,2)))
    #model.add(Dropout(0.2))

    #conv6
    model.add(Conv2D(f_size[5], k_size[5], padding= 'same', kernel_regularizer=regularizers.l2(r_lr)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2,2)))
    model.add(Dropout(r_dropout[5]))
    #Clasificacion - Flatten
    model.add(Flatten())
    model.add(Dense(n_clases, activation='softmax'))
    model.summary()

    return model


model = def_model(in_shape,n_clases,f_size,k_size,r_lr)
print(y_train[0])
model.compile(loss='categorical_crossentropy',optimizer='rmsprop',metrics=['accuracy'])
hist = model.fit(x_train, y_train, batch_size = 64,epochs=60, 
                validation_data=( x_val,y_val),
                verbose=2, shuffle=True)
plt.plot(hist.history['accuracy'],label='Train')
plt.plot(hist.history['val_accuracy'],label='Val')
plt.legend()
plt.show()
model.evaluate(x_test,y_test)

Logre un accuracy de 0.7799 con estos cambios:

• Aumentar dropouts: donde estaban 0.2 aumente a 0.3 y los 0.3 a 0.4. Esto con la intención de disminuir el overfitting.
• Agregue una capa densa con activación relu antes de la capa de clasificación: con num_clases*2 neuronas con la intención de apoyar mas la parte de clasificación y menos la extración de caracteristicas en las capas convolucionales.
• Cambié el optimizer a adam por curiosidad
• Solo fueron 50 epochs para que fuera mas rapido las pruebas

En el link de Kaggle de los recursos, el notepad no coincide del todo con las clases 😃
Las diferencias son:
-> En el notepad vienen las líneas de normalización (In [8], y In [9]
-> Al momento de crear el modelo, el modelo del link tiene adicional “model.add(BatchNormalization())”, que tampoco se explicó en las clases.

Estas diferencias provocan que el código no se ejecute correctamente

Después de varios intentos sin resultados satisfactorios decidí dejarlo tal cual como lo implementó el profesor pero cambié el numero de filtros de 32 a 64, el resultado fue bastante aceptable

Es cierto, el modificar las epocas de 32 a 64 ayuda a mejorar el modelo.

Cambié mi optimizador a: optimizer=keras.optimizers.Adam(
learning_rate=0.0001)
Sí, le puse otro 0.
base_filtros en 64
El accuracy sobre el lote de test arroja un 85.94%
Sobre el propio train es de 88.79%
Sobre el de validación es del 86.40%

Claro que se pude seguir mejorando. Probaría con AveragePooling en vez de Max.

Llegué a un 81.42 en val

Cambié el learning rate a 0.5e-4 y empecé con 64 filtros, les anexo mi notebook:
https://colab.research.google.com/drive/1Mj7flDtjC3wc3ds1vl_ApviwA1-rzX42?usp=sharing

A modo de comentario, ejecuté el ejercicio en Colab, el primer epochs duró 8 minutos, mientras que en Kaggle duró 28 segundos. Me enamoré de Kaggle 😃

llegue al 80.54 % en accuracy en test
Mi codigo:

base_filters = 32
w_regularizer = lambda: regularizers.l2(1e-4)

model = Sequential()
# Conv 1
model.add(Conv2D(base_filters, kernel_size=(3, 3), padding='same', kernel_regularizer=w_regularizer(), activation='relu', input_shape=x_train.shape[1:]))
model.add(MaxPooling2D(pool_size=(2, 2)))
# Conv 2
model.add(Conv2D(base_filters, kernel_size=(3, 3), padding='same', kernel_regularizer=w_regularizer(), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
# Conv 3
model.add(Conv2D(2 * base_filters, kernel_size=(3, 3), padding='same', kernel_regularizer=w_regularizer(), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
# Conv 4
model.add(Conv2D(3 * base_filters, kernel_size=(3, 3), padding='same', kernel_regularizer=w_regularizer(), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
# Conv 5
model.add(Conv2D(4 * base_filters, kernel_size=(3, 3), padding='same', kernel_regularizer=w_regularizer(), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.4))
# Classification - flatten
model.add(Flatten())
model.add(Dense(num_classes, activation='softmax'))

Alguna idea para mejorar la curva val?