MobileNetV3-Large for Bacterial Colony Classification

This model is a fine-tuned MobileNetV3-Large for classifying bacterial colony images from the DIBaS dataset.

Model Description

Architecture: MobileNetV3-Large (ImageNet pretrained)
Task: Multi-class image classification (33 bacterial species)
Input Size: 224×224×3 RGB
Parameters: 4.24M
Validation Accuracy: 95.45%
Macro F1-Score: 0.954

Available Formats

Format	File	Size	Use Case
PyTorch (.bin)	`pytorch_model.bin`	16.4 MB	Training, fine-tuning
TorchScript (.pt)	`mobilenet_v3_large.pt`	17.6 MB	Python inference, iOS (Core ML)
ONNX (.onnx)	`mobilenet_v3_large.onnx` + `.data`	17.0 MB	Cross-platform, Android, Edge

Quick Start

Installation

pip install torch torchvision timm huggingface_hub

Load PyTorch Model

import torch
import timm
from huggingface_hub import hf_hub_download

# Download checkpoint
checkpoint_path = hf_hub_download(
    repo_id="ihoflaz/dibas-mobilenet-v3-large",
    filename="pytorch_model.bin"
)

# Create model
model = timm.create_model("mobilenetv3_large_100", pretrained=False, num_classes=33)
model.load_state_dict(torch.load(checkpoint_path, map_location="cpu"))
model.eval()

# Inference
from torchvision import transforms
from PIL import Image

transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

image = Image.open("bacteria_image.jpg").convert("RGB")
input_tensor = transform(image).unsqueeze(0)

with torch.no_grad():
    output = model(input_tensor)
    pred_idx = output.argmax(dim=1).item()
    confidence = torch.softmax(output, dim=1)[0, pred_idx].item()

print(f"Predicted class: {pred_idx}, Confidence: {confidence:.2%}")

Load TorchScript Model

import torch
from huggingface_hub import hf_hub_download

# Download TorchScript model
model_path = hf_hub_download(
    repo_id="ihoflaz/dibas-mobilenet-v3-large",
    filename="mobilenet_v3_large.pt"
)

# Load and use
model = torch.jit.load(model_path, map_location="cpu")
model.eval()

# Inference (same preprocessing as above)
with torch.no_grad():
    output = model(input_tensor)

Load ONNX Model

import onnxruntime as ort
import numpy as np
from huggingface_hub import hf_hub_download

# Download ONNX files
onnx_path = hf_hub_download(
    repo_id="ihoflaz/dibas-mobilenet-v3-large",
    filename="mobilenet_v3_large.onnx"
)
# Data file will be downloaded automatically if in same directory

# Create session
session = ort.InferenceSession(onnx_path)

# Inference
input_name = session.get_inputs()[0].name
output = session.run(None, {input_name: input_array})[0]
pred_idx = np.argmax(output, axis=1)[0]

Download Labels

from huggingface_hub import hf_hub_download

labels_path = hf_hub_download(
    repo_id="ihoflaz/dibas-mobilenet-v3-large",
    filename="labels.txt"
)

with open(labels_path) as f:
    labels = [line.strip() for line in f.readlines()]

print(f"Predicted: {labels[pred_idx]}")

Class Labels (33 species)

Acinetobacter_baumannii, Actinomyces_israelii, Bacteroides_fragilis,
Bifidobacterium_spp, Candida_albicans, Clostridium_perfringens,
Enterococcus_faecalis, Enterococcus_faecium, Escherichia_coli,
Fusobacterium, Lactobacillus_casei, Lactobacillus_crispatus,
Lactobacillus_delbrueckii, Lactobacillus_gasseri, Lactobacillus_jensenii,
Lactobacillus_johnsonii, Lactobacillus_paracasei, Lactobacillus_plantarum,
Lactobacillus_reuteri, Lactobacillus_rhamnosus, Lactobacillus_salivarius,
Listeria_monocytogenes, Micrococcus_spp, Neisseria_gonorrhoeae,
Porphyromonas_gingivalis, Propionibacterium_acnes, Proteus,
Pseudomonas_aeruginosa, Staphylococcus_aureus, Staphylococcus_epidermidis,
Staphylococcus_saprophyticus, Streptococcus_agalactiae, Veillonella

Training Details

Dataset: DIBaS (Digital Image of Bacterial Species)
Split: 70% train / 20% val / 10% test (stratified, seed=42)
Optimizer: AdamW (lr=1e-4, weight_decay=0.01)
Scheduler: CosineAnnealingLR
Epochs: 20
Batch Size: 32
Mixed Precision: FP16 (AMP)
Augmentation: RandomResizedCrop, HorizontalFlip, ColorJitter

Mobile Deployment

iOS (Core ML)

Convert TorchScript to Core ML on macOS:

import coremltools as ct
import torch

model = torch.jit.load("mobilenet_v3_large.pt", map_location="cpu")
mlmodel = ct.convert(
    model,
    inputs=[ct.ImageType(shape=(1, 3, 224, 224), scale=1/255.0,
            bias=[-0.485/0.229, -0.456/0.224, -0.406/0.225])]
)
mlmodel.save("BacteriaClassifier.mlpackage")

Android (ONNX Runtime)

val session = OrtEnvironment.getEnvironment()
    .createSession(modelBytes, OrtSession.SessionOptions())

Citation

@misc{dibas-mobilenet-v3-large,
  author = {İbrahim Hulusi Oflaz},
  title = {MobileNetV3-Large for Bacterial Colony Classification},
  year = {2025},
  publisher = {Hugging Face},
  url = {https://huggingface.co/ihoflaz/dibas-mobilenet-v3-large}
}

References

DIBaS Dataset: http://misztal.edu.pl/software/databases/dibas/
Zieliński, B., et al. "Deep learning approach to bacterial colony classification." PloS one 12.9 (2017)

License

MIT License

Downloads last month: 13