cerviguard_transfer_zones

CerviGuard - Cervical Transformation Zone Classifier

Maintained by SmartClover SRL on Hugging Face.

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

Model Description

This model classifies cervical images into 3 transformation zone types, which is important for colposcopy evaluation and cervical cancer screening.

---

Model Architecture

Overview

BaseCNN - A simple convolutional neural network with 4 conv blocks and 2 fully connected layers.

┌─────────────────────────────────────────────────────────────┐
│                    INPUT (256×256×3)                        │
└─────────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────────┐
│  CONV BLOCK 1                                               │
│  Conv2d(3→32, 3×3) → BatchNorm2d → ReLU → MaxPool2d(2×2)   │
│  Output: 128×128×32                                         │
└─────────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────────┐
│  CONV BLOCK 2                                               │
│  Conv2d(32→64, 3×3) → BatchNorm2d → ReLU → MaxPool2d(2×2)  │
│  Output: 64×64×64                                           │
└─────────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────────┐
│  CONV BLOCK 3                                               │
│  Conv2d(64→128, 3×3) → BatchNorm2d → ReLU → MaxPool2d(2×2) │
│  Output: 32×32×128                                          │
└─────────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────────┐
│  CONV BLOCK 4                                               │
│  Conv2d(128→256, 3×3) → BatchNorm2d → ReLU → MaxPool2d(2×2)│
│  Output: 16×16×256                                          │
└─────────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────────┐
│  GLOBAL POOLING                                             │
│  AdaptiveAvgPool2d(1×1)                                     │
│  Output: 1×1×256 → Flatten → 256                            │
└─────────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────────┐
│  FC BLOCK 1                                                 │
│  Linear(256→256) → ReLU → Dropout(0.4)                     │
└─────────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────────┐
│  FC BLOCK 2                                                 │
│  Linear(256→128) → ReLU → Dropout(0.4)                     │
└─────────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────────┐
│  CLASSIFIER                                                 │
│  Linear(128→3)                                              │
└─────────────────────────────────────────────────────────────┘
                            │
┌─────────────────────────────────────────────────────────────┐
│                 OUTPUT (3 logits)                           │
│            [Type 1, Type 2, Type 3]                         │
└─────────────────────────────────────────────────────────────┘

Layer Details

Model Summary

---

Training Configuration

---

Performance

Per-Class Performance

---

Usage

Installation

pip install torch torchvision safetensors huggingface_hub

Quick Start (Local)

import torch
from PIL import Image
from torchvision import transforms

# Load model
from model import BaseCNN
model = BaseCNN.from_pretrained("./")
model.eval()

# Preprocess image
transform = transforms.Compose([
    transforms.Resize((256, 256)),
    transforms.ToTensor(),
])

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()

labels = ["Type 1", "Type 2", "Type 3"]
print(f"Prediction: {labels[prediction]}")
print(f"Confidence: {probabilities[0][prediction]:.2%}")

Load from Hugging Face Hub

from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
import torch
import json
import importlib.util

# Download files
repo_id = "toderian/cerviguard_transfer_zones"
model_weights = hf_hub_download(repo_id, "model.safetensors")
config_file = hf_hub_download(repo_id, "config.json")
model_file = hf_hub_download(repo_id, "model.py")

# Load model class dynamically
spec = importlib.util.spec_from_file_location("model", model_file)
model_module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(model_module)

# Load config and create model
with open(config_file) as f:
    config = json.load(f)

model = model_module.BaseCNN(**config['model_config'])
model.load_state_dict(load_file(model_weights))
model.eval()

# Now use model for inference

---

Files in This Repository

---

Limitations

• Model was trained on a specific dataset and may not generalize to all cervical imaging equipment
• Type 2 classification has lower accuracy (56.41% F1) as it represents an intermediate state
• Input images should be 256×256 RGB
• This is a custom PyTorch model, not compatible with transformers.AutoModel

---

Citation

@misc{cerviguard-transfer-zones,
  title={CerviGuard Cervical Transformation Zone Classifier},
  author={smartclover},
  year={2026},
  howpublished={\url{https://huggingface.co/smartclover/cerviguard_transfer_zones}}
}

---

License

MIT License