🧙🏼♂️ Cuando estamos usando el flow_from_directory y definimos el class_mode ‘binary’ noten que identifica que cada carpeta corresponde a una categoría en particular. es importante que cuando carguemos nuestra data esté debidamente organizada para no causar desastres de ahí en adelante.
Redes convolucionales y su importancia
La importancia del computer vision
¿Qué herramientas usaremos para redes neuronales convolucionales?
¿Qué son las redes convolucionales?
Mi primera red neuronal convolucional
Creando nuestra primera red convolucional
Entrenando nuestra primera red convolucional
Manejo de imágenes
Consejos para el manejo de imágenes
Manejo de imágenes con Python
Fundamentos de redes neuronales convolucionales
Kernel en redes neuronales
El kernel en acción
Padding y Strides
Capa de pooling
Arquitectura de redes convolucionales
Quiz: Fundamentos de redes neuronales convolucionales
Resolviendo un problema de clasificación
Clasificación con redes neuronales convolucionales
Creación de red convolucional para clasificación
Entrenamiento de un modelo de clasificación con redes convolucionales
Optimización de red neuronal convolucional
Data augmentation
Aplicando data augmentation
Callbacks: early stopping y checkpoints
Batch normalization
Optimización de modelo de clasificación
Entrenamiento de nuestro modelo de clasificación optimizado
Quiz: Optimización de red neuronal convolucional
Resolviendo una competencia de Kaggle
Clasificando entre perros y gatos
Entrenamiento del modelo de clasificación de perros y gatos
Resumen y siguientes pasos
Siguientes pasos con redes neuronales convolucionales
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
Si ya tienes una cuenta,
Entrenamiento del modelo de clasificación de perros y gatos
23/25Recursos
Aportes 6
Preguntas 4
Ordenar por:
Logré un accuracy de 0.90 use una arquitectura diferente, con:
C32, C64, C128, C256, C512, C512, D512, Dropout 0.3, D1
- C Conv2D
- D Dense
Dejo el link del Notebook, ya que también use las capas de MaxPool y BatchNormalization en cada convolución.
El error fue que en la capa de salida del modelo el profesor puso 1 neurona en vez de 2, solo hay que corregir eso y podras hacer predicciones
Probé con un dataset de rostros humanos:
```python
model = Sequential()
model.add(keras.layers.Conv2D(32, (3,3), activation="relu", input_shape=(150,150,3)))
model.add(keras.layers.MaxPooling2D(pool_size=(2,2)))
## conv 2
model.add(keras.layers.Conv2D(64, (3,3), activation="relu"))
model.add(keras.layers.MaxPooling2D(pool_size=(2,2)))
## conv 3
model.add(keras.layers.Conv2D(128, (3,3), activation="relu"))
model.add(keras.layers.MaxPooling2D(pool_size=(2,2)))
## conv 4
model.add(keras.layers.Conv2D(128, (3,3), activation="relu"))
model.add(keras.layers.MaxPooling2D(pool_size=(2,2)))
## Clasificación-Flatten
model.add(keras.layers.Flatten())
model.add(keras.layers.Dropout(0.5))
model.add(keras.layers.Dense(512, activation='relu'))
model.add(keras.layers.Dense(1, activation='sigmoid'))
model.summary()
train_datagen = ImageDataGenerator(
rescale=1./255,
rotation_range=40,
width_shift_range = 0.2,
height_shift_range = 0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True
)
test_datagen = ImageDataGenerator(1./255)
train_generator= train_datagen.flow_from_directory('/kaggle/input/gender-recognition-200k-images-celeba/Dataset/Train',
target_size=(150,150),
batch_size=32,
class_mode='binary'
)
validation_generator=test_datagen.flow_from_directory('/kaggle/input/gender-recognition-200k-images-celeba/Dataset/Validation',
target_size=(150,150),
batch_size=32,
class_mode='binary'
)
Found 160000 images belonging to 2 classes.
Found 22598 images belonging to 2 classes.
checkpoint = ModelCheckpoint('Model_caras.keras', monitor='val_accuracy', verbose=1, save_best_only=True)
model.compile(
loss='binary_crossentropy',
optimizer= keras.optimizers.Adam(),
metrics=['accuracy']
)
hist = model.fit(train_generator, steps_per_epoch=2000//32,
epochs=100,
validation_data=validation_generator,
validation_steps=1000//32,
callbacks=[checkpoint])
```
```js
test_generator=test_datagen.flow_from_directory('/kaggle/input/gender-recognition-200k-images-celeba/Dataset/Test',
target_size=(150,150),
batch_size=32,
class_mode='binary'
)
test_generator=test_datagen.flow_from_directory('/kaggle/input/gender-recognition-200k-images-celeba/Dataset/Test',
target_size=(150,150),
batch_size=32,
class_mode='binary'
)
Found 20001 images belonging to 2 classes.
model2 = keras.models.load_model('./Model_caras.keras')
626/626 ━━━━━━━━━━━━━━━━━━━━ 28s 44ms/step - accuracy: 0.9375 - loss: 13.6663
[14.009474754333496, 0.9361531734466553]
```
Para entrenar un modelo de clasificación de perros y gatos con una red convolucional en Keras, puedes seguir estos pasos usando imágenes de entrenamiento y validación, además de técnicas de \*\*Data Augmentation\*\* para mejorar el rendimiento del modelo:
\### Paso 1: Preparar el Dataset
Para este ejemplo, se asume que tienes las imágenes de perros y gatos en carpetas separadas para el conjunto de entrenamiento y validación:
```
data/
├── train/
│ ├── dogs/ # imágenes de perros
│ └── cats/ # imágenes de gatos
└── validation/
├── dogs/
└── cats/
```
\### Paso 2: Crear el Modelo
```python
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
\# Crear la red convolucional
model = models.Sequential(\[
layers.Conv2D(32, (3, 3), activation='relu', input\_shape=(150, 150, 3)),
layers.MaxPooling2D((2, 2)),
layers.Conv2D(64, (3, 3), activation='relu'),
layers.MaxPooling2D((2, 2)),
layers.Conv2D(128, (3, 3), activation='relu'),
layers.MaxPooling2D((2, 2)),
layers.Conv2D(128, (3, 3), activation='relu'),
layers.MaxPooling2D((2, 2)),
layers.Flatten(),
layers.Dropout(0.5),
layers.Dense(512, activation='relu'),
layers.Dense(1, activation='sigmoid')
])
model.compile(loss='binary\_crossentropy',
optimizer='adam',
metrics=\['accuracy'])
model.summary()
```
\### Paso 3: Generar los Datos con Aumento de Datos
```python
train\_datagen = ImageDataGenerator(
rescale=1./255,
rotation\_range=20,
width\_shift\_range=0.2,
height\_shift\_range=0.2,
shear\_range=0.2,
zoom\_range=0.2,
horizontal\_flip=True
)
validation\_datagen = ImageDataGenerator(rescale=1./255)
train\_generator = train\_datagen.flow\_from\_directory(
'data/train',
target\_size=(150, 150),
batch\_size=32,
class\_mode='binary'
)
validation\_generator = validation\_datagen.flow\_from\_directory(
'data/validation',
target\_size=(150, 150),
batch\_size=32,
class\_mode='binary'
)
```
\### Paso 4: Entrenar el Modelo con Callbacks
```python
checkpoint = tf.keras.callbacks.ModelCheckpoint(
filepath='best\_model.keras',
monitor='val\_accuracy',
save\_best\_only=True,
verbose=1
)
early\_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val\_loss',
patience=5,
verbose=1,
restore\_best\_weights=True
)
history = model.fit(
train\_generator,
steps\_per\_epoch=train\_generator.samples // 32,
epochs=30,
validation\_data=validation\_generator,
validation\_steps=validation\_generator.samples // 32,
callbacks=\[checkpoint, early\_stopping]
)
```
\### Paso 5: Evaluar el Modelo
Una vez entrenado, puedes evaluar el modelo en el conjunto de validación:
```python
loss, accuracy = model.evaluate(validation\_generator)
print(f'Accuracy: {accuracy\*100:.2f}%')
```
Este modelo utiliza varias capas convolucionales y una capa de `Dropout` para evitar el sobreajuste, junto con técnicas de \*\*Data Augmentation\*\* para mejorar su capacidad de generalización. Los `callbacks` de \*\*checkpoint\*\* y \*\*early stopping\*\* guardan el mejor modelo y detienen el entrenamiento si el rendimiento no mejora.
Found 1000 images belonging to 2 classes.
Found 2000 images belonging to 2 classes.
Epoch 1/10
1/32 ━━━━━━━━━━━━━━━━━━━━ 5:50 11s/step - accuracy: 0.5000 - loss: 0.6948
31/32 ━━━━━━━━━━━━━━━━━━━━ 0s 387ms/step - accuracy: 0.5336 - loss: 0.7417
32/32 ━━━━━━━━━━━━━━━━━━━━ 41s 963ms/step - accuracy: 0.5326 - loss: 0.7399 - val_accuracy: 0.5755 - val_loss: 0.6924
Epoch 2/10
32/32 ━━━━━━━━━━━━━━━━━━━━ 0s 432us/step - accuracy: 0.0000e+00 - loss: 0.0000e+00 - val_accuracy: 0.0000e+00 - val_loss: 0.0000e+00
Epoch 3/10
32/32 ━━━━━━━━━━━━━━━━━━━━ 11s 289ms/step - accuracy: 0.5488 - loss: 0.6931 - val_accuracy: 0.5075 - val_loss: 0.6892
Epoch 4/10
32/32 ━━━━━━━━━━━━━━━━━━━━ 0s 303us/step - accuracy: 0.0000e+00 - loss: 0.0000e+00 - val_accuracy: 0.0000e+00 - val_loss: 0.0000e+00
Epoch 5/10
32/32 ━━━━━━━━━━━━━━━━━━━━ 11s 297ms/step - accuracy: 0.5186 - loss: 0.6887 - val_accuracy: 0.6245 - val_loss: 0.6655
Epoch 6/10
32/32 ━━━━━━━━━━━━━━━━━━━━ 0s 296us/step - accuracy: 0.0000e+00 - loss: 0.0000e+00 - val_accuracy: 0.0000e+00 - val_loss: 0.0000e+00
Epoch 7/10
32/32 ━━━━━━━━━━━━━━━━━━━━ 11s 304ms/step - accuracy: 0.6038 - loss: 0.6731 - val_accuracy: 0.6155 - val_loss: 0.6613
Epoch 8/10
32/32 ━━━━━━━━━━━━━━━━━━━━ 0s 367us/step - accuracy: 0.0000e+00 - loss: 0.0000e+00 - val_accuracy: 0.0000e+00 - val_loss: 0.0000e+00
Epoch 9/10
32/32 ━━━━━━━━━━━━━━━━━━━━ 11s 299ms/step - accuracy: 0.6291 - loss: 0.6470 - val_accuracy: 0.6290 - val_loss: 0.6559
Epoch 10/10
32/32 ━━━━━━━━━━━━━━━━━━━━ 0s 292us/step - accuracy: 0.0000e+00 - loss: 0.0000e+00 - val_accuracy: 0.0000e+00 - val_loss: 0.0000e+00
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?