Update app.py

app.py

@@ -1,71 +1,79 @@
 import gradio as gr
-import torch
-from transformers import DetrImageProcessor, DetrForObjectDetection, pipeline
+from transformers import pipeline
 from PIL import Image, ImageDraw
-import numpy as np
-
-# Load Object Detection model (DETR)
-processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
-model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
+import torch
 
-# Load Classification pipeline (ViT)
-classifier = pipeline("image-classification", model="google/vit-base-patch16-224")
+# Initialize the detection pipeline using the DETR architecture
+# This model runs locally within the Space environment
+try:
+    detector = pipeline("object-detection", model="facebook/detr-resnet-50")
+except Exception as e:
+    detector = None
 
-def process_analysis(input_img):
-    if input_img is None:
-        return None, "No image provided.", "No data."
+def analyze_system(image):
+    if image is None:
+        return None, {"status": "error", "message": "No input signal detected."}
     
-    # 1. Object Detection
-    inputs = processor(images=input_img, return_tensors="pt")
-    outputs = model(**inputs)
+    if detector is None:
+        return image, {"status": "error", "message": "Model initialization failed."}
     
-    # Convert outputs (bounding boxes and class logits) to COCO API
-    target_sizes = torch.tensor([input_img.size[::-1]])
-    results = processor.post_process_object_detection(outputs, target_sizes=target_sizes, threshold=0.9)[0]
+    # Perform high-precision inference
+    predictions = detector(image)
     
-    # Draw boxes
-    draw = ImageDraw.Draw(input_img)
-    detection_log = []
-    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-        box = [round(i, 2) for i in box.tolist()]
-        label_name = model.config.id2label[label.item()]
-        draw.rectangle(box, outline="red", width=3)
-        draw.text((box[0], box[1]), f"{label_name} {round(score.item(), 3)}", fill="red")
-        detection_log.append(f"Detected: {label_name} | Confidence: {round(score.item(), 4)} | Box: {box}")
+    # Prepare drawing context for visual telemetry
+    annotated_image = image.copy()
+    draw = ImageDraw.Draw(annotated_image)
     
-    # 2. Classification
-    class_results = classifier(input_img)
-    class_text = "\n".join([f"{res['label']}: {round(res['score'], 4)}" for res in class_results])
+    telemetry_report = []
     
-    detection_text = "\n".join(detection_log) if detection_log else "No high-confidence objects detected."
+    for pred in predictions:
+        box = pred["box"]
+        label = pred["label"]
+        score = pred["score"]
+        
+        # Extract spatial coordinates
+        xmin, ymin, xmax, ymax = box["xmin"], box["ymin"], box["xmax"], box["ymax"]
+        
+        # Draw identification borders using a high-contrast industrial green
+        draw.rectangle([xmin, ymin, xmax, ymax], outline="#00FF00", width=4)
+        
+        # Compile telemetry data
+        telemetry_report.append({
+            "component_class": label,
+            "confidence_rating": round(float(score), 4),
+            "spatial_coordinates": {
+                "xmin": xmin,
+                "ymin": ymin,
+                "xmax": xmax,
+                "ymax": ymax
+            }
+        })
     
-    return input_img, class_text, detection_text
+    return annotated_image, telemetry_report
 
-# UI Definition
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="slate")) as demo:
-    gr.Markdown("# 🛡️ DeepVision Forensic Suite")
-    gr.Markdown("**Technical Utility:** Multi-model image analysis for object localization and semantic classification.")
+# Construct the Gradio Interface with a technical, utility-focused theme
+with gr.Blocks(theme=gr.themes.Monochrome(primary_hue="blue")) as demo:
+    gr.Markdown("# 🛰️ Neural Industrial Inspector")
+    gr.Markdown("**System Status**: Operational | **Core**: DETR-ResNet-50 Transformer")
     
     with gr.Row():
-        with gr.Column():
-            input_image = gr.Image(type="pil", label="Input Source")
-            analyze_btn = gr.Button("RUN ANALYSIS", variant="primary")
+        with gr.Column(scale=1):
+            input_img = gr.Image(type="pil", label="Optical System Feed")
+            run_btn = gr.Button("INITIATE SYSTEM SCAN", variant="primary")
         
-        with gr.Column():
-            output_image = gr.Image(type="pil", label="Object Localization (90% Threshold)")
+        with gr.Column(scale=1):
+            output_img = gr.Image(type="pil", label="Visual Diagnostic Overlay")
+            output_data = gr.JSON(label="Structured Telemetry Data")
             
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### Semantic Classification (ViT)")
-            class_out = gr.Textbox(label="Top Predictions", lines=5)
-        with gr.Column():
-            gr.Markdown("### Detection Metadata (DETR)")
-            detect_out = gr.Textbox(label="Spatial Coordinates", lines=5)
-
-    analyze_btn.click(
-        fn=process_analysis,
-        inputs=[input_image],
-        outputs=[output_image, class_out, detect_out]
+    gr.Examples(
+        examples=[],
+        inputs=input_img
+    )
+    
+    run_btn.click(
+        fn=analyze_system, 
+        inputs=input_img, 
+        outputs=[output_img, output_data]
     )
 
 if __name__ == "__main__":