Keras Subclassing API ile Derin Öğrenme Modelleri Kurma

TensorFlow & Keras ile kompleks derin öğrenme modelleri nasıl kurulur?

Freepik

Geçen yazımda Subclassing API yaklaşımı ile esnek bir katman nasıl oluşturulur anlatmıştım. Bu makalede bir adım daha ileri atacağız ve bu yöntem ile nasıl model kuracağımızı göreceğiz.

Sequential API ve Functional API ile model kurmak kolaydır ama bu yöntemler ile kompleks modeller oluşturmak zordur. İleri düzey derin öğrenme modelleri kurmak için Subclassing API kullanmak daha iyi bir fikir.

Keras ile Bir Sinir Ağı İnşa Etmek için 3 Yöntem

Bunu göstermek için bir regresyon problemini ele alalım. Bunun için geçen derslerde kullandığımız California Housing veri setini kullanalım. Bu veri seti California’daki ev fiyatlarını ve bu evlerin özelliklerini gösteriyor.

Yapay zekaya ilginiz varsa TensorFlow ve Keras ile derin öğrenme Udemy kursumuzu inceleyebilirsiniz.

Hadi veri setini yüklemek ile başlayalım.

Veri Setini Yükleme

Öncelikle fetch_california_housing fonksiyonunu ile veri setimizi import edelim.

from sklearn.datasets import fetch_california_housing
housing = fetch_california_housing()

Tamam veri setini housing değişkenine atadık. Hadi veri ön işleme aşamasına geçelim.

Veri Ön İşleme

Veri ön işleme veri analizinin önemli aşamalarından biridir. Unutmayın ne kadar iyi veriniz varsa o kadar iyi model kurabilirsiniz. Öncelikle veri setimizi eğitim, validasyon ve test şeklinde parçalayalım. Eğitim verileri ile model kurulur, validasyon verileri ile hiperparametre ayarı yapılır ve test verileri ile model test edilir. Hadi veri setini parçalamak için Scikit-Learn’ deki train_test_split fonksiyonunu kullanalım.

from sklearn.model_selection import train_test_split

X_train_full, X_test, y_train_full, y_test = train_test_split(
      housing.data, housing.target, random_state=42)

X_train, X_valid, y_train, y_valid = train_test_split(
      X_train_full, y_train_full, random_state=42)

Tamam, böylece veri setlerimizi oluşturduk. Artık model kurma aşamasına geçebiliriz.

Model Kurma

Bu bölümde Subclassing API ile nasıl model kurulacağını göstereceğim. Öncelikle TensorFlow ve Keras’ı import edelim.

import tensorflow as tf
from tensorflow import keras

Subclassing yönteminde, constructor ’da katmanları tanımlanır ve call metodunda sinir ağı inşa edilir. Şimdi bir mimari ele alalım:

Oluşturacağımız Model Mimarisi

İki girdisi ve bir çıktısı olan bir model kurmak isteyelim. Bunun için bir sınıf oluşturalım. Geçen derste anlattığım gibi esnek bir katman oluştururken keras.layer.Layer sınıfından miras alıyorduk. Model kurarken keras.Model sınıfından miras alacağız. Miras almak demek kalıtım almak demek. Bu yöntem, bir üst sınıfın tüm değişken ve metotlarını başka bir sınıfın içinde kullanmamızı sağlar.

class WideAndDeepModel(tf.keras.Model):
    def __init__(self, units=30, activation="relu", **kwargs):
        super().__init__(**kwargs) 
        self.norm_layer_wide = tf.keras.layers.Normalization()
        self.norm_layer_deep = tf.keras.layers.Normalization()
        self.hidden1 = tf.keras.layers.Dense(units, activation=activation)
        self.hidden2 = tf.keras.layers.Dense(units, activation=activation)
        self.main_output = tf.keras.layers.Dense(1)    
    def call(self, inputs):
        input_wide, input_deep = inputs
        norm_wide = self.norm_layer_wide(input_wide)
        norm_deep = self.norm_layer_deep(input_deep)
        hidden1 = self.hidden1(norm_deep)
        hidden2 = self.hidden2(hidden1)
        concat = tf.keras.layers.concatenate([norm_wide, hidden2])
        output = self.main_output(concat)
        return output

Harika, böylece modelimizin mimarisini oluşturduk. Şimdi modelden bir örnek alalım. Öncelikle sizin de benim ürettiğim sonuçları bulmanız için set_seed metodunu kullanalım ve ardından örneğimizi oluşturalım.

tf.random.set_seed(42)
model = WideAndDeepModel(30, activation="relu", name="my_model")

Tamam böylece modelden bir örnek aldık. Şimdi modeli compile edelim. Bu aşamada modelde kullanacağımız loss, optimizer ve metriği belirleyeceğiz. Optimizer olarak genelde kullanılan Adam’ı kullanalım.

optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
model.compile(loss="mse", optimizer=optimizer, 
              metrics=["RootMeanSquaredError"])

Tamam böylece modelimizi compile ettik. Modelimizde iki girdi var değil mi? Şimdi bu girdileri oluşturalım. Önce eğitim için girdileri oluşturalım. Toplamda 7 girdi değişkenimiz var. Bunlardan ilk 5 öznitelik wide girdi son 5 öznitelikte deep girdisi olsun.

X_train_wide, X_train_deep = X_train[:, :5], X_train[:, 2:]
X_valid_wide, X_valid_deep = X_valid[:, :5], X_valid[:, 2:]
X_test_wide, X_test_deep = X_test[:, :5], X_test[:, 2:]

Tamam model için girdi verilerimizi oluşturduk. Şimdi model eğitim aşamasına geçelim.

Model Eğitim

Modeli eğitmeden önce modelin normalleştirme katmanı için adapt metodunu kullanmamız gerekiyor. Bu metot ne yapıyordu? Eğitim verilerinden ortalama ve varyans gibi istatistikleri öğreniyordu. Daha sonra bu istatistikler test verileri için kullanılıyordu. Öncelikle girdi verilerini adapt metodu ile veri ön işleme yapalım. Her iki girdinin de ayrı ayrı istatistikleri olacağı için bu metodu ikisi içinde kullanalım.

model.norm_layer_wide.adapt(X_train_wide)
model.norm_layer_deep.adapt(X_train_deep)

Tamam, artık fit metodunu çağırıp eğitime başlayabiliriz.

history = model.fit((X_train_wide, X_train_deep),
                    y_train,
                    validation_data=((X_valid_wide, X_valid_deep), y_valid),
                    epochs=10)

Modelin eğitim ve validasyon verileri için loss ve metrik değerlerini burada görebilirsiniz. Tamam böylece modelimizi eğittik. Hiperparametreleri ayarlayarak modelin performansını arttırabiliriz ama bu yazı, Keras’ı öğrenmeye yönelik olduğu için şimdilik bu değerler ile çok uğraşmayalım. Şimdi modeli test verisini kullanarak değerlendirelim.

eval_results = model.evaluate((X_test_wide, X_test_deep), (y_test, y_test))
eval_results

# Output:
loss: 0.3589 - root_mean_squared_error: 0.5991

Modelimizin test verisi üzerindeki loss ve metrik değerlerini burada görebilirsiniz.

Yeni Verileri Tahmin Etme

Şimdi bir adım daha ileri atalım ve modelimizin yeni verileri nasıl tahmin ettiğine bakalım. Öncelikle test verisinden bir kaç örnek alalım.

X_new_wide, X_new_deep = X_test_wide[:3], X_test_deep[:3]

Tamam elimizde örnek veriler var. Şimdi modelimizi kullanarak bu verilerin etiketlerini tahmin edelim. Bunun için predict metodunu çağıracağız.

y_pred= model.predict((X_new_wide, X_new_deep))
y_pred

# Output:
1/1 [==============================] - 0s 113ms/step
array([[0.4832632],
       [1.6469457],
       [3.5325484]], dtype=float32)

Modelin tahmin ettiği değer bunlar. Şimdi gerçek değerlere bakalım.

y_test[:3]

# Output:
array([0.477  , 0.458  , 5.00001])

Gerçek etiketlerde bu değerler. Tahminleri dediğim gibi daha iyi hale getirebiliriz. Bu yazıda Subclassing API ile nasıl bir derin öğrenme model kuracağınızı anlattım.

Son Sözler

Sonuç olarak kompleks modeller kurmak için en iyi yol Subclassing yöntemi. Bu yöntemin Functional API ile arasındaki en büyük fark call metodunu kullanmak. Bu yöntem içinde for döngüsü ya da if ifadesi kullanabiliriz. Dolayısıyla araştırma yapmak, yeni deneyler tasarlamak için Subclassing yöntemi idealdir.

Bu yazıda anlattıklarımı daha ayrıntılı olarak görmek için aşağıdaki videoyu izleyebilirsiniz.

Bu derste kullandığım notebook’a buradan ulaşabilirsiniz. Aşağıdaki yazılarda dikkatinizi çekebilir.

Derin Öğrenme Yol Haritası

Yapay Zekada Yeni Devrim: GPT-4

Bir yazının daha sonuna geldik. Yazıyı okuduğunuz için teşekkür ederim. Yazı hoşunuza gittiyse aşağıdaki alkış simgesine bir kaç kez tıklamayı unutmayın. Gelecek makalelerde görüşmek üzere. Şimdilik hoşça kalın.

Hadi bağlanalım: YouTube | Udemy | Twitter | Instagram | LinkedIn.