Upload folder using huggingface_hub

README.md

@@ -1,270 +1,357 @@
-# Cervical Type Classification - Model Training
-
-## Overview
-
-This project classifies cervical images into 3 transformation zone types:
-- **Type 1**: Fully visible squamocolumnar junction (SCJ)
-- **Type 2**: Partially visible SCJ
-- **Type 3**: SCJ not visible (inside cervical canal)
-
-## Best Model Summary
-
-| Metric | Value |
-|--------|-------|
-| **Validation Accuracy** | **65.52%** |
-| **Macro F1** | **65.61%** |
-| Best Epoch | 34 |
-| Total Parameters | 1,327,235 |
-
+---
+license: mit
+language:
+- en
+tags:
+- image-classification
+- medical
+- cervical-cancer
+- pytorch
+- cnn
+- colposcopy
+datasets:
+- custom
+metrics:
+- accuracy
+- f1
+pipeline_tag: image-classification
+library_name: pytorch
 ---
 
-## Best Model Configuration
-
-**Run Name:** `L32_64_128_256_Res_SE_lr5e-04_d0.3`
+# Cervical Cancer Classification CNN
 
-### Architecture
+A CNN model for classifying cervical colposcopy images into 4 severity classes for cervical cancer screening.
 
-| Component | Value |
-|-----------|-------|
-| Conv Layers | [32, 64, 128, 256] |
-| FC Layers | [256, 128] |
-| Kernel Size | 3x3 |
-| Pooling | MaxPool 2x2 |
-| Batch Normalization | Yes |
-| Activation | ReLU |
-| Residual Connections | **Yes** |
-| SE Attention | **Yes** |
+## Model Description
 
-### Training Settings
+This model classifies cervical images into:
 
-| Parameter | Value |
-|-----------|-------|
-| Learning Rate | 5e-4 |
-| Weight Decay | 1e-4 |
-| Dropout | 0.3 |
-| Batch Size | 32 |
-| Focal Loss Gamma | 2.0 |
-| Label Smoothing | 0.1 |
-| Data Augmentation | Yes |
+| Class | Label | Description | Clinical Action |
+|-------|-------|-------------|-----------------|
+| 0 | Normal | Healthy cervical tissue | Routine screening in 3-5 years |
+| 1 | LSIL | Low-grade Squamous Intraepithelial Lesion | Monitor, repeat test in 6-12 months |
+| 2 | HSIL | High-grade Squamous Intraepithelial Lesion | Colposcopy, biopsy, treatment required |
+| 3 | Cancer | Invasive cervical cancer | Immediate oncology referral |
 
 ---
 
-## Performance Metrics
-
-### Per-Class Metrics
+## Model Architecture
 
-| Class | Precision | Recall | F1-Score | Support |
-|-------|-----------|--------|----------|---------|
-| **Type 1** | 79.26% | 61.49% | 69.26% | 348 |
-| **Type 2** | 58.09% | 75.29% | 65.58% | 348 |
-| **Type 3** | 64.40% | 59.77% | 62.00% | 348 |
-| **Macro Avg** | 67.25% | 65.52% | **65.61%** | 1044 |
-
-### Confusion Matrix
+### Architecture Diagram
 
 ```
-                 Predicted
-              Type 1  Type 2  Type 3
-Actual Type 1   214      84      50
-       Type 2    21     262      65
-       Type 3    35     105     208
+┌─────────────────────────────────────────────────────────────┐
+│                    INPUT IMAGE                              │
+│                   (3 × 224 × 298)                           │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+┌─────────────────────────▼───────────────────────────────────┐
+│  CONV BLOCK 1                                               │
+│  ├── Conv2d(3 → 32, kernel=3×3, padding=1)                  │
+│  ├── BatchNorm2d(32)                                        │
+│  ├── ReLU                                                   │
+│  └── MaxPool2d(2×2)                                         │
+│  Output: 32 × 112 × 149                                     │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+┌─────────────────────────▼───────────────────────────────────┐
+│  CONV BLOCK 2                                               │
+│  ├── Conv2d(32 → 64, kernel=3×3, padding=1)                 │
+│  ├── BatchNorm2d(64)                                        │
+│  ├── ReLU                                                   │
+│  └── MaxPool2d(2×2)                                         │
+│  Output: 64 × 56 × 74                                       │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+┌─────────────────────────▼───────────────────────────────────┐
+│  CONV BLOCK 3                                               │
+│  ├── Conv2d(64 → 128, kernel=3×3, padding=1)                │
+│  ├── BatchNorm2d(128)                                       │
+│  ├── ReLU                                                   │
+│  └── MaxPool2d(2×2)                                         │
+│  Output: 128 × 28 × 37                                      │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+┌─────────────────────────▼───────────────────────────────────┐
+│  CONV BLOCK 4                                               │
+│  ├── Conv2d(128 → 256, kernel=3×3, padding=1)               │
+│  ├── BatchNorm2d(256)                                       │
+│  ├── ReLU                                                   │
+│  └── MaxPool2d(2×2)                                         │
+│  Output: 256 × 14 × 18                                      │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+┌─────────────────────────▼───────────────────────────────────┐
+│  GLOBAL AVERAGE POOLING                                     │
+│  └── AdaptiveAvgPool2d(1×1)                                 │
+│  Output: 256 × 1 × 1 → Flatten → 256                        │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+┌─────────────────────────▼───────────────────────────────────┐
+│  FC BLOCK 1                                                 │
+│  ├── Linear(256 → 256)                                      │
+│  ├── ReLU                                                   │
+│  └── Dropout(0.5)                                           │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+┌─────────────────────────▼───────────────────────────────────┐
+│  FC BLOCK 2                                                 │
+│  ├── Linear(256 → 128)                                      │
+│  ├── ReLU                                                   │
+│  └── Dropout(0.5)                                           │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+┌─────────────────────────▼───────────────────────────────────┐
+│  CLASSIFIER                                                 │
+│  └── Linear(128 → 4)                                        │
+│  Output: 4 class logits                                     │
+└─────────────────────────┬───────────────────────────────────┘
+                          │
+                          ▼
+              [Normal, LSIL, HSIL, Cancer]
 ```
 
-### Interpretation
-
-| Finding | Implication |
-|---------|-------------|
-| Type 1 has highest precision (79%) | When model predicts Type 1, it's usually correct |
-| Type 2 has highest recall (75%) | Model catches most Type 2 cases |
-| Type 3 has lowest metrics | Hardest to classify - often confused with Type 2 |
-| Type 2 ↔ Type 3 confusion is common | 105 Type 3 misclassified as Type 2 |
-
----
+### Architecture Summary Table
+
+| Layer | Type | Input Shape | Output Shape | Parameters |
+|-------|------|-------------|--------------|------------|
+| conv_layers.0 | Conv2d | (3, 224, 298) | (32, 224, 298) | 896 |
+| conv_layers.1 | BatchNorm2d | (32, 224, 298) | (32, 224, 298) | 64 |
+| conv_layers.2 | ReLU | - | - | 0 |
+| conv_layers.3 | MaxPool2d | (32, 224, 298) | (32, 112, 149) | 0 |
+| conv_layers.4 | Conv2d | (32, 112, 149) | (64, 112, 149) | 18,496 |
+| conv_layers.5 | BatchNorm2d | (64, 112, 149) | (64, 112, 149) | 128 |
+| conv_layers.6 | ReLU | - | - | 0 |
+| conv_layers.7 | MaxPool2d | (64, 112, 149) | (64, 56, 74) | 0 |
+| conv_layers.8 | Conv2d | (64, 56, 74) | (128, 56, 74) | 73,856 |
+| conv_layers.9 | BatchNorm2d | (128, 56, 74) | (128, 56, 74) | 256 |
+| conv_layers.10 | ReLU | - | - | 0 |
+| conv_layers.11 | MaxPool2d | (128, 56, 74) | (128, 28, 37) | 0 |
+| conv_layers.12 | Conv2d | (128, 28, 37) | (256, 28, 37) | 295,168 |
+| conv_layers.13 | BatchNorm2d | (256, 28, 37) | (256, 28, 37) | 512 |
+| conv_layers.14 | ReLU | - | - | 0 |
+| conv_layers.15 | MaxPool2d | (256, 28, 37) | (256, 14, 18) | 0 |
+| avgpool | AdaptiveAvgPool2d | (256, 14, 18) | (256, 1, 1) | 0 |
+| fc_layers.0 | Linear | 256 | 256 | 65,792 |
+| fc_layers.1 | ReLU | - | - | 0 |
+| fc_layers.2 | Dropout | - | - | 0 |
+| fc_layers.3 | Linear | 256 | 128 | 32,896 |
+| fc_layers.4 | ReLU | - | - | 0 |
+| fc_layers.5 | Dropout | - | - | 0 |
+| classifier | Linear | 128 | 4 | 516 |
+| **Total** | | | | **488,580** |
+
+### PyTorch Model Code
 
-## Grid Search Results
-
-A grid search of 32 configurations was performed on January 17, 2026.
-
-### Search Space
-
-| Parameter | Values Tested |
-|-----------|---------------|
-| Conv Layers | [32,64,128,256], [64,128,256] |
-| Learning Rate | 5e-4, 1e-4 |
-| Dropout | 0.3, 0.4 |
-| Residual | Yes, No |
-| SE Attention | Yes, No |
-
-### Top 10 Configurations
-
-| Rank | Configuration | Accuracy | Key Features |
-|------|--------------|----------|--------------|
-| 1 | L32_64_128_256_Res_SE_lr5e-04_d0.3 | **65.52%** | 4-layer, Res+SE |
-| 2 | L64_128_256_Res_SE_lr5e-04_d0.3 | 65.04% | 3-layer, Res+SE |
-| 3 | L32_64_128_256_Res_SE_lr1e-04_d0.3 | 64.94% | 4-layer, lower LR |
-| 4 | L64_128_256_Res_SE_lr1e-04_d0.3 | 64.37% | 3-layer, lower LR |
-| 5 | L32_64_128_256_Res_SE_lr5e-04_d0.4 | 64.18% | Higher dropout |
-| 6 | L32_64_128_256_Res_lr5e-04_d0.4 | 64.08% | No SE |
-| 7 | L32_64_128_256_Res_lr1e-04_d0.3 | 63.60% | No SE, lower LR |
-| 8 | L32_64_128_256_Res_SE_lr1e-04_d0.4 | 63.51% | Lower LR, higher dropout |
-| 9 | L64_128_256_Res_SE_lr5e-04_d0.4 | 63.22% | 3-layer, higher dropout |
-| 10 | L64_128_256_Res_SE_lr1e-04_d0.4 | 63.12% | 3-layer, lower LR |
-
-### Key Findings
-
-| Finding | Evidence |
-|---------|----------|
-| **Residual + SE is critical** | Top 10 models all use residual connections; top 4 use both Res+SE |
-| **4-layer network is better** | [32,64,128,256] outperforms [64,128,256] |
-| **Higher LR (5e-4) preferred** | 5e-4 consistently beats 1e-4 |
-| **Lower dropout (0.3) preferred** | 0.3 dropout outperforms 0.4 |
-| **Plain CNN performs worst** | Models without Res or SE are at the bottom |
-
-### What Worked vs What Didn't
-
-| Worked | Didn't Work |
-|--------|-------------|
-| Residual connections | Plain convolutions |
-| SE attention blocks | No attention |
-| 4 conv layers | 3 conv layers |
-| LR = 5e-4 | LR = 1e-4 (too slow) |
-| Dropout = 0.3 | Dropout = 0.4 (too aggressive) |
-| Focal Loss | - |
-| Label smoothing 0.1 | - |
+```python
+import torch
+import torch.nn as nn
+
+class CervicalCancerCNN(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+        # Convolutional layers: [32, 64, 128, 256]
+        self.conv_layers = nn.Sequential(
+            # Block 1: 3 -> 32
+            nn.Conv2d(3, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+
+            # Block 2: 32 -> 64
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+
+            # Block 3: 64 -> 128
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+
+            # Block 4: 128 -> 256
+            nn.Conv2d(128, 256, kernel_size=3, padding=1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+        )
+
+        self.avgpool = nn.AdaptiveAvgPool2d(1)
+
+        # Fully connected layers: [256, 128] -> 4
+        self.fc_layers = nn.Sequential(
+            nn.Linear(256, 256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.5),
+            nn.Linear(256, 128),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.5),
+        )
+
+        self.classifier = nn.Linear(128, 4)
+
+    def forward(self, x):
+        x = self.conv_layers(x)
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc_layers(x)
+        x = self.classifier(x)
+        return x
+```
 
 ---
 
-## Data
+## Performance
 
-| Split | Samples | Classes | Distribution |
-|-------|---------|---------|--------------|
-| Train | ~7,000 | 3 | Balanced after augmentation |
-| Test | 1,044 | 3 | [348, 348, 348] |
+### Overall Metrics
 
-### Image Specifications
-
-- Size: Variable (resized during training)
-- Channels: 3 (RGB)
-- Source: Colposcopy images
-
----
+| Metric | Value |
+|--------|-------|
+| **Accuracy** | 59.52% |
+| **Macro F1** | 59.85% |
+| **Parameters** | 488,580 |
 
-## Model Files
+### Per-Class Metrics
 
-### Best Model Location
+| Class | Precision | Recall | F1 Score | Support |
+|-------|-----------|--------|----------|---------|
+| Normal | 0.595 | 0.595 | 0.595 | 84 |
+| LSIL | 0.521 | 0.583 | 0.551 | 84 |
+| HSIL | 0.446 | 0.440 | 0.443 | 84 |
+| Cancer | 0.853 | 0.762 | 0.805 | 84 |
 
-```
-./best_model.pth  (this folder)
-```
+### Confusion Matrix
 
-Original training output:
 ```
-/data/downloads/cervical_type/_output/grid_search_v2_20260117_212011/run_001_L32_64_128_256_Res_SE_lr5e-04_d0.3/
+Predicted →     Normal    LSIL    HSIL   Cancer
+Actual ↓
+Normal            50        9       17       8
+LSIL              24       49       11       0
+HSIL               9       35       37       3
+Cancer             1        1       18      64
 ```
 
-### Checkpoint Contents
+---
 
-```python
-{
-    "epoch": 34,
-    "model_state_dict": ...,
-    "optimizer_state_dict": ...,
-    "scheduler_state_dict": ...,
-    "metrics": {...},
-    "model_config": {...}
-}
-```
+## Usage
 
-### Files in This Folder
+### Installation
 
-| File | Description |
-|------|-------------|
-| `best_model.pth` | Model checkpoint (weights + optimizer state) |
-| `config.json` | Training configuration used |
-| `training_history.json` | Loss/accuracy per epoch |
-| `grid_search_summary.json` | All 32 grid search results |
-| `README.md` | This file |
+```bash
+pip install torch torchvision safetensors huggingface_hub
+```
 
 ### Loading the Model
 
 ```python
 import torch
+from safetensors.torch import load_file
+from huggingface_hub import hf_hub_download
+import json
+
+# Download model files
+model_file = hf_hub_download("toderian/cerviguard_lesion", "model.safetensors")
+config_file = hf_hub_download("toderian/cerviguard_lesion", "config.json")
 
-# Load checkpoint (from this folder)
-checkpoint = torch.load('best_model.pth', weights_only=False)
+# Load config
+with open(config_file) as f:
+    config = json.load(f)
 
-# Create model with same config
-model = BaseCNN(
-    conv_layers=[32, 64, 128, 256],
-    fc_layers=[256, 128],
-    num_classes=3,
-    dropout=0.3,
-    use_residual=True,
-    use_se_attention=True
-)
+# Define model (copy from above or download modeling_cervical.py)
+model = CervicalCancerCNN()
 
 # Load weights
-model.load_state_dict(checkpoint['model_state_dict'])
+state_dict = load_file(model_file)
+model.load_state_dict(state_dict)
 model.eval()
 ```
 
----
-
-## Output Structure
+### Inference
 
-```
-_output/
-└── grid_search_v2_20260117_212011/
-    ├── grid_search_config.json    # Search space definition
-    ├── all_results.json           # All 32 run results
-    ├── summary.json               # Sorted results + best run
-    ├── logs/
-    │   └── grid_search.log
-    └── run_001_.../               # Best run
-        ├── checkpoints/
-        │   ├── best_model.pth     # Best validation accuracy
-        │   ├── latest.pth         # Final epoch
-        │   └── epoch_*.pth        # Periodic saves
-        └── logs/
-            ├── run_config.json
-            └── training_history.json
+```python
+from PIL import Image
+import torchvision.transforms as T
+
+# Preprocessing
+transform = T.Compose([
+    T.Resize((224, 298)),
+    T.ToTensor(),
+    T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+])
+
+# Load and preprocess image
+image = Image.open("cervical_image.jpg").convert("RGB")
+input_tensor = transform(image).unsqueeze(0)
+
+# Inference
+with torch.no_grad():
+    output = model(input_tensor)
+    probabilities = torch.softmax(output, dim=1)
+    prediction = output.argmax(dim=1).item()
+
+classes = ["Normal", "LSIL", "HSIL", "Cancer"]
+print(f"Prediction: {classes[prediction]}")
+print(f"Confidence: {probabilities[0][prediction]:.2%}")
 ```
 
 ---
 
-## Comparison with v1 Baseline
+## Training Details
+
+| Parameter | Value |
+|-----------|-------|
+| Learning Rate | 1e-4 |
+| Batch Size | 32 |
+| Optimizer | Adam |
+| Loss | CrossEntropyLoss |
+| Dropout | 0.5 |
+| Epochs | 34 (early stopping at 24) |
 
-| Version | Accuracy | Improvement |
-|---------|----------|-------------|
-| v1 Baseline | 61.69% | - |
-| **v2 Best (Res+SE)** | **65.52%** | **+3.83%** |
+### Dataset
 
-The addition of residual connections and SE attention improved accuracy by nearly 4%.
+| Split | Samples | Distribution |
+|-------|---------|--------------|
+| Train | 3,003 | Imbalanced [1540, 469, 854, 140] |
+| Test | 336 | Balanced [84, 84, 84, 84] |
 
 ---
 
-## Recommendations for Future Work
+## Limitations
 
-1. **Try deeper networks** - Add 5th conv layer [32, 64, 128, 256, 512]
-2. **Transfer learning** - Use pretrained EfficientNet or ResNet backbone
-3. **Address Type 3 confusion** - Type 3 is often misclassified as Type 2
-4. **Ensemble methods** - Combine top 3-5 models
-5. **Test Time Augmentation** - Average predictions over augmented versions
-6. **More training data** - Current ~7k samples may be limiting
+- Trained on limited dataset (~3k samples)
+- HSIL class has lowest performance (F1=0.443)
+- Should not be used as sole diagnostic tool
+- Intended for research and screening assistance only
 
----
+## Medical Disclaimer
 
-## Quick Start
+⚠️ **This model is for research purposes only.** It should not be used as a substitute for professional medical diagnosis. Always consult qualified healthcare professionals for cervical cancer screening and diagnosis.
 
-```bash
-# Run the best configuration
-python train_grid_v2.py
+---
 
-# Or load and evaluate the best model
-python evaluate.py --model /path/to/best_model.pth
-```
+## Files in This Repository
+
+| File | Description |
+|------|-------------|
+| `model.safetensors` | Model weights (safetensors format) |
+| `pytorch_model.bin` | Model weights (legacy PyTorch format) |
+| `config.json` | Model configuration |
+| `preprocessor_config.json` | Image preprocessing settings |
+| `modeling_cervical.py` | Model class definition |
+| `example_inference.py` | Example inference script |
 
 ---
 
-*Last updated: January 2026*
-*Grid search: 32 configurations, ~15 hours on single GPU*
+## Citation
+
+```bibtex
+@misc{cervical-cancer-cnn-2025,
+  author = {Toderian},
+  title = {Cervical Cancer Classification CNN},
+  year = {2025},
+  publisher = {Hugging Face},
+  url = {https://huggingface.co/toderian/cerviguard_lesion}
+}
+```

config.json

@@ -1,26 +1,32 @@
 {
-  "batch_size": 32,
-  "learning_rate": 0.0005,
-  "weight_decay": 0.0001,
-  "layers": [
-    32,
-    64,
-    128,
-    256
-  ],
-  "use_residual": true,
-  "use_se_attention": true,
-  "focal_gamma": 2.0,
-  "label_smoothing": 0.1,
-  "dropout": 0.3,
-  "kernel": 3,
-  "batchnorm": true,
-  "activation": "ReLU",
-  "pool": true,
-  "fc_multipliers": [
-    1.0,
-    0.5
-  ],
-  "nr_classes": 3,
-  "augmentation": true
-}
+  "architectures": ["CervicalCancerCNN"],
+  "model_type": "cervical-cancer-cnn",
+  "auto_map": {
+    "AutoModel": "modeling_cervical.CervicalCancerCNN"
+  },
+  "num_labels": 4,
+  "num_classes": 4,
+  "id2label": {
+    "0": "Normal",
+    "1": "LSIL",
+    "2": "HSIL",
+    "3": "Cancer"
+  },
+  "label2id": {
+    "Normal": 0,
+    "LSIL": 1,
+    "HSIL": 2,
+    "Cancer": 3
+  },
+  "conv_layers": [32, 64, 128, 256],
+  "fc_layers": [256, 128],
+  "dropout": 0.5,
+  "input_channels": 3,
+  "input_size": {
+    "height": 224,
+    "width": 298
+  },
+  "total_parameters": 488580,
+  "problem_type": "single_label_classification",
+  "torch_dtype": "float32"
+}

example_inference.py

@@ -0,0 +1,189 @@
+"""
+Example inference script for Cervical Cancer Classification model.
+
+Usage:
+    # From local directory:
+    python example_inference.py --image path/to/image.jpg --model ./
+
+    # From Hugging Face Hub:
+    python example_inference.py --image path/to/image.jpg --model toderian/cerviguard_lesion
+"""
+
+import argparse
+import torch
+import torch.nn as nn
+from PIL import Image
+import torchvision.transforms as T
+from pathlib import Path
+import json
+
+
+class CervicalCancerCNN(nn.Module):
+    """CNN for cervical cancer classification."""
+
+    def __init__(self, config=None):
+        super().__init__()
+
+        config = config or {}
+        conv_channels = config.get("conv_layers", [32, 64, 128, 256])
+        fc_sizes = config.get("fc_layers", [256, 128])
+        dropout = config.get("dropout", 0.5)
+        num_classes = config.get("num_classes", 4)
+
+        # Convolutional layers
+        layers = []
+        in_channels = 3
+        for out_channels in conv_channels:
+            layers.extend([
+                nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
+                nn.BatchNorm2d(out_channels),
+                nn.ReLU(inplace=True),
+                nn.MaxPool2d(kernel_size=2, stride=2),
+            ])
+            in_channels = out_channels
+
+        self.conv_layers = nn.Sequential(*layers)
+        self.avgpool = nn.AdaptiveAvgPool2d(1)
+
+        # FC layers
+        fc_blocks = []
+        in_features = conv_channels[-1]
+        for fc_size in fc_sizes:
+            fc_blocks.extend([
+                nn.Linear(in_features, fc_size),
+                nn.ReLU(inplace=True),
+                nn.Dropout(dropout),
+            ])
+            in_features = fc_size
+
+        self.fc_layers = nn.Sequential(*fc_blocks)
+        self.classifier = nn.Linear(in_features, num_classes)
+
+    def forward(self, x):
+        x = self.conv_layers(x)
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc_layers(x)
+        x = self.classifier(x)
+        return x
+
+
+def load_model_local(model_dir, device="cpu"):
+    """Load model from local directory."""
+    model_dir = Path(model_dir)
+
+    # Load config
+    config_path = model_dir / "config.json"
+    config = {}
+    if config_path.exists():
+        with open(config_path) as f:
+            config = json.load(f)
+
+    # Create model
+    model = CervicalCancerCNN(config)
+
+    # Load weights
+    if (model_dir / "model.safetensors").exists():
+        from safetensors.torch import load_file
+        state_dict = load_file(str(model_dir / "model.safetensors"))
+        model.load_state_dict(state_dict)
+    elif (model_dir / "pytorch_model.bin").exists():
+        state_dict = torch.load(model_dir / "pytorch_model.bin", map_location=device, weights_only=True)
+        model.load_state_dict(state_dict)
+    else:
+        raise FileNotFoundError(f"No model weights found in {model_dir}")
+
+    model.to(device)
+    model.eval()
+    return model, config
+
+
+def load_model_hub(repo_id, device="cpu"):
+    """Load model from Hugging Face Hub."""
+    from huggingface_hub import hf_hub_download, snapshot_download
+
+    # Download model files
+    model_dir = snapshot_download(repo_id=repo_id)
+    return load_model_local(model_dir, device)
+
+
+def load_model(model_path, device="cpu"):
+    """Load model from local path or Hugging Face Hub."""
+    model_path = Path(model_path)
+
+    if model_path.exists():
+        return load_model_local(model_path, device)
+    else:
+        # Assume it's a Hugging Face repo ID
+        return load_model_hub(str(model_path), device)
+
+
+def get_preprocessor(config):
+    """Get image preprocessing transform."""
+    # Get size from config or use defaults
+    input_size = config.get("input_size", {"height": 224, "width": 298})
+    height = input_size.get("height", 224)
+    width = input_size.get("width", 298)
+
+    return T.Compose([
+        T.Resize((height, width)),
+        T.ToTensor(),
+        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+
+
+def predict(model, image_tensor, config):
+    """Run inference and return prediction."""
+    # Get label mapping from config
+    id2label = config.get("id2label", {
+        "0": "Normal",
+        "1": "LSIL",
+        "2": "HSIL",
+        "3": "Cancer"
+    })
+
+    with torch.no_grad():
+        output = model(image_tensor)
+        probabilities = torch.softmax(output, dim=1)[0]
+        prediction = output.argmax(dim=1).item()
+
+    return {
+        "class_id": prediction,
+        "class_name": id2label.get(str(prediction), f"Class {prediction}"),
+        "probabilities": {
+            id2label.get(str(i), f"Class {i}"): f"{prob:.2%}"
+            for i, prob in enumerate(probabilities.tolist())
+        },
+        "confidence": f"{probabilities[prediction]:.2%}"
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Cervical Cancer Classification")
+    parser.add_argument("--image", required=True, help="Path to input image")
+    parser.add_argument("--model", default="./", help="Path to model dir or HF repo ID")
+    parser.add_argument("--device", default="cpu", help="Device (cpu/cuda)")
+    args = parser.parse_args()
+
+    print(f"Loading model from {args.model}...")
+    model, config = load_model(args.model, args.device)
+
+    print(f"Processing image: {args.image}")
+    transform = get_preprocessor(config)
+    image = Image.open(args.image).convert('RGB')
+    image_tensor = transform(image).unsqueeze(0).to(args.device)
+
+    result = predict(model, image_tensor, config)
+
+    print("\n" + "=" * 50)
+    print("PREDICTION RESULT")
+    print("=" * 50)
+    print(f"Class: {result['class_name']}")
+    print(f"Confidence: {result['confidence']}")
+    print("\nAll probabilities:")
+    for cls, prob in result['probabilities'].items():
+        print(f"  {cls}: {prob}")
+
+
+if __name__ == "__main__":
+    main()

model.py

@@ -0,0 +1,200 @@
+"""
+Cervical Cancer Classification Model
+
+This file provides the model architecture for easy import.
+
+Usage:
+    from model import CervicalCancerCNN, load_model, predict
+
+    model = load_model("model.safetensors")
+    result = predict(model, image_tensor)
+"""
+
+import torch
+import torch.nn as nn
+from pathlib import Path
+
+
+class CervicalCancerCNN(nn.Module):
+    """
+    CNN for cervical cancer classification.
+
+    Classifies cervical colposcopy images into 4 severity classes:
+    - 0: Normal - Healthy cervical tissue
+    - 1: LSIL - Low-grade Squamous Intraepithelial Lesion
+    - 2: HSIL - High-grade Squamous Intraepithelial Lesion
+    - 3: Cancer - Invasive cervical cancer
+
+    Architecture:
+        Conv[32,64,128,256] -> AvgPool -> FC[256,128] -> Classifier[4]
+
+    Input:
+        Tensor of shape (batch, 3, 224, 298)
+
+    Output:
+        Logits of shape (batch, 4)
+    """
+
+    # Class labels
+    CLASSES = {
+        0: "Normal",
+        1: "LSIL",
+        2: "HSIL",
+        3: "Cancer"
+    }
+
+    def __init__(self, config=None):
+        super().__init__()
+
+        # Default configuration
+        config = config or {}
+        conv_channels = config.get("conv_layers", [32, 64, 128, 256])
+        fc_sizes = config.get("fc_layers", [256, 128])
+        dropout = config.get("dropout", 0.5)
+        num_classes = config.get("num_classes", 4)
+
+        # Build convolutional layers
+        layers = []
+        in_channels = 3
+        for out_channels in conv_channels:
+            layers.extend([
+                nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
+                nn.BatchNorm2d(out_channels),
+                nn.ReLU(inplace=True),
+                nn.MaxPool2d(kernel_size=2, stride=2),
+            ])
+            in_channels = out_channels
+
+        self.conv_layers = nn.Sequential(*layers)
+        self.avgpool = nn.AdaptiveAvgPool2d(1)
+
+        # Build fully connected layers
+        fc_blocks = []
+        in_features = conv_channels[-1]
+        for fc_size in fc_sizes:
+            fc_blocks.extend([
+                nn.Linear(in_features, fc_size),
+                nn.ReLU(inplace=True),
+                nn.Dropout(dropout),
+            ])
+            in_features = fc_size
+
+        self.fc_layers = nn.Sequential(*fc_blocks)
+        self.classifier = nn.Linear(in_features, num_classes)
+
+    def forward(self, x):
+        """Forward pass."""
+        x = self.conv_layers(x)
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc_layers(x)
+        x = self.classifier(x)
+        return x
+
+    def predict_class(self, x):
+        """Predict class labels and probabilities."""
+        self.eval()
+        with torch.no_grad():
+            logits = self.forward(x)
+            probs = torch.softmax(logits, dim=1)
+            preds = torch.argmax(logits, dim=1)
+        return preds, probs
+
+
+def load_model(model_path, device="cpu"):
+    """
+    Load model from file.
+
+    Args:
+        model_path: Path to model weights (.safetensors or .bin/.pth)
+        device: Device to load model on ("cpu" or "cuda")
+
+    Returns:
+        Loaded model in eval mode
+    """
+    model = CervicalCancerCNN()
+
+    model_path = Path(model_path)
+
+    if model_path.suffix == ".safetensors":
+        from safetensors.torch import load_file
+        state_dict = load_file(str(model_path))
+    else:
+        checkpoint = torch.load(model_path, map_location=device, weights_only=False)
+        if isinstance(checkpoint, dict) and "model_state_dict" in checkpoint:
+            state_dict = checkpoint["model_state_dict"]
+        else:
+            state_dict = checkpoint
+
+    model.load_state_dict(state_dict)
+    model.to(device)
+    model.eval()
+
+    return model
+
+
+def predict(model, image_tensor, device="cpu"):
+    """
+    Run prediction on an image tensor.
+
+    Args:
+        model: Loaded CervicalCancerCNN model
+        image_tensor: Preprocessed image tensor (1, 3, 224, 298)
+        device: Device for inference
+
+    Returns:
+        Dictionary with prediction results
+    """
+    model.eval()
+    image_tensor = image_tensor.to(device)
+
+    with torch.no_grad():
+        logits = model(image_tensor)
+        probs = torch.softmax(logits, dim=1)[0]
+        pred_class = torch.argmax(logits, dim=1).item()
+
+    return {
+        "class_id": pred_class,
+        "class_name": CervicalCancerCNN.CLASSES[pred_class],
+        "confidence": probs[pred_class].item(),
+        "probabilities": {
+            CervicalCancerCNN.CLASSES[i]: probs[i].item()
+            for i in range(4)
+        }
+    }
+
+
+def get_preprocessing_transform():
+    """
+    Get the preprocessing transform for input images.
+
+    Returns:
+        torchvision.transforms.Compose object
+    """
+    import torchvision.transforms as T
+
+    return T.Compose([
+        T.Resize((224, 298)),
+        T.ToTensor(),
+        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+
+
+# Quick usage example
+if __name__ == "__main__":
+    import sys
+
+    # Create model
+    model = CervicalCancerCNN()
+    print(f"Model created with {sum(p.numel() for p in model.parameters()):,} parameters")
+
+    # Print architecture
+    print("\nArchitecture:")
+    print(model)
+
+    # Test forward pass
+    dummy_input = torch.randn(1, 3, 224, 298)
+    output = model(dummy_input)
+    print(f"\nInput shape: {dummy_input.shape}")
+    print(f"Output shape: {output.shape}")
+    print(f"Output classes: {list(CervicalCancerCNN.CLASSES.values())}")

model.safetensors

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

modeling_cervical.py

@@ -0,0 +1,166 @@
+"""
+Cervical Cancer Classification Model
+
+Custom CNN model for classifying cervical images into 4 severity classes.
+"""
+
+import torch
+import torch.nn as nn
+
+
+class CervicalCancerCNN(nn.Module):
+    """
+    CNN for cervical cancer classification.
+
+    Classifies cervical images into 4 classes:
+    - 0: Normal
+    - 1: LSIL (Low-grade Squamous Intraepithelial Lesion)
+    - 2: HSIL (High-grade Squamous Intraepithelial Lesion)
+    - 3: Cancer
+
+    Args:
+        config: Optional configuration dict with keys:
+            - conv_layers: List of conv channel sizes (default: [32, 64, 128, 256])
+            - fc_layers: List of FC layer sizes (default: [256, 128])
+            - num_classes: Number of output classes (default: 4)
+            - dropout: Dropout rate (default: 0.5)
+    """
+
+    def __init__(self, config=None):
+        super().__init__()
+
+        # Default config
+        self.config = config or {
+            "conv_layers": [32, 64, 128, 256],
+            "fc_layers": [256, 128],
+            "num_classes": 4,
+            "dropout": 0.5,
+            "input_channels": 3,
+        }
+
+        conv_channels = self.config.get("conv_layers", [32, 64, 128, 256])
+        fc_sizes = self.config.get("fc_layers", [256, 128])
+        dropout = self.config.get("dropout", 0.5)
+        num_classes = self.config.get("num_classes", 4)
+        input_channels = self.config.get("input_channels", 3)
+
+        # Build convolutional layers
+        layers = []
+        in_channels = input_channels
+
+        for out_channels in conv_channels:
+            layers.extend([
+                nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
+                nn.BatchNorm2d(out_channels),
+                nn.ReLU(inplace=True),
+                nn.MaxPool2d(kernel_size=2, stride=2),
+            ])
+            in_channels = out_channels
+
+        self.conv_layers = nn.Sequential(*layers)
+        self.avgpool = nn.AdaptiveAvgPool2d(1)
+
+        # Build fully connected layers
+        fc_blocks = []
+        in_features = conv_channels[-1]
+
+        for fc_size in fc_sizes:
+            fc_blocks.extend([
+                nn.Linear(in_features, fc_size),
+                nn.ReLU(inplace=True),
+                nn.Dropout(dropout),
+            ])
+            in_features = fc_size
+
+        self.fc_layers = nn.Sequential(*fc_blocks)
+        self.classifier = nn.Linear(in_features, num_classes)
+
+        # Class labels
+        self.id2label = {
+            0: "Normal",
+            1: "LSIL",
+            2: "HSIL",
+            3: "Cancer"
+        }
+        self.label2id = {v: k for k, v in self.id2label.items()}
+
+    def forward(self, x):
+        """
+        Forward pass.
+
+        Args:
+            x: Input tensor of shape (batch, 3, height, width)
+
+        Returns:
+            Logits tensor of shape (batch, num_classes)
+        """
+        x = self.conv_layers(x)
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc_layers(x)
+        x = self.classifier(x)
+        return x
+
+    def predict(self, x):
+        """
+        Predict class labels.
+
+        Args:
+            x: Input tensor of shape (batch, 3, height, width)
+
+        Returns:
+            Tuple of (predicted_class_ids, probabilities)
+        """
+        self.eval()
+        with torch.no_grad():
+            logits = self.forward(x)
+            probs = torch.softmax(logits, dim=1)
+            preds = torch.argmax(logits, dim=1)
+        return preds, probs
+
+    @classmethod
+    def from_pretrained(cls, model_path, device="cpu"):
+        """
+        Load pretrained model.
+
+        Args:
+            model_path: Path to model directory or checkpoint file
+            device: Device to load model on
+
+        Returns:
+            Loaded model
+        """
+        import os
+        from pathlib import Path
+
+        model_path = Path(model_path)
+
+        # Try different file formats
+        if model_path.is_dir():
+            if (model_path / "model.safetensors").exists():
+                weights_path = model_path / "model.safetensors"
+                use_safetensors = True
+            elif (model_path / "pytorch_model.bin").exists():
+                weights_path = model_path / "pytorch_model.bin"
+                use_safetensors = False
+            else:
+                raise FileNotFoundError(f"No model weights found in {model_path}")
+        else:
+            weights_path = model_path
+            use_safetensors = str(model_path).endswith(".safetensors")
+
+        # Create model
+        model = cls()
+
+        # Load weights
+        if use_safetensors:
+            from safetensors.torch import load_file
+            state_dict = load_file(str(weights_path))
+        else:
+            state_dict = torch.load(weights_path, map_location=device, weights_only=True)
+
+        model.load_state_dict(state_dict)
+        model.to(device)
+        model.eval()
+
+        return model

preprocessor_config.json

@@ -0,0 +1,14 @@
+{
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [0.485, 0.456, 0.406],
+  "image_std": [0.229, 0.224, 0.225],
+  "image_processor_type": "ImageProcessor",
+  "resample": 3,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 224,
+    "width": 298
+  }
+}

pytorch_model.bin

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