Updated app.py and requirements

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,362 @@
+# Hugging Face Spaces Deployment Guide
+
+## 📋 Prerequisites
+
+1. A Hugging Face account (create one at https://huggingface.co/join)
+2. Your trained ConvNeXt model uploaded to Hugging Face Model Hub
+3. Git installed on your system
+4. Git LFS (Large File Storage) installed
+
+---
+
+## 🚀 Step-by-Step Deployment Instructions
+
+### Step 1: Create a New Space on Hugging Face
+
+1. Go to https://huggingface.co/spaces
+2. Click **"Create new Space"**
+3. Fill in the details:
+   - **Space name**: `project-phoenix-cervical-classification` (or your preferred name)
+   - **License**: MIT (or your choice)
+   - **Select SDK**: Choose **Gradio**
+   - **SDK version**: 4.0.0 or latest
+   - **Hardware**: CPU (Free) or GPU (Paid - recommended for faster inference)
+   - **Visibility**: Public or Private
+
+4. Click **"Create Space"**
+
+---
+
+### Step 2: Clone Your Space Repository
+
+Open a terminal and run:
+
+```bash
+# Navigate to your project directory
+cd "C:\Meet\Projects\Project_8_Phoenix_Cervical Cancer Image Classification\Project-Phoenix\Phoenix\Project-Phoenix"
+
+# Clone your Hugging Face Space
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+```
+
+Replace `YOUR_USERNAME` with your Hugging Face username and `YOUR_SPACE_NAME` with your space name.
+
+---
+
+### Step 3: Set Up Git LFS (for Large Files)
+
+```bash
+# Install Git LFS if not already installed
+# For Windows: Download from https://git-lfs.github.com/
+# Or use: choco install git-lfs
+
+# Initialize Git LFS in the repository
+git lfs install
+```
+
+---
+
+### Step 4: Copy Files to Space Repository
+
+Copy the following files from your Project-Phoenix directory to the cloned space directory:
+
+```bash
+# Copy the main app file
+Copy-Item -Path "../app.py" -Destination "."
+
+# Copy requirements
+Copy-Item -Path "../requirements.txt" -Destination "."
+
+# Copy README (rename to README.md)
+Copy-Item -Path "../README_HF.md" -Destination "./README.md"
+```
+
+Or manually copy:
+- `app.py`
+- `requirements.txt`
+- Rename `README_HF.md` to `README.md`
+
+---
+
+### Step 5: Update the Model ID in app.py (if needed)
+
+Make sure your `app.py` has the correct model ID. Open `app.py` and verify line 33:
+
+```python
+HF_MODEL_ID = os.getenv("HF_MODEL_ID", "Meet2304/convnextv2-cervical-cell-classification")
+```
+
+Change `"Meet2304/convnextv2-cervical-cell-classification"` to your actual model ID if different.
+
+---
+
+### Step 6: Commit and Push to Hugging Face
+
+```bash
+# Add all files
+git add .
+
+# Commit the changes
+git commit -m "Initial deployment of Project Phoenix Gradio app"
+
+# Push to Hugging Face
+git push
+```
+
+You may be prompted for credentials:
+- **Username**: Your Hugging Face username
+- **Password**: Use a Hugging Face **Access Token** (not your password)
+
+To create an access token:
+1. Go to https://huggingface.co/settings/tokens
+2. Click "New token"
+3. Name it (e.g., "Space Deploy")
+4. Select "write" permission
+5. Copy the token and use it as the password
+
+---
+
+### Step 7: Monitor Deployment
+
+1. Go to your Space URL: `https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
+2. You'll see a "Building" status
+3. Check the **Logs** tab to monitor the build process
+4. Common stages:
+   - Installing dependencies from requirements.txt
+   - Loading the model from Hugging Face Hub
+   - Starting the Gradio server
+
+The build typically takes 3-10 minutes depending on hardware.
+
+---
+
+### Step 8: Test Your Deployed App
+
+Once the status changes to "Running":
+
+1. Your app will be live at: `https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
+2. Test both tabs:
+   - **Basic Prediction**: Upload a cell image and click "Classify"
+   - **Prediction + Explainability**: Upload an image and see GRAD-CAM visualization
+
+---
+
+## 🔧 Troubleshooting
+
+### Build Fails Due to Dependencies
+
+If you see errors during installation:
+
+1. Check the **Logs** tab for specific errors
+2. Common issues:
+   - **PyTorch version**: May need to specify CPU version for free tier
+   - **OpenCV**: Sometimes requires additional system libraries
+
+Update `requirements.txt` if needed:
+
+```txt
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.30.0
+gradio>=4.0.0
+opencv-python-headless>=4.8.0  # Use headless version for servers
+numpy>=1.24.0
+Pillow>=10.0.0
+grad-cam>=1.4.8
+```
+
+### Model Not Loading
+
+If you see "Model not found" errors:
+
+1. Verify your model is public (or the Space has access if private)
+2. Check the model ID is correct in `app.py`
+3. Ensure your model was properly uploaded to Hugging Face Model Hub
+
+### Out of Memory on CPU
+
+If the free CPU tier runs out of memory:
+
+1. Upgrade to a GPU Space (paid)
+2. Or optimize the model:
+   - Use model quantization
+   - Reduce batch size (already 1 in this app)
+
+---
+
+## 🌐 Connecting Your Next.js Frontend to the Deployed Space
+
+### Option 1: Use Gradio Client API (Recommended)
+
+The easiest way is to use Gradio's client API. Your Space provides an API endpoint automatically.
+
+1. **Get your Space API URL**: `https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space`
+
+2. **Install Gradio Client in your Next.js project**:
+
+```bash
+cd "C:\Meet\Projects\Project_8_Phoenix_Cervical Cancer Image Classification\Project-Phoenix\Phoenix\phoenix-app"
+npm install @gradio/client
+```
+
+3. **Create an API service file** (`src/lib/inference-api.ts`):
+
+```typescript
+import { client } from "@gradio/client";
+
+const SPACE_URL = "https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space";
+
+export async function predictBasic(imageFile: File) {
+  try {
+    const app = await client(SPACE_URL);
+    
+    const result = await app.predict("/predict_basic", [imageFile]);
+    
+    return result.data;
+  } catch (error) {
+    console.error("Prediction error:", error);
+    throw error;
+  }
+}
+
+export async function predictWithExplainability(imageFile: File) {
+  try {
+    const app = await client(SPACE_URL);
+    
+    const result = await app.predict("/predict_with_explainability", [imageFile]);
+    
+    return result.data;
+  } catch (error) {
+    console.error("Prediction with explainability error:", error);
+    throw error;
+  }
+}
+```
+
+4. **Update your inference page** to use the API:
+
+```typescript
+// In your handleAnalyze function
+const handleAnalyze = async () => {
+  setIsAnalyzing(true);
+  
+  try {
+    if (selectedSource === 'upload' && fileState.files.length > 0) {
+      const file = fileState.files[0].file as File;
+      const result = await predictBasic(file);
+      
+      setAnalysisResult({
+        predicted_class: result.label,
+        confidence: result.confidences[0].confidence,
+        top_predictions: result.confidences.map((c: any) => ({
+          class: c.label,
+          probability: c.confidence
+        }))
+      });
+    } else if (selectedSource === 'sample' && selectedSample) {
+      // For sample images, fetch the image first then predict
+      const response = await fetch(currentImage!);
+      const blob = await response.blob();
+      const file = new File([blob], 'sample.jpg', { type: 'image/jpeg' });
+      
+      const result = await predictBasic(file);
+      
+      setAnalysisResult({
+        predicted_class: result.label,
+        confidence: result.confidences[0].confidence,
+        top_predictions: result.confidences.map((c: any) => ({
+          class: c.label,
+          probability: c.confidence
+        }))
+      });
+    }
+  } catch (error) {
+    console.error("Analysis error:", error);
+    // Handle error appropriately
+  } finally {
+    setIsAnalyzing(false);
+  }
+};
+```
+
+### Option 2: Use Direct API Endpoint
+
+Alternatively, you can use the automatic API endpoint that Gradio creates:
+
+```typescript
+const SPACE_API = "https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space/api/predict";
+
+async function predictWithFetch(imageFile: File) {
+  const formData = new FormData();
+  formData.append('data', imageFile);
+  
+  const response = await fetch(SPACE_API, {
+    method: 'POST',
+    body: formData,
+  });
+  
+  return await response.json();
+}
+```
+
+---
+
+## 📊 Monitoring and Analytics
+
+1. **View Usage Statistics**: Go to your Space settings to see usage metrics
+2. **Check Logs**: Monitor real-time logs in the Space interface
+3. **Set up Alerts**: Configure notifications for errors or downtime
+
+---
+
+## 🔐 Security Considerations
+
+1. **API Keys**: If you need authentication, use Hugging Face's built-in authentication
+2. **Rate Limiting**: Consider implementing rate limiting for public spaces
+3. **Model Access**: Ensure your model repository has appropriate access controls
+
+---
+
+## 💰 Cost Considerations
+
+- **CPU (Free)**: Limited resources, slower inference
+- **CPU Basic ($5/month)**: Better performance
+- **GPU T4 Small ($0.60/hour)**: Recommended for production
+- **GPU A10G Large ($3.15/hour)**: High-performance inference
+
+---
+
+## 🎯 Next Steps
+
+1. **Deploy the Space** following steps 1-7
+2. **Test the interface** directly on Hugging Face
+3. **Integrate with your Next.js frontend** using the API
+4. **Monitor performance** and upgrade hardware if needed
+5. **Collect user feedback** and iterate
+
+---
+
+## 📝 Additional Resources
+
+- [Gradio Documentation](https://gradio.app/docs/)
+- [Hugging Face Spaces Guide](https://huggingface.co/docs/hub/spaces)
+- [Gradio Client Library](https://gradio.app/guides/getting-started-with-the-js-client/)
+
+---
+
+## ✅ Quick Checklist
+
+- [ ] Created Hugging Face Space
+- [ ] Cloned Space repository
+- [ ] Copied app.py, requirements.txt, README.md
+- [ ] Updated model ID in app.py
+- [ ] Committed and pushed to Hugging Face
+- [ ] Verified deployment in Logs
+- [ ] Tested both prediction modes
+- [ ] Integrated API with Next.js frontend
+- [ ] Tested end-to-end workflow
+
+---
+
+**Need Help?** Check the logs tab in your Space or refer to Hugging Face documentation.

README.md

@@ -1,14 +1,35 @@
 ---
-title: Project Phoenix
-emoji: 🐨
-colorFrom: pink
-colorTo: pink
+title: Project Phoenix - Cervical Cancer Cell Classification
+emoji: 🔬
+colorFrom: purple
+colorTo: blue
 sdk: gradio
-sdk_version: 6.0.0
+sdk_version: 4.0.0
 app_file: app.py
 pinned: false
 license: mit
-short_description: Explainable  cervical cancer classification
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Project Phoenix - Cervical Cancer Cell Classification
+
+This is a Gradio application for automated classification of cervical cancer cells using a fine-tuned ConvNeXt V2 model.
+
+## Model
+
+The model classifies cervical cells into 5 categories:
+- Dyskeratotic
+- Koilocytotic
+- Metaplastic
+- Parabasal
+- Superficial-Intermediate
+
+## Features
+
+- Basic prediction mode for quick classification
+- Explainability mode with GRAD-CAM visualization
+- High accuracy ConvNeXt V2 architecture
+- Real-time inference
+
+## Usage
+
+Upload a cervical cell image and get instant classification results with confidence scores.

app.py

@@ -0,0 +1,348 @@
+"""
+Project Phoenix - Cervical Cancer Cell Classification
+Gradio application for running inference on ConvNeXt V2 model from Hugging Face
+with explainability features (GRAD-CAM).
+Deployed on Hugging Face Spaces.
+"""
+
+import os
+import numpy as np
+import cv2
+from typing import Dict, Tuple, Optional
+
+# Deep Learning
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from PIL import Image
+
+# Transformers
+from transformers import (
+    ConvNextV2ForImageClassification,
+    AutoImageProcessor
+)
+
+# GRAD-CAM
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+
+# Gradio
+import gradio as gr
+
+# ========== CONFIGURATION ==========
+
+# Hugging Face model ID
+HF_MODEL_ID = os.getenv("HF_MODEL_ID", "Meet2304/convnextv2-cervical-cell-classification")
+
+# Class names
+CLASS_NAMES = [
+    'im_Dyskeratotic',
+    'im_Koilocytotic',
+    'im_Metaplastic',
+    'im_Parabasal',
+    'im_Superficial-Intermediate'
+]
+
+# Display names (cleaner for UI)
+DISPLAY_NAMES = [
+    'Dyskeratotic',
+    'Koilocytotic',
+    'Metaplastic',
+    'Parabasal',
+    'Superficial-Intermediate'
+]
+
+# Device
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# ========== MODEL LOADING ==========
+
+print("Loading model from Hugging Face...")
+print(f"Model ID: {HF_MODEL_ID}")
+print(f"Device: {DEVICE}")
+
+# Load image processor
+processor = AutoImageProcessor.from_pretrained(HF_MODEL_ID)
+print("✓ Processor loaded")
+
+# Load model
+model = ConvNextV2ForImageClassification.from_pretrained(HF_MODEL_ID)
+model = model.to(DEVICE)
+model.eval()
+print("✓ Model loaded and set to evaluation mode")
+
+print(f"Model configuration:")
+print(f"  - Number of classes: {model.config.num_labels}")
+print(f"  - Image size: {model.config.image_size}")
+print(f"  - Total parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+# ========== HELPER FUNCTIONS ==========
+
+def preprocess_image(image: Image.Image) -> Tuple[torch.Tensor, np.ndarray]:
+    """
+    Preprocess image for model input.
+
+    Returns:
+        Tuple of (preprocessed_tensor, original_image_array)
+    """
+    # Store original for visualization
+    original_image = np.array(image.convert('RGB'))
+
+    # Preprocess using the model's processor
+    inputs = processor(images=image, return_tensors="pt")
+    pixel_values = inputs['pixel_values'].to(DEVICE)
+
+    return pixel_values, original_image
+
+
+class ConvNeXtGradCAMWrapper(nn.Module):
+    """Wrapper for ConvNeXtV2ForImageClassification to make it compatible with GRAD-CAM."""
+
+    def __init__(self, model):
+        super().__init__()
+        self.model = model
+
+    def forward(self, x):
+        outputs = self.model(pixel_values=x)
+        return outputs.logits
+
+
+def get_target_layers(model):
+    """Get the target layers for GRAD-CAM from ConvNeXt model."""
+    return [model.convnextv2.encoder.stages[-1].layers[-1]]
+
+
+def apply_gradcam(
+    pixel_values: torch.Tensor,
+    original_image: np.ndarray,
+    target_class: Optional[int] = None
+) -> Tuple[np.ndarray, int, float]:
+    """
+    Apply GRAD-CAM to visualize model attention.
+
+    Args:
+        pixel_values: Preprocessed image tensor
+        original_image: Original image as numpy array
+        target_class: Target class index (None for predicted class)
+
+    Returns:
+        Tuple of (visualization, predicted_class, confidence)
+    """
+    # Wrap the model
+    wrapped_model = ConvNeXtGradCAMWrapper(model)
+
+    # Get target layers
+    target_layers = get_target_layers(model)
+
+    # Initialize GRAD-CAM
+    cam = GradCAM(model=wrapped_model, target_layers=target_layers)
+
+    # Get prediction
+    model.eval()
+    with torch.no_grad():
+        outputs = model(pixel_values)
+        logits = outputs.logits
+        predicted_class = logits.argmax(-1).item()
+        probabilities = F.softmax(logits, dim=-1)[0]
+
+    # Use predicted class if target not specified
+    if target_class is None:
+        target_class = predicted_class
+
+    # Create target for GRAD-CAM
+    targets = [ClassifierOutputTarget(target_class)]
+
+    # Generate GRAD-CAM
+    grayscale_cam = cam(input_tensor=pixel_values, targets=targets)
+    grayscale_cam = grayscale_cam[0, :]
+
+    # Resize original image to match CAM dimensions
+    cam_h, cam_w = grayscale_cam.shape
+    rgb_image_for_overlay = cv2.resize(original_image, (cam_w, cam_h)).astype(np.float32) / 255.0
+
+    # Create visualization
+    visualization = show_cam_on_image(
+        rgb_image_for_overlay,
+        grayscale_cam,
+        use_rgb=True,
+        colormap=cv2.COLORMAP_JET
+    )
+
+    return visualization, predicted_class, float(probabilities[predicted_class].item())
+
+
+# ========== GRADIO INTERFACE FUNCTIONS ==========
+
+def predict_basic(image):
+    """
+    Basic prediction without explainability.
+    
+    Args:
+        image: PIL Image or numpy array
+        
+    Returns:
+        Dictionary with class probabilities for Gradio Label component
+    """
+    if image is None:
+        return None
+    
+    try:
+        # Convert to PIL Image if needed
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        
+        # Preprocess
+        pixel_values, _ = preprocess_image(image)
+        
+        # Predict
+        model.eval()
+        with torch.no_grad():
+            outputs = model(pixel_values)
+            logits = outputs.logits
+            probabilities = F.softmax(logits, dim=-1)[0]
+        
+        # Format for Gradio Label component
+        return {DISPLAY_NAMES[i]: float(probabilities[i]) for i in range(len(DISPLAY_NAMES))}
+    
+    except Exception as e:
+        print(f"Error in prediction: {e}")
+        return None
+
+
+def predict_with_explainability(image):
+    """
+    Prediction with GRAD-CAM explainability.
+    
+    Args:
+        image: PIL Image or numpy array
+        
+    Returns:
+        Tuple of (probabilities_dict, gradcam_image, info_text)
+    """
+    if image is None:
+        return None, None, "Please upload an image."
+    
+    try:
+        # Convert to PIL Image if needed
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        
+        # Preprocess
+        pixel_values, original_image = preprocess_image(image)
+        
+        # Predict
+        model.eval()
+        with torch.no_grad():
+            outputs = model(pixel_values)
+            logits = outputs.logits
+            probabilities = F.softmax(logits, dim=-1)[0]
+            predicted_class = logits.argmax(-1).item()
+        
+        # Apply GRAD-CAM
+        visualization, pred_class, confidence = apply_gradcam(pixel_values, original_image)
+        
+        # Format probabilities for Gradio
+        probs_dict = {DISPLAY_NAMES[i]: float(probabilities[i]) for i in range(len(DISPLAY_NAMES))}
+        
+        # Create info text
+        info_text = f"**Predicted Class:** {DISPLAY_NAMES[predicted_class]}\n\n"
+        info_text += f"**Confidence:** {confidence*100:.2f}%\n\n"
+        info_text += "The heatmap shows regions the model focused on for classification."
+        
+        return probs_dict, visualization, info_text
+    
+    except Exception as e:
+        print(f"Error in prediction with explainability: {e}")
+        return None, None, f"Error: {str(e)}"
+
+
+# ========== GRADIO INTERFACE ==========
+
+# Custom CSS for better styling
+custom_css = """
+.gradio-container {
+    font-family: 'Arial', sans-serif;
+}
+.header {
+    text-align: center;
+    margin-bottom: 2rem;
+}
+"""
+
+# Create Gradio Blocks interface
+with gr.Blocks(css=custom_css, title="Project Phoenix - Cervical Cancer Cell Classification") as demo:
+    
+    gr.Markdown("""
+    # 🔬 Project Phoenix - Cervical Cancer Cell Classification
+    
+    ConvNeXt V2 model for automated classification of cervical cancer cells into 5 categories:
+    - **Dyskeratotic**: Abnormal keratinization
+    - **Koilocytotic**: HPV-infected cells
+    - **Metaplastic**: Transitional cells
+    - **Parabasal**: Immature cells
+    - **Superficial-Intermediate**: Mature cells
+    """)
+    
+    with gr.Tabs():
+        # Tab 1: Basic Prediction
+        with gr.TabItem("🎯 Basic Prediction"):
+            gr.Markdown("Upload an image to classify the cervical cell type.")
+            
+            with gr.Row():
+                with gr.Column():
+                    input_image_basic = gr.Image(type="pil", label="Upload Cell Image")
+                    predict_btn_basic = gr.Button("Classify", variant="primary", size="lg")
+                
+                with gr.Column():
+                    output_label_basic = gr.Label(label="Classification Results", num_top_classes=5)
+            
+            predict_btn_basic.click(
+                fn=predict_basic,
+                inputs=input_image_basic,
+                outputs=output_label_basic
+            )
+        
+        # Tab 2: Prediction with Explainability
+        with gr.TabItem("🔍 Prediction + Explainability (GRAD-CAM)"):
+            gr.Markdown("Upload an image to classify and visualize model attention using GRAD-CAM.")
+            
+            with gr.Row():
+                with gr.Column():
+                    input_image_explain = gr.Image(type="pil", label="Upload Cell Image")
+                    predict_btn_explain = gr.Button("Classify with Explainability", variant="primary", size="lg")
+                
+                with gr.Column():
+                    output_label_explain = gr.Label(label="Classification Results", num_top_classes=5)
+                    output_gradcam = gr.Image(label="GRAD-CAM Heatmap")
+                    output_info = gr.Markdown(label="Analysis")
+            
+            predict_btn_explain.click(
+                fn=predict_with_explainability,
+                inputs=input_image_explain,
+                outputs=[output_label_explain, output_gradcam, output_info]
+            )
+    
+    # Footer
+    gr.Markdown("""
+    ---
+    ### 📊 About the Model
+    
+    This model is a fine-tuned **ConvNeXt V2** neural network trained on the SIPaKMeD dataset 
+    for cervical cancer cell classification. The model achieves high accuracy in distinguishing 
+    between different cell types, which is crucial for early cancer detection and diagnosis.
+    
+    **GRAD-CAM** (Gradient-weighted Class Activation Mapping) provides visual explanations by 
+    highlighting the regions in the image that were most important for the model's decision.
+    
+    🔗 **Model**: [Meet2304/convnextv2-cervical-cell-classification](https://huggingface.co/Meet2304/convnextv2-cervical-cell-classification)
+    """)
+
+# ========== LAUNCH ==========
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

config.json

@@ -0,0 +1,56 @@
+{
+  "architectures": [
+    "ConvNextV2ForImageClassification"
+  ],
+  "depths": [
+    3,
+    3,
+    9,
+    3
+  ],
+  "drop_path_rate": 0.0,
+  "dtype": "float32",
+  "hidden_act": "gelu",
+  "hidden_sizes": [
+    96,
+    192,
+    384,
+    768
+  ],
+  "id2label": {
+    "0": "im_Dyskeratotic",
+    "1": "im_Koilocytotic",
+    "2": "im_Metaplastic",
+    "3": "im_Parabasal",
+    "4": "im_Superficial-Intermediate"
+  },
+  "image_size": 224,
+  "initializer_range": 0.02,
+  "label2id": {
+    "im_Dyskeratotic": 0,
+    "im_Koilocytotic": 1,
+    "im_Metaplastic": 2,
+    "im_Parabasal": 3,
+    "im_Superficial-Intermediate": 4
+  },
+  "layer_norm_eps": 1e-12,
+  "model_type": "convnextv2",
+  "num_channels": 3,
+  "num_stages": 4,
+  "out_features": [
+    "stage4"
+  ],
+  "out_indices": [
+    4
+  ],
+  "patch_size": 4,
+  "problem_type": "single_label_classification",
+  "stage_names": [
+    "stem",
+    "stage1",
+    "stage2",
+    "stage3",
+    "stage4"
+  ],
+  "transformers_version": "4.56.1"
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a363f59155c438aa2a0a7dfe9a1c30395a5f1e4ed5e3764eb524bbf13780cc09
+size 111505052

preprocessor_config.json

@@ -0,0 +1,22 @@
+{
+  "crop_pct": 0.875,
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.485,
+    0.456,
+    0.406
+  ],
+  "image_processor_type": "ConvNextImageProcessor",
+  "image_std": [
+    0.229,
+    0.224,
+    0.225
+  ],
+  "resample": 3,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "shortest_edge": 384
+  }
+}

requirements.txt

@@ -1,6 +1,8 @@
-torch
-safetensors
-scikit-learn
-transformers
-numpy
-pillow
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.30.0
+gradio>=4.0.0
+opencv-python>=4.8.0
+numpy>=1.24.0
+Pillow>=10.0.0
+grad-cam>=1.4.8

scaler.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ef706dea6fa21cce93467d3fe62ef52728bb0ef994a68ff1f88ad193daffd93
+size 1383