Update app.py

app.py

@@ -1,167 +1,146 @@
-"""
-BraTS 2020 Brain Tumor Segmentation - Gradio Web Interface
-Interactive inference for brain MRI tumor segmentation
-"""
-
 import gradio as gr
 import numpy as np
 import tensorflow as tf
-import h5py
-import matplotlib.pyplot as plt
-import io
-from PIL import Image
-import os
+import tensorflow.keras.backend as K
+from tensorflow.keras.layers import Dense, BatchNormalization, Dropout, Input
+from tensorflow.keras.models import Model
+import cv2
+
+# Sınıf isimleri
+class_names = ["Glioma", "Meningioma", "No Tumor", "Pituitary"]
+
+# Model yapısını reconstruct et
+def build_model():
+    img_size = (224, 224)
+    inputs = tf.keras.Input(shape=img_size + (3,))
+    base_model = tf.keras.applications.efficientnet.EfficientNetB3(
+        include_top=False, 
+        weights="imagenet", 
+        input_tensor=inputs, 
+        pooling='max'
+    )
+    base_model.trainable = True
+    
+    x = base_model.output
+    x = Dense(256, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(0.3)(x)
+    outputs = Dense(len(class_names), activation='softmax')(x)
+    
+    model = Model(inputs, outputs)
+    return model
 
-# Model configuration
-os.environ["SM_FRAMEWORK"] = "tf.keras"
-import segmentation_models as sm
+# Model oluştur ve weights yükle
+model = build_model()
+model.load_weights("best_weights_balanced.h5")
 
-class BraTSInference:
-    def __init__(self):
-        print("Loading model...")
-        self.model = sm.Unet(
-            'efficientnetb0',
-            input_shape=(256, 256, 4),
-            classes=3,
-            activation='sigmoid',
-            encoder_weights=None
-        )
-        self.model.load_weights('best_model_weights.h5')
-        self.class_names = ['Necrotic', 'Enhancing Tumor', 'Edema']
-    
-    def predict_from_h5(self, h5_file):
-        """H5 dosyasından segmentasyon yap"""
-        try:
-            # H5 dosyasını oku
-            with h5py.File(h5_file.name, 'r') as f:
-                image = f['image'][:]
-            
-            # Resize
-            image_resized = tf.image.resize(image, (256, 256), method='bilinear').numpy()
-            
-            # Normalize (opsiyonel)
-            image_resized = (image_resized - image_resized.min()) / (image_resized.max() - image_resized.min() + 1e-7)
-            
-            # Predict
-            image_batch = np.expand_dims(image_resized, axis=0)
-            prediction = self.model.predict(image_batch, verbose=0)[0]
-            
-            # Görselleştir
-            fig, axes = plt.subplots(2, 4, figsize=(14, 7))
-            fig.suptitle('BraTS 2020 Brain Tumor Segmentation', fontsize=14, fontweight='bold')
-            
-            # MRI channels
-            modalities = ['T1', 'T1c', 'T2', 'FLAIR']
-            for i, mod in enumerate(modalities):
-                axes[0, i].imshow(image_resized[:, :, i], cmap='gray')
-                axes[0, i].set_title(mod)
-                axes[0, i].axis('off')
-            
-            # Predictions
-            for i, class_name in enumerate(self.class_names):
-                axes[1, i].imshow(image_resized[:, :, 0], cmap='gray', alpha=0.5)
-                axes[1, i].imshow(prediction[:, :, i], cmap='hot', alpha=0.5)
-                axes[1, i].set_title(f'{class_name}')
-                axes[1, i].axis('off')
-            
-            plt.tight_layout()
-            
-            # Save to buffer
-            buf = io.BytesIO()
-            plt.savefig(buf, format='png', dpi=100, bbox_inches='tight')
-            buf.seek(0)
-            plt.close()
-            
-            # Metrics
-            metrics_text = "📊 SEGMENTATION RESULTS\n\n"
-            for i, class_name in enumerate(self.class_names):
-                pred_binary = (prediction[:, :, i] > 0.5).astype(np.float32)
-                area_pixels = np.sum(pred_binary)
-                area_mm2 = area_pixels * 0.94 * 0.94
-                percentage = (area_pixels / (256*256)) * 100
-                
-                metrics_text += f"{class_name}:\n"
-                metrics_text += f"  • Area: {area_mm2:.2f} mm²\n"
-                metrics_text += f"  • Coverage: {percentage:.2f}%\n\n"
-            
-            metrics_text += "⚠️ Disclaimer: This model requires radiologist validation"
-            
-            return Image.open(buf), metrics_text
-        
-        except Exception as e:
-            return None, f"❌ Error: {str(e)}"
+# Son conv layer'ı otomatik bul
+def get_last_conv_layer_name(model):
+    """Find the last convolutional layer in the model"""
+    for layer in reversed(model.layers):
+        if 'conv' in layer.name.lower():
+            return layer.name
+    return None
 
-# Initialize
-inference = BraTSInference()
+# Grad-CAM fonksiyonu
+def get_gradcam(img_array, model, last_conv_layer_name):
+    grad_model = tf.keras.models.Model(
+        [model.inputs],
+        [model.get_layer(last_conv_layer_name).output, model.output]
+    )
+    
+    with tf.GradientTape() as tape:
+        conv_outputs, predictions = grad_model(img_array)
+        pred_index = tf.argmax(predictions[0])
+        class_channel = predictions[:, pred_index]
+    
+    grads = tape.gradient(class_channel, conv_outputs)
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+    
+    conv_outputs = conv_outputs[0]
+    heatmap = conv_outputs @ pooled_grads[..., tf.newaxis]
+    heatmap = tf.squeeze(heatmap)
+    
+    # Normalize to 0-1
+    heatmap_min = tf.math.reduce_min(heatmap)
+    heatmap_max = tf.math.reduce_max(heatmap)
+    heatmap = (heatmap - heatmap_min) / (heatmap_max - heatmap_min + K.epsilon())
+    
+    return heatmap.numpy(), pred_index.numpy()
 
-# Gradio Interface
-def create_interface():
-    with gr.Blocks(title="BraTS 2020 Segmentation") as demo:
-        gr.Markdown("# 🧠 BraTS 2020 Brain Tumor Segmentation")
-        gr.Markdown("""
-        Advanced U-Net model for multi-class brain tumor segmentation
-        - **Necrotic Tissue**: Dead tumor region
-        - **Enhancing Tumor**: Active tumor with contrast enhancement
-        - **Edema**: Tumor surrounding tissue
-        """)
-        
-        with gr.Row():
-            with gr.Column():
-                file_input = gr.File(
-                    label="📁 Upload H5 File",
-                    file_types=[".h5"]
-                )
-                submit_btn = gr.Button("🔍 Analyze", variant="primary")
-            
-            with gr.Column():
-                output_image = gr.Image(
-                    label="📊 Segmentation Results",
-                    type="pil"
-                )
-                output_text = gr.Textbox(
-                    label="📈 Metrics",
-                    lines=8,
-                    interactive=False
-                )
-        
-        submit_btn.click(
-            fn=inference.predict_from_h5,
-            inputs=file_input,
-            outputs=[output_image, output_text]
-        )
-        
-        # Examples
-        gr.Examples(
-            examples=[
-                ["volume_100_slice_100.h5"],
-                ["volume_100_slice_105.h5"],
-                ["volume_100_slice_110.h5"],
-                ["volume_100_slice_115.h5"],
-                ["volume_100_slice_120.h5"],
-            ],
-            inputs=file_input,
-            label="📂 Example MRI Files (Preloaded from BraTS 2020)"
-        )
-        
-        gr.Markdown("""
-        ### 📋 Model Information
-        - **Architecture**: U-Net with EfficientNetB0 Encoder
-        - **Performance**: 90.34% Sensitivity | 99.96% Specificity
-        - **Dataset**: BraTS 2020 Training (14,299 slices)
-        
-        ### ⚠️ Important Notes
-        - Model trained on BraTS 2020 dataset
-        - Requires radiologist validation for clinical use
-        - Not for autonomous clinical decisions
-        
-        ### 📚 References
-        - [BraTS Challenge](https://www.med.upenn.edu/cbica/brats2020/)
-        - [Segmentation Models](https://github.com/qubvel/segmentation_models)
-        - [U-Net Paper](https://arxiv.org/abs/1505.04597)
-        """)
-    
-    return demo
+def predict_and_explain(img):
+    # Görüntüyü hazırla
+    img_resized = cv2.resize(img, (224, 224))
+    
+    # Gradio'dan gelen image 0-255 range'de
+    # preprocess_input bu range'i normalize ediyor
+    img_array = np.expand_dims(img_resized, axis=0)
+    img_array = tf.keras.applications.efficientnet.preprocess_input(img_array.astype(np.float32))
+    
+    # Tahmin
+    predictions = model.predict(img_array, verbose=0)
+    pred_class = np.argmax(predictions[0])
+    confidence = predictions[0][pred_class]
+    
+    # Grad-CAM - son conv layer'ı bul
+    last_conv_layer_name = get_last_conv_layer_name(model)
+    heatmap, _ = get_gradcam(img_array, model, last_conv_layer_name)
+    heatmap = cv2.resize(heatmap, (img_resized.shape[1], img_resized.shape[0]))
+    # Heatmap'ı ters çevir: kırmızı = model odaklandığı yer
+    heatmap = 1 - heatmap
+    heatmap = np.uint8(255 * heatmap)
+    heatmap_colored = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+    
+    # Original image for overlay (normalize to 0-255)
+    img_for_display = cv2.resize(img, (224, 224))
+    if img_for_display.max() <= 1.0:
+        img_for_display = (img_for_display * 255).astype(np.uint8)
+    
+    # Overlay
+    superimposed = cv2.addWeighted(img_for_display, 0.6, heatmap_colored, 0.4, 0)
+    
+    # Sonuçlar
+    results = {class_names[i]: float(predictions[0][i]) for i in range(4)}
+    
+    return results, superimposed
+
+# Gradio arayüzü
+demo = gr.Interface(
+    fn=predict_and_explain,
+    inputs=gr.Image(label="Upload Brain MRI Image"),
+    outputs=[
+        gr.Label(num_top_classes=4, label="Prediction Confidence"),
+        gr.Image(label="Grad-CAM Explanation (Red = High Attention)")
+    ],
+    title="🧠 Brain Tumor MRI Classification (99% Accuracy)",
+    description="""
+    **EfficientNetB3 + Grad-CAM Explainable AI**
+    
+    This model classifies brain MRI images into 4 categories:
+    - **Glioma** - Tumor from glial cells (malignant)
+    - **Meningioma** - Tumor from meninges (usually benign)
+    - **Pituitary** - Pituitary gland tumor
+    - **No Tumor** - Normal brain tissue
+    
+    **Model Performance** (Test Accuracy: 99.11%):
+    - Sensitivity: >96% for all tumor types
+    - Specificity: >99% for all classes
+    - Zero false negatives for tumor detection
+    
+    Grad-CAM visualization shows which regions the model focuses on for its decision.
+    
+    ⚠️ **DISCLAIMER**: This tool is for research and educational purposes only. 
+    NOT approved for clinical diagnosis. Always consult qualified medical professionals.
+    
+    📊 **Usage Instructions**:
+    1. Upload a brain MRI image (axial T1/T2 view preferred)
+    2. Model will predict tumor type with confidence score
+    3. Grad-CAM heatmap shows areas of focus (red = high attention)
+    4. If confidence < 80%, consider expert review
+    """,
+    examples=[],  # Örnek görüntü ekleyebilirsin
+    theme=gr.themes.Soft()
+)
 
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch(share=True)
+    demo.launch()