TensorFlow Callbacks: Kapsamlı Bir Rehber

TensorFlow Callbacks: Kapsamlı Bir Rehber

TensorFlow ve Keras, derin öğrenme modellerini eğitmek için güçlü ve esnek bir çerçeve sunar. Model eğitimi, genellikle karmaşık ve zaman alıcı bir süreçtir. Bu süreçte, modelin performansını izlemek, eğitimi belirli koşullara göre ayarlamak veya durdurmak, model ağırlıklarını kaydetmek gibi birçok operasyonel görev ortaya çıkar. İşte tam bu noktada “callbacks” (geri çağırmalar) devreye girer. TensorFlow Callbacks, eğitim döngüsünün belirli aşamalarında (epoch başlangıcı/bitişi, batch başlangıcı/bitişi, eğitim başlangıcı/bitişi gibi) otomatik olarak tetiklenen işlevlerdir. Bu rehberde, TensorFlow Callbacks’in ne olduğunu, neden önemli olduklarını, standart callback’leri ve kendi özel callback’lerinizi nasıl oluşturacağınızı derinlemesine inceleyeceğiz.

Callbacks Nedir ve Neden Önemlidir?

Callbacks, bir modelin eğitim döngüsü sırasında belirli olaylar meydana geldiğinde (örneğin, bir epoch’un sonu, bir batch’in başlangıcı) otomatik olarak yürütülen fonksiyonlardır. Keras API’sinin temel bir parçası olan bu mekanizma, geliştiricilere eğitim sürecini dinamik olarak kontrol etme ve izleme imkanı sunar.

Callbacks’in önemini birkaç maddede özetleyebiliriz:

* Eğitim İzleme ve Görselleştirme: Eğitim metriklerini (doğruluk, kayıp vb.) gerçek zamanlı olarak izlemek ve TensorBoard gibi araçlarla görselleştirmek.
* Model Kaydetme: En iyi performans gösteren model ağırlıklarını veya tüm modeli otomatik olarak kaydetmek.
* Erken Durdurma: Modelin aşırı öğrenmesini (overfitting) önlemek için doğrulama kaybı belirli bir süre iyileşmediğinde eğitimi otomatik olarak durdurmak.
* Öğrenme Oranı Ayarlama: Eğitim ilerledikçe veya belirli metrikler plato çizdiğinde öğrenme oranını dinamik olarak değiştirmek.
* Özel Davranışlar: Standart callback’lerin kapsamadığı özel ihtiyaçlara yönelik fonksiyonellikler eklemek.

Callbacks, model.fit() yöntemine bir liste olarak geçirilir ve eğitim döngüsü boyunca Keras tarafından otomatik olarak yönetilir. Bu sayede, model eğitim kodunun karmaşıklığı artmadan, eğitim süreci üzerinde güçlü bir kontrol sahibi olunur.

Standart TensorFlow Callbacks

TensorFlow, yaygın kullanım senaryolarını kapsayan bir dizi önceden tanımlanmış callback sunar. Bu bölümde, en sık kullanılan standart callback’leri ve bunların nasıl yapılandırılacağını inceleyeceğiz.

tf.keras.callbacks.ModelCheckpoint

ModelCheckpoint callback’i, modelin ağırlıklarını veya tüm modelin yapısını ve ağırlıklarını belirli aralıklarla veya belirli bir metriğe göre en iyi performansı gösterdiğinde kaydetmek için kullanılır. Bu, uzun süreli eğitimlerde modelin ilerlemesini korumak veya dağıtım için en iyi modeli saklamak için kritik öneme sahiptir.

Ana Parametreler:

* filepath: Modelin kaydedileceği dosya yolu. {epoch:02d}-{val_loss:.2f} gibi format dizeleri kullanılabilir.
* monitor: İzlenecek metrik (örn. 'val_loss', 'val_accuracy').
* verbose: Detay seviyesi (0: sessiz, 1: mesaj gösterir).
* save_best_only: True ise, yalnızca izlenen metrikte en iyi performansı gösteren model kaydedilir.
* save_weights_only: True ise, yalnızca modelin ağırlıkları kaydedilir; aksi takdirde tüm model (yapı, optimizatör durumu vb.) kaydedilir.
* mode: 'auto', 'min', 'max'. İzlenen metriğin nasıl değerlendirileceğini belirler. 'min' (örn. kayıp için), 'max' (örn. doğruluk için).
* save_freq: Kaydetme sıklığı. 'epoch' veya batch sayısı olabilir.

Örnek Kullanım:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import numpy as np

Basit bir model oluşturalım
model = Sequential([
    Dense(10, activation='relu', input_shape=(784,)),
    Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

Rastgele veri oluşturalım
x_train = np.random.rand(1000, 784)
y_train = np.random.randint(0, 10, 1000)
x_val = np.random.rand(200, 784)
y_val = np.random.randint(0, 10, 200)

ModelCheckpoint callback'i
checkpoint_filepath = 'model_checkpoints/best_model_epoch_{epoch:02d}_val_loss_{val_loss:.2f}.h5'
model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(
    filepath=checkpoint_filepath,
    monitor='val_loss',
    save_best_only=True,
    mode='min',
    verbose=1
)

Modeli eğitelim
model.fit(x_train, y_train,
          epochs=10,
          validation_data=(x_val, y_val),
          callbacks=[model_checkpoint_callback])

Bu örnek, her epoch sonunda doğrulama kaybı (val_loss) izler ve en iyi doğrulama kaybına sahip modeli kaydeder.

tf.keras.callbacks.EarlyStopping

EarlyStopping callback’i, modelin aşırı öğrenmesini önlemek için kullanılır. Belirli bir metrik (genellikle doğrulama kaybı) belirli bir süre boyunca iyileşmediğinde eğitimi otomatik olarak durdurur. Bu, eğitim süresini optimize etmeye ve daha genellenebilir modeller elde etmeye yardımcı olur.

Ana Parametreler:

* monitor: İzlenecek metrik (örn. 'val_loss', 'val_accuracy').
* min_delta: İzlenen metrikteki mutlak değişim. Bu değişimden daha az bir iyileşme, iyileşme olarak kabul edilmez.
* patience: İzlenen metrik patience sayısı kadar epoch boyunca iyileşmediğinde eğitim durdurulur.
* verbose: Detay seviyesi.
* mode: 'auto', 'min', 'max'.
* baseline: Bu değerin altına düşülmediği veya üzerine çıkılmadığı sürece (mode’a bağlı olarak) eğitim durdurulmaz.
* restore_best_weights: True ise, eğitim durduğunda en iyi epoch’taki model ağırlıkları geri yüklenir.

Örnek Kullanım:

# EarlyStopping callback'i
early_stopping_callback = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss',
    patience=3, # 3 epoch boyunca iyileşme olmazsa durdur
    min_delta=0.001, # En az 0.001'lik bir iyileşme olmalı
    mode='min',
    verbose=1,
    restore_best_weights=True
)

Modeli eğitelim (daha fazla epoch ile, erken durdurmayı test etmek için)
model.fit(x_train, y_train,
          epochs=50, # Yeterince yüksek bir değer veriyoruz
          validation_data=(x_val, y_val),
          callbacks=[model_checkpoint_callback, early_stopping_callback])

Bu örnek, doğrulama kaybı 3 epoch boyunca 0.001’den daha az iyileşirse eğitimi durdurur ve en iyi ağırlıkları geri yükler.

tf.keras.callbacks.ReduceLROnPlateau

ReduceLROnPlateau callback’i, bir metrik (genellikle doğrulama kaybı) belirli bir süre boyunca iyileşmediğinde öğrenme oranını (learning rate) azaltmak için kullanılır. Bu, modelin bir plato çizdiği durumlarda daha küçük adımlarla optimal noktaya yaklaşmasına yardımcı olabilir.

Ana Parametreler:

* monitor: İzlenecek metrik.
* factor: Öğrenme oranının çarpılacağı faktör (örn. 0.1, öğrenme oranını 10 kat azaltır).
* patience: İzlenen metrik patience sayısı kadar epoch boyunca iyileşmediğinde öğrenme oranı azaltılır.
* verbose: Detay seviyesi.
* mode: 'auto', 'min', 'max'.
* min_delta: İzlenen metrikteki mutlak değişim.
* cooldown: Öğrenme oranı azaltıldıktan sonra, tekrar azaltılmadan önce beklenecek epoch sayısı.
* min_lr: Öğrenme oranının düşebileceği minimum değer.

Örnek Kullanım:

# ReduceLROnPlateau callback'i
reduce_lr_callback = tf.keras.callbacks.ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.2, # Öğrenme oranını 5 kat azalt
    patience=2, # 2 epoch boyunca iyileşme olmazsa
    min_delta=0.001,
    mode='min',
    verbose=1,
    min_lr=0.00001 # Minimum öğrenme oranı
)

Modeli eğitelim
model.fit(x_train, y_train,
          epochs=50,
          validation_data=(x_val, y_val),
          callbacks=[early_stopping_callback, reduce_lr_callback])

Bu örnek, doğrulama kaybı 2 epoch boyunca 0.001’den daha az iyileşirse öğrenme oranını 0.2 faktörüyle çarpar.

tf.keras.callbacks.TensorBoard

TensorBoard callback’i, model eğitimi sırasında metrikleri, grafikleri, ağırlık histogramlarını ve diğer görselleştirmeleri TensorBoard arayüzünde görüntülemek için gerekli günlük dosyalarını oluşturur. Bu, eğitim sürecini anlamak ve hata ayıklamak için paha biçilmez bir araçtır.

Ana Parametreler:

* log_dir: Günlük dosyalarının kaydedileceği dizin.
* histogram_freq: Ağırlık ve aktivasyon histogramlarının kaç epoch’ta bir hesaplanıp kaydedileceği. (0 ise kaydedilmez).
* write_graph: True ise modelin hesaplama grafiği kaydedilir.
* write_images: True ise, modelin ilk katmanlarındaki ağırlıkların görsel temsilleri kaydedilir.
* update_freq: Güncelleme sıklığı. 'batch', 'epoch' veya bir tam sayı olabilir (batch sayısı).

TensorBoard’u Başlatma:
Eğitim bittikten veya devam ederken, terminalde tensorboard --logdir path/to/log_dir komutunu çalıştırarak TensorBoard arayüzünü başlatabilirsiniz.

Örnek Kullanım:

import datetime

TensorBoard callback'i
log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir=log_dir,
    histogram_freq=1, # Her epoch'ta ağırlık histogramlarını kaydet
    write_graph=True,
    write_images=False,
    update_freq='epoch'
)

Modeli eğitelim
model.fit(x_train, y_train,
          epochs=10,
          validation_data=(x_val, y_val),
          callbacks=[tensorboard_callback])

Bu, her epoch sonunda TensorBoard’a metrikleri ve histogramları kaydeder.

tf.keras.callbacks.CSVLogger

CSVLogger callback’i, eğitim metriklerini (kayıp, doğruluk, doğrulama kaybı, doğrulama doğruluğu vb.) bir CSV dosyasına kaydetmek için kullanılır. Bu, eğitim geçmişini daha sonra analiz etmek veya başka araçlarla görselleştirmek için kullanışlıdır.

Ana Parametreler:

* filename: CSV dosyasının adı.
* separator: CSV dosyasında kullanılacak ayırıcı (varsayılan ‘,’).
* append: True ise, dosya zaten varsa yeni veriler sona eklenir; aksi takdirde dosya üzerine yazılır.

Örnek Kullanım:

# CSVLogger callback'i
csv_logger_callback = tf.keras.callbacks.CSVLogger(
    'training_log.csv',
    append=True, # Mevcut dosyaya ekle
    separator=';'
)

Modeli eğitelim
model.fit(x_train, y_train,
          epochs=10,
          validation_data=(x_val, y_val),
          callbacks=[csv_logger_callback])

Bu, her epoch sonunda eğitim metriklerini training_log.csv adlı bir dosyaya kaydeder.

tf.keras.callbacks.LambdaCallback

LambdaCallback callback’i, basit ve tek seferlik callback’ler oluşturmak için kullanışlıdır. Eğitim döngüsünün farklı aşamalarında tetiklenecek lambda fonksiyonları tanımlamanıza olanak tanır. Karmaşık durumlar için özel bir callback sınıfı oluşturmak yerine, hızlı prototipleme veya basit görevler için idealdir.

Ana Parametreler:

* on_epoch_begin: Her epoch başlangıcında çağrılacak lambda.
* on_epoch_end: Her epoch sonunda çağrılacak lambda.
* on_batch_begin: Her batch başlangıcında çağrılacak lambda.
* on_batch_end: Her batch sonunda çağrılacak lambda.
* on_train_begin: Eğitimin başlangıcında çağrılacak lambda.
* on_train_end: Eğitimin sonunda çağrılacak lambda.

Her lambda fonksiyonu, çağrıldığı faza bağlı olarak belirli argümanlar alır (örn. epoch, batch, logs).

Örnek Kullanım:

# LambdaCallback örneği
lambda_callback = tf.keras.callbacks.LambdaCallback(
    on_epoch_begin=lambda epoch, logs: print(f"\nEpoch {epoch+1} başlıyor..."),
    on_epoch_end=lambda epoch, logs: print(f"Epoch {epoch+1} bitti. Val Accuracy: {logs['val_accuracy']:.4f}"),
    on_batch_end=lambda batch, logs: print(f"Batch {batch+1} bitti. Loss: {logs['loss']:.4f}", end='\r')
)

Modeli eğitelim
model.fit(x_train, y_train,
          epochs=3,
          validation_data=(x_val, y_val),
          callbacks=[lambda_callback])

Bu örnek, epoch başlangıç ve bitişinde mesajlar yazdırır ve her batch sonunda kayıp değerini günceller.

tf.keras.callbacks.TerminateOnNaN

TerminateOnNaN callback’i, eğitim sırasında bir modelin kaybının veya herhangi bir metrik değerinin NaN (Not a Number) haline gelmesi durumunda eğitimi otomatik olarak durdurur. Bu, modelin kararsız hale geldiğini veya öğrenme oranının çok yüksek olduğunu gösteren bir işarettir ve daha fazla eğitim genellikle anlamsızdır.

Örnek Kullanım:

# TerminateOnNaN callback'i
terminate_on_nan_callback = tf.keras.callbacks.TerminateOnNaN()

Modeli eğitelim
model.fit(x_train, y_train,
          epochs=10,
          validation_data=(x_val, y_val),
          callbacks=[terminate_on_nan_callback])

Bu callback, genellikle diğer callback’lerle birlikte kullanılır ve eğitim kararlılığını sağlamak için bir güvenlik önlemi görevi görür.

Özel Callbacks Oluşturma

Standart callback’ler birçok yaygın senaryoyu kapsasa da, bazen model eğitim sürecine tamamen özelleştirilmiş davranışlar eklemek gerekebilir. TensorFlow, tf.keras.callbacks.Callback sınıfından türeterek kendi özel callback’lerinizi oluşturmanıza olanak tanır.

Neden Özel Callback Oluşturmalıyız?

* Özel Metrikleri Hesaplama ve Kaydetme: Belirli bir metriği (örn. F1 skoru, IoU) her epoch sonunda hesaplayıp kaydetmek.
* Dinamik Hiperparametre Ayarı: Öğrenme oranı dışında başka hiperparametreleri (örn. dropout oranı, optimizatör parametreleri) eğitim sırasında değiştirmek.
* Model Değerlendirme ve Görselleştirme: Eğitim sırasında modelin ara katman çıktılarını veya tahminlerini görselleştirmek.
* Dış Sistemlerle Entegrasyon: Eğitim ilerlemesini bir mesajlaşma uygulamasına göndermek veya bir veritabanına kaydetmek.
* Koşullu İşlemler: Belirli koşullar altında özel bir eylem gerçekleştirmek (örn. belirli bir epoch’tan sonra bir modeli dondurmak/çözmek).

Özel Callback Sınıfı Oluşturma

Özel bir callback oluşturmak için tf.keras.callbacks.Callback sınıfından türetmeli ve ihtiyacınız olan olaylara karşılık gelen yöntemleri geçersiz kılmalısınız. Bu yöntemler, eğitim döngüsünün belirli noktalarında Keras tarafından çağrılır.

Temel Callback Yöntemleri:

* on_train_begin(self, logs=None): Eğitimin başlangıcında çağrılır.
* on_train_end(self, logs=None): Eğitimin sonunda çağrılır.
* on_epoch_begin(self, epoch, logs=None): Her epoch’un başlangıcında çağrılır.
* on_epoch_end(self, epoch, logs=None): Her epoch’un sonunda çağrılır.
* on_batch_begin(self, batch, logs=None): Her batch’in başlangıcında çağrılır.
* on_batch_end(self, batch, logs=None): Her batch’in sonunda çağrılır.
* on_test_begin(self, logs=None), on_test_end(self, logs=None), on_test_batch_begin(self, batch, logs=None), on_test_batch_end(self, batch, logs=None): model.evaluate() için.
* on_predict_begin(self, logs=None), on_predict_end(self, logs=None), on_predict_batch_begin(self, batch, logs=None), on_predict_batch_end(self, batch, logs=None): model.predict() için.

Her yöntemin logs argümanı, o anki eğitim fazına ait metrikleri içeren bir sözlüktür (dictionary). Örneğin, on_epoch_end için logs sözlüğü, loss, accuracy, val_loss, val_accuracy gibi metrikleri içerebilir.

Callback sınıfınız içinde self.model aracılığıyla eğittiğiniz modele erişebilir, self.model.optimizer aracılığıyla optimizatöre ve onun parametrelerine erişebilirsiniz.

Örnek: Öğrenme Oranını Yazdıran Özel Callback

Bu örnek, her epoch sonunda güncel öğrenme oranını yazdıran basit bir özel callback oluşturacaktır.

class LearningRateLogger(tf.keras.callbacks.Callback):
    def on_epoch_begin(self, epoch, logs=None):
        # self.model.optimizer, Keras optimizatör nesnesidir.
        # optimizatörün 'lr' özelliğine erişebiliriz.
        lr = self.model.optimizer.lr
        # Eğer optimizatör bir Schedule kullanıyorsa, lr bir Tensor olabilir.
        # Bu durumda .numpy() ile değerini almamız gerekir.
        if hasattr(lr, 'numpy'):
            lr_value = lr.numpy()
        else:
            lr_value = lr
        print(f"\nEpoch {epoch+1}: Current Learning Rate is {lr_value:.6f}")

Modeli tekrar oluşturalım veya mevcut modeli kullanalım
model = Sequential([
    Dense(10, activation='relu', input_shape=(784,)),
    Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

Özel callback'imizi oluşturalım
lr_logger_callback = LearningRateLogger()

Modeli eğitelim
model.fit(x_train, y_train,
          epochs=5,
          validation_data=(x_val, y_val),
          callbacks=[lr_logger_callback, reduce_lr_callback]) # ReduceLROnPlateau ile birlikte kullanabiliriz

Bu callback, on_epoch_begin yöntemini geçersiz kılarak, her epoch başladığında mevcut öğrenme oranını yazdırır. reduce_lr_callback ile birlikte kullanıldığında, öğrenme oranındaki değişiklikleri gözlemlememizi sağlar.

Daha Karmaşık Bir Örnek: Özel Metrik Hesaplama ve Kaydetme

Diyelim ki, modelin performansını her epoch sonunda F1 skoru ile ölçmek ve bu değeri bir dosyaya kaydetmek istiyoruz. Keras’ın yerleşik metrikleri arasında F1 skoru bulunmayabilir (veya sınıflandırma probleminize özel bir F1 hesaplaması gerekebilir).

from sklearn.metrics import f1_score
import numpy as np

class F1ScoreLogger(tf.keras.callbacks.Callback):
    def __init__(self, validation_data, filepath='f1_scores.csv'):
        super().__init__()
        self.validation_data = validation_data
        self.filepath = filepath
        # Dosyayı başlat ve başlıkları yaz
        with open(self.filepath, 'w') as f:
            f.write('epoch,f1_score\n')

    def on_epoch_end(self, epoch, logs=None):
        x_val, y_val = self.validation_data
        # Modelden tahminler al
        y_pred_probs = self.model.predict(x_val, verbose=0)
        y_pred = np.argmax(y_pred_probs, axis=1)

        # F1 skorunu hesapla
        # average='weighted' kullanıyoruz çünkü dengesiz sınıflar olabilir
        f1 = f1_score(y_val, y_pred, average='weighted')

        # Loglara F1 skorunu ekle (TensorBoard veya diğer callback'ler için)
        logs['val_f1_score'] = f1
        print(f" - val_f1_score: {f1:.4f}")

        # F1 skorunu dosyaya kaydet
        with open(self.filepath, 'a') as f:
            f.write(f'{epoch+1},{f1:.4f}\n')

Modeli tekrar oluşturalım veya mevcut modeli kullanalım
model = Sequential([
    Dense(10, activation='relu', input_shape=(784,)),
    Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

F1ScoreLogger callback'ini oluşturalım
f1_logger_callback = F1ScoreLogger(validation_data=(x_val, y_val), filepath='f1_scores_log.csv')

Modeli eğitelim
model.fit(x_train, y_train,
          epochs=5,
          validation_data=(x_val, y_val),
          callbacks=[f1_logger_callback])

Bu örnek, on_epoch_end yöntemini kullanarak her epoch sonunda doğrulama verileri üzerinde F1 skorunu hesaplar, bunu logs sözlüğüne ekler (böylece diğer callback’ler de bu değere erişebilir) ve ayrı bir CSV dosyasına kaydeder.

Gelişmiş Callback Kullanımı ve En İyi Uygulamalar

Callbacks, eğitim sürecini daha verimli ve kontrol edilebilir hale getirmek için güçlü araçlardır. İşte gelişmiş kullanım senaryoları ve en iyi uygulamalar:

Birden Fazla Callback Kullanımı

model.fit() metoduna birden fazla callback geçirebilirsiniz. Keras, bu callback’leri listenin sırasına göre çağırır. Ancak, çoğu callback’in çağrılma sırası önemli değildir. Örneğin, EarlyStopping ve ModelCheckpoint birlikte sorunsuz çalışır. ReduceLROnPlateau ve EarlyStopping genellikle birlikte kullanılır.

callbacks_list = [
    tf.keras.callbacks.ModelCheckpoint(filepath='best_model.h5', monitor='val_loss', save_best_only=True),
    tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=5),
    tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3),
    tf.keras.callbacks.TensorBoard(log_dir='tensorboard_logs')
]

model.fit(x_train, y_train,
          epochs=100,
          validation_data=(x_val, y_val),
          callbacks=callbacks_list)

Callback’lerde Durum Yönetimi

Özel callback’lerinizde sınıf değişkenlerini kullanarak durum bilgisi saklayabilirsiniz. Örneğin, belirli bir eşiğe ulaşıldığında bir sayacı artırmak veya önceki epoch’lardan gelen metrikleri depolamak isteyebilirsiniz.

class CustomSaver(tf.keras.callbacks.Callback):
    def __init__(self, threshold):
        super().__init__()
        self.threshold = threshold
        self.best_accuracy = 0

    def on_epoch_end(self, epoch, logs=None):
        current_accuracy = logs.get('val_accuracy')
        if current_accuracy is not None and current_accuracy > self.best_accuracy:
            self.best_accuracy = current_accuracy
            if current_accuracy > self.threshold:
                print(f"\nAccuracy {current_accuracy:.4f} eşiği ({self.threshold:.4f}) aştı. Modeli kaydediyorum...")
                self.model.save(f"model_acc_{current_accuracy:.4f}.h5")

custom_saver = CustomSaver(threshold=0.85)
... model.fit(..., callbacks=[custom_saver])

Performans Hususları

Callback’ler, eğitim döngüsüne ek kod eklediği için küçük bir performans yükü getirebilir. Özellikle on_batch_end gibi sık çağrılan yöntemlerde karmaşık hesaplamalar yapmak, eğitimi yavaşlatabilir. Performans kritikse, hesaplamaları on_epoch_end gibi daha seyrek çağrılan yöntemlere taşımayı düşünün. TensorBoard callback’inde histogram_freq parametresini çok sık ayarlamak da performans üzerinde etkili olabilir.

Hata Ayıklama

Callback’lerinizde hata ayıklarken, print() ifadeleri kullanmak veya bir hata ayıklayıcı (debugger) eklemek faydalı olabilir. logs sözlüğünün içeriğini anlamak, callback’lerinizin doğru verilere eriştiğinden emin olmak için önemlidir.

Callback’leri model.evaluate() ve model.predict() ile Kullanma

Callbacks sadece model.fit() ile değil, aynı zamanda model.evaluate() ve model.predict() ile de kullanılabilir. Bu, değerlendirme veya tahmin süreçlerini izlemek veya belirli işlemler yapmak için yararlı olabilir. Örneğin, on_test_end veya on_predict_batch_end yöntemlerini geçersiz kılarak bu işlemlere müdahale edebilirsiniz.

class PredictionLogger(tf.keras.callbacks.Callback):
    def on_predict_batch_end(self, batch, logs=None):
        # logs sözlüğü 'outputs' anahtarını içerebilir
        print(f"Predict batch {batch}: outputs shape {logs['outputs'].shape}")

prediction_logger = PredictionLogger()
predictions = model.predict(x_test, callbacks=[prediction_logger])

Sonuç

TensorFlow Callbacks, derin öğrenme model eğitimi sürecini yönetmek, izlemek ve optimize etmek için vazgeçilmez bir araçtır. ModelCheckpoint ile en iyi modellerinizi kaydetmek, EarlyStopping ile aşırı öğrenmeyi önlemek, ReduceLROnPlateau ile öğrenme oranını dinamik olarak ayarlamak ve TensorBoard ile eğitimi görselleştirmek gibi standart işlevler, her veri bilimcinin araç kutusunda bulunmalıdır.

Daha da önemlisi, tf.keras.callbacks.Callback sınıfından türeterek kendi özel callback’lerinizi oluşturma yeteneği, TensorFlow’un esnekliğini doruklara taşır. Bu sayede, projenizin benzersiz gereksinimlerine uygun, tamamen özelleştirilmiş davranışlar ekleyebilirsiniz. Callback’leri etkili bir şekilde kullanarak, daha sağlam, verimli ve genellenebilir derin öğrenme modelleri geliştirebilirsiniz. Bu rehber, callback’lerin temel prensiplerini anlamanıza ve kendi projelerinizde bunları etkin bir şekilde kullanmaya başlamanıza yardımcı olmayı amaçlamıştır.