NN_clasification_spider_or_snake

Cree este codigo como practica de todo lo aprendido en el curso. Me encanto geniall !!

Para el código use python tensorflow y las librerías usadas durante el curso, así como lo aprendido en las ultimas clases de transferencia de aprendizaje.

import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
import numpy as np
from tensorflow.keras.preprocessing import image
import matplotlib.pyplot as plt
# Configuración de parámetros
IMG_SIZE = (224, 224) # tamaño de las imagenes
BATCH_SIZE = 32
EPOCHS = 20 # epocas de entrenamiento
LEARNING_RATE = 0.0001 # tasa de aprendizaje

# Ruta principal donde están las imágenes organizadas en carpetas por clase
base_dir = "dataset"

# Configuración de generadores para dividir y cargar los datos
datagen = ImageDataGenerator(
rescale=1.0 / 255,
validation_split=0.2 # Dividir 80% para entrenamiento y 20% para validación
)

# Generador de datos de entrenamiento
train_generator = datagen.flow_from_directory(
base_dir,
target_size=IMG_SIZE,
batch_size=BATCH_SIZE,
class_mode="binary", # Clasificación binaria (serpiente o araña)
subset="training", # Subconjunto de entrenamiento
shuffle=True,
)

# Generador de datos de validación
val_generator = datagen.flow_from_directory(
base_dir,
target_size=IMG_SIZE,
batch_size=BATCH_SIZE,
class_mode="binary", # Clasificación binaria
subset="validation" # Subconjunto de validación
)

# Cargar MobileNetV2 preentrenado
base_model = MobileNetV2(weights="imagenet", include_top=False, input_shape=(224, 224, 3))
base_model.trainable = False # Congelar las capas del modelo base

# Agregar capas personalizadas
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(128, activation="relu")(x)
predictions = Dense(1, activation="sigmoid")(x) # Salida binaria (sigmoid para 0 o 1)

# Construir el modelo
model = Model(inputs=base_model.input, outputs=predictions)

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

# Resumen del modelo
model.summary() # estadisticas de como quedo el entrenamiento

# Entrenar el modelo
history = model.fit(
train_generator,
validation_data=val_generator,
epochs=EPOCHS,
steps_per_epoch=train_generator.samples // BATCH_SIZE,
validation_steps=val_generator.samples // BATCH_SIZE
)
print("---------------------------------------------------------------")
# Guardar el modelo entrenado
model.save("modelo_serpiente_arana.h5")
print("Modelo entrenado y guardado como 'modelo_serpiente_arana.h5'")
print("---------------------------------------------------------------")
# Evaluar el modelo en los datos de validación
val_loss, val_accuracy = model.evaluate(val_generator)
print(f"Pérdida en validación: {val_loss:.4f}")
print(f"Precisión en validación: {val_accuracy:.4f}")
print("---------------------------------------------------------------")
# Función para predecir imágenes individuales
def predecir_imagen(model, img_path):
# Cargar y procesar la imagen
img = image.load_img(img_path, target_size=IMG_SIZE)
img_array = image.img_to_array(img) / 255.0
img_array = np.expand_dims(img_array, axis=0)
# Mostrar imagen al usuario
plt.imshow(img)
plt.axis("off") # Ocultar los ejes
plt.title("Imagen cargada para predicción")
plt.show()
# Realizar la predicción
prediction = model.predict(img_array)[0][0]
if prediction > 0.5:
print(f"La imagen es una serpiente con probabilidad {prediction:.2f}")
else:
print(f"La imagen es una araña con probabilidad {1 - prediction:.2f}")

print("---------------------------------------------------------------")
# Cargar el modelo para predicciones
model = tf.keras.models.load_model("modelo_serpiente_arana.h5")

# Ejemplo de predicción
ruta_imagen = "dataset/arañas/98.jpg" # Cambia esto a la ruta de tu imagen de prueba
predecir_imagen(model, ruta_imagen)

Epoch 1/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 19s 2s/step - accuracy: 0.4308 - loss: 0.7965 - val_accuracy: 0.8125 - val_loss: 0.4945
Epoch 2/20
1/6 ━━━━━━━━━━━━━━━━━━━━ 2s 496ms/step - accuracy: 0.7500 - loss: 0.5937C:\Users\GMADRO04\Documents\Domestika\IA_python_intro\myenv\Lib\site-packages\keras\src\trainers\epoch_iterator.py:107: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.
self._interrupted_warning()
6/6 ━━━━━━━━━━━━━━━━━━━━ 2s 219ms/step - accuracy: 0.7500 - loss: 0.5937 - val_accuracy: 0.7812 - val_loss: 0.5086
Epoch 3/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 6s 1s/step - accuracy: 0.7834 - loss: 0.5024 - val_accuracy: 0.9375 - val_loss: 0.3076
Epoch 4/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 2s 262ms/step - accuracy: 0.8750 - loss: 0.3663 - val_accuracy: 1.0000 - val_loss: 0.2881
Epoch 5/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 6s 948ms/step - accuracy: 0.9301 - loss: 0.3092 - val_accuracy: 1.0000 - val_loss: 0.2245
Epoch 6/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 2s 228ms/step - accuracy: 0.9688 - loss: 0.2436 - val_accuracy: 1.0000 - val_loss: 0.1955
Epoch 7/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 6s 963ms/step - accuracy: 0.9608 - loss: 0.2315 - val_accuracy: 1.0000 - val_loss: 0.1269
Epoch 8/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 2s 233ms/step - accuracy: 0.9375 - loss: 0.2186 - val_accuracy: 1.0000 - val_loss: 0.1281
Epoch 9/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 6s 1s/step - accuracy: 0.9790 - loss: 0.1682 - val_accuracy: 1.0000 - val_loss: 0.1162
Epoch 10/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 2s 242ms/step - accuracy: 0.9688 - loss: 0.1458 - val_accuracy: 1.0000 - val_loss: 0.0986
Epoch 11/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 6s 1s/step - accuracy: 0.9889 - loss: 0.1276 - val_accuracy: 1.0000 - val_loss: 0.0847
Epoch 12/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 2s 255ms/step - accuracy: 0.9524 - loss: 0.1262 - val_accuracy: 1.0000 - val_loss: 0.0861
Epoch 13/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 6s 901ms/step - accuracy: 0.9947 - loss: 0.0907 - val_accuracy: 1.0000 - val_loss: 0.0648
Epoch 14/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 2s 225ms/step - accuracy: 1.0000 - loss: 0.0656 - val_accuracy: 1.0000 - val_loss: 0.0515
Epoch 15/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 6s 994ms/step - accuracy: 0.9984 - loss: 0.0783 - val_accuracy: 1.0000 - val_loss: 0.0496
Epoch 16/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 2s 308ms/step - accuracy: 1.0000 - loss: 0.0694 - val_accuracy: 1.0000 - val_loss: 0.0524
Epoch 17/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 5s 819ms/step - accuracy: 0.9975 - loss: 0.0748 - val_accuracy: 1.0000 - val_loss: 0.0392
Epoch 18/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 2s 224ms/step - accuracy: 1.0000 - loss: 0.0398 - val_accuracy: 1.0000 - val_loss: 0.0321
Epoch 19/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 5s 1s/step - accuracy: 0.9975 - loss: 0.0659 - val_accuracy: 1.0000 - val_loss: 0.0360
Epoch 20/20
6/6 ━━━━━━━━━━━━━━━━━━━━ 2s 244ms/step - accuracy: 1.0000 - loss: 0.0382 - val_accuracy: 1.0000 - val_loss: 0.0434
---------------------------------------------------------------
WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.
Modelo entrenado y guardado como 'modelo_serpiente_arana.h5'
---------------------------------------------------------------
2/2 ━━━━━━━━━━━━━━━━━━━━ 2s 376ms/step - accuracy: 1.0000 - loss: 0.0384
Pérdida en validación: 0.0370
Precisión en validación: 1.0000
---------------------------------------------------------------
---------------------------------------------------------------
WARNING:absl:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.
1/1 ━━━━━━━━━━━━━━━━━━━━ 2s 2s/step
La imagen es una araña con probabilidad 0.99
(myenv)