egyptian_cars_recognition_computer_vision_model

Egyptian Cars Recognition — EfficientNetV2-S (1211 classes)

A fine-grained image classifier that identifies the make, model, and production generation of cars from a single photo. Trained on 1211 distinct car generations, with a price-mapping companion dataset of cars commonly sold in the Egyptian market.

Model Overview

Performance

Evaluated on a held-out test set of 26,818 images (10% stratified split):

For context: random guessing on 1211 classes yields 0.083% accuracy. The model performs ~720× better than random on top-1, and finds the correct generation in its top-5 guesses 92% of the time.

Intended Use

Suitable for:

• ✅ Identifying car make, model, and generation from photos
• ✅ Visual search and tagging in automotive catalogs
• ✅ Price estimation (when paired with the companion price dataset)
• ✅ Educational and research applications in fine-grained classification
• ✅ Demonstrating transfer learning on imbalanced, large-class problems

Not suitable for (without further validation):

• ❌ Insurance / forensic identification (accuracy too low for high-stakes decisions)
• ❌ Commercial deployment without further fine-tuning on your specific data distribution
• ❌ Distinguishing fine variants within a generation (trim levels, individual model years within the same generation)

Class Labels

Classes are named in the format: Company_Model_BeginYear_EndYear

Examples:

• Toyota_Camry_2018_2024
• Honda_Civic_2016_2021
• BMW_3-Series_2012_2018

The full list is available in class_names.json. Each class represents a generation (typically 5-8 years of production with the same overall design), not individual model years.

Quick Start

Installation

pip install torch torchvision pillow huggingface_hub

Inference Example

import json
import torch
import torch.nn as nn
from PIL import Image
from torchvision import transforms
from torchvision.models import efficientnet_v2_s
from huggingface_hub import hf_hub_download

# Download model files
REPO_ID = "PatrickBLB/egyptian_cars_recognition_computer_vision_model"
model_path = hf_hub_download(repo_id=REPO_ID, filename="efficientnet_v2s_cars.pt")
classes_path = hf_hub_download(repo_id=REPO_ID, filename="class_names.json")

# Load class names
with open(classes_path, "r") as f:
    class_names = json.load(f)

# Build and load model
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
checkpoint = torch.load(model_path, map_location=device, weights_only=False)

model = efficientnet_v2_s(weights=None)
model.classifier[1] = nn.Linear(model.classifier[1].in_features, len(class_names))
model.load_state_dict(checkpoint["model_state"])
model.to(device).eval()

# Prepare image
transform = transforms.Compose([
    transforms.Resize((300, 300)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

img = Image.open("your_car_image.jpg").convert("RGB")
tensor = transform(img).unsqueeze(0).to(device)

# Predict
with torch.no_grad():
    probs = torch.softmax(model(tensor), dim=1)
    top5_probs, top5_idx = probs.topk(5, dim=1)

for prob, idx in zip(top5_probs[0], top5_idx[0]):
    print(f"{class_names[idx]:<40} {prob.item()*100:.2f}%")

See inference_example.py for a more complete example, including price mapping.

Training Details

Dataset

• Size: ~257,000 images across 1211 classes
• Source: Web-scraped car images organized by company, model, and generation
• Class structure: Company_Model_BeginYear_EndYear (e.g., Toyota_Camry_2018_2024)
• Class distribution: Heavily imbalanced (24 to 563 images per class, mean ~170)
• Splits: 80% train / 10% validation / 10% test, stratified by class, seed=42
• Preprocessing: All images pre-resized to 320×320 to optimize training I/O

Training Configuration

Handling Class Imbalance

Two techniques were combined to address the 23.5× class imbalance:

1. Class-weighted loss — Inverse-frequency weighting, normalized so the mean weight is 1.0
2. Weighted random sampling — Each sample is drawn with probability inversely proportional to its class size

Together these ensure rare classes receive sufficient training signal despite their small population.

Price Mapping

This model can be paired with a companion CSV (combined_cars.csv) containing average prices in Egyptian Pounds (EGP) for cars commonly sold in the Egyptian market. The CSV uses the same combined_title format as the model's class labels, enabling direct lookup of an estimated price from a predicted class.

See the inference script for an example of how to combine classification output with price lookup.

Limitations and Biases

Known Limitations

• Performance varies significantly by class. Common cars (e.g., Toyota Camry, Hyundai Elantra) likely perform well above the 60% average. Rare classes with fewer than 50 training images may perform substantially worse.
• Confusion between visually similar generations. Mid-cycle facelifts and platform-shared vehicles across brands are common error patterns.
• Limited to generations in training data. New cars released after dataset compilation may not be recognized.
• Geographic bias toward Egyptian/regional market. The companion price dataset focuses on cars common in Egypt. Predictions are still valid globally but price mapping is regional.

Data Quality Notes

• Images are web-scraped and not professionally curated. Some label noise is expected.
• Photo conditions vary widely (lighting, angle, occlusion).
• Some classes may have limited viewpoint diversity (e.g., mostly front-3/4 views).

License

This model is released under CC BY-NC 4.0 (Creative Commons Attribution-NonCommercial 4.0 International).

You are free to:

• ✅ Use the model for personal, educational, and research purposes
• ✅ Modify and build upon the model
• ✅ Share derivatives with attribution

You may not:

• ❌ Use the model for commercial purposes without separate permission
• ❌ Use the model in any way that violates the terms of the source data

Citation

If you use this model in your work, please cite:

@misc{patrickblb2026egyptiancars,
  author    = {Patrick BLB},
  title     = {Egyptian Cars Recognition: EfficientNetV2-S Fine-Grained Classifier (1211 classes)},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/PatrickBLB/egyptian_cars_recognition_computer_vision_model}
}

Acknowledgments

• Backbone: EfficientNetV2 by Tan & Le (Google)
• Pretrained weights: torchvision ImageNet-1K weights
• Framework: PyTorch + torchvision

Contact

For questions, issues, or licensing inquiries: @PatrickBLB on Hugging Face