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

app.py

@@ -1,63 +1,59 @@
-# ----------------------------------------------------------------------------------
+# -----------------------------
+# 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
 import gradio as gr
 
-# Explicación:
-# transformers: librería de Hugging Face con modelos ya entrenados, como DETR.
+# Librerías utilizadas:
+# transformers: Hugging Face, modelos preentrenados 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.
+# 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.
 
 # ----------------------------------------------------------------------------------
-# Cargar el procesador y el modelo
-# ----------------------------------------------------------------------------------
+
+# Cargar procesador y modelo preentrenado
 processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
 model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
 
-# Explicación:
-# 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.
+# 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.
 
 # ----------------------------------------------------------------------------------
-# Función para procesar la imagen
-# ----------------------------------------------------------------------------------
+
+# Función para procesar la imagen y detectar objetos
 def detect_objects(image):
-    # Preprocesamiento
-    inputs = processor(images=image, return_tensors="pt")
+    # 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)
 
     # 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.
+    # 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.
 
-    # Detectar objetos
-    with torch.no_grad():
+    # Detección de objetos
+    with torch.no_grad():  # no calculamos gradientes, solo inferencia
         outputs = model(**inputs)
 
-    # 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
+    # Postprocesamiento para obtener resultados entendibles
     target_sizes = torch.tensor([image.size[::-1]])  # (alto, ancho)
-    results = processor.post_process_object_detection(outputs, target_sizes=target_sizes, threshold=0.9)[0]
+    results = processor.post_process_object_detection(
+        outputs, target_sizes=target_sizes, threshold=0.9
+    )[0]
 
     # 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
+    # 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.
 
-    # Crear lista de resultados con nombre y puntuación
+    # Preparar resultados para mostrar
     labels = results["labels"]
     scores = results["scores"]
     boxes = results["boxes"]
@@ -65,48 +61,40 @@ def detect_objects(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)
 
-# 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.
+    return "\n".join(detected_objects)
 
 # ----------------------------------------------------------------------------------
-# 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
-)
-
-# 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.
 
-# ----------------------------------------------------------------------------------
-# Ejecutar la aplicación
-# ----------------------------------------------------------------------------------
-if __name__ == "__main__":
-    # Para Hugging Face Space, no usar live=True al lanzar
+# Crear interfaz con Gradio
+def create_interface():
     interface = gr.Interface(
-        fn=detect_objects,
-        inputs=gr.Image(type="pil"),
-        outputs=gr.Textbox(),
+        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
         title="Detección de Objetos con Transformers",
         description="Sube una imagen y descubre qué objetos detecta el modelo DETR."
     )
+
+    # 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.
+
     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()
+
+# ----------------------------------------------------------------------------------
+# 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.
+# ----------------------------------------------------------------------------------
 

requirements.txt

@@ -5,4 +5,3 @@ torchvision==0.15.2
 timm==0.9.8
 pillow==9.5.0
 huggingface-hub>=0.19.0
-