Initial commit

.gitignore

@@ -0,0 +1,20 @@
+__pycache__
+*.pyc
+*.pth
+*.pt
+*.ipynb_checkpoints
+*.DS_Store
+*.env
+*.log
+*.tmp
+*.csv
+*.xlsx
+*.tar.gz
+*.zip
+*.sublime-project
+*.sublime-workspace
+.vscode/
+.idea/
+.pytest_cache/
+results/
+temp_*

LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kudakwashe M
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,39 @@
+# 🧬 Malaria Cell Classifier with Grad-CAM & Streamlit UI
+
+A deep learning-based malaria detection system using ResNet50 and Grad-CAM explainability.
+
+## 🚀 Features
+
+- ✅ Binary classification of blood smear images (`Infected` / `Uninfected`)
+- 🔍 Grad-CAM visualizations to highlight infected regions
+- 🌐 Interactive Streamlit web interface
+- 📦 Easy-to-deploy structure
+
+## 🛠️ Built With
+
+- [PyTorch](https://pytorch.org/) 
+- [Streamlit](https://streamlit.io/) 
+- [Grad-CAM](https://arxiv.org/abs/1610.02391) 
+- [ResNet50](https://pytorch.org/vision/stable/models.html) 
+
+## 📦 Dataset
+
+Uses the [Malaria Cell Images Dataset](https://www.kaggle.com/iarunava/cell-images-for-detecting-malaria) 
+
+## 📁 Folder Structure
+
+Place raw images in:
+data/cell_images/
+├── Parasitized/
+└── Uninfected/
+
+
+## 📷 Example Output
+
+![Example Grad-CAM Output](image.png)
+
+## 🧪 Usage
+
+### Train the Model
+```bash
+python notebooks/train.py

app/app.py

@@ -0,0 +1,82 @@
+import os
+import streamlit as st
+import torch
+from PIL import Image
+import numpy as np
+import warnings
+import torch.nn.functional as F
+
+# Avoid OMP error from PyTorch/OpenCV
+os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
+
+# Suppress FutureWarning from Matplotlib
+warnings.filterwarnings("ignore", category=UserWarning)
+
+# Import custom modules
+from models.resnet_model import MalariaResNet50
+from gradcam import visualize_gradcam
+
+
+# -----------------------------
+# Streamlit Page Setup
+# -----------------------------
+st.set_page_config(page_title="🧬 Malaria Cell Classifier", layout="wide")
+st.title("🧬 Malaria Cell Classifier with Grad-CAM")
+st.write("Upload a blood smear image and the model will classify it as infected or uninfected, and highlight key regions using Grad-CAM.")
+
+
+# -----------------------------
+# Load Model
+# -----------------------------
+@st.cache_resource
+def load_model():
+    # Ensure model class doesn't wrap backbone
+    model = MalariaResNet50(num_classes=2)
+    model.load_state_dict(torch.load("models/malaria_model.pth", map_location='cpu'))
+    model.eval()
+    return model
+
+model = load_model()
+
+
+# -----------------------------
+# Upload Image
+# -----------------------------
+uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "png", "jpeg"])
+
+if uploaded_file is not None:
+    # Save uploaded image temporarily
+    temp_image_path = f"temp_{uploaded_file.name}"
+    with open(temp_image_path, "wb") as f:
+        f.write(uploaded_file.getbuffer())
+
+    # Display original image (resize if needed)
+    image = Image.open(uploaded_file).convert("RGB")
+    max_size = (400, 400)  # Max width and height
+    image.thumbnail(max_size)
+    st.image(image, caption="Uploaded Image", use_container_width=False)
+
+    # Predict button
+    if st.button("Predict"):
+        with st.spinner("Classifying..."):
+            # Run prediction
+            pred_label, confidence = model.predict(temp_image_path, device='cpu', show_image=False)
+            st.success(f"✅ Prediction: **{pred_label}** | Confidence: **{confidence:.2%}**")
+
+            # Show Grad-CAM
+            st.subheader("🔍 Grad-CAM Visualization")
+            with st.expander("ℹ️ What is Grad-CAM?"):
+                st.markdown("""
+                **Grad-CAM (Gradient-weighted Class Activation Mapping)** is an interpretability method that shows which parts of an image are most important for a CNN's prediction.
+            
+                How it works:
+                1. Gradients flow from the output neuron back to the last convolutional layer.
+                2. These gradients are global average pooled to get importance weights.
+                3. A weighted combination creates a coarse heatmap.
+                4. Final heatmap is overlaid on the original image.
+            
+                🔬 In this app:
+                - Helps understand *why* the model thinks a blood smear cell is infected
+                - Makes predictions more transparent and reliable
+                """)
+            visualize_gradcam(model, temp_image_path)

data_prep/data_prep.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Visualize data
+
+# In[1]:
+
+
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+import cv2
+from pathlib import Path
+from collections import defaultdict
+
+
+# In[2]:
+
+
+data_dir = "malaria_data/cell_images"
+parasitized_dir = os.path.join(data_dir, 'Parasitized')
+uninfected_dir = os.path.join(data_dir, 'Uninfected')
+
+parasitized_files = list(Path(parasitized_dir).glob('*.png'))
+uninfected_files = list(Path(uninfected_dir).glob('*.png'))
+
+print(f"Parasitized Images: {len(parasitized_files)}")
+print(f"Uninfected Images: {len(uninfected_files)}")
+
+
+# In[3]:
+
+
+labels = ['Parasitized', 'Uninfected']
+counts = [len(parasitized_files), len(uninfected_files)]
+
+plt.figure(figsize=(6, 4))
+plt.bar(labels, counts, color=['#ff7f0e', '#1f77b4'])
+plt.title("Class Distribution")
+plt.ylabel("Number of Images")
+plt.show()
+
+
+# In[4]:
+
+
+def plot_samples(image_files, title, num_samples=5):
+    plt.figure(figsize=(15, 3))
+    for i in range(num_samples):
+        img = cv2.imread(str(image_files[i]))
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        plt.subplot(1, num_samples, i+1)
+        plt.imshow(img)
+        plt.axis("off")
+    plt.suptitle(title)
+    plt.show()
+
+plot_samples(parasitized_files, "Parasitized Cells")
+plot_samples(uninfected_files, "Uninfected Cells")
+
+
+# In[5]:
+
+
+def get_image_sizes(file_list):
+    sizes = []
+    for f in file_list:
+        img = cv2.imread(str(f))
+        sizes.append(img.shape[:2])  # height, width
+    return sizes
+
+parasitized_sizes = get_image_sizes(parasitized_files)
+uninfected_sizes = get_image_sizes(uninfected_files)
+
+all_sizes = parasitized_sizes + uninfected_sizes
+unique_sizes = set(all_sizes)
+
+print("Unique image sizes found:")
+print(unique_sizes)
+
+
+# In[6]:
+
+
+total_images = len(parasitized_files) + len(uninfected_files)
+avg_height = np.mean([size[0] for size in all_sizes])
+avg_width = np.mean([size[1] for size in all_sizes])
+
+print(f"\nTotal Images: {total_images}")
+print(f"Average Image Size: {avg_width:.0f}x{avg_height:.0f}")
+print(f"Min/Max Height: {min(s[0] for s in all_sizes)} / {max(s[0] for s in all_sizes)}")
+print(f"Min/Max Width: {min(s[1] for s in all_sizes)} / {max(s[1] for s in all_sizes)}")
+
+
+# In[7]:
+
+
+sample_img = cv2.imread(str(parasitized_files[5]))
+print("Image shape:", sample_img.shape)
+
+
+# # Data preprocessing
+
+# In[8]:
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Assuming you have your image data in a numpy array called 'image_data'
+# For a single image:
+plt.figure(figsize=(10, 6))
+plt.hist(sample_img.ravel(), bins=256, range=(0, 256), color='blue', alpha=0.7)
+plt.title('Pixel Value Distribution')
+plt.xlabel('Pixel Intensity')
+plt.ylabel('Frequency')
+plt.grid(True, linestyle='--', alpha=0.5)
+plt.show()
+
+
+# # Data Splitting
+
+# In[20]:
+
+
+import os
+import shutil
+from pathlib import Path
+import random
+from sklearn.model_selection import train_test_split
+import numpy as np
+import matplotlib.pyplot as plt
+import cv2
+import torch
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+
+
+# In[21]:
+
+
+RAW_DATA_DIR = 'malaria_data/cell_images'
+OUTPUT_DIR = 'malaria_ds/split_dataset'
+
+PARASITIZED_DIR = os.path.join(RAW_DATA_DIR, 'Parasitized')
+UNINFECTED_DIR = os.path.join(RAW_DATA_DIR, 'Uninfected')
+
+# Output directories
+TRAIN_DIR = os.path.join(OUTPUT_DIR, 'train')
+VAL_DIR = os.path.join(OUTPUT_DIR, 'validation')
+TEST_DIR = os.path.join(OUTPUT_DIR, 'test')
+
+# Ensure output directories exist
+os.makedirs(PARASITIZED_DIR, exist_ok=True)
+os.makedirs(UNINFECTED_DIR, exist_ok=True)
+
+print("Paths defined.")
+
+
+# In[22]:
+
+
+def split_class_files(class_dir, train_dir, val_dir, test_dir):
+    all_files = list(Path(class_dir).glob('*.*'))
+    train_files, test_files = train_test_split(all_files, test_size=0.1, random_state=42)
+    train_files, val_files = train_test_split(train_files, test_size=0.1 / (1 - 0.1), random_state=42)
+
+    for f in train_files:
+        shutil.copy(f, train_dir)
+    for f in val_files:
+        shutil.copy(f, val_dir)
+    for f in test_files:
+        shutil.copy(f, test_dir)
+
+    return len(all_files)
+
+def create_split_folders():
+    class_names = ['Parasitized', 'Uninfected']
+    for folder in ['train', 'validation', 'test']:
+        for cls in class_names:
+            os.makedirs(os.path.join(OUTPUT_DIR, folder, cls), exist_ok=True)
+
+    print("Splitting Parasitized Images:")
+    total_parasitized = split_class_files(
+        os.path.join(RAW_DATA_DIR, 'Parasitized'),
+        os.path.join(OUTPUT_DIR, 'train', 'Parasitized'),
+        os.path.join(OUTPUT_DIR, 'validation', 'Parasitized'),
+        os.path.join(OUTPUT_DIR, 'test', 'Parasitized')
+    )
+
+    print("\nSplitting Uninfected Images:")
+    total_uninfected = split_class_files(
+        os.path.join(RAW_DATA_DIR, 'Uninfected'),
+        os.path.join(OUTPUT_DIR, 'train', 'Uninfected'),
+        os.path.join(OUTPUT_DIR, 'validation', 'Uninfected'),
+        os.path.join(OUTPUT_DIR, 'test', 'Uninfected')
+    )
+
+    print(f"\nTotal Parasitized: {total_parasitized}, Uninfected: {total_uninfected}")
+    print("Dataset split completed.")
+
+
+# ## Data Aug and transforms
+
+# In[23]:
+
+
+IMG_SIZE = (128, 128)
+BATCH_SIZE = 32
+
+# Custom class_to_idx mapping to fix label order
+class_to_idx = {'Uninfected': 0, 'Parasitized': 1}
+idx_to_class = {v: k for k, v in class_to_idx.items()}
+
+# Define transforms
+train_transforms = transforms.Compose([
+    transforms.Resize(IMG_SIZE),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    transforms.RandomRotation(20),
+    transforms.RandomHorizontalFlip(),
+])
+
+val_test_transforms = transforms.Compose([
+    transforms.Resize(IMG_SIZE),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+])
+
+# Custom Dataset Class to enforce class_to_idx
+class CustomImageFolder(datasets.ImageFolder):
+    def __init__(self, root, transform, class_to_idx_override=None):
+        super().__init__(root=root, transform=transform)
+        if class_to_idx_override:
+            self.class_to_idx = class_to_idx_override
+            self.samples = [
+                (path, class_to_idx[cls]) 
+                for path, cls_idx in self.samples 
+                for cls in [self.classes[cls_idx]] 
+                if cls in class_to_idx_override
+            ]
+            self.classes = list(class_to_idx_override.keys())
+
+
+
+# In[24]:
+
+
+def get_dataloaders():
+    # Create datasets
+    train_dataset = CustomImageFolder(root=os.path.join(OUTPUT_DIR, 'train'), transform=train_transforms, class_to_idx_override=class_to_idx)
+    val_dataset = CustomImageFolder(root=os.path.join(OUTPUT_DIR, 'validation'), transform=val_test_transforms, class_to_idx_override=class_to_idx)
+    test_dataset = CustomImageFolder(root=os.path.join(OUTPUT_DIR, 'test'), transform=val_test_transforms, class_to_idx_override=class_to_idx)
+
+    # Create data loaders
+    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
+    val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False)
+    test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)
+
+    print(f"Train: {len(train_dataset)}, Val: {len(val_dataset)}, Test: {len(test_dataset)}")
+    print("Class Mapping:", train_dataset.class_to_idx)
+
+    return train_loader, val_loader, test_loader, train_dataset, val_dataset, test_dataset
+
+
+# In[26]:
+
+
+def show_batch_sample(loader, dataset):
+    images, labels = next(iter(loader))
+    plt.figure(figsize=(12, 6))
+    for i in range(min(6, BATCH_SIZE)):
+        img = images[i].numpy().transpose((1, 2, 0))
+        img = np.clip(img * np.array([0.229, 0.224, 0.225]) + np.array([0.485, 0.456, 0.406]), 0, 1)
+        plt.subplot(2, 3, i+1)
+        plt.imshow(img)
+        plt.title(idx_to_class[labels[i].item()])
+        plt.axis("off")
+    plt.suptitle("Sample Batch from DataLoader")
+    plt.show()
+
+
+# In[32]:
+
+
+create_split_folders()
+train_loader, val_loader, test_loader, train_dataset, val_dataset, test_dataset = get_dataloaders()
+show_batch_sample(train_loader, train_dataset)
+
+
+# In[34]:
+
+
+print(train_dataset)
+

grdcam/gradcam.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import cv2
+import numpy as np
+from torchvision import transforms
+import matplotlib.pyplot as plt
+from PIL import Image
+import streamlit as st
+
+
+# In[2]:
+
+
+def preprocess_image(image_path):
+    """
+    Load and preprocess an image for inference.
+    """
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    ])
+
+    img = Image.open(image_path).convert('RGB')
+    tensor = transform(img)
+    return tensor.unsqueeze(0), img
+
+
+# In[3]:
+
+
+def get_last_conv_layer(model):
+    """
+    Get the last convolutional layer in the model.
+    """
+    # For ResNet architecture
+    for name, module in reversed(list(model.named_modules())):
+        if isinstance(module, nn.Conv2d):
+            return name
+    raise ValueError("No Conv2d layers found in the model.")
+
+
+# In[4]:
+
+
+def apply_gradcam(model, image_tensor, target_class=None):
+    """
+    Apply Grad-CAM to an image.
+    """
+    device = next(model.parameters()).device
+    image_tensor = image_tensor.to(device)
+
+    # Register hooks to get activations and gradients
+    features = []
+    gradients = []
+
+    def forward_hook(module, input, output):
+        features.append(output.detach())
+
+    def backward_hook(module, grad_input, grad_output):
+        gradients.append(grad_output[0].detach())
+
+    last_conv_layer_name = get_last_conv_layer(model)
+    last_conv_layer = dict(model.named_modules())[last_conv_layer_name]
+    handle_forward = last_conv_layer.register_forward_hook(forward_hook)
+    handle_backward = last_conv_layer.register_full_backward_hook(backward_hook)
+
+    # Forward pass
+    model.eval()
+    output = model(image_tensor)
+    if target_class is None:
+        target_class = output.argmax(dim=1).item()
+
+    # Zero out all gradients
+    model.zero_grad()
+
+    # Backward pass
+    one_hot = torch.zeros_like(output)
+    one_hot[0][target_class] = 1
+    output.backward(gradient=one_hot)
+
+    # Remove hooks
+    handle_forward.remove()
+    handle_backward.remove()
+
+    # Get feature maps and gradients
+    feature_map = features[-1].squeeze().cpu().numpy()
+    gradient = gradients[-1].squeeze().cpu().numpy()
+
+    # Global Average Pooling on gradients
+    pooled_gradients = np.mean(gradient, axis=(1, 2), keepdims=True)
+    cam = feature_map * pooled_gradients
+    cam = np.sum(cam, axis=0)
+
+    # Apply ReLU
+    cam = np.maximum(cam, 0)
+
+    # Normalize the CAM
+    cam = cam - np.min(cam)
+    cam = cam / np.max(cam)
+
+    # Resize CAM to match the original image size
+    cam = cv2.resize(cam, (224, 224))
+
+    return cam
+
+
+# In[5]:
+
+
+def overlay_heatmap(original_image, heatmap, alpha=0.5):
+    """
+    Overlay the heatmap on the original image.
+
+    Args:
+        original_image (np.ndarray): Original image (H, W, 3), uint8
+        heatmap (np.ndarray): Grad-CAM heatmap (H', W'), float between 0 and 1
+        alpha (float): Weight for the heatmap
+
+    Returns:
+        np.ndarray: Overlayed image
+    """
+    # Ensure heatmap is 2D
+    if heatmap.ndim == 3:
+        heatmap = np.mean(heatmap, axis=2)
+
+    # Resize heatmap to match original image size
+    heatmap_resized = cv2.resize(heatmap, (original_image.shape[1], original_image.shape[0]))
+
+    # Normalize heatmap to [0, 255]
+    heatmap_resized = np.uint8(255 * heatmap_resized)
+
+    # Apply colormap
+    heatmap_colored = cv2.applyColorMap(heatmap_resized, cv2.COLORMAP_JET)
+
+    # Convert from BGR to RGB
+    heatmap_colored = cv2.cvtColor(heatmap_colored, cv2.COLOR_BGR2RGB)
+
+    # Superimpose: blend heatmap and original image
+    superimposed_img = heatmap_colored * alpha + original_image * (1 - alpha)
+    return np.uint8(superimposed_img)
+
+def visualize_gradcam(model, image_path):
+    """
+    Visualize Grad-CAM for a given image.
+    """
+    # Preprocess image
+    image_tensor, original_image = preprocess_image(image_path)
+    original_image_np = np.array(original_image)  # PIL -> numpy array
+
+    # Resize original image for better display
+    max_size = (400, 400)  # Max width and height
+    original_image_resized = cv2.resize(original_image_np, max_size)
+
+    # Apply Grad-CAM
+    cam = apply_gradcam(model, image_tensor)
+
+    # Resize CAM to match original image size
+    heatmap_resized = cv2.resize(cam, (original_image_np.shape[1], original_image_np.shape[0]))
+
+    # Normalize heatmap to [0, 255]
+    heatmap_resized = np.uint8(255 * heatmap_resized / np.max(heatmap_resized))
+
+    # Apply color map
+    heatmap_colored = cv2.applyColorMap(heatmap_resized, cv2.COLORMAP_JET)
+    heatmap_colored = cv2.cvtColor(heatmap_colored, cv2.COLOR_BGR2RGB)
+
+    # Overlay
+    superimposed_img = heatmap_colored * 0.4 + original_image_np * 0.6
+    superimposed_img = np.clip(superimposed_img, 0, 255).astype(np.uint8)
+
+    # Display results
+    fig, axes = plt.subplots(1, 2, figsize=(8, 4))  # Adjust figsize as needed
+    axes[0].imshow(original_image_resized)
+    axes[0].set_title("Original Image")
+    axes[0].axis("off")
+
+    axes[1].imshow(superimposed_img)
+    axes[1].set_title("Grad-CAM Heatmap")
+    axes[1].axis("off")
+
+    plt.tight_layout()
+    st.pyplot(fig)
+    plt.close(fig)
+
+
+# In[6]:
+
+
+if __name__ == "__main__":
+
+    from models.resnet_model import MalariaResNet50
+    # Load your trained model
+    model = MalariaResNet50(num_classes=2)
+    model.load_state_dict(torch.load("models/malaria_model.pth"))
+    model.eval()
+
+    # Path to an image
+    image_path = "malaria_ds/split_dataset/test/Parasitized/C33P1thinF_IMG_20150619_114756a_cell_181.png"
+
+    # Visualize Grad-CAM
+    visualize_gradcam(model, image_path)
+
+
+# In[ ]:
+
+
+
+

models/resnet_model.ipynb

@@ -0,0 +1,129 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "72678f69-46b9-4908-b301-85ad5d4a6055",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torchvision import models, transforms\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "import torch.nn.functional as F\n",
+    "from torchvision.models import resnet50, ResNet50_Weights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "88eb14fe-a198-4378-8817-13924bb328e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MalariaResNet50(nn.Module):\n",
+    "    def __init__(self, num_classes=2):\n",
+    "        super(MalariaResNet50, self).__init__()\n",
+    "        # Load pretrained ResNet50\n",
+    "        self.backbone = models.resnet50(weights=ResNet50_Weights.DEFAULT)\n",
+    "\n",
+    "        # Replace final fully connected layer for binary classification\n",
+    "        num_ftrs = self.backbone.fc.in_features\n",
+    "        self.backbone.fc = nn.Linear(num_ftrs, num_classes)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        return self.backbone(x)\n",
+    "\n",
+    "    def predict(self, image_path, device='cpu', show_image=False):\n",
+    "        \"\"\"\n",
+    "        Predict class of a single image.\n",
+    "\n",
+    "        Args:\n",
+    "            image_path (str): Path to input image\n",
+    "            device (torch.device): 'cuda' or 'cpu'\n",
+    "            show_image (bool): Whether to display the image\n",
+    "\n",
+    "        Returns:\n",
+    "            pred_label (str): \"Infected\" or \"Uninfected\"\n",
+    "            confidence (float): Confidence score (softmax output)\n",
+    "        \"\"\"\n",
+    "        from torchvision import transforms\n",
+    "        from PIL import Image\n",
+    "        import matplotlib.pyplot as plt\n",
+    "\n",
+    "        transform = transforms.Compose([\n",
+    "            transforms.Resize((224, 224)),\n",
+    "            transforms.ToTensor(),\n",
+    "            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
+    "        ])\n",
+    "\n",
+    "        # Load and preprocess image\n",
+    "        img = Image.open(image_path).convert('RGB')\n",
+    "        img_tensor = transform(img).unsqueeze(0).to(device)\n",
+    "\n",
+    "        # Inference\n",
+    "        self.eval()\n",
+    "        with torch.no_grad():\n",
+    "            output = self(img_tensor)\n",
+    "            probs = F.softmax(output, dim=1)\n",
+    "            _, preds = torch.max(output, 1)\n",
+    "\n",
+    "        pred_idx = preds.item()\n",
+    "        confidence = probs[0][pred_idx].item()\n",
+    "\n",
+    "        classes = ['Uninfected', 'Infected']\n",
+    "        pred_label = classes[pred_idx]\n",
+    "\n",
+    "        if show_image:\n",
+    "            plt.imshow(img)\n",
+    "            plt.title(f\"Predicted: {pred_label} ({confidence:.2%})\")\n",
+    "            plt.axis(\"off\")\n",
+    "            plt.show()\n",
+    "\n",
+    "        return pred_label, confidence\n",
+    "\n",
+    "    def save(self, path):\n",
+    "        \"\"\"Save model state dict\"\"\"\n",
+    "        torch.save(self.state_dict(), path)\n",
+    "        print(f\"Model saved to {path}\")\n",
+    "\n",
+    "    def load(self, path):\n",
+    "        \"\"\"Load model state dict from file\"\"\"\n",
+    "        state_dict = torch.load(path, map_location=torch.device('cpu'))\n",
+    "        self.load_state_dict(state_dict)\n",
+    "        print(f\"Model loaded from {path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "70b8f814-f126-4a12-afe8-051b9b9d4c2a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.17"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

models/resnet_model.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[1]:
+
+
+import torch
+import torch.nn as nn
+from torchvision import models, transforms
+from PIL import Image
+import numpy as np
+import torch.nn.functional as F
+from torchvision.models import resnet50, ResNet50_Weights
+
+
+# In[4]:
+
+
+class MalariaResNet50(nn.Module):
+    def __init__(self, num_classes=2):
+        super(MalariaResNet50, self).__init__()
+        # Load pretrained ResNet50
+        self.backbone = models.resnet50(weights=ResNet50_Weights.DEFAULT)
+
+        # Replace final fully connected layer for binary classification
+        num_ftrs = self.backbone.fc.in_features
+        self.backbone.fc = nn.Linear(num_ftrs, num_classes)
+
+    def forward(self, x):
+        return self.backbone(x)
+
+    def predict(self, image_path, device='cpu', show_image=False):
+        """
+        Predict class of a single image.
+
+        Args:
+            image_path (str): Path to input image
+            device (torch.device): 'cuda' or 'cpu'
+            show_image (bool): Whether to display the image
+
+        Returns:
+            pred_label (str): "Infected" or "Uninfected"
+            confidence (float): Confidence score (softmax output)
+        """
+        from torchvision import transforms
+        from PIL import Image
+        import matplotlib.pyplot as plt
+
+        transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+        ])
+
+        # Load and preprocess image
+        img = Image.open(image_path).convert('RGB')
+        img_tensor = transform(img).unsqueeze(0).to(device)
+
+        # Inference
+        self.eval()
+        with torch.no_grad():
+            output = self(img_tensor)
+            probs = F.softmax(output, dim=1)
+            _, preds = torch.max(output, 1)
+
+        pred_idx = preds.item()
+        confidence = probs[0][pred_idx].item()
+
+        classes = ['Uninfected', 'Infected']
+        pred_label = classes[pred_idx]
+
+        if show_image:
+            plt.imshow(img)
+            plt.title(f"Predicted: {pred_label} ({confidence:.2%})")
+            plt.axis("off")
+            plt.show()
+
+        return pred_label, confidence
+
+    def save(self, path):
+        """Save model state dict"""
+        torch.save(self.state_dict(), path)
+        print(f"Model saved to {path}")
+
+    def load(self, path):
+        """Load model state dict from file"""
+        state_dict = torch.load(path, map_location=torch.device('cpu'))
+        self.load_state_dict(state_dict)
+        print(f"Model loaded from {path}")
+
+
+# In[ ]:
+
+
+
+

notebooks/app.ipynb

@@ -0,0 +1,179 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "fa37d83b-2543-4b97-a6dd-f54fc56bfd9a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import streamlit as st\n",
+    "import torch\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "import torch.nn.functional as F"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "cfa28009-cc5a-42bf-a5a9-b1cbaeb09fa2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import custom modules\n",
+    "from models.resnet_model import MalariaResNet50\n",
+    "from gradcam import visualize_gradcam"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4dbb399f-01b7-4143-97d0-0fc4b1a33148",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-05-28 22:57:39.942 WARNING streamlit.runtime.scriptrunner_utils.script_run_context: Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:39.948 WARNING streamlit.runtime.scriptrunner_utils.script_run_context: Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:41.270 \n",
+      "  \u001b[33m\u001b[1mWarning:\u001b[0m to view this Streamlit app on a browser, run it with the following\n",
+      "  command:\n",
+      "\n",
+      "    streamlit run C:\\Users\\HP\\miniconda3\\envs\\pytorch_env\\lib\\site-packages\\ipykernel_launcher.py [ARGUMENTS]\n",
+      "2025-05-28 22:57:41.272 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:41.274 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:41.275 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n"
+     ]
+    }
+   ],
+   "source": [
+    "st.set_page_config(page_title=\"🧬 Malaria Cell Classifier\", layout=\"wide\")\n",
+    "st.title(\"🧬 Malaria Cell Classifier with Grad-CAM\")\n",
+    "st.write(\"Upload a blood smear image and the model will classify it as infected or uninfected, and highlight key regions using Grad-CAM.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "cfba0e0a-094e-491f-8d7b-abe0643344dc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-05-28 22:57:41.317 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:41.319 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:41.320 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:41.833 Thread 'Thread-3': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:41.840 Thread 'Thread-3': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Downloading: \"https://download.pytorch.org/models/resnet50-11ad3fa6.pth\" to C:\\Users\\HP/.cache\\torch\\hub\\checkpoints\\resnet50-11ad3fa6.pth\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████| 97.8M/97.8M [00:09<00:00, 11.2MB/s]\n",
+      "2025-05-28 22:57:53.490 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:53.497 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load Model\n",
+    "@st.cache_resource\n",
+    "def load_model():\n",
+    "    model = MalariaResNet50(num_classes=2)\n",
+    "    model.load_state_dict(torch.load(\"models/malaria_model.pth\", map_location=torch.device('cpu')))\n",
+    "    model.eval()\n",
+    "    return model\n",
+    "\n",
+    "model = load_model()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "11f5d404-6c4c-4484-a11a-acede1e5ab7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-05-28 22:57:53.586 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:53.592 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:53.594 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:53.600 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n",
+      "2025-05-28 22:57:53.606 Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Upload Image\n",
+    "uploaded_file = st.file_uploader(\"Choose an image...\", type=[\"jpg\", \"png\", \"jpeg\"])\n",
+    "\n",
+    "if uploaded_file is not None:\n",
+    "    # Save uploaded image temporarily\n",
+    "    temp_image_path = f\"temp_{uploaded_file.name}\"\n",
+    "    with open(temp_image_path, \"wb\") as f:\n",
+    "        f.write(uploaded_file.getbuffer())\n",
+    "\n",
+    "    # Display original image\n",
+    "    image = Image.open(uploaded_file).convert(\"RGB\")\n",
+    "    st.image(image, caption=\"Uploaded Image\", use_column_width=True)\n",
+    "\n",
+    "    # Predict button\n",
+    "    if st.button(\"Predict\"):\n",
+    "        with st.spinner(\"Classifying...\"):\n",
+    "            # Run prediction and show Grad-CAM\n",
+    "            pred_label, confidence = model.predict(temp_image_path, device='cpu', show_image=False)\n",
+    "            \n",
+    "            st.success(f\"✅ Prediction: **{pred_label}** | Confidence: **{confidence:.2%}**\")\n",
+    "\n",
+    "            # Show Grad-CAM\n",
+    "            st.subheader(\"🔍 Grad-CAM Visualization\")\n",
+    "            visualize_gradcam(model, temp_image_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8fa9705e-7775-489a-ad09-27e96793dcc3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.17"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/evaluate.py.ipynb

@@ -0,0 +1,184 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f7c4548e-c6b2-48dc-9df1-58a7c06481d8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "9bd4822d-3ccd-416d-a03f-a0eda7b2bfaa",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# Import custom modules\n",
+    "from models.resnet_model import MalariaResNet50\n",
+    "from data_prep import get_dataloaders"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "91ac3fe5-c5d7-497d-9a6d-2903f6b97bf7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MODEL_PATH = 'models/malaria_model.pth'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "1c7e9e80-2986-4979-8450-6821e6e0a3a8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Total Classes: 2\n",
+      "Train batches: 689, Val batches: 87, Test batches: 87\n",
+      "Using device: cuda\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/lib/python3.12/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
+      "  warnings.warn(msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model loaded from models/malaria_model.pth\n",
+      "Running inference on test set...\n",
+      "\n",
+      "Test Accuracy: 0.9699\n",
+      "\n",
+      "Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      " Parasitized       0.97      0.97      0.97      1378\n",
+      "  Uninfected       0.97      0.97      0.97      1378\n",
+      "\n",
+      "    accuracy                           0.97      2756\n",
+      "   macro avg       0.97      0.97      0.97      2756\n",
+      "weighted avg       0.97      0.97      0.97      2756\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def evaluate():\n",
+    "    # Get all loaders and datasets\n",
+    "    train_loader, val_loader, test_loader, train_dataset, val_dataset, test_dataset = get_dataloaders()\n",
+    "\n",
+    "    # Define device\n",
+    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "    print(f\"Using device: {device}\")\n",
+    "\n",
+    "    # Initialize and load model\n",
+    "    model = MalariaResNet50(num_classes=2)\n",
+    "    model.load(MODEL_PATH)\n",
+    "    model = model.to(device)\n",
+    "    model.eval()  # Set to evaluation mode\n",
+    "\n",
+    "    # Get test data\n",
+    "    y_true = []\n",
+    "    y_pred = []\n",
+    "\n",
+    "    print(\"Running inference on test set...\")\n",
+    "    with torch.no_grad():\n",
+    "        for inputs, labels in test_loader:\n",
+    "            inputs = inputs.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "\n",
+    "            outputs = model(inputs)\n",
+    "            _, preds = torch.max(outputs, 1)\n",
+    "\n",
+    "            y_true.extend(labels.cpu().numpy())\n",
+    "            y_pred.extend(preds.cpu().numpy())\n",
+    "\n",
+    "    # -----------------------------\n",
+    "    # Compute Metrics\n",
+    "    # -----------------------------\n",
+    "    classes = test_dataset.classes  # ['uninfected', 'parasitized']\n",
+    "\n",
+    "    # Accuracy\n",
+    "    acc = accuracy_score(y_true, y_pred)\n",
+    "    print(f\"\\nTest Accuracy: {acc:.4f}\")\n",
+    "\n",
+    "    # Classification Report\n",
+    "    print(\"\\nClassification Report:\")\n",
+    "    print(classification_report(y_true, y_pred, target_names=classes))\n",
+    "\n",
+    "    # Confusion Matrix\n",
+    "    cm = confusion_matrix(y_true, y_pred)\n",
+    "\n",
+    "    plt.figure(figsize=(6, 5))\n",
+    "    sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\", xticklabels=classes, yticklabels=classes)\n",
+    "    plt.xlabel(\"Predicted\")\n",
+    "    plt.ylabel(\"True\")\n",
+    "    plt.title(\"Confusion Matrix\")\n",
+    "    plt.show()\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    evaluate()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b8ec551-2713-4b2e-b33c-cdc7930f8c54",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

requirements.txt

@@ -0,0 +1,238 @@
+absl-py==2.2.2
+aiohappyeyeballs==2.6.1
+aiohttp==3.11.18
+aiosignal==1.3.2
+albucore==0.0.24
+albumentations==2.0.7
+alembic @ file:///home/conda/feedstock_root/build_artifacts/alembic_1743207807124/work
+altair==5.5.0
+annotated-types @ file:///home/conda/feedstock_root/build_artifacts/annotated-types_1733247046149/work
+anyio @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_anyio_1742243108/work
+archspec @ file:///home/conda/feedstock_root/build_artifacts/archspec_1737352602016/work
+argon2-cffi @ file:///home/conda/feedstock_root/build_artifacts/argon2-cffi_1733311059102/work
+argon2-cffi-bindings @ file:///home/conda/feedstock_root/build_artifacts/argon2-cffi-bindings_1725356585055/work
+arrow @ file:///home/conda/feedstock_root/build_artifacts/arrow_1733584251875/work
+asttokens @ file:///home/conda/feedstock_root/build_artifacts/asttokens_1733250440834/work
+async-lru @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_async-lru_1742153708/work
+async_generator @ file:///home/conda/feedstock_root/build_artifacts/async_generator_1734180388035/work
+attrs @ file:///home/conda/feedstock_root/build_artifacts/attrs_1741918516150/work
+babel @ file:///home/conda/feedstock_root/build_artifacts/babel_1738490167835/work
+beautifulsoup4 @ file:///home/conda/feedstock_root/build_artifacts/beautifulsoup4_1744783198182/work
+bleach @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_bleach_1737382993/work
+blinker @ file:///home/conda/feedstock_root/build_artifacts/blinker_1731096409132/work
+boltons @ file:///home/conda/feedstock_root/build_artifacts/boltons_1733827268945/work
+Brotli @ file:///home/conda/feedstock_root/build_artifacts/brotli-split_1725267488082/work
+cached-property @ file:///home/conda/feedstock_root/build_artifacts/cached_property_1615209429212/work
+cachetools==5.5.2
+certifi @ file:///home/conda/feedstock_root/build_artifacts/certifi_1746569525376/work/certifi
+certipy @ file:///home/conda/feedstock_root/build_artifacts/certipy_1743237988054/work
+cffi @ file:///home/conda/feedstock_root/build_artifacts/cffi_1725560558132/work
+charset-normalizer @ file:///home/conda/feedstock_root/build_artifacts/charset-normalizer_1746214863626/work
+click==8.2.1
+colorama @ file:///home/conda/feedstock_root/build_artifacts/colorama_1733218098505/work
+comm @ file:///home/conda/feedstock_root/build_artifacts/comm_1733502965406/work
+conda @ file:///home/conda/feedstock_root/build_artifacts/conda_1744220005005/work/conda-src
+conda-libmamba-solver @ file:///home/conda/feedstock_root/build_artifacts/conda-libmamba-solver_1745834476052/work/src
+conda-package-handling @ file:///home/conda/feedstock_root/build_artifacts/conda-package-handling_1736345463896/work
+conda_package_streaming @ file:///home/conda/feedstock_root/build_artifacts/conda-package-streaming_1741620732069/work
+constants==0.6.0
+contourpy==1.3.2
+cryptography @ file:///home/conda/feedstock_root/build_artifacts/cryptography-split_1746241906404/work
+cycler==0.12.1
+datasets==3.6.0
+debugpy @ file:///home/conda/feedstock_root/build_artifacts/debugpy_1744321241074/work
+decorator @ file:///home/conda/feedstock_root/build_artifacts/decorator_1740384970518/work
+defusedxml @ file:///home/conda/feedstock_root/build_artifacts/defusedxml_1615232257335/work
+dill==0.3.8
+distro @ file:///home/conda/feedstock_root/build_artifacts/distro_1734729835256/work
+exceptiongroup @ file:///home/conda/feedstock_root/build_artifacts/exceptiongroup_1746947292760/work
+executing @ file:///home/conda/feedstock_root/build_artifacts/executing_1745502089858/work
+fastjsonschema @ file:///home/conda/feedstock_root/build_artifacts/python-fastjsonschema_1733235979760/work/dist
+filelock==3.18.0
+fonttools==4.58.0
+fqdn @ file:///home/conda/feedstock_root/build_artifacts/fqdn_1733327382592/work/dist
+frozendict @ file:///home/conda/feedstock_root/build_artifacts/frozendict_1728841327252/work
+frozenlist==1.6.0
+fsspec==2025.3.0
+gitdb==4.0.12
+GitPython==3.1.44
+greenlet @ file:///home/conda/feedstock_root/build_artifacts/greenlet_1746824022659/work
+grpcio==1.71.0
+h11 @ file:///home/conda/feedstock_root/build_artifacts/h11_1745526374115/work
+h2 @ file:///home/conda/feedstock_root/build_artifacts/h2_1738578511449/work
+hpack @ file:///home/conda/feedstock_root/build_artifacts/hpack_1737618293087/work
+httpcore @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_httpcore_1745602916/work
+httpx @ file:///home/conda/feedstock_root/build_artifacts/httpx_1733663348460/work
+huggingface-hub==0.31.2
+hyperframe @ file:///home/conda/feedstock_root/build_artifacts/hyperframe_1737618333194/work
+idna @ file:///home/conda/feedstock_root/build_artifacts/idna_1733211830134/work
+imageio==2.37.0
+importlib_metadata @ file:///home/conda/feedstock_root/build_artifacts/importlib-metadata_1737420181517/work
+importlib_resources @ file:///home/conda/feedstock_root/build_artifacts/importlib_resources_1736252299705/work
+ipykernel @ file:///home/conda/feedstock_root/build_artifacts/ipykernel_1719845459717/work
+ipython @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_ipython_1745672166/work
+ipython_genutils @ file:///home/conda/feedstock_root/build_artifacts/ipython_genutils_1733399582966/work
+ipython_pygments_lexers @ file:///home/conda/feedstock_root/build_artifacts/ipython_pygments_lexers_1737123620466/work
+ipywidgets==8.1.7
+isoduration @ file:///home/conda/feedstock_root/build_artifacts/isoduration_1733493628631/work/dist
+iterative-stratification==0.1.9
+jedi @ file:///home/conda/feedstock_root/build_artifacts/jedi_1733300866624/work
+Jinja2 @ file:///home/conda/feedstock_root/build_artifacts/jinja2_1741263328855/work
+joblib==1.5.0
+json5 @ file:///home/conda/feedstock_root/build_artifacts/json5_1743722064131/work
+jsonpatch @ file:///home/conda/feedstock_root/build_artifacts/jsonpatch_1733814567314/work
+jsonpointer @ file:///home/conda/feedstock_root/build_artifacts/jsonpointer_1725302935093/work
+jsonschema @ file:///home/conda/feedstock_root/build_artifacts/jsonschema_1733472696581/work
+jsonschema-specifications @ file:///tmp/tmpuvkyqc9y/src
+jupyter-events @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_jupyter_events_1738765986/work
+jupyter-lsp @ file:///home/conda/feedstock_root/build_artifacts/jupyter-lsp-meta_1733492907176/work/jupyter-lsp
+jupyter_client @ file:///home/conda/feedstock_root/build_artifacts/jupyter_client_1733440914442/work
+jupyter_core @ file:///home/conda/feedstock_root/build_artifacts/jupyter_core_1727163409502/work
+jupyter_server @ file:///home/conda/feedstock_root/build_artifacts/jupyter_server_1734702637701/work
+jupyter_server_terminals @ file:///home/conda/feedstock_root/build_artifacts/jupyter_server_terminals_1733427956852/work
+jupyterhub @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_jupyterhub-base_1744782338/work
+jupyterlab @ file:///home/conda/feedstock_root/build_artifacts/jupyterlab_1746536008058/work
+jupyterlab_pygments @ file:///home/conda/feedstock_root/build_artifacts/jupyterlab_pygments_1733328101776/work
+jupyterlab_server @ file:///home/conda/feedstock_root/build_artifacts/jupyterlab_server_1733599573484/work
+jupyterlab_widgets==3.0.15
+kiwisolver==1.4.8
+lazy_loader==0.4
+libmambapy @ file:///home/conda/feedstock_root/build_artifacts/mamba-split_1746515836725/work/libmambapy
+Mako @ file:///home/conda/feedstock_root/build_artifacts/mako_1744317760971/work
+Markdown==3.8
+MarkupSafe @ file:///home/conda/feedstock_root/build_artifacts/markupsafe_1733219680183/work
+matplotlib==3.10.3
+matplotlib-inline @ file:///home/conda/feedstock_root/build_artifacts/matplotlib-inline_1733416936468/work
+menuinst @ file:///home/conda/feedstock_root/build_artifacts/menuinst_1731146972698/work
+mistune @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_mistune_1742402716/work
+mpmath==1.3.0
+multidict==6.4.3
+multiprocess==0.70.16
+narwhals==1.41.0
+nbclassic @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_nbclassic_1746550383/work
+nbclient @ file:///home/conda/feedstock_root/build_artifacts/nbclient_1734628800805/work
+nbconvert @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_nbconvert-core_1738067871/work
+nbformat @ file:///home/conda/feedstock_root/build_artifacts/nbformat_1733402752141/work
+nest_asyncio @ file:///home/conda/feedstock_root/build_artifacts/nest-asyncio_1733325553580/work
+networkx==3.4.2
+notebook @ file:///home/conda/feedstock_root/build_artifacts/notebook_1746547590747/work
+notebook_shim @ file:///home/conda/feedstock_root/build_artifacts/notebook-shim_1733408315203/work
+numpy==1.26.4
+nvidia-cublas-cu12==12.6.4.1
+nvidia-cuda-cupti-cu12==12.6.80
+nvidia-cuda-nvrtc-cu12==12.6.77
+nvidia-cuda-runtime-cu12==12.6.77
+nvidia-cudnn-cu12==9.5.1.17
+nvidia-cufft-cu12==11.3.0.4
+nvidia-cufile-cu12==1.11.1.6
+nvidia-curand-cu12==10.3.7.77
+nvidia-cusolver-cu12==11.7.1.2
+nvidia-cusparse-cu12==12.5.4.2
+nvidia-cusparselt-cu12==0.6.3
+nvidia-ml-py==12.575.51
+nvidia-nccl-cu12==2.26.2
+nvidia-nvjitlink-cu12==12.6.85
+nvidia-nvtx-cu12==12.6.77
+oauthlib @ file:///home/conda/feedstock_root/build_artifacts/oauthlib_1733752848439/work
+opencv-python==4.11.0.86
+opencv-python-headless==4.11.0.86
+overrides @ file:///home/conda/feedstock_root/build_artifacts/overrides_1734587627321/work
+packaging==24.2
+pamela @ file:///home/conda/feedstock_root/build_artifacts/pamela_1734511180361/work
+pandas==2.2.3
+pandocfilters @ file:///home/conda/feedstock_root/build_artifacts/pandocfilters_1631603243851/work
+parso @ file:///home/conda/feedstock_root/build_artifacts/parso_1733271261340/work
+pexpect @ file:///home/conda/feedstock_root/build_artifacts/pexpect_1733301927746/work
+pickleshare @ file:///home/conda/feedstock_root/build_artifacts/pickleshare_1733327343728/work
+pillow==11.2.1
+pkgutil_resolve_name @ file:///home/conda/feedstock_root/build_artifacts/pkgutil-resolve-name_1733344503739/work
+platformdirs @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_platformdirs_1746710438/work
+pluggy @ file:///home/conda/feedstock_root/build_artifacts/pluggy_1733222765875/work
+prometheus_client @ file:///home/conda/feedstock_root/build_artifacts/prometheus_client_1733327310477/work
+prompt_toolkit @ file:///home/conda/feedstock_root/build_artifacts/prompt-toolkit_1744724089886/work
+propcache==0.3.1
+protobuf==6.31.0
+psutil @ file:///home/conda/feedstock_root/build_artifacts/psutil_1740663123172/work
+ptyprocess @ file:///home/conda/feedstock_root/build_artifacts/ptyprocess_1733302279685/work/dist/ptyprocess-0.7.0-py2.py3-none-any.whl#sha256=92c32ff62b5fd8cf325bec5ab90d7be3d2a8ca8c8a3813ff487a8d2002630d1f
+pure_eval @ file:///home/conda/feedstock_root/build_artifacts/pure_eval_1733569405015/work
+pyarrow==20.0.0
+pycosat @ file:///home/conda/feedstock_root/build_artifacts/pycosat_1732588402431/work
+pycparser @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_pycparser_1733195786/work
+pydantic @ file:///home/conda/feedstock_root/build_artifacts/pydantic_1746631911634/work
+pydantic_core @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_pydantic-core_1746625309/work
+pydeck==0.9.1
+Pygments @ file:///home/conda/feedstock_root/build_artifacts/pygments_1736243443484/work
+PyJWT @ file:///home/conda/feedstock_root/build_artifacts/pyjwt_1732782409051/work
+pynvml==12.0.0
+pyparsing==3.2.3
+PySocks @ file:///home/conda/feedstock_root/build_artifacts/pysocks_1733217236728/work
+python-dateutil @ file:///home/conda/feedstock_root/build_artifacts/python-dateutil_1733215673016/work
+python-json-logger @ file:///home/conda/feedstock_root/build_artifacts/python-json-logger_1677079630776/work
+pytz @ file:///home/conda/feedstock_root/build_artifacts/pytz_1742920838005/work
+PyYAML @ file:///home/conda/feedstock_root/build_artifacts/pyyaml_1737454647378/work
+pyzmq @ file:///home/conda/feedstock_root/build_artifacts/pyzmq_1743831245863/work
+referencing @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_referencing_1737836872/work
+regex==2024.11.6
+requests @ file:///home/conda/feedstock_root/build_artifacts/requests_1733217035951/work
+rfc3339_validator @ file:///home/conda/feedstock_root/build_artifacts/rfc3339-validator_1733599910982/work
+rfc3986-validator @ file:///home/conda/feedstock_root/build_artifacts/rfc3986-validator_1598024191506/work
+rpds-py @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_rpds-py_1743037659/work
+ruamel.yaml @ file:///home/conda/feedstock_root/build_artifacts/ruamel.yaml_1736248036158/work
+ruamel.yaml.clib @ file:///home/conda/feedstock_root/build_artifacts/ruamel.yaml.clib_1728724466132/work
+safetensors==0.5.3
+scikit-image==0.25.2
+scikit-learn==1.6.1
+scipy==1.15.3
+seaborn==0.13.2
+Send2Trash @ file:///home/conda/feedstock_root/build_artifacts/send2trash_1733322040660/work
+setuptools==80.1.0
+simsimd==6.2.1
+six @ file:///home/conda/feedstock_root/build_artifacts/six_1733380938961/work
+smmap==5.0.2
+sniffio @ file:///home/conda/feedstock_root/build_artifacts/sniffio_1733244044561/work
+soupsieve @ file:///home/conda/feedstock_root/build_artifacts/soupsieve_1746563585861/work
+SQLAlchemy @ file:///home/conda/feedstock_root/build_artifacts/sqlalchemy_1743109724354/work
+stack_data @ file:///home/conda/feedstock_root/build_artifacts/stack_data_1733569443808/work
+streamlit==1.45.1
+stringzilla==3.12.5
+sympy==1.14.0
+tenacity==9.1.2
+tensorboard==2.19.0
+tensorboard-data-server==0.7.2
+terminado @ file:///home/conda/feedstock_root/build_artifacts/terminado_1710262609923/work
+threadpoolctl==3.6.0
+tifffile==2025.5.10
+timm==1.0.15
+tinycss2 @ file:///home/conda/feedstock_root/build_artifacts/tinycss2_1729802851396/work
+tokenizers==0.21.1
+toml==0.10.2
+tomli @ file:///home/conda/feedstock_root/build_artifacts/tomli_1733256695513/work
+torch==2.7.0
+torchcam==0.4.0
+torchvision==0.22.0
+torchxrayvision==1.3.4
+tornado @ file:///home/conda/feedstock_root/build_artifacts/tornado_1732615905931/work
+tqdm @ file:///home/conda/feedstock_root/build_artifacts/tqdm_1735661334605/work
+traitlets @ file:///home/conda/feedstock_root/build_artifacts/traitlets_1733367359838/work
+transformers==4.51.3
+triton==3.3.0
+truststore @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_truststore_1739009763/work
+types-python-dateutil @ file:///home/conda/feedstock_root/build_artifacts/types-python-dateutil_1733612335562/work
+typing-inspection @ file:///home/conda/feedstock_root/build_artifacts/typing-inspection_1741438046699/work
+typing_extensions @ file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_typing_extensions_1744302253/work
+typing_utils @ file:///home/conda/feedstock_root/build_artifacts/typing_utils_1733331286120/work
+tzdata==2025.2
+uri-template @ file:///home/conda/feedstock_root/build_artifacts/uri-template_1733323593477/work/dist
+urllib3 @ file:///home/conda/feedstock_root/build_artifacts/urllib3_1744323578849/work
+watchdog==6.0.0
+wcwidth @ file:///home/conda/feedstock_root/build_artifacts/wcwidth_1733231326287/work
+webcolors @ file:///home/conda/feedstock_root/build_artifacts/webcolors_1733359735138/work
+webencodings @ file:///home/conda/feedstock_root/build_artifacts/webencodings_1733236011802/work
+websocket-client @ file:///home/conda/feedstock_root/build_artifacts/websocket-client_1733157342724/work
+Werkzeug==3.1.3
+wheel==0.45.1
+widgetsnbextension==4.0.14
+xxhash==3.5.0
+yarl==1.20.0
+zipp @ file:///home/conda/feedstock_root/build_artifacts/zipp_1732827521216/work
+zstandard==0.23.0