Yapay zeka modelleri, 2025 yılında hızla evrilerek günlük hayatı, iş süreçlerini ve yaratıcılığı dönüştürmeye devam ediyor. GPT-5, Claude, Gemini ve diğer modeller karşılaştırması, bu rekabetçi arenada hangi modelin hangi alanda üstünlük sağladığını ortaya koyuyor. Eylül 2025 itibarıyla, OpenAI’nin GPT-5’i genel performans lideri olarak öne çıkarken, Anthropic’in Claude’u etik odaklı yaklaşımlarda, Google’ın Gemini’si ise multimodal yeteneklerde fark yaratıyor. Bu makalede, güncel benchmark’lar, kullanım senaryoları ve fiyatlandırma detaylarıyla tarafsız bir GPT-5, Claude, Gemini ve diğer modeller karşılaştırması yaparak, okuyuculara en uygun seçimi yapma rehberi sunacağız.

GPT-5, Claude, Gemini ve Diğer Modellerin Temel Özellikleri

Yapay zeka modellerinin temel özellikleri, parametre sayısı, bağlam penceresi ve multimodal entegrasyon gibi unsurlarla belirlenir. 2025 Eylül verilerine göre, GPT-5, Claude Opus 4.1 ve Gemini 2.5 Pro gibi modeller, trilyonlarca parametreye ulaşarak daha karmaşık görevleri yönetebiliyor. Bu bölümde, GPT-5, Claude, Gemini ve diğer modeller karşılaştırması kapsamında her birinin çekirdek özelliklerini inceleyeceğiz.

GPT-5’in Yenilikçi Yapısı ve Performans Metrikleri

OpenAI tarafından geliştirilen GPT-5, 2025 Ağustos’ta piyasaya sürülen en son model olarak, gelişmiş ajanik yetenekler ve mantıksal akıl yürütme ile dikkat çekiyor. Yaklaşık 2 trilyon parametreye sahip olan GPT-5, 1 milyon token’lık bağlam penceresi sunarak uzun metinleri sorunsuz işliyor. Multimodal özellikleriyle metin, görüntü ve ses entegrasyonunu sağlıyor; örneğin, bir fotoğrafı analiz edip kod üreterek geliştiricilere destek oluyor.

GPT-5’in güçlü yönleri arasında matematik ve kodlama performansı yer alıyor. AIME 2025 matematik yarışmasında %94.6 başarı oranı elde eden model, GPQA testlerinde %88.4 skora ulaşmış. Bu, önceki GPT-4o’ya göre %15’lik bir artış anlamına geliyor. Ancak, etik filtreleri nedeniyle bazı yaratıcı içeriklerde kısıtlamalar getirebiliyor. Gerçek dünya örneği: Bir geliştirici, GPT-5’i kullanarak bir web uygulamasının prototipini 30 dakikada oluşturmuş, bu da geliştirme süresini %50 kısaltmış.

Claude Opus 4.1’in Etik Odaklı Yaklaşımı

Anthropic’in Claude Opus 4.1 modeli, “güvenli AI” felsefesiyle tasarlanmış olup, 2025 Temmuz’da güncellenen versiyonuyla uzun metin tutarlılığında lider konumda. 1.5 trilyon parametreye sahip Claude, 500 bin token bağlam penceresi ile karmaşık belgeleri analiz edebiliyor. Etik bias’ları minimize etmek için özel eğitim verileri kullanan model, hassas sektörlerde (sağlık, hukuk) tercih ediliyor.

Claude’un matematik performansı AIME’de %93 ile GPT-5’i yakından takip ediyor, ancak kodlama görevlerinde daha tutarlı sonuçlar veriyor. SWE-bench testinde %65 başarı oranıyla öne çıkıyor. Örnek: Bir hukuk firması, Claude’u sözleşme incelemelerinde kullanarak manuel emeği %40 azaltmış. Dezavantajı ise, bazen aşırı temkinli yanıtlar vermesi, bu da yaratıcı görevlerde yavaşlamaya yol açıyor.

Gemini 2.5 Pro’nun Multimodal Üstünlüğü

Google DeepMind’in Gemini 2.5 Pro modeli, 2025 Mart’ta tanıtılan “Deep Think” moduyla akıl yürütmeyi adım adım işleyerek doğruluk oranını artırıyor. 1.8 trilyon parametre ve 2 milyon token bağlam penceresi ile en geniş kapasiteye sahip. Multimodal yapısı, video ve ses analizi için optimize edilmiş; örneğin, bir videoyu izleyip özet çıkarabiliyor.

Gemini’nin benchmark’larda MMLU testinde %86.4 skora ulaşması, genel bilgi işlemeyle farkını ortaya koyuyor. Kodlama ve veri analizi için maliyet etkinliği yüksek. Gerçek örnek: Bir pazarlama ekibi, Gemini’yi sosyal medya trendlerini analiz etmek için kullanarak kampanya dönüşümünü %25 artırmış. Ancak, gizlilik endişeleri nedeniyle kurumsal kullanımda sınırlı kalabiliyor.

Diğer Modeller: Grok 4 ve Llama 3’ün Katkıları

GPT-5, Claude, Gemini ve diğer modeller karşılaştırmasında, xAI’nin Grok 4’ü ve Meta’nın Llama 3’ü gibi açık kaynak alternatifler de yer alıyor. Grok 4, 2025 Ağustos’ta çıkan versiyonuyla mantıksal akıl yürütmede GPT-5’i %90 oranında yakalıyor ve mizah odaklı yanıtlarıyla benzersiz. Llama 3 ise, 405 milyar parametresiyle ücretsiz erişim sağlayarak geliştiricilere esneklik sunuyor.

Aşağıdaki tablo, GPT-5, Claude, Gemini ve diğer modeller karşılaştırması için temel özellikleri özetliyor:

Model	Parametre Sayısı	Bağlam Penceresi	Multimodal Destek	Ana Güçlü Yönü
GPT-5	2 Trilyon	1 Milyon Token	Evet (Metin, Görüntü, Ses)	Matematik ve Ajanik
Claude Opus 4.1	1.5 Trilyon	500 Bin Token	Evet (Metin, Görüntü)	Etik ve Tutarlılık
Gemini 2.5 Pro	1.8 Trilyon	2 Milyon Token	Evet (Metin, Video, Ses)	Akıl Yürütme ve Genişlik
Grok 4	1.2 Trilyon	800 Bin Token	Evet (Metin, Görüntü)	Mantık ve Yaratıcılık
Llama 3	405 Milyar	128 Bin Token	Hayır (Sadece Metin)	Açık Kaynak Erişimi

Bu tablo, model seçiminde başlangıç noktası olabilir; örneğin, açık kaynak tercih edenler Llama 3’ü, geniş bağlam için Gemini’yi seçebilir.

GPT-5, Claude, Gemini ve Diğer Modellerin Performans Karşılaştırması

Performans, yapay zeka modellerinin kalitesini belirleyen en kritik faktör. 2025 Eylül benchmark’larına göre, GPT-5 genel lider olsa da, her model belirli alanlarda üstünlük sağlıyor. GPT-5, Claude, Gemini ve diğer modeller karşılaştırması, standart testler üzerinden yapılmalı.

Benchmark Sonuçları ve Analiz

Standart benchmark’lar gibi MMLU (genel bilgi), GPQA (uzmanlık) ve SWE-bench (kodlama), modellerin gücünü ölçer. Eylül 2025 verilerine göre, GPT-5 AIME matematik testinde %94.6 ile lider, Gemini MMLU’da %86.4 ile takip ediyor. Claude Opus 4.1 ise etik testlerde %95 doğrulukla öne çıkıyor.

Aşağıdaki tablo, GPT-5, Claude, Gemini ve diğer modeller karşılaştırması için ana benchmark sonuçlarını gösteriyor:

Benchmark	GPT-5 (%)	Claude Opus 4.1 (%)	Gemini 2.5 Pro (%)	Grok 4 (%)	Llama 3 (%)
MMLU (Genel)	92.1	89.5	86.4	90.2	85.7
GPQA (Uzman)	88.4	86.2	84.1	87.5	82.3
AIME (Matematik)	94.6	93.0	91.2	92.8	88.5
SWE-bench (Kod)	65.0	64.5	62.0	63.8	60.2

Bu sonuçlar, GPT-5’in dengeli performansını vurguluyor; örneğin, bir araştırma ekibi GPQA’da GPT-5’i kullanarak uzmanlık raporlarını %20 daha hızlı hazırlamış.

Kodlama ve Matematik Performansında Farklar

Kodlama görevlerinde Claude Opus 4.1, tutarlılığıyla %65 SWE-bench skoru alırken, GPT-5 ajanik özelliklerle karmaşık projeleri yönetiyor. Matematikte ise GPT-5’in üstünlüğü net: Bir üniversite projesinde, model diferansiyel denklemleri çözerek manuel hesaplamaları %70 kısaltmış. Gemini ise, “Deep Think” moduyla adım adım akıl yürütmede etkili; örneğin, bir veri bilimcisi Gemini’yi kullanarak büyük veri setlerini optimize etmiş.

Yaygın kullanım listesi:

• Kod Tamamlama: Claude için ideal, hataları %15 daha az yapıyor.
• Matematik Çözümleme: GPT-5, olasılık hesaplarında lider.
• proje yönetimi: Gemini’nin geniş penceresi, uzun kod tabanlarını tarıyor.
• Hata Ayıklama: Grok 4, mizahlı açıklamalarıyla öğrenmeyi kolaylaştırıyor.

Kullanım Alanlarına Göre GPT-5, Claude, Gemini ve Diğer Modeller Karşılaştırması

Modellerin gücü, kullanım alanına göre değişir. GPT-5, Claude, Gemini ve diğer modeller karşılaştırması, yaratıcı yazım, kod geliştirme ve veri analizi gibi senaryolarda farklı sonuçlar veriyor.

Yaratıcı Yazım ve İçerik Üretimi

Yaratıcı görevlerde Claude Opus 4.1, insan benzeri üslubuyla öne çıkıyor; bir blog yazısında %20 daha doğal metinler üretiyor. GPT-5 ise, multimodal entegrasyonla hikaye görselleştirmesi yapıyor. Gemini, video script’leri için uygun. Örnek: Bir yazar, Claude’u roman taslağı için kullanarak ilhamını %30 artırmış.

Kod Geliştirme ve Yazılım Mühendisliği

Kodlamada GPT-5 ve Claude başa baş gidiyor; SWE-bench’te benzer skorlar. Gemini 2.5 Pro, Google entegrasyonuyla bulut projelerinde etkili. Grok 4 ise, açık kaynak kodlarda hızlı. Vaka: Bir startup, GPT-5 ile mobil app geliştirerek lansman süresini 2 haftaya indirmiş.

Veri Analizi ve Araştırma Uygulamaları

Veri için Gemini’nin geniş penceresi ideal; büyük dataset’leri işliyor. GPT-5, istatistiksel çıkarımlarda lider. Llama 3, ücretsiz analizi için tercih ediliyor. Örnek: Bir finans analisti, Gemini’yi piyasa trendleri için kullanarak tahmin doğruluğunu %18 yükseltmiş.

Aşağıdaki liste, kullanım senaryolarını özetler:

1. Eğitim: Claude’un etik yaklaşımıyla ders planları.
2. Pazarlama: GPT-5’in yaratıcı sloganları.
3. Sağlık: Gemini’nin tıbbi görüntü analizi.
4. E-ticaret: Grok 4’ün kişiselleştirilmiş önerileri.
5. Araştırma: Llama 3’ün açık veri işleme.

Fiyatlandırma, Erişilebilirlik ve Maliyet Etkinliği

GPT-5, Claude, Gemini ve diğer modeller karşılaştırmasında fiyatlandırma kritik. Eylül 2025’te, GPT-5 1 milyon token için $12-20 arasında değişirken, Llama 3 ücretsiz. Claude Opus 4.1 $8-15, Gemini 2.5 Pro $3-7.

Aşağıdaki tablo, maliyetleri karşılaştırıyor:

Model	Giriş Maliyeti (1M Token)	Ücretsiz Erişim	Kurumsal Plan
GPT-5	$12-20	Sınırlı	$50+/ay
Claude Opus 4.1	$8-15	Hayır	$30+/ay
Gemini 2.5 Pro	$3-7	Evet (Sınırlı)	$20+/ay
Grok 4	$5-10	Evet	$25+/ay
Llama 3	Ücretsiz	Tam	Yok

Bu, bütçe odaklı kullanıcılar için Gemini’yi, premium için GPT-5’i öneriyor.

Etik Hususlar ve Gelecek Trendleri

GPT-5, Claude, Gemini ve diğer modeller karşılaştırmasında etik, bias minimizasyonuyla Claude’un üstünlüğü var. Gelecekte, 2026’da multimodal ajanlar bekleniyor; GPT-5’in liderliği devam edebilir. Trendler: Daha ucuz modeller (örneğin, Çin’in DeepSeek $294K maliyetiyle) ve açık kaynak artışı.

SSS (Sıkça Sorulan Sorular)

GPT-5, Claude ve Gemini arasında en iyi model hangisi?

Genel performans için GPT-5 lider, ancak kullanım alanına göre değişir: Kodlama için Claude, multimodal için Gemini.

2025 Eylül benchmark’larında Gemini 2.5 Pro’nun skoru nedir?

MMLU’da %86.4, AIME’de %91.2 ile güçlü bir konumda.

Claude Opus 4.1’in etik avantajları neler?

Bias’ları minimize eden eğitimle, hassas sektörlerde %95 doğruluk sağlar.

GPT-5’in bağlam penceresi ne kadar?

1 milyon token, uzun metinler için ideal.

Diğer modellerden Grok 4 ne sunuyor?

Mantıksal akıl yürütmede GPT-5’i yakalayan, mizahlı yanıtlar.

Fiyatlandırma açısından en uygun model hangisi?

Gemini 2.5 Pro, $3-7 aralığıyla maliyet etkin.

---

Chronos-T5-Small Model Detayları

Model Hakkında

Chronos-T5-Small, Amazon tarafından geliştirilmiş, zaman serisi tahmini için özelleştirilmiş bir dil modelidir. Geleneksel zaman serisi yöntemlerinden farklı olarak, zaman serisi verilerini token’lar halinde ele alarak dil modelleme tekniklerini zaman serisi tahminine uyarlar.

Teknik Özellikler:

• Mimari: T5 (Text-to-Text Transfer Transformer) tabanlı
• Model Boyutu: Küçük (small) versiyon
• Parametre Sayısı: ~20M
• Giriş Formatı: Zaman serisi token’ları
• Çıkış Formatı: Gelecek zaman periyotları tahmini
• Eğitim Verisi: Çeşitli zaman serisi veri kümeleri

Temel Çalışma Prensibi:

Zaman serisi verilerini bir dil gibi ele alır:

• Zaman serisi değerleri → Token’lar
• Zaman serisi pattern’leri → Dil yapıları
• Tahmin → Metin üretimi benzeri çıktı

Kullanım Alanları:

• Finansal tahmin (hisse senedi, döviz kuru)
• Talep tahmini (perakende, üretim)
• Enerji tüketimi tahmini
• Hava durumu ve iklim verisi analizi
• IoT sensör verisi tahmini

---

İndirme ve Erişim

Resmi Model Sayfası:
https://huggingface.co/amazon/chronos-t5-small

Model Ailesi:

• chronos-t5-small (~20M parametre)
• chronos-t5-base (~80M parametre)
• chronos-t5-large (~200M parametre)

İndirme Seçenekleri:

from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

model_name = "amazon/chronos-t5-small"
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

---

Kurulum ve Temel Kullanım

Gereksinimler:

pip install transformers torch
pip install pandas numpy matplotlib
pip install datasets

Temel Zaman Serisi Tahmini:

import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
import numpy as np

# Model ve tokenizer yükleme
model_name = "amazon/chronos-t5-small"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

# Zaman serisi verisi (örnek)
time_series = [10.2, 11.5, 12.8, 14.1, 15.4, 16.7, 18.0]

# Tokenization ve tahmin
inputs = tokenizer(time_series, return_tensors="pt", padding=True)

with torch.no_grad():
    outputs = model.generate(
        inputs.input_ids,
        max_length=20,
        num_beams=5,
        early_stopping=True
    )

# Tahminleri decode etme
predictions = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("Tahminler:", predictions)

Detaylı Kullanım Örneği:

import pandas as pd
from chronos import ChronosPipeline

# Chronos pipeline ile tahmin
pipeline = ChronosPipeline.from_pretrained("amazon/chronos-t5-small")

# Zaman serisi verisi
series = pd.Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0])

# Tahmin yapma
forecast = pipeline.predict(series, prediction_length=5)
print("5 periyotluk tahmin:", forecast)

---

Veri Hazırlama ve Ön İşleme

Zaman Serisi Formatı:

# Pandas Series formatı
import pandas as pd
time_series = pd.Series(
    data=[100, 110, 120, 130, 140, 150],
    index=pd.date_range('2024-01-01', periods=6, freq='D')
)

# NumPy array formatı
import numpy as np
time_series_array = np.array([100, 110, 120, 130, 140, 150])

Özellik Mühendisliği:

def prepare_timeseries_data(data, context_length=10):
    """
    Zaman serisi verisini model için hazırlama
    """
    # Normalizasyon
    mean = data.mean()
    std = data.std()
    normalized_data = (data - mean) / std

    # Context window oluşturma
    windows = []
    for i in range(len(normalized_data) - context_length):
        window = normalized_data[i:i+context_length]
        windows.append(window)

    return windows, mean, std

---

Eğitim ve Fine-Tuning

Transfer Learning için:

from transformers import Seq2SeqTrainingArguments, Seq2SeqTrainer

# Fine-tuning configuration
training_args = Seq2SeqTrainingArguments(
    output_dir="./chronos-finetuned",
    per_device_train_batch_size=4,
    prediction_loss_only=True,
    learning_rate=5e-5,
    num_train_epochs=10,
)

# Trainer oluşturma
trainer = Seq2SeqTrainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=val_dataset,
)

Özel Veri Kümesi ile Eğitim:

from datasets import Dataset
import pandas as pd

# Özel zaman serisi veri kümesi oluşturma
def create_dataset(time_series_list, context_length=20, prediction_length=5):
    examples = []
    for series in time_series_list:
        for i in range(len(series) - context_length - prediction_length):
            input_seq = series[i:i+context_length]
            target_seq = series[i+context_length:i+context_length+prediction_length]
            examples.append({
                'input_ids': input_seq,
                'labels': target_seq
            })
    return Dataset.from_list(examples)

---

Değerlendirme ve Metrikler

Tahmin Kalitesi Metrikleri:

from sklearn.metrics import mean_absolute_error, mean_squared_error

def evaluate_predictions(actual, predicted):
    """
    Tahmin performansını değerlendirme
    """
    mae = mean_absolute_error(actual, predicted)
    mse = mean_squared_error(actual, predicted)
    rmse = np.sqrt(mse)

    return {
        'MAE': mae,
        'MSE': mse, 
        'RMSE': rmse,
        'MAPE': np.mean(np.abs((actual - predicted) / actual)) * 100
    }

---

Production Kullanımı

API Entegrasyonu:

from fastapi import FastAPI
import uvicorn

app = FastAPI()

@app.post("/predict")
async def predict_timeseries(data: dict):
    time_series = data["series"]
    predictions = pipeline.predict(time_series, prediction_length=data.get("horizon", 5))
    return {"predictions": predictions.tolist()}

# Çalıştırma: uvicorn main:app --reload

Batch Tahminleme:

def batch_predict(time_series_list, prediction_length=5):
    """
    Toplu zaman serisi tahmini
    """
    all_predictions = []
    for series in time_series_list:
        prediction = pipeline.predict(series, prediction_length=prediction_length)
        all_predictions.append(prediction)
    return all_predictions

---

Performans Optimizasyonu

GPU Kullanımı:

# GPU desteği
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# Mixed precision training
from torch.cuda.amp import autocast
with autocast():
    outputs = model(**inputs)

Bellek Optimizasyonu:

# Gradient checkpointing
model.gradient_checkpointing_enable()

# Dynamic padding
from transformers import DataCollatorForSeq2Seq
data_collator = DataCollatorForSeq2Seq(tokenizer, model=model, padding=True)

---

Sınırlamalar ve Çözümler

Sınırlamalar:

• ⚠️ Uzun zaman serilerinde performans düşüşü
• ⚠️ Mevsimsel pattern’lerde zorluk
• ⚠️ Anomali içeren verilerde yanılgı

Çözüm Önerileri:

• ✅ Veri ön işleme ve temizleme
• ✅ Model fine-tuning
• ✅ Ensemble yöntemleri
• ✅ Hybrid modeller (geleneksel + ML)

---

Not: Chronos-T5 modelleri, zaman serisi tahmininde dil modelleme yaklaşımının öncülerindendir. Hem akademik hem de endüstriyel uygulamalar için uygundur.

---

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.