Subida inicial del proyecto

app.py

@@ -0,0 +1,145 @@
+
+# Cargue de libreria 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.
+
+#----------------------------------------------------------------------------------------------------------
+
+# 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.
+
+#--------------------------------------------------------------------------------------------------------
+
+# 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.
+
+#--------------------------------------------------------------------------------------------------------
+
+    # 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.
+
+#--------------------------------------------------------------------------------------------------------
+
+    # 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.
+
+#-------------------------------------------------------------------------------------------------------
+
+    # Crear una lista de los 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()}")
+   
+    return "\n".join(detected_objects)
+
+# Explicación:
+
+# 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
+
+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()
+
+
+# --------------------------------------------
+# 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.