image-classifier-efficientnet

🌸 102-Flower Image Classifier — EfficientNet-B0

A PyTorch EfficientNet-B0 image classification model trained to recognize 102 flower categories from the Oxford 102 Category Flower Dataset.

Model Performance

The model was trained using transfer learning with an ImageNet-pretrained EfficientNet-B0 backbone.

Dataset

This model was trained using the Oxford 102 Category Flower Dataset, created by Maria-Elena Nilsback and Andrew Zisserman.

The dataset contains 102 flower categories with variations in scale, pose, lighting, and appearance.

Official dataset page:

https://www.robots.ox.ac.uk/~vgg/data/flowers/102/

Please review the original dataset documentation and terms before using or redistributing dataset-derived material.

Files

• checkpoint.pth — trained PyTorch checkpoint
• model_config.json — model architecture information
• training_config.json — training configuration
• class_config.json — exact class/index mappings
• labels.txt — flower labels
• requirements.txt — Python dependencies

Checkpoint Contents

The checkpoint.pth file contains:

• epoch
• model_state_dict
• optimizer_state_dict
• class_to_idx

Use the Model

Install the dependencies:

pip install torch torchvision pillow

Load the model:

import json
import torch
import torch.nn as nn
from torchvision import models, transforms
from PIL import Image

checkpoint = torch.load(
    "checkpoint.pth",
    map_location="cpu",
    weights_only=False
)

model = models.efficientnet_b0(weights=None)

model.classifier[1] = nn.Linear(
    model.classifier[1].in_features,
    102
)

model.load_state_dict(
    checkpoint["model_state_dict"]
)

model.eval()

with open(
    "class_config.json",
    "r",
    encoding="utf-8"
) as f:
    class_config = json.load(f)

idx_to_class = {
    int(k): v
    for k, v in class_config["idx_to_class"].items()
}

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

image = Image.open(
    "flower.jpg"
).convert("RGB")

x = transform(
    image
).unsqueeze(0)

with torch.inference_mode():
    probabilities = torch.softmax(
        model(x),
        dim=1
    )

    confidence, prediction = probabilities.max(
        dim=1
    )

idx = prediction.item()

print(
    "Prediction:",
    idx_to_class[idx]
)

print(
    "Confidence:",
    f"{confidence.item() * 100:.2f}%"
)

Top-5 Predictions

You can also get the five most likely flower categories:

with torch.inference_mode():
    probabilities = torch.softmax(
        model(x),
        dim=1
    )

    values, indices = torch.topk(
        probabilities,
        k=5
    )

for probability, index in zip(
    values[0],
    indices[0]
):
    flower = idx_to_class[index.item()]
    confidence = probability.item() * 100

    print(
        f"{flower}: {confidence:.2f}%"
    )

Training Configuration

The model was trained using transfer learning.

• Architecture: EfficientNet-B0
• Classes: 102
• Image size: 224 × 224
• Batch size: 32
• Epochs: 3
• Optimizer: AdamW
• Learning rate: 0.001
• Loss: CrossEntropyLoss
• Scheduler: StepLR
• Mixed precision: CUDA when available

Training Augmentation

• Random resized crop
• Random horizontal flip
• Color jitter
• ImageNet normalization

Validation Preprocessing

• Resize to 256
• Center crop to 224
• ImageNet normalization

Evaluation

The best validation accuracy achieved during training was:

94.38%

This result corresponds to the validation split used during training.

Performance may vary on images that differ substantially from the training data.

Interactive Demo

An interactive Gradio application can be deployed using this model so that users can upload flower images directly through a web browser.

The demo can provide:

• Image upload
• Flower prediction
• Confidence score
• Top-5 predictions

Limitations

This model is designed to classify images into the 102 flower categories represented in the training dataset.

Predictions may be less reliable when:

• The image does not contain a supported flower category.
• The flower is heavily obscured.
• The image is blurry or poorly illuminated.
• Multiple flowers appear in the image.
• The image differs substantially from the training distribution.

This model should be considered an image-classification research/demo model and not a definitive botanical identification system.

Citation

If you use this model or the underlying dataset, please provide attribution to the original dataset authors.

Maria-Elena Nilsback and Andrew Zisserman

"Automated Flower Classification over a Large Number of Classes."

Proceedings of the Indian Conference on Computer Vision, Graphics and Image Processing (ICVGIP), 2008.

Dataset Reference

Oxford 102 Category Flower Dataset:

https://www.robots.ox.ac.uk/~vgg/data/flowers/102/

Author

Naila Rais

Hugging Face:

nailarais1

Model:

nailarais1/image-classifier-efficientnet

Architecture:

EfficientNet-B0

Best validation accuracy:

94.38%