Spaces:
Sleeping
Sleeping
Download app.py from Tada-tot/BrainVision: direct link, hf CLI and curl.
- Browser
- Download file 7 kB
-
https://huggingface.co/spaces/Tada-tot/BrainVision/resolve/main/app.py
- Command line
-
hf download hf://spaces/Tada-tot/BrainVision/app.py
-
curl -L -o app.py https://huggingface.co/spaces/Tada-tot/BrainVision/resolve/main/app.py
7 kB
| import os | |
| import cv2 | |
| import json | |
| import torch | |
| import numpy as np | |
| import gradio as gr | |
| import safetensors.torch | |
| import albumentations as A | |
| import segmentation_models_pytorch as smp | |
| from albumentations.pytorch import ToTensorV2 | |
| from huggingface_hub import hf_hub_download | |
| # Configuration - embed directly in code or load from repo | |
| CONFIG = { | |
| "IMG_SIZE": 256, | |
| "FILTER_SIZE": 3, | |
| "CLIP_LIMIT": 3.0, | |
| "GRID_SIZE": (8, 8), | |
| "NORMALIZE_MEAN": [0.485, 0.456, 0.406], | |
| "NORMALIZE_STD": [0.229, 0.224, 0.225] | |
| } | |
| BEST_MODEL = None | |
| MODEL_NAME = "BrainVision" # Set your model name | |
| DEVICE = "cuda" if torch.cuda.is_available() else "cpu" | |
| def load_model(): | |
| """Load model from Hugging Face Hub or local files.""" | |
| global BEST_MODEL | |
| try: | |
| model_path = "best_model_raw_resnet50.safetensors" | |
| if not os.path.exists(model_path): | |
| return "Error: Model file not found." | |
| encoder_name = "resnet50" | |
| model = smp.Unet( | |
| encoder_name=encoder_name, | |
| encoder_weights='imagenet', | |
| in_channels=3, | |
| classes=1, | |
| activation=None) | |
| state_dict = safetensors.torch.load_file(model_path, device=DEVICE) | |
| model.load_state_dict(state_dict) | |
| model.to(DEVICE) | |
| model.eval() | |
| BEST_MODEL = model | |
| return f"Model loaded successfully on {DEVICE}" | |
| except Exception as e: | |
| return f"Error loading model: {str(e)}" | |
| def apply_clahe_and_median_filter(image_np): | |
| """Applies Median Filter and CLAHE to a numpy image.""" | |
| image = cv2.medianBlur(image_np, CONFIG['FILTER_SIZE']) | |
| lab_img = cv2.cvtColor(image, cv2.COLOR_RGB2LAB) | |
| l, a, b = cv2.split(lab_img) | |
| clahe = cv2.createCLAHE(clipLimit=CONFIG['CLIP_LIMIT'], tileGridSize=tuple(CONFIG['GRID_SIZE'])) | |
| updated_l = clahe.apply(l) | |
| return cv2.cvtColor(cv2.merge((updated_l, a, b)), cv2.COLOR_LAB2RGB) | |
| def dice_score(pred_mask, gt_mask): | |
| """Calculates the Dice score between two binary masks.""" | |
| intersection = np.sum(pred_mask & gt_mask) | |
| union = np.sum(pred_mask) + np.sum(gt_mask) | |
| return (2.0 * intersection) / union if union > 0 else np.nan | |
| def iou_score(pred_mask, gt_mask): | |
| """Calculates the Intersection over Union score.""" | |
| intersection = np.logical_and(pred_mask, gt_mask).sum() | |
| union = np.logical_or(pred_mask, gt_mask).sum() | |
| return intersection / union if union > 0 else np.nan | |
| def predict_and_compare(mri_image, ground_truth_mask): | |
| """Predicts a tumor mask and compares it to a ground truth mask.""" | |
| mri_image_np = np.array(mri_image.convert('RGB')) if mri_image else None | |
| ground_truth_mask_np = np.array(ground_truth_mask.convert('L')) if ground_truth_mask else None | |
| if BEST_MODEL is None: | |
| return None, None, "Error: Model not loaded. Please check model path." | |
| if mri_image_np is None: | |
| return None, None, "Error: Please upload a brain MRI image." | |
| processed_image = mri_image_np.copy() | |
| val_transform = A.Compose([ | |
| A.Resize(CONFIG['IMG_SIZE'], CONFIG['IMG_SIZE']), | |
| A.Normalize(mean=CONFIG['NORMALIZE_MEAN'], std=CONFIG['NORMALIZE_STD']), | |
| ToTensorV2()]) | |
| augmented = val_transform(image=processed_image) | |
| input_tensor = augmented['image'].unsqueeze(0).to(DEVICE) | |
| with torch.no_grad(): | |
| output = BEST_MODEL(input_tensor) | |
| pred_mask = (torch.sigmoid(output).squeeze().cpu().numpy() > 0.5).astype(np.uint8) * 255 | |
| pred_mask_resized = cv2.resize(pred_mask, (mri_image_np.shape[1], mri_image_np.shape[0])) | |
| pred_overlay = mri_image_np.copy() | |
| contours, _ = cv2.findContours(pred_mask_resized, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) | |
| cv2.drawContours(pred_overlay, contours, -1, (255, 0, 0), 2) # Red for Prediction | |
| status_msg = "Prediction Completed!" | |
| dice = iou = np.nan | |
| comparison_output = None | |
| if ground_truth_mask_np is not None: | |
| gt_mask_resized = cv2.resize(ground_truth_mask_np, (mri_image_np.shape[1], mri_image_np.shape[0])) | |
| dice = dice_score(pred_mask_resized, gt_mask_resized) | |
| iou = iou_score(pred_mask_resized, gt_mask_resized) | |
| comparison_output = mri_image_np.copy() | |
| gt_contours, _ = cv2.findContours(gt_mask_resized, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) | |
| cv2.drawContours(comparison_output, gt_contours, -1, (0, 255, 0), 2) # Green for Ground Truth | |
| cv2.drawContours(comparison_output, contours, -1, (255, 0, 0), 2) # Red for Prediction | |
| return pred_overlay, comparison_output, status_msg, dice, iou | |
| def clear_interface(): | |
| """Resets the interface.""" | |
| return None, None, "", np.nan, np.nan | |
| # Load model on startup | |
| try: | |
| status_text = load_model() | |
| except Exception as e: | |
| print(f"Error loading model: {e}") | |
| # Create Gradio interface | |
| with gr.Blocks(theme=gr.themes.Soft(), title="🧠👁️ BrainVision") as demo: | |
| gr.Markdown("# Brain Tumor Segmentation") | |
| gr.Markdown("Upload a brain MRI scan and an optional ground truth mask. The model will predict the tumor segmentation.") | |
| with gr.Accordion("📖 How to Use", open=True): | |
| gr.Markdown(""" | |
| 1. **Upload MRI Image** (required): Upload a brain MRI scan | |
| 2. **Upload Ground Truth** (optional): For performance evaluation | |
| 3. **Click Predict**: Run the segmentation model | |
| 4. **View Results**: See the predicted tumor mask overlaid on the original image | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("### Upload Images") | |
| mri_input = gr.Image(type="pil", label="Brain MRI (Required) - 3 Channel RGB") | |
| gt_mask_input = gr.Image(type="pil", label="Ground Truth Mask (Optional) - Binary Image") | |
| with gr.Row(): | |
| predict_btn = gr.Button("🔮 Predict", variant="primary") | |
| clear_btn = gr.Button("🗑️ Clear") | |
| with gr.Column(scale=2): | |
| gr.Markdown("### Results") | |
| with gr.Row(): | |
| pred_output = gr.Image(label="Predicted Segmentation") | |
| comparison_output = gr.Image(label="Comparison (GT vs Prediction)") | |
| with gr.Row(): | |
| dice_output = gr.Number(label="Dice Score", precision=4) | |
| iou_output = gr.Number(label="IoU Score", precision=4) | |
| status_output = gr.Textbox(label="Status", value=status_text) | |
| gr.Markdown(f"**Model Name:** {MODEL_NAME} | **Device:** {DEVICE} | **Status:** {'Ready' if BEST_MODEL is not None else 'Stall'}") | |
| # Event handlers | |
| predict_btn.click( | |
| fn=predict_and_compare, | |
| inputs=[mri_input, gt_mask_input], | |
| outputs=[pred_output, comparison_output, status_output, dice_output, iou_output]) | |
| clear_btn.click( | |
| fn=clear_interface, | |
| outputs=[pred_output, comparison_output, status_output, dice_output, iou_output]) | |
| if __name__ == "__main__": | |
| demo.launch(share=True) | |