Update app.py

app.py

@@ -1,16 +1,55 @@
 import gradio as gr
 import torch
+import torch.nn.functional as F
 from torchvision import transforms
 from PIL import Image
+from torchvision.transforms.functional import to_pil_image
 from model import load_model
+import matplotlib.pyplot as plt
+import numpy as np
+from thop import profile
+import io
 
-# Device selection
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+def calculate_performance_metrics(model, device, input_size=(1,3,224,224)):
+    model.to(device)
+    inputs = torch.randn(input_size).to(device)
+    flops, params = profile(model, inputs=(inputs,), verbose=False)
+    params_million = params / 1e6
+    flops_billion = flops / 1e9
+    # timing
+    with torch.no_grad():
+        start = torch.cuda.Event(enable_timing=True)
+        end = torch.cuda.Event(enable_timing=True)
+        start.record()
+        _ = model(inputs)
+        end.record()
+        torch.cuda.synchronize()
+    speed_gpu_ms = start.elapsed_time(end)
+    # CPU timing
+    inputs_cpu = inputs.to('cpu')
+    start_c = torch.cuda.Event(enable_timing=True)
+    end_c = torch.cuda.Event(enable_timing=True)
+    # use time.time as fallback for CPU
+    import time
+    t0 = time.time()
+    _ = model(inputs_cpu)
+    t1 = time.time()
+    speed_cpu_ms = (t1 - t0) * 1000
+    return {
+        'params_million': round(params_million,2),
+        'flops_billion': round(flops_billion,2),
+        'speed_cpu_ms': round(speed_cpu_ms,2),
+        'speed_gpu_ms': round(speed_gpu_ms,2)
+    }
 
-# Model cache
-models_cache = {}
+# Preprocess transform
+def get_transform():
+    return transforms.Compose([
+        transforms.Resize((224,224)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485,0.456,0.406], std=[0.229,0.224,0.225])
+    ])
 
-# Common class names
 class_names = [
     'Alzheimer Disease',
     'Mild Alzheimer Risk',
@@ -20,50 +59,44 @@ class_names = [
     'Parkinson Disease'
 ]
 
-# Image preprocessing
-transform = transforms.Compose([
-    transforms.Resize((448, 448)),
-    transforms.ToTensor(),
-    transforms.Normalize(mean=[0.485, 0.456, 0.406],
-                         std=[0.229, 0.224, 0.225])
-])
+# Gradio predict function
+def predict_and_monitor(version, image):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = load_model(version, device)
+    # preprocess
+    img = image.convert("RGB")
+    tensor = get_transform()(img).unsqueeze(0).to(device)
+    # inference
+    with torch.no_grad():
+        outputs = model(tensor)
+        probs = F.softmax(outputs, dim=1)[0]
+    # prepare top3
+    topk = torch.topk(probs, k=3)
+    pred_items = {class_names[i]: round(float(probs[i]),4) for i in range(len(class_names))}
+    # metrics
+    metrics = calculate_performance_metrics(model, device)
+    # plot input image with prediction
+    buf = io.BytesIO()
+    plt.figure(figsize=(4,4))
+    plt.imshow(img)
+    plt.title(f"Top1: {topk.indices[0]} ({topk.values[0]:.4f})")
+    plt.axis('off')
+    plt.savefig(buf, format='png')
+    plt.close()
+    buf.seek(0)
+    return pred_items, metrics, buf
 
-def predict(version: str, image: Image.Image):
-    """
-    Predict Alzheimer/Parkinson risk using selected version (f, c, q) on a 2D brain slice.
-    """
-    try:
-        # Load model if not cached
-        if version not in models_cache:
-            models_cache[version] = load_model(version, device)
-        model = models_cache[version]
-
-        # Convert and preprocess image
-        img = image.convert("RGB")
-        tensor = transform(img).unsqueeze(0).to(device)
-
-        # Inference
-        with torch.no_grad():
-            outputs = model(tensor)
-            probs = torch.nn.functional.softmax(outputs, dim=1)[0]
-
-        # Return full probability mapping
-        return {class_names[i]: float(probs[i]) for i in range(len(class_names))}
-    except Exception as e:
-        # Raise a Gradio error to display in UI
-        raise gr.Error(f"Inference error: {str(e)}")
-
-# Build Gradio interface
 with gr.Blocks() as demo:
-    gr.Markdown("## 🧠 Vbai-DPA 2.1 Alzheimer & Parkinson Risk Classification")
-    gr.Markdown("Seçmek istediğin modeli (f, c veya q) seç ve bir 2D beyin dilimi yükle.")
-
+    gr.Markdown("# Vbai-DPA 2.1 Risk Classification & Monitoring")
+    with gr.Row():
+        version = gr.Radio(['f','c','q'], value='c', label="Model Version")
+        image_in = gr.Image(type="pil", label="Brain Slice (224x224)")
     with gr.Row():
-        version_selector = gr.Radio(choices=['f', 'c', 'q'], value='c', label="Model Version")
-        image_input = gr.Image(type="pil", label="Brain Slice Image")
-    output = gr.JSON(label="Olasılıklar (JSON)")  # Use JSON output to handle errors and full mapping
-    predict_btn = gr.Button("Tahmin Et")
-    predict_btn.click(fn=predict, inputs=[version_selector, image_input], outputs=output)
+        preds = gr.JSON(label="Prediction Probabilities")
+        stats = gr.JSON(label="Performance Metrics")
+        plot = gr.Image(label="Input & Top-1");
+    btn = gr.Button("Run")
+    btn.click(fn=predict_and_monitor, inputs=[version, image_in], outputs=[preds, stats, plot])
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     demo.launch()