Actualizar app.py con notas, análisis y justificaciones, actualizar requirements.txt

app.py

@@ -1,86 +1,67 @@
-
-# Cargue de libreria necesarias
-
+# ----------------------------------------------------------------------------------
+# Carga de librerías necesarias
+# ----------------------------------------------------------------------------------
 from transformers import DetrImageProcessor, DetrForObjectDetection
 import torch
 from PIL import Image
 import gradio as gr
 
-#transformers: librería de Hugging Face que tiene modelos ya entrenados como DETR.
-# DetrImageProcessor: se encarga de preprocesar la imagen para que el modelo la entienda.
-# DetrForObjectDetection: es el modelo DETR entrenado.
-# torch: es PyTorch, la librería para hacer cálculos con redes neuronales.
-# PIL.Image: permite trabajar con imágenes en Python.
-# gradio: sirve para hacer una interfaz gráfica web sencilla y probar el modelo.
-
-#----------------------------------------------------------------------------------------------------------
-
+# Explicación:
+# transformers: librería de Hugging Face con modelos ya entrenados, como DETR.
+# DetrImageProcessor: preprocesa la imagen para que el modelo la entienda.
+# DetrForObjectDetection: modelo DETR preentrenado.
+# torch: PyTorch, biblioteca para cálculos con redes neuronales.
+# PIL.Image: permite trabajar con imágenes.
+# gradio: para crear interfaces gráficas web sencillas.
+
+# ----------------------------------------------------------------------------------
 # Cargar el procesador y el modelo
+# ----------------------------------------------------------------------------------
 processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
 model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
 
 # Explicación:
-# Aquí cargamos un modelo ya entrenado de Hugging Face: facebook/detr-resnet-50.
-# No necesitamos entrenar nada desde cero, porque este modelo ya sabe detectar objetos comunes (personas, perros, autos, etc.).
-# processor prepara la imagen (redimensionar, normalizar).
-# model es el “cerebro” que detecta objetos.
-
-# Decisión tomada: usamos un modelo preentrenado porque entrenar uno desde cero requiere millones de imágenes y mucho poder de cómputo. Con Hugging Face podemos reutilizar un modelo listo.
-
-#--------------------------------------------------------------------------------------------------------
+# Se carga un modelo preentrenado: facebook/detr-resnet-50
+# No necesitamos entrenar nada desde cero.
+# processor prepara la imagen (redimensiona y normaliza).
+# model detecta los objetos.
+# Decisión: usar modelo preentrenado para evitar requerir millones de imágenes y alto poder de cómputo.
 
+# ----------------------------------------------------------------------------------
 # Función para procesar la imagen
+# ----------------------------------------------------------------------------------
 def detect_objects(image):
     # Preprocesamiento
     inputs = processor(images=image, return_tensors="pt")
 
-# Explicación:
-
-# La función detect_objects será la encargada de recibir una imagen y devolver qué objetos encontró.
-# processor convierte la imagen en tensores (estructuras numéricas que entiende PyTorch).
-# return_tensors="pt" indica que los tensores se hacen para PyTorch (pt = pytorch).
-# Decisión tomada: usamos processor en lugar de hacer manualmente redimensionar/normalizar la imagen porque así evitamos errores y aprovechamos la configuración estándar del modelo.
-
-#--------------------------------------------------------------------------------------------------------
+    # Explicación:
+    # detect_objects recibe la imagen y devuelve los objetos encontrados.
+    # processor convierte la imagen en tensores que entiende PyTorch.
+    # return_tensors="pt" indica que se generan tensores para PyTorch.
 
     # Detectar objetos
     with torch.no_grad():
         outputs = model(**inputs)
 
-# Explicación:
-
-# torch.no_grad() desactiva el cálculo de gradientes porque no vamos a entrenar, solo a usar el modelo.
-# model(**inputs) corre la imagen por la red neuronal y devuelve predicciones:
-# qué objetos cree que hay
-# dónde están ubicados
-
-# Decisión tomada: usar no_grad() ahorra memoria y acelera la ejecución, ideal para inferencia.
-
-#--------------------------------------------------------------------------------------------------------
+    # Explicación:
+    # torch.no_grad() desactiva el cálculo de gradientes, porque no entrenamos.
+    # model(**inputs) corre la imagen por la red neuronal y devuelve predicciones.
 
     # Filtrar resultados
     target_sizes = torch.tensor([image.size[::-1]])  # (alto, ancho)
     results = processor.post_process_object_detection(outputs, target_sizes=target_sizes, threshold=0.9)[0]
 
-# Explicación:
-
-# image.size[::-1]: invierte el orden del tamaño de la imagen (porque PIL usa (ancho, alto) y el modelo espera (alto, ancho)).
-# post_process_object_detection: convierte las predicciones crudas en resultados entendibles:
-# nombres de clases (ej: "dog", "car").
-# puntaje de confianza (score).
-# cajas delimitadoras (boxes) que marcan dónde está el objeto.
-# threshold=0.9: solo se aceptan predicciones con 90% de confianza o más.
-
-# Decisión tomada: se fija un umbral alto (0.9) para reducir falsos positivos. Si bajamos a 0.5, detectaría más objetos, pero también más errores.
-
-#-------------------------------------------------------------------------------------------------------
+    # Explicación:
+    # image.size[::-1]: invierte ancho y alto (PIL usa ancho,alto y el modelo espera alto, ancho)
+    # post_process_object_detection convierte predicciones en resultados entendibles
+    # threshold=0.9: solo se aceptan predicciones con 90% de confianza
+    # Decisión: umbral alto para reducir falsos positivos
 
-    # Crear una lista de los resultados con nombre y puntuación
+    # Crear lista de resultados con nombre y puntuación
     labels = results["labels"]
     scores = results["scores"]
     boxes = results["boxes"]
 
-    # Mostrar los objetos detectados
     detected_objects = []
     for score, label, box in zip(scores, labels, boxes):
         detected_objects.append(f"Objeto: {label}, Score: {score:.2f}, Box: {box.tolist()}")
@@ -88,58 +69,44 @@ def detect_objects(image):
     return "\n".join(detected_objects)
 
 # Explicación:
+# labels: números que representan clases (1=persona, 17=gato, etc.)
+# scores: probabilidad de acierto
+# boxes: coordenadas de la caja delimitadora
+# Se muestra el resultado como texto para entender primero qué devuelve el modelo.
+# Decisión: esto permite ver resultados rápidamente; luego se puede mejorar para dibujar cajas.
+
+# ----------------------------------------------------------------------------------
+# Crear interfaz con Gradio
+# ----------------------------------------------------------------------------------
+interface = gr.Interface(
+    fn=detect_objects,            # conecta la app con el modelo
+    inputs=gr.Image(type="pil"),  # entrada: imagen cargada por el usuario
+    outputs=gr.Textbox(),         # salida: resultados en texto
+    title="Detección de Objetos con Transformers",
+    description="Sube una imagen y descubre qué objetos detecta el modelo DETR.",
+    live=True                      # procesa automáticamente al cargar la imagen
+)
 
-# labels: números que representan clases de objetos (ejemplo: 1 = persona, 17 = gato).
-# scores: probabilidad de que el objeto detectado sea correcto.
-# boxes: coordenadas de las cajas que enmarcan al objeto.
-# Luego se arma un texto con los resultados:
-# Objeto: 1, Score: 0.98, Box: [12, 34, 200, 300]
-
-# Decisión tomada: mostrar los resultados como texto para entender primero qué devuelve el modelo. Después podemos mejorarlo para dibujar cajas en la imagen (más visual).
-
-#-----------------------------------------------------------------------------------------------------
-
-# Paso 4: Crear interfaz con Gradio
-# --------------------------------------------
-def create_interface():
-    interface = gr.Interface(
-        fn=detect_objects,                # función que conecta la app con el modelo
-        inputs=gr.Image(type="pil"),      # entrada: imagen cargada por el usuario
-        outputs=gr.Textbox(),             # salida: resultados en formato texto
-        live=True,                        # procesa inmediatamente al cargar
-        title="Detección de Objetos con Transformers",
-        description="Sube una imagen y descubre qué objetos detecta el modelo DETR."
-    )
-
-    interface.launch()
-
-
-# --------------------------------------------
-# Paso 4: Crear interfaz con Gradio
+# Explicación:
+# gr.Interface facilita crear interfaces web.
+# live=True: la imagen se procesa inmediatamente.
+# Decisión: usar Gradio para una prueba rápida y despliegue simple.
 
-def create_interface():
+# ----------------------------------------------------------------------------------
+# Ejecutar la aplicación
+# ----------------------------------------------------------------------------------
+if __name__ == "__main__":
+    # Para Hugging Face Space, no usar live=True al lanzar
     interface = gr.Interface(
-        fn=detect_objects,                # función que conecta la app con el modelo
-        inputs=gr.Image(type="pil"),      # entrada: imagen cargada por el usuario
-        outputs=gr.Textbox(),             # salida: resultados en formato texto
-        live=True,                        # procesa inmediatamente al cargar
+        fn=detect_objects,
+        inputs=gr.Image(type="pil"),
+        outputs=gr.Textbox(),
         title="Detección de Objetos con Transformers",
         description="Sube una imagen y descubre qué objetos detecta el modelo DETR."
     )
-
     interface.launch()
 
+# Explicación:
+# La aplicación solo se ejecuta si se corre directamente python app.py
+# Esto evita que se ejecute si el archivo es importado como módulo.
 
-# --------------------------------------------
-# Ejecutar la aplicación
-# --------------------------------------------
-if __name__ == "__main__":
-    create_interface()
-
-# Interfaz con Gradio (create_interface())
-# Permite subir imágenes y ver los resultados.
-# Entrada: gr.Image(type="pil").
-# Salida: gr.Textbox() con los objetos detectados.
-# live=True: procesa apenas se carga la imagen.
-# Ejecución (if __name__ == "__main__":)
-# Se asegura que la aplicación solo corra al ejecutar python app.py.