MobileNetV3-Small: Hafif ve Verimli Görüntü Sınıflandırma Modeli

MobileNetV3-Small Modeli: Detaylı Açıklama

Model Nedir?

timm/mobilenetv3_small_100.lamb_in1k, özellikle mobil ve edge cihazlar için optimize edilmiş hafif bir konvolüsyonel sinir ağı modelidir. ImageNet-1k veri seti üzerinde LAMB optimizer ile eğitilmiş olup, yüksek doğruluk ve düşük hesaplama maliyeti sunar.

Teknik Özellikler:

• Mimari: MobileNetV3-Small (Hafifletilmiş CNN)
• Optimizer: LAMB (Layer-wise Adaptive Moments)
• Eğitim Verisi: ImageNet-1k (1.3M görüntü)
• Çıktı: 1000 sınıf ImageNet sınıflandırması
• Öne Çıkan Özellik: Düşük güç tüketimi, yüksek verimlilik

Ana Avantajlar:

• ✅ Düşük bellek kullanımı
• ✅ Hızlı çıkarım süresi
• ✅ Mobil cihazlarda yüksek performans
• ✅ Düşük güç tüketimi

Kullanım Alanları:

1. Mobil Görüntü Sınıflandırma
2. Edge AI Uygulamaları
3. Gerçek Zamanlı Nesne Tanıma
4. Gömülü Sistemler
5. IoT Cihazları için AI

Kurulum ve Kullanım Kodu

1. Gereksinimlerin Yüklenmesi

pip install timm torch torchvision Pillow

2. Modelin Yüklenmesi

import timm
import torch
from PIL import Image
import requests
from io import BytesIO

# Modeli yükle
model = timm.create_model(
    'timm/mobilenetv3_small_100.lamb_in1k',
    pretrained=True
)
model.eval()  # Değerlendirme modu

# ImageNet sınıf etiketlerini yükle
from timm.data import ImageNetInfo
imagenet_info = ImageNetInfo()
class_names = imagenet_info.get_class_names()

3. Görüntü Ön İşleme

# Görüntü işleme için transformlar
from timm.data import create_transform
from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD

transform = create_transform(
    input_size=224,
    is_training=False,
    mean=IMAGENET_DEFAULT_MEAN,
    std=IMAGENET_DEFAULT_STD
)

def load_and_preprocess_image(image_path_or_url):
    """Görüntüyü yükle ve ön işleme yap"""
    if image_path_or_url.startswith('http'):
        response = requests.get(image_path_or_url)
        image = Image.open(BytesIO(response.content)).convert('RGB')
    else:
        image = Image.open(image_path_or_url).convert('RGB')

    return transform(image).unsqueeze(0)  # Batch dimension ekle

4. Tahmin Yapma

def classify_image(image_path):
    """Görüntüyü sınıflandır"""
    # Görüntüyü yükle ve işle
    input_tensor = load_and_preprocess_image(image_path)

    # Tahmin yap
    with torch.no_grad():
        output = model(input_tensor)

    # Sonuçları işle
    probabilities = torch.nn.functional.softmax(output[0], dim=0)
    top5_prob, top5_indices = torch.topk(probabilities, 5)

    print("En Olası 5 Sınıf:")
    print("-" * 40)
    for i, (prob, idx) in enumerate(zip(top5_prob, top5_indices)):
        print(f"{i+1}. {class_names[idx]:<30} %{prob.item()*100:.2f}")

    return top5_prob, top5_indices

# Örnek kullanım
# results = classify_image("kedi.jpg")

5. GPU Desteği ile Hızlandırılmış Kullanım

# GPU kullanımı
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)

def fast_classify(image_path):
    """GPU ile hızlı sınıflandırma"""
    input_tensor = load_and_preprocess_image(image_path).to(device)

    with torch.no_grad():
        output = model(input_tensor)

    return torch.nn.functional.softmax(output[0], dim=0)

6. Toplu İşlemler

def batch_classify(image_paths, batch_size=4):
    """Toplu görüntü sınıflandırma"""
    results = {}

    for i in range(0, len(image_paths), batch_size):
        batch_paths = image_paths[i:i+batch_size]
        batch_tensors = []

        for path in batch_paths:
            batch_tensors.append(load_and_preprocess_image(path))

        batch_tensor = torch.cat(batch_tensors, 0).to(device)

        with torch.no_grad():
            batch_output = model(batch_tensor)

        # Sonuçları işle
        for j, path in enumerate(batch_paths):
            probs = torch.nn.functional.softmax(batch_output[j], dim=0)
            top_prob, top_idx = torch.topk(probs, 1)
            results[path] = {
                'class': class_names[top_idx.item()],
                'confidence': top_prob.item()
            }

    return results

Performans Optimizasyonu

1. Quantization ile Model Küçültme

# Modeli quantize et (daha küçük boyut)
quantized_model = torch.quantization.quantize_dynamic(
    model, {torch.nn.Linear}, dtype=torch.qint8
)

2. ONNX Formatına Dönüştürme

# ONNX formatına dönüştür
dummy_input = torch.randn(1, 3, 224, 224)
torch.onnx.export(
    model, 
    dummy_input, 
    "mobilenetv3_small.onnx",
    opset_version=11
)

İndirme ve Kurulum

Otomatik İndirme:

Model, timm kütüphanesi ile otomatik olarak indirilir:

import timm
model = timm.create_model('timm/mobilenetv3_small_100.lamb_in1k', pretrained=True)

Manuel İndirme:

• Hugging Face Hub: https://huggingface.co/timm/mobilenetv3_small_100.lamb_in1k
• Model Boyutu: ~10MB
• Gereksinimler: Python 3.6+, PyTorch 1.8+

Örnek Uygulama: Gerçek Zamanlı Sınıflandırma

import cv2
import numpy as np

def real_time_classification():
    """Webcam ile gerçek zamanlı sınıflandırma"""
    cap = cv2.VideoCapture(0)

    while True:
        ret, frame = cap.read()
        if not ret:
            break

        # Görüntüyü işle
        pil_image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
        input_tensor = transform(pil_image).unsqueeze(0).to(device)

        # Tahmin yap
        with torch.no_grad():
            output = model(input_tensor)

        probabilities = torch.nn.functional.softmax(output[0], dim=0)
        top_prob, top_idx = torch.topk(probabilities, 1)

        # Sonuçları göster
        label = f"{class_names[top_idx.item()]}: %{top_prob.item()*100:.1f}"
        cv2.putText(frame, label, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
        cv2.imshow('Real-time Classification', frame)

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

# Gerçek zamanlı sınıflandırmayı başlat
# real_time_classification()

Önemli Notlar

1. Model Boyutu: ~10MB (çok hafif)
2. Giriş Boyutu: 224×224 piksel
3. Çıktı: 1000 sınıf ImageNet kategorisi
4. En İyi Kullanım: Mobil cihazlar ve edge computing
5. Performans: CPU’da bile yüksek hız

Bu model, özellikle kaynak kısıtlı ortamlarda yüksek performanslı görüntü sınıflandırma için ideal bir çözüm sunar. Mobil cihazlarda, gömülü sistemlerde ve gerçek zamanlı uygulamalarda rahatlıkla kullanılabilir.