Redes convolucionales y su importancia

1

La importancia del computer vision

2

驴Qu茅 herramientas usaremos para redes neuronales convolucionales?

3

驴Qu茅 son las redes convolucionales?

Mi primera red neuronal convolucional

4

Creando nuestra primera red convolucional

5

Entrenando nuestra primera red convolucional

Manejo de im谩genes

6

Consejos para el manejo de im谩genes

7

Manejo de im谩genes con Python

Fundamentos de redes neuronales convolucionales

8

Kernel en redes neuronales

9

El kernel en acci贸n

10

Padding y Strides

11

Capa de pooling

12

Arquitectura de redes convolucionales

Quiz: Fundamentos de redes neuronales convolucionales

Resolviendo un problema de clasificaci贸n

13

Clasificaci贸n con redes neuronales convolucionales

14

Creaci贸n de red convolucional para clasificaci贸n

15

Entrenamiento de un modelo de clasificaci贸n con redes convolucionales

Optimizaci贸n de red neuronal convolucional

16

Data augmentation

17

Aplicando data augmentation

18

Callbacks: early stopping y checkpoints

19

Batch normalization

20

Optimizaci贸n de modelo de clasificaci贸n

21

Entrenamiento de nuestro modelo de clasificaci贸n optimizado

Quiz: Optimizaci贸n de red neuronal convolucional

Resolviendo una competencia de Kaggle

22

Clasificando entre perros y gatos

23

Entrenamiento del modelo de clasificaci贸n de perros y gatos

Resumen y siguientes pasos

24

Siguientes pasos con redes neuronales convolucionales

25

Comparte tu proyecto de clasificaci贸n con redes convolucionales y certif铆cate

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Entrenamiento de un modelo de clasificaci贸n con redes convolucionales

15/25
Recursos

Aportes 11

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥渕odel.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?