Arreglo compatibilidad NumPy y actualización app.py y requirements

app.py

@@ -2,99 +2,101 @@
 # app.py - Detección de objetos con DETR y Gradio
 # -----------------------------
 
+# -----------------------------
 # Carga de librerías necesarias
+# -----------------------------
 from transformers import DetrImageProcessor, DetrForObjectDetection
 import torch
-from PIL import Image
+from PIL import Image, ImageDraw
 import gradio as gr
 
-# Librerías utilizadas:
-# transformers: Hugging Face, modelos preentrenados como DETR.
-# DetrImageProcessor: preprocesa la imagen para que el modelo la entienda.
-# DetrForObjectDetection: modelo DETR preentrenado para detección de objetos.
-# torch: cálculos con tensores y redes neuronales.
-# PIL.Image: manejo de imágenes en Python.
-# gradio: interfaz gráfica web sencilla para probar el modelo.
-
-# ----------------------------------------------------------------------------------
+# -----------------------------
+# Justificación de librerías:
+# -----------------------------
+# transformers: Librería de Hugging Face, permite usar modelos preentrenados como DETR para tareas de visión por computadora.
+# DetrImageProcessor: Preprocesa la imagen para que DETR la entienda.
+# DetrForObjectDetection: Modelo DETR preentrenado en COCO para detección de objetos.
+# torch: Cálculos de tensores y soporte para GPU si está disponible.
+# PIL.Image: Manejo de imágenes en Python.
+# gradio: Interfaz gráfica web sencilla para probar modelos de ML.
+# -----------------------------
 
-# Cargar procesador y modelo preentrenado
+# -----------------------------
+# Cargar modelo y procesador preentrenado
+# -----------------------------
 processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
 model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
 
-# Justificación:
-# Usamos un modelo preentrenado porque entrenar uno desde cero requiere millones de imágenes y mucho poder de cómputo.
-# Hugging Face permite reutilizar un modelo ya entrenado con buenas métricas en objetos comunes.
-
-# ----------------------------------------------------------------------------------
+# -----------------------------
+# Justificación de decisiones:
+# -----------------------------
+# 1. Se usa modelo preentrenado para evitar entrenar desde cero, lo cual requiere millones de imágenes y alto costo computacional.
+# 2. Se usa processor de Hugging Face para manejar correctamente el tamaño de la imagen y normalizarla.
+# 3. Torch se usa para tensor computations y evitar errores de incompatibilidad.
+# -----------------------------
 
-# Función para procesar la imagen y detectar objetos
+# -----------------------------
+# Función para detectar objetos en la imagen
+# -----------------------------
 def detect_objects(image):
-    # Preprocesamiento de la imagen
-    # padding=True: necesario para que imágenes de diferentes tamaños se puedan convertir en batch sin errores
-    inputs = processor(images=image, return_tensors="pt", padding=True)
+    # Manejo de casos donde no se sube imagen
+    if image is None:
+        return "⚠️ Por favor, sube una imagen para detectar objetos."
 
-    # Explicación:
-    # El processor convierte la imagen a tensores PyTorch, lista para la red neuronal.
-    # return_tensors="pt" indica que se usan tensores de PyTorch.
-    # padding=True evita errores de batch cuando la imagen no coincide con el tamaño esperado.
+    # Preprocesamiento
+    inputs = processor(images=image, return_tensors="pt", padding=True)
 
-    # Detección de objetos
-    with torch.no_grad():  # no calculamos gradientes, solo inferencia
+    # Inferencia (sin calcular gradientes)
+    with torch.no_grad():
         outputs = model(**inputs)
 
-    # Postprocesamiento para obtener resultados entendibles
+    # Postprocesamiento
     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:
-    # threshold=0.9: solo aceptamos predicciones con 90% o más de confianza para reducir falsos positivos.
-    # post_process_object_detection convierte las predicciones crudas en nombres de clases, scores y boxes.
-
-    # Preparar resultados para mostrar
-    labels = results["labels"]
-    scores = results["scores"]
-    boxes = results["boxes"]
-
+    # Preparar visualización de resultados
+    draw = ImageDraw.Draw(image)
     detected_objects = []
-    for score, label, box in zip(scores, labels, boxes):
-        detected_objects.append(f"Objeto: {label}, Score: {score:.2f}, Box: {box.tolist()}")
-
-    return "\n".join(detected_objects)
+    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+        # Coordenadas de la caja
+        box = [round(i, 2) for i in box.tolist()]
+        draw.rectangle(box, outline="red", width=2)
+        draw.text((box[0], box[1]-10), f"{label}: {score:.2f}", fill="red")
+        detected_objects.append(f"Objeto: {label}, Score: {score:.2f}, Box: {box}")
 
-# ----------------------------------------------------------------------------------
+    # Devuelve la imagen con cajas y un resumen textual
+    return image, "\n".join(detected_objects)
 
+# -----------------------------
 # Crear interfaz con Gradio
+# -----------------------------
 def create_interface():
     interface = gr.Interface(
         fn=detect_objects,             # función principal que conecta modelo con la app
         inputs=gr.Image(type="pil"),   # entrada: imagen cargada por el usuario
-        outputs=gr.Textbox(),          # salida: resultados en texto
-        live=True,                     # procesa inmediatamente al cargar la imagen
+        outputs=[gr.Image(type="pil"), gr.Textbox()],  # salida: imagen con cajas y texto
         title="Detección de Objetos con Transformers",
-        description="Sube una imagen y descubre qué objetos detecta el modelo DETR."
+        description="Sube una imagen y descubre qué objetos detecta el modelo DETR. Las cajas rojas indican los objetos detectados."
+        # NOTA: Se quita live=True para evitar errores de NoneType
     )
-
-    # Explicación:
-    # live=True: la imagen se procesa automáticamente al cargar, sin necesidad de un botón extra.
-    # gr.Image(type="pil") permite subir y trabajar con imágenes en formato PIL, compatible con el processor.
-    # Textbox devuelve los resultados como texto legible.
-
+    # Explicación: Gradio permite subir imagen en PIL y obtener resultados tanto visuales como textuales.
     interface.launch()
 
-# ----------------------------------------------------------------------------------
-
+# -----------------------------
 # Ejecutar la aplicación
+# -----------------------------
 if __name__ == "__main__":
     create_interface()
 
-# ----------------------------------------------------------------------------------
+# -----------------------------
 # Conclusión:
-# Esta aplicación permite cargar imágenes y obtener los objetos detectados usando DETR.
-# La decisión de usar un modelo preentrenado y el processor de Hugging Face simplifica la implementación y reduce riesgos de error.
-# padding=True corrige el error que aparecía en versiones recientes de transformers y NumPy.
-# Puede ejecutarse localmente con `python app.py` y también desplegarse en Hugging Face Spaces.
-# ----------------------------------------------------------------------------------
-
+# -----------------------------
+# 1. Esta app permite subir imágenes y detectar objetos con DETR.
+# 2. Se muestra la imagen con cajas rojas y texto con la clase y score.
+# 3. Se maneja el caso de no subir imagen para evitar errores de tipo NoneType.
+# 4. Se usan librerías estables y preentrenadas para minimizar errores y tiempo de desarrollo.
+# 5. Puede ejecutarse localmente con: python app.py
+# 6. También puede desplegarse en Hugging Face Spaces si se desea.
+# -----------------------------