TensorFlow ile Model Eğitimi: Veri Hazırlama, Eğitim ve Değerlendirme

import tensorflow as tf
import numpy as np

# Veri yükleme fonksiyonu
def veri_yukle_ve_isle(goruntu_yolu, etiket):
    """Görüntüyü diskten yükle ve ön işle."""
    goruntu = tf.io.read_file(goruntu_yolu)
    goruntu = tf.image.decode_jpeg(goruntu, channels=3)
    goruntu = tf.image.resize(goruntu, [224, 224])
    goruntu = tf.cast(goruntu, tf.float32) / 255.0
    # ImageNet ortalamasıyla normalize et
    ortalama = tf.constant([0.485, 0.456, 0.406])
    std = tf.constant([0.229, 0.224, 0.225])
    goruntu = (goruntu - ortalama) / std
    return goruntu, etiket

# Veri artırma fonksiyonu
def veri_artir(goruntu, etiket):
    """Eğitim verisi için rastgele dönüşümler uygula."""
    goruntu = tf.image.random_flip_left_right(goruntu)
    goruntu = tf.image.random_brightness(goruntu, 0.2)
    goruntu = tf.image.random_contrast(goruntu, 0.8, 1.2)
    goruntu = tf.image.random_saturation(goruntu, 0.8, 1.2)
    return goruntu, etiket

# Performanslı veri pipeline'ı
def pipeline_olustur(dosya_yollari, etiketler, batch_boyutu=32, egitim=True):
    """Optimize edilmiş tf.data pipeline'ı oluştur."""
    ds = tf.data.Dataset.from_tensor_slices((dosya_yollari, etiketler))

    if egitim:
        ds = ds.shuffle(buffer_size=10000, seed=42)

    ds = ds.map(veri_yukle_ve_isle, num_parallel_calls=tf.data.AUTOTUNE)

    if egitim:
        ds = ds.map(veri_artir, num_parallel_calls=tf.data.AUTOTUNE)

    ds = ds.batch(batch_boyutu)
    ds = ds.prefetch(tf.data.AUTOTUNE)
    return ds

from tensorflow.keras import layers, models, optimizers

def model_olustur(sinif_sayisi, ogrenme_hizi=0.001):
    """Transfer learning tabanlı sınıflandırma modeli oluştur."""
    # Önceden eğitilmiş backbone
    backbone = tf.keras.applications.EfficientNetV2S(
        include_top=False,
        weights='imagenet',
        input_shape=(224, 224, 3)
    )
    backbone.trainable = False  # Backbone'u dondur

    # Model mimarisi
    girdiler = layers.Input(shape=(224, 224, 3))
    x = backbone(girdiler, training=False)
    x = layers.GlobalAveragePooling2D()(x)
    x = layers.BatchNormalization()(x)
    x = layers.Dense(512, activation='relu')(x)
    x = layers.Dropout(0.4)(x)
    x = layers.Dense(256, activation='relu')(x)
    x = layers.Dropout(0.3)(x)
    ciktilar = layers.Dense(sinif_sayisi, activation='softmax')(x)

    model = models.Model(inputs=girdiler, outputs=ciktilar)

    # Model derleme
    model.compile(
        optimizer=optimizers.Adam(learning_rate=ogrenme_hizi),
        loss='sparse_categorical_crossentropy',
        metrics=[
            'accuracy',
            tf.keras.metrics.TopKCategoricalAccuracy(k=5, name='top5_accuracy')
        ]
    )

    return model

model = model_olustur(sinif_sayisi=100)
model.summary()

import os
from datetime import datetime

# Log dizini
log_dizini = os.path.join("logs", datetime.now().strftime("%Y%m%d-%H%M%S"))

# Callback listesi
callbacks = [
    # Erken durdurma: val_loss 7 epoch boyunca iyileşmezse dur
    tf.keras.callbacks.EarlyStopping(
        monitor='val_loss',
        patience=7,
        restore_best_weights=True,
        verbose=1
    ),

    # Öğrenme hızı azaltma: val_loss 3 epoch iyileşmezse yarıya indir
    tf.keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss',
        factor=0.5,
        patience=3,
        min_lr=1e-7,
        verbose=1
    ),

    # En iyi modeli kaydet
    tf.keras.callbacks.ModelCheckpoint(
        filepath='en_iyi_model.keras',
        monitor='val_accuracy',
        save_best_only=True,
        verbose=1
    ),

    # TensorBoard logları
    tf.keras.callbacks.TensorBoard(
        log_dir=log_dizini,
        histogram_freq=1,
        write_graph=True
    ),

    # CSV log
    tf.keras.callbacks.CSVLogger('egitim_log.csv')
]

# Aşama 1: Sadece sınıflandırma katmanlarını eğit
print("Aşama 1: Sınıflandırma katmanları eğitimi")
gecmis_1 = model.fit(
    egitim_ds,
    epochs=20,
    validation_data=dogrulama_ds,
    callbacks=callbacks,
    verbose=1
)

# Aşama 2: Fine-tuning — backbone'un son katmanlarını aç
print("\nAşama 2: Fine-tuning")
backbone = model.layers[1]
backbone.trainable = True

# Son 30 katman hariç tümünü dondur
for layer in backbone.layers[:-30]:
    layer.trainable = False

# Düşük öğrenme hızıyla yeniden derle
model.compile(
    optimizer=optimizers.Adam(learning_rate=1e-5),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

gecmis_2 = model.fit(
    egitim_ds,
    epochs=30,
    validation_data=dogrulama_ds,
    callbacks=callbacks,
    verbose=1
)

# Özel eğitim döngüsü
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
kayip_fn = tf.keras.losses.SparseCategoricalCrossentropy()
egitim_dogruluk = tf.keras.metrics.SparseCategoricalAccuracy()
dogrulama_dogruluk = tf.keras.metrics.SparseCategoricalAccuracy()

@tf.function  # Performans için grafik moduna derle
def egitim_adimi(goruntuler, etiketler):
    """Tek bir eğitim adımı."""
    with tf.GradientTape() as tape:
        tahminler = model(goruntuler, training=True)
        kayip = kayip_fn(etiketler, tahminler)
        # L2 regularizasyon kaybını ekle
        toplam_kayip = kayip + tf.add_n(model.losses) if model.losses else kayip

    # Gradyanları hesapla ve uygula
    gradyanlar = tape.gradient(toplam_kayip, model.trainable_variables)
    # Gradyan kırpma (gradient clipping) ile kararsızlığı önle
    gradyanlar = [tf.clip_by_norm(g, 1.0) for g in gradyanlar]
    optimizer.apply_gradients(zip(gradyanlar, model.trainable_variables))

    egitim_dogruluk.update_state(etiketler, tahminler)
    return toplam_kayip

@tf.function
def dogrulama_adimi(goruntuler, etiketler):
    """Tek bir doğrulama adımı."""
    tahminler = model(goruntuler, training=False)
    kayip = kayip_fn(etiketler, tahminler)
    dogrulama_dogruluk.update_state(etiketler, tahminler)
    return kayip

# Eğitim döngüsü
EPOCH_SAYISI = 30
en_iyi_dogruluk = 0.0

for epoch in range(EPOCH_SAYISI):
    egitim_dogruluk.reset_state()
    dogrulama_dogruluk.reset_state()

    # Eğitim
    for batch_goruntuler, batch_etiketler in egitim_ds:
        kayip = egitim_adimi(batch_goruntuler, batch_etiketler)

    # Doğrulama
    for batch_goruntuler, batch_etiketler in dogrulama_ds:
        dogrulama_adimi(batch_goruntuler, batch_etiketler)

    print(f"Epoch {epoch+1}/{EPOCH_SAYISI} - "
          f"Eğitim Doğruluk: {egitim_dogruluk.result():.4f} - "
          f"Doğrulama Doğruluk: {dogrulama_dogruluk.result():.4f}")

    # En iyi modeli kaydet
    if dogrulama_dogruluk.result() > en_iyi_dogruluk:
        en_iyi_dogruluk = dogrulama_dogruluk.result()
        model.save_weights('en_iyi_agirliklar.weights.h5')

# Karışık hassasiyetli eğitimi etkinleştir
tf.keras.mixed_precision.set_global_policy('mixed_float16')

# Model oluştururken son katmana dikkat: softmax FP32 olmalı
girdiler = layers.Input(shape=(224, 224, 3))
x = backbone(girdiler, training=False)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(512, activation='relu')(x)
x = layers.Dropout(0.4)(x)
# Son katmanı FP32'de tut (sayısal kararlılık için)
ciktilar = layers.Dense(sinif_sayisi, activation='softmax', dtype='float32')(x)

model_mp = models.Model(inputs=girdiler, outputs=ciktilar)

# Optimizer'ı loss scaling ile kullan
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)

model_mp.compile(
    optimizer=optimizer,
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

print(f"Hesaplama politikası: {tf.keras.mixed_precision.global_policy()}")

import matplotlib.pyplot as plt

def egitim_grafikleri(gecmis):
    """Eğitim ve doğrulama metriklerini çiz."""
    fig, axes = plt.subplots(1, 2, figsize=(14, 5))

    # Doğruluk grafiği
    axes[0].plot(gecmis.history['accuracy'], label='Eğitim')
    axes[0].plot(gecmis.history['val_accuracy'], label='Doğrulama')
    axes[0].set_title('Model Doğruluğu')
    axes[0].set_xlabel('Epoch')
    axes[0].set_ylabel('Doğruluk')
    axes[0].legend()
    axes[0].grid(True)

    # Kayıp grafiği
    axes[1].plot(gecmis.history['loss'], label='Eğitim')
    axes[1].plot(gecmis.history['val_loss'], label='Doğrulama')
    axes[1].set_title('Model Kaybı')
    axes[1].set_xlabel('Epoch')
    axes[1].set_ylabel('Kayıp')
    axes[1].legend()
    axes[1].grid(True)

    plt.tight_layout()
    plt.savefig('egitim_grafikleri.png', dpi=150)
    plt.show()

tensorboard --logdir logs --port 6006

# Keras formatında kaydetme
model.save('son_model.keras')

# TensorFlow SavedModel formatında kaydetme (serving için)
model.save('saved_model/my_model')

# TFLite'a dönüştürme — dinamik aralık kuantizasyonu
converter = tf.lite.TFLiteConverter.from_saved_model('saved_model/my_model')
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()
with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

# Tam tam sayı kuantizasyonu (full integer quantization)
def temsilci_veri_seti():
    """Kalibrasyon için temsili veri seti üret."""
    for i in range(100):
        veri = np.random.rand(1, 224, 224, 3).astype(np.float32)
        yield [veri]

converter_int8 = tf.lite.TFLiteConverter.from_saved_model('saved_model/my_model')
converter_int8.optimizations = [tf.lite.Optimize.DEFAULT]
converter_int8.representative_dataset = temsilci_veri_seti
converter_int8.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter_int8.inference_input_type = tf.uint8
converter_int8.inference_output_type = tf.uint8

tflite_int8_model = converter_int8.convert()
with open('model_int8.tflite', 'wb') as f:
    f.write(tflite_int8_model)

print(f"Orijinal model: {os.path.getsize('model.tflite') / 1024:.1f} KB")
print(f"INT8 model: {os.path.getsize('model_int8.tflite') / 1024:.1f} KB")