2026’da TensorFlow ile Görüntü Sınıflandırma Rehberi

GİRİŞ

CNN ve Görüntü İşlemenin Temelleri

Convolutional Neural Networks (CNN), bilgisayarlı görü alanında devrim yaratmış bir deep learning mimarisidir. 2026 yılında TensorFlow 2.15 ve Keras ile görüntü sınıflandırma projeleri geliştirmek, hem akademik araştırmalar hem de endüstriyel uygulamalar için kritik bir beceri haline gelmiştir.

2026’da görüntü sınıflandırma projelerinde CNN kullanan şirketler ortalama %87 doğruluk oranlarına ulaşmaktadır. Google Cloud Vision API, Amazon Rekognition gibi servisler de CNN tabanlı modeller kullanmaktadır.

KURULUM

Geliştirme Ortamı ve Kütüphane Kurulumu

TensorFlow 2026 kurulumu için Python 3.9 veya üzeri gereklidir. GPU desteği için CUDA 12.2 ve cuDNN 8.9 kullanılması önerilir. Bir NVIDIA RTX 4080 ile ImageNet veri setinde eğitim süresi 4 saate kadar düşmüştür.

# Sanal ortam oluşturma ve aktifleştirme
python -m venv tf_cnn_env
source tf_cnn_env/bin/activate  # Linux/Mac
tf_cnn_env\Scripts\activate.bat  # Windows

# TensorFlow ve gerekli kütüphaneler
pip install tensorflow==2.15.0
pip install numpy==1.24.3
pip install matplotlib==3.7.1
pip install scikit-learn==1.3.0
pip install opencv-python==4.8.0
pip install pillow==10.0.0

GPU Konfigürasyonu Kontrolü

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import VGG16
from sklearn.metrics import classification_report, confusion_matrix

# GPU konfigürasyonu
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
    try:
        for gpu in gpus:
            tf.config.experimental.set_memory_growth(gpu, True)
        print(f"GPU sayısı: {len(gpus)}")
        print(f"TensorFlow sürümü: {tf.__version__}")
    except RuntimeError as e:
        print(e)
else:
    print("GPU bulunamadı, CPU kullanılacak")

VERİ HAZIRLAMA

Veri Hazırlama ve Ön İşleme

Görüntü sınıflandırma projelerinde veri kalitesi başarının %70’ini belirler. Bu projede CIFAR-10 veri setini kullanacağız – 10 sınıfta 60,000 adet 32×32 piksel renkli görüntü içerir. Her sınıfta 6,000 görüntü bulunur.

Veri Seti Yükleme ve İnceleme

# CIFAR-10 veri seti yükleme
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.cifar10.load_data()

# Veri seti bilgileri
print(f"Eğitim seti boyutu: {X_train.shape}")
print(f"Test seti boyutu: {X_test.shape}")
print(f"Sınıf sayısı: {len(np.unique(y_train))}")

# Sınıf isimleri
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 
               'dog', 'frog', 'horse', 'ship', 'truck']

# Veri görselleştirme
plt.figure(figsize=(12, 8))
for i in range(20):
    plt.subplot(4, 5, i + 1)
    plt.imshow(X_train[i])
    plt.title(f"{class_names[y_train[i][0]]}")
    plt.axis('off')
plt.tight_layout()
plt.show()

Veri Normalização ve Augmentation

Görüntü verileri 0-255 arasında piksel değerleri içerir. Bu değerleri 0-1 aralığına normalize etmek, gradyan descent algoritmasının daha stabil çalışmasını sağlar. Ayrıca data augmentation ile veri setini yapay olarak büyütebiliriz.

# Veri normalizasyonu
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0

# One-hot encoding
y_train_cat = tf.keras.utils.to_categorical(y_train, 10)
y_test_cat = tf.keras.utils.to_categorical(y_test, 10)

# Data Augmentation
train_datagen = ImageDataGenerator(
    rotation_range=20,        # 20 derece döndürme
    width_shift_range=0.1,    # Yatay kaydırma
    height_shift_range=0.1,   # Dikey kaydırma
    horizontal_flip=True,     # Yatay çevirme
    zoom_range=0.1,           # Zoom efekti
    shear_range=0.1,          # Eğme efekti
    fill_mode='nearest'       # Boş piksel doldurma
)

# Validation için augmentation yok
val_datagen = ImageDataGenerator()

# Veri akışları oluşturma
train_generator = train_datagen.flow(X_train, y_train_cat, batch_size=32)
val_generator = val_datagen.flow(X_test, y_test_cat, batch_size=32)

MODEL MİMARİSİ

CNN Model Mimarisi Tasarımı

Modern CNN mimarileri convolution, pooling ve fully connected katmanların optimal kombinasyonundan oluşur. 2026’da en popüler yaklaşım Transfer Learning ve Custom Architecture hibrit modelleridir.

Özel CNN Mimarisi

# CNN Model Oluşturma
model = tf.keras.Sequential([
    # İlk konvolüsyon bloğu
    tf.keras.layers.Conv2D(32, (3, 3), activation='relu', 
                          input_shape=(32, 32, 3)),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Conv2D(32, (3, 3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2, 2),
    tf.keras.layers.Dropout(0.25),
    
    # İkinci konvolüsyon bloğu  
    tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2, 2),
    tf.keras.layers.Dropout(0.25),
    
    # Üçüncü konvolüsyon bloğu
    tf.keras.layers.Conv2D(128, (3, 3), activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Conv2D(128, (3, 3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2, 2),
    tf.keras.layers.Dropout(0.25),
    
    # Fully Connected katmanlar
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(10, activation='softmax')  # 10 sınıf
])

# Model özeti
model.summary()

Transfer Learning Yaklaşımı

VGG16 gibi önceden eğitilmiş modelleri kullanarak transfer learning uygulayabiliriz. Bu yaklaşım özellikle küçük veri setlerinde %15-20 daha yüksek doğruluk sağlar.

# Transfer Learning - VGG16 Base
base_model = VGG16(weights='imagenet', 
                   include_top=False, 
                   input_shape=(32, 32, 3))

# Base modelin katmanlarını dondurma
base_model.trainable = False

# Transfer learning modeli
transfer_model = tf.keras.Sequential([
    base_model,
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.Dense(10, activation='softmax')
])

print("Transfer Learning Model:")
transfer_model.summary()

# Model karşılaştırması
print(f"Özel CNN parametreler: {model.count_params():,}")
print(f"Transfer Learning parametreler: {transfer_model.count_params():,}")

EĞİTİM

Model Eğitimi ve Optimizasyon

Model eğitimi aşamasında doğru optimizer, learning rate ve loss function seçimi kritik önemdedir. Adam optimizer ile 0.001 learning rate genellikle iyi başlangıç değerleridir.

# Early Stopping ve Model Checkpoint
early_stopping = tf.keras.callbacks.EarlyStopping(
    monitor='val_accuracy',
    patience=5,
    restore_best_weights=True
)

model_checkpoint = tf.keras.callbacks.ModelCheckpoint(
    'best_model.h5',
    monitor='val_accuracy',
    save_best_only=True,
    verbose=1
)

# Learning Rate Scheduler
lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.5,
    patience=3,
    min_lr=1e-7,
    verbose=1
)

Model Compilation ve Training

# Model derleme
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# Callback listesi
callbacks = [early_stopping, model_checkpoint, lr_scheduler]

# Model eğitimi
history = model.fit(
    train_generator,
    epochs=50,
    validation_data=val_generator,
    callbacks=callbacks,
    verbose=1
)

# Eğitim sonuçlarını görselleştirme
plt.figure(figsize=(15, 5))

plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Eğitim Doğruluğu')
plt.plot(history.history['val_accuracy'], label='Validasyon Doğruluğu')
plt.title('Model Doğruluğu')
plt.xlabel('Epoch')
plt.ylabel('Doğruluk')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Eğitim Loss')
plt.plot(history.history['val_loss'], label='Validasyon Loss')
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

DEĞERLENDIRME

Performans Değerlendirme ve İyileştirme

Model performansını sadece accuracy ile değil, precision, recall, F1-score ve confusion matrix ile de analiz etmeliyiz. CIFAR-10’da iyi bir model %85+ test accuracy’si sağlar.

Detaylı Performans Analizi

# Test verisi üzerinde tahmin
y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true = np.argmax(y_test_cat, axis=1)

# Confusion Matrix
cm = confusion_matrix(y_true, y_pred_classes)

# Classification Report
print("Sınıf bazlı performans:")
print(classification_report(y_true, y_pred_classes, 
                          target_names=class_names))

# Confusion Matrix Görselleştirme
plt.figure(figsize=(10, 8))
import seaborn as sns
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
           xticklabels=class_names, yticklabels=class_names)
plt.title('Confusion Matrix')
plt.xlabel('Tahmin Edilen')
plt.ylabel('Gerçek')
plt.show()

# En çok karıştırılan sınıflar
max_confusion = np.unravel_index(np.argmax(cm - np.diag(np.diag(cm))), cm.shape)
print(f"En çok karıştırılan: {class_names[max_confusion[0]]} → {class_names[max_confusion[1]]}")

Model İyileştirme Stratejileri

DEPLOYMENT

Model Deployment ve Üretim

Eğitilmiş modeli üretim ortamına taşımak için TensorFlow Serving, Flask API veya TensorFlow Lite kullanabiliriz. Her seçeneğin farklı performans ve kaynak gereksinimleri vardır.

Flask API ile Model Servis

from flask import Flask, request, jsonify
import tensorflow as tf
import numpy as np
from PIL import Image
import io

app = Flask(__name__)

# Model yükleme
model = tf.keras.models.load_model('best_model.h5')
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 
               'dog', 'frog', 'horse', 'ship', 'truck']

@app.route('/predict', methods=['POST'])
def predict():
    try:
        # Dosya kontrolü
        if 'file' not in request.files:
            return jsonify({'error': 'Dosya bulunamadı'}), 400
        
        file = request.files['file']
        if file.filename == '':
            return jsonify({'error': 'Dosya seçilmedi'}), 400
        
        # Görüntü işleme
        image = Image.open(io.BytesIO(file.read()))
        image = image.convert('RGB')
        image = image.resize((32, 32))
        
        # Numpy array'e çevirme ve normalizasyon
        img_array = np.array(image) / 255.0
        img_array = np.expand_dims(img_array, axis=0)
        
        # Tahmin yapma
        predictions = model.predict(img_array)
        predicted_class = np.argmax(predictions[0])
        confidence = float(predictions[0][predicted_class])
        
        return jsonify({
            'predicted_class': class_names[predicted_class],
            'confidence': round(confidence * 100, 2),
            'all_predictions': {
                class_names[i]: round(float(predictions[0][i]) * 100, 2) 
                for i in range(len(class_names))
            }
        })
    
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/health', methods=['GET'])
def health():
    return jsonify({'status': 'healthy', 'model_loaded': True})

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

Docker Container Oluşturma

# Dockerfile
FROM python:3.9-slim

WORKDIR /app

# Sistem bağımlılıkları
RUN apt-get update && apt-get install -y \
    libglib2.0-0 \
    libsm6 \
    libxext6 \
    libxrender-dev \
    libgomp1 \
    && rm -rf /var/lib/apt/lists/*

# Python kütüphaneleri
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Uygulama dosyaları
COPY app.py .
COPY best_model.h5 .

EXPOSE 5000

CMD ["python", "app.py"]

# requirements.txt dosyası
# tensorflow==2.15.0
# flask==2.3.2
# pillow==10.0.0
# numpy==1.24.3

# Docker build ve run komutları
# docker build -t cnn-classifier .
# docker run -p 5000:5000 cnn-classifier