cerviguard_lesion

Cervical Cancer Classification CNN

Maintained by SmartClover SRL on Hugging Face.

_{HF ecosystem update version: v1.3.}

A CNN model for classifying cervical colposcopy images into 4 severity classes for cervical cancer screening.

Model Description

This model classifies cervical images into:

---

Model Architecture

Architecture Diagram

┌─────────────────────────────────────────────────────────────┐
│                    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]

Architecture Summary Table

PyTorch Model Code

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

---

Performance

Overall Metrics

Per-Class Metrics

Confusion Matrix

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

---

Usage

Installation

pip install torch torchvision safetensors huggingface_hub

Loading the Model

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 config
with open(config_file) as f:
    config = json.load(f)

# Define model (copy from above or download modeling_cervical.py)
model = CervicalCancerCNN()

# Load weights
state_dict = load_file(model_file)
model.load_state_dict(state_dict)
model.eval()

Inference

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%}")

---

Training Details

Dataset

---

Limitations

• 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

⚠️ 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.

---

Files in This Repository

---

Citation

@misc{cervical-cancer-cnn-2025,
  author = {SmartClover},
  title = {Cervical Cancer Lesion Classification CNN},
  year = {2026},
  publisher = {SmartClover},
  url = {https://huggingface.co/smartclover/cerviguard_lesion}
}