No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Entrenamiento del modelo de clasificación de perros y gatos

23/25
Recursos

Aportes 6

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

🧙🏼‍♂️ 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.

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]) ```![](https://static.platzi.com/media/user_upload/image-10d85541-0508-461f-9b69-b2a47520674a.jpg) ```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