merged code

app.py

@@ -119,8 +119,148 @@ body {
     font-weight: bold;
     color: #1976d2;
 }
+.custom-row {
+    display: flex;
+    justify-content: center; /* Align horizontally */
+    align-items: center;     /* Align vertically */
+    padding: 10px;           /* Adjust as needed for spacing */
+}
+.custom-button {
+    background-color: #800000;
+    color: white;
+    font-size: 12px;         /* Small font size */
+    width: 100px !important;            /* Fixed width */
+    height: 35px !important;            /* Fixed height */
+    border-radius: 6px;      /* Slightly rounded corners */
+    padding: 0 !important;              /* Remove extra padding */
+    cursor: pointer;
+    text-align: center;
+    margin: 0 auto;          /* Center within its container */
+    box-sizing: border-box;  /* Ensure consistent sizing */
+}
+#run-button {
+    background-color: #800000 !important;
+    color: white !important;
+    font-size: 12px !important;  /* Small font size */
+    width: 100px !important;     /* Fixed width */
+    height: 35px !important;     /* Fixed height */
+    border-radius: 6px !important;
+    padding: 0 !important;
+    text-align: center !important;
+    display: block !important;   /* Ensure block-level alignment */
+    margin: 0 auto !important;   /* Center horizontally */
+    box-sizing: border-box !important;
+}
+/* Custom border styles for all Gradio components */
+.gradio-container, .gradio-row, .gradio-column, .gradio-input, .gradio-image, .gradio-checkgroup, .gradio-button, .gradio-markdown {
+    border: 3px #800000 !important;  /* Border width and color */
+    border-radius: 8px !important;      /* Rounded corners */
+}
+/* Additional customizations for images to enhance visibility of the border */
+.gradio-image img {
+    border-radius: 8px !important;
+    border: 3px solid black !important;  /* Border for image */
+}
+/* Custom Row for images and buttons */
+.custom-row img {
+    border-radius: 10px;
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+}
+#highlighted-text {
+    font-weight: bold;
+    color: #1976d2;
+}
+.gradio-block {
+    max-height: 100vh;  /* Allow scrolling within the Gradio blocks */
+    overflow-y: auto;   /* Enable scrolling for the content if it overflows */
+}
+#neural-vista-title {
+    color: #800000 !important;  /* Purple color for the title */
+    font-size: 32px;           /* Adjust font size as needed */
+    font-weight: bold;
+    text-align: center;
+}
+#neural-vista-text {
+    color: #800000  !important;  /* Purple color for the title */
+    font-size: 18px;           /* Adjust font size as needed */
+    font-weight: bold;
+    text-align: center;
+    
+}
+
+
 """
 
+import netron
+import threading
+import gradio as gr
+import os
+from PIL import Image
+import cv2
+import numpy as np
+from yolov5 import xai_yolov5
+from yolov8 import xai_yolov8s
+
+# Sample images directory
+sample_images = {
+    "Sample 1": os.path.join(os.getcwd(), "data/xai/sample1.jpeg"),
+    "Sample 2": os.path.join(os.getcwd(), "data/xai/sample2.jpg"),
+}
+
+def load_sample_image(sample_name):
+    """Load a sample image based on user selection."""
+    image_path = sample_images.get(sample_name)
+    if image_path and os.path.exists(image_path):
+        return Image.open(image_path)
+    return None
+
+def process_image(sample_choice, uploaded_image, yolo_versions, target_lyr = -5, n_components = 8):
+    """Process the image using selected YOLO models."""
+    # Load sample or uploaded image
+    if uploaded_image is not None:
+        image = uploaded_image
+    else:
+        image = load_sample_image(sample_choice)
+
+    # Preprocess image
+    image = np.array(image)
+    image = cv2.resize(image, (640, 640))
+    result_images = []
+
+    # Apply selected models
+    for yolo_version in yolo_versions:
+        if yolo_version == "yolov5":
+            result_images.append(xai_yolov5(image, target_lyr = -5, n_components = 8)) 
+        elif yolo_version == "yolov8s":
+            result_images.append(xai_yolov8s(image))
+        else:
+            result_images.append((Image.fromarray(image), f"{yolo_version} not implemented."))
+    return result_images
+
+def view_model(selected_models):
+    """Generate Netron visualization for the selected models."""
+    netron_html = ""
+    for model in selected_models:
+        if model=="yolov8s":
+            netron_html = f"""
+            <iframe 
+                src="https://netron.app/?url=https://huggingface.co/spaces/BhumikaMak/NeuralVista/resolve/main/weight_files/yolov8s.pt" 
+                width="100%" 
+                height="800" 
+                frameborder="0">
+            </iframe>
+            """
+        if model == "yolov5":
+            netron_html = f"""
+            <iframe 
+                src="https://netron.app/?url=https://huggingface.co/FFusion/FFusionXL-BASE/blob/main/vae_encoder/model.onnx" 
+                width="100%" 
+                height="800" 
+                frameborder="0">
+            </iframe>
+            """
+    return netron_html if netron_html else "<p>No valid models selected for visualization.</p>"
+
 with gr.Blocks(css=custom_css) as demo:
     gr.HTML("""
       <div style="border: 2px solid #a05252; padding: 20px; border-radius: 8px;">
@@ -144,6 +284,120 @@ with gr.Blocks(css=custom_css) as demo:
             gr.Image(yolov8_result, label="Detections & Interpretability Map")
             gr.Markdown(description_yolov8)
             gr.Image(yolov8_dff, label="Feature Factorization & discovered concept")
+
+    default_sample = "Sample 1"
+
+    with gr.Row():
+        # Left side: Sample selection and image upload
+        with gr.Column():
+            sample_selection = gr.Radio(
+                choices=list(sample_images.keys()),
+                label="Select a Sample Image",
+                value=default_sample,
+            )
+
+            upload_image = gr.Image(
+                label="Upload an Image",
+                type="pil",  
+            )
+
+            selected_models = gr.CheckboxGroup(
+                choices=["yolov5", "yolov8s"],
+                value=["yolov5"],
+                label="Select Model(s)",
+            )
+            #with gr.Row(elem_classes="custom-row"):
+            run_button = gr.Button("Run", elem_id="run-button")
+
+
+        with gr.Column():
+            sample_display = gr.Image(
+                value=load_sample_image(default_sample),  
+                label="Selected Sample Image",
+            )
+    
+    gr.HTML("""
+        <span style="font-size: 14px; font-weight: bold;">The visualization demonstrates object detection and interpretability. Detected objects are highlighted with bounding boxes, while the heatmap reveals regions of focus, offering insights into the model's decision-making process.</span>
+        """)
+    # Results and visualization
+    with gr.Row(elem_classes="custom-row"):
+        result_gallery = gr.Gallery(
+            label="Results",
+            rows=1, 
+            height="auto",       # Adjust height automatically based on content
+            columns=1 ,
+            object_fit="contain"
+        ) 
+        netron_display = gr.HTML(label="Netron Visualization")
+
+    # Update sample image
+    sample_selection.change(
+        fn=load_sample_image,
+        inputs=sample_selection,
+        outputs=sample_display,
+    )
+    
+
+    gr.HTML("""
+        <span style="font-size: 14px; ">
+            <span style="color: #800000;">Concept Discovery</span> is the process of uncovering the hidden, high-level features that a deep learning model has learned. It provides a way to understand the essence of its internal representations, akin to peering into the mind of the model and revealing the meaningful patterns it detects in the data.
+            <br><br>
+            <span style="color: #800000;">Deep Feature Factorization</span> (DFF) serves as a tool for breaking down these complex features into simpler, more interpretable components. By applying matrix factorization on activation maps, it untangles the intricate web of learned representations, making it easier to comprehend what the model is truly focusing on. Together, these methods bring us closer to understanding the underlying logic of neural networks, shedding light on the often enigmatic decisions they make.
+        </span>
+    """)
+
+    with gr.Row(elem_classes="custom-row"):
+        dff_gallery = gr.Gallery(
+            label="Deep Feature Factorization",
+            rows=2,          # 8 rows
+            columns=4,       # 1 image per row
+            object_fit="fit",
+            height="auto"    # Adjust as needed
+        ) 
+
+    # Multi-threaded processing
+    def run_both(sample_choice, uploaded_image, selected_models):
+        results = []
+        netron_html = ""
+
+        # Thread to process the image
+        def process_thread():
+            nonlocal results
+            target_lyr = -5 
+            n_components = 8
+            results = process_image(sample_choice, uploaded_image, selected_models, target_lyr = -5, n_components = 8)
+
+        # Thread to generate Netron visualization
+        def netron_thread():
+            nonlocal netron_html
+            gr.HTML("""
+            Generated abstract visualizations of model""")
+            netron_html = view_model(selected_models)
+
+        # Launch threads
+        t1 = threading.Thread(target=process_thread)
+        t2 = threading.Thread(target=netron_thread)
+        t1.start()
+        t2.start()
+        t1.join()
+        t2.join()
+        image1, text, image2 = results[0]
+        if isinstance(image2, list):
+            # Check if image2 contains exactly 8 images
+            if len(image2) == 8:
+                print("image2 contains 8 images.")
+            else:
+                print("Warning: image2 does not contain exactly 8 images.")
+        else:
+            print("Error: image2 is not a list of images.")
+        return [(image1, text)], netron_html, image2
+
+    # Run button click
+    run_button.click(
+        fn=run_both,
+        inputs=[sample_selection, upload_image, selected_models],
+        outputs=[result_gallery, netron_display, dff_gallery],
+    )
             
 
 demo.launch()