Entrenamiento gatos y perros

Para entrenar una red neuronal que me clasifique perros y gatos he bajado este dataset:

https://www.microsoft.com/en-us/download/details.aspx?id=54765

Tiene 15000 imagenes de gatos y perros.

He utilizado el siguiente código para entrenar una red convolucional:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.optimizers import Adam
import matplotlib.pyplot as plt

# Definir rutas
train_dir = 'dataset/'  # Asegúrate de que tus imágenes están organizadas en carpetas "gatos" y "perros"

# Preprocesamiento de las imágenes
train_datagen = ImageDataGenerator(
    rescale=1. / 255,  # Normaliza las imágenes
    shear_range=0.2,  # Aumenta las imágenes con transformaciones aleatorias
    zoom_range=0.2,
    horizontal_flip=True
)

train_generator = train_datagen.flow_from_directory(
    train_dir,
    target_size=(64, 64),  # Redimensiona las imágenes a 64x64
    batch_size=32,
    class_mode='binary'  # Como es un problema de clasificación binaria (gato o perro)
)

# Definir el modelo CNN
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)),
    MaxPooling2D((2, 2)),

    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),

    Conv2D(64, (3, 3), activation='relu'),

    Flatten(),

    Dense(64, activation='relu'),
    Dropout(0.5),
    Dense(1, activation='sigmoid')  # Salida binaria (0 o 1)
])

# Compilar el modelo
model.compile(
    optimizer=Adam(),
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# Entrenar el modelo
history = model.fit(
    train_generator,
    steps_per_epoch=train_generator.samples // train_generator.batch_size,
    epochs=10
)

# Evaluar el modelo
plt.plot(history.history['accuracy'])
plt.title('Precisión del modelo')
plt.xlabel('Épocas')
plt.ylabel('Precisión')
plt.show()

# Guardar el modelo entrenado
model.save('modelo_gato_perro.h5')

He guardado el modelo para no tener que entrenar, ya que tarda mucho. El resultado es el siguiente:

https://trifulcas.com/wp-content/uploads/2024/11/modelo_gato_perro.h5

Con ese modelo podemos hacer predicciones.

from tensorflow.keras.preprocessing import image
import numpy as np
from tensorflow.keras.models import load_model
for i  in range(100):
    # Cargar la imagen
    img_path = f'dataset/Dog/{i*10}.jpg'  # Cambia la ruta de la imagen
    img = image.load_img(img_path, target_size=(64, 64))  # Redimensionar a 64x64
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)  # Hacer batch

    # Normalizar la imagen
    img_array /= 255.
    model = load_model('modelo_gato_perro.h5')
    # Realizar la predicción
    prediction = model.predict(img_array)

    # Mostrar el resultado
    if prediction[0] > 0.5:
        print("Es un perro.")
    else:
        print(f"Es un gato {i}.")

 

Podríamos mirar la precisión, o incluso descargar imágenes de perros y gatos para probar