PyGAD ile Genetik Algoritmayı Kullanarak Keras Modelleri Nasıl Eğitilir
PyGAD, genetik algoritma oluşturmak ve makine öğrenimi algoritmalarını eğitmek için kullanılan açık kaynaklı bir Python kitaplığıdır. Genetik algoritmayı farklı problem türleri ile çalışacak şekilde özelleştirmek için çok çeşitli parametreler sunar.
PyGAD, sinir ağları (NN’ler) ve evrişimli sinir ağları (CNN’ler) oluşturmayı ve eğitmeyi destekleyen kendi modüllerine sahiptir. Bu modüllerin iyi çalışmasına rağmen, herhangi bir ek optimizasyon önlemi olmaksızın Python’da uygulanırlar. Bu, basit problemler için bile nispeten yüksek hesaplama sürelerine yol açar.
En son PyGAD sürümü 2.8.0 (20 Eylül 2020'de piyasaya sürüldü), Keras modellerini eğitmek için yeni bir modülü destekliyor. Keras Python’da oluşturulmuş olsa da hızlıdır. Bunun nedeni, Keras’ın arka uç olarak TensorFlow kullanması ve TensorFlow’un oldukça optimize edilmiş olmasıdır.
Bu öğreticide, PyGAD kullanılarak Keras modellerinin nasıl eğitileceği anlatılmaktadır. Tartışma, Sıralı Modeli veya İşlevsel API’yi kullanarak Keras modellerini oluşturmayı, Keras model parametrelerinin ilk popülasyonunu oluşturmayı, uygun bir uygunluk işlevi oluşturmayı ve daha fazlasını içerir.
Ayrıca bu öğreticideki kodu takip edebilir ve ML Showcase’den bir Gradient Topluluk Not Defterinde ücretsiz olarak çalıştırabilirsiniz . Tam eğitim taslağı aşağıdaki gibidir:
- PyGAD ile başlarken
pygad.kerasgamodül- PyGAD kullanarak Keras modelini eğitme adımları
- Problem türünü belirleme
- Bir Keras modeli oluşturma
pygad.kerasga.KerasGASınıfı örnekleme- Eğitim verilerinin hazırlanması
- Kayıp işlevi
- Fitness fonksiyonu
- Nesil geri arama işlevi (isteğe bağlı)
pygad.GASınıfın bir örneğini oluşturma- Genetik algoritmayı çalıştırmak
- Fitness ve nesil arsası
- Eğitilen model hakkında istatistikler
- Regresyon için eksiksiz kod
- Bir CNN kullanarak sınıflandırma için eksiksiz kod
Başlayalım.
Bu projeyi hayata geçirin
PyGAD ile Başlarken
Bu eğiticiye başlamak için PyGAD’i kurmak çok önemlidir. Zaten PyGAD yüklediyseniz, __version__en azından PyGAD 2.8.0'ın kurulu olduğundan emin olmak için özniteliği kontrol edin .
import pygadprint(pygad.__version__)
PyGAD, PyPI (Python Paket Dizini) üzerinde mevcuttur ve yükleyici kullanılarak pipyüklenebilir. Halihazırda PyGAD kurulu değilse, PyGAD 2.8.0 veya üstünü kurduğunuzdan emin olun.
pip install pygad>=2.8.0PyGAD belgelerini, bazı örnek problemler de dahil olmak üzere Dokümanları Oku bölümünde bulabilirsiniz . Aşağıda basit bir problemin nasıl çözüleceğine, yani doğrusal bir modelin parametrelerinin optimize edilmesine bir örnek verilmiştir.
import pygad
import numpyfunction_inputs = [4,-2,3.5,5,-11,-4.7]
desired_output = 44 def fitness_func(solution, solution_idx):
output = numpy.sum(solution*function_inputs)
fitness = 1.0 / (numpy.abs(output - desired_output) + 0.000001)
return fitnessnum_generations = 100
num_parents_mating = 10
sol_per_pop = 20
num_genes = len(function_inputs)ga_instance = pygad.GA(num_generations=num_generations,
num_parents_mating=num_parents_mating,
fitness_func=fitness_func,
sol_per_pop=sol_per_pop,
num_genes=num_genes)ga_instance.run()ga_instance.plot_result()
pygad.kerasga Modül
PyGAD 2.8.0'dan başlayarak, adlı yeni bir modül kerasgatanıtıldı. Adını kısaltmasıdır Keras G enetic bir lgorithm. Modül aşağıdaki işlevleri sunar:
KerasGASınıfı kullanarak ilk çözüm popülasyonunu oluşturun . Her çözüm, Keras modeli için tüm parametreleri içerir.model_weights_as_vector()İşlevi kullanarak Keras modelinin parametrelerini bir kromozom (yani 1-D vektör) olarak temsil edin .model_weights_as_matrix()Fonksiyonu kullanarak Keras modelinin parametrelerini kromozomdan geri yükleyin .
pygad.kerasgaModül adında bir sınıf vardır KerasGA. Bu sınıfın kurucusu iki parametre kabul eder:
model: Keras modeli.num_solutions: Popülasyondaki çözüm sayısı.
Bu iki parametreye bağlı olarak, pygad.kerasga.KerasGAsınıf 3 örnek niteliği oluşturur:
model: Keras modeline bir referans.num_solutions: Popülasyondaki çözüm sayısı.population_weights: Model parametrelerini tutan iç içe geçmiş bir liste. Bu liste her nesilden sonra güncellenir.
Keras modelinin modeldeğişkene kaydedildiğini varsayarsak, aşağıdaki kod KerasGAsınıfın bir örneğini oluşturur ve onu keras_gadeğişkene kaydeder . num_solutionsBağımsız değişken popülasyon 10 çözümleri sahip olduğu anlamına gelir değeri 10 atanır.
Yapıcı, num_solutionsbağımsız değişkenin değerine eşit bir uzunluk listesi oluşturur . Listedeki her öğe, model_weights_as_vector()işlev kullanılarak 1 boyutlu bir vektöre dönüştürüldükten sonra modelin parametreleri için farklı değerler tutar .
KerasGASınıfın örneğine bağlı olarak , ilk popülasyon population_weightsöznitelikten döndürülebilir . Modelin 60 parametreye sahip olduğunu ve 10 çözüm olduğunu varsayarsak, ilk popülasyonun şekli olur 10x60.
import pygad.kerasgakeras_ga = pygad.kerasga.KerasGA(model=model,
num_solutions=10)initial_population = keras_ga.population_weights
Sonraki bölüm PyGAD kullanarak bir Keras modelini eğitme adımlarını özetlemektedir. Bu adımların her biri daha ayrıntılı olarak tartışılacaktır.
PyGAD Kullanarak Keras Modeli Eğitmek İçin Adımlar
PyGAD kullanarak bir Keras modelini eğitmenin adımları şu şekilde özetlenmiştir:
- Problem Türünü Belirleme
- Keras Modeli Oluşturma
pygad.kerasga.KerasGASınıfı Örneklemek- Eğitim Verilerinin Hazırlanması
- Kayıp İşlevi
- Fitness fonksiyonu
- Nesil Geri Arama İşlevi (İsteğe Bağlı)
pygad.GASınıfın Bir Örneğini Oluşturma- Genetik Algoritmayı Çalıştırmak
Sonraki bölümlerde bu adımların her biri ele alınmaktadır.
Problem Türünü Belirleme
Problem türü (sınıflandırma veya regresyon) aşağıdakilerin belirlenmesine yardımcı olur:
- Kayıp işlevi (uygunluk işlevini oluşturmak için kullanılır)
- Keras modelindeki çıktı katmanı
- Eğitim verileri
Bir regresyon problemi için, kayıp fonksiyonu ortalama mutlak hata, ortalama kare hata veya burada listelenen başka bir fonksiyon olabilir .
Bir sınıflandırma problemi için kayıp fonksiyonu ikili çapraz entropi (ikili sınıflandırma için), kategorik çapraz entropi (çok sınıflı problemler için) veya bu sayfada listelendiği gibi başka bir fonksiyon olabilir .
Çıktı katmanındaki etkinleştirme işlevi, sorunun sınıflandırma mı yoksa gerileme mi olduğuna bağlı olarak farklılık gösterir. Bir sınıflandırma problemi için, regresyon için doğrusal ile karşılaştırıldığında softmax olabilir .
Çıktıya gelince, bir regresyon problemi için çıktı, sınıflandırma problemleri için bir sınıf etiketine kıyasla sürekli bir fonksiyon olacaktır.
Özetle, eğitim verilerinin ve kayıp işlevinin doğru seçilmesi için problemin türünü önceden belirlemek çok önemlidir.
Keras Modeli Oluşturma
Bir Keras modeli oluşturmanın 3 yolu vardır:
PyGAD, hem Sıralı Model hem de Fonksiyonel API kullanarak bir Keras modeli oluşturmayı destekler.
Sıralı Model
Keras kullanarak Sıralı Model oluşturmak için, tensorflow.keras.layersmodülü kullanarak her katmanı oluşturmanız yeterlidir . Ardından tensorflow.keras.Sequentialsınıfın bir örneğini oluşturun . Son olarak, add()katmanları modele eklemek için yöntemi kullanın.
import tensorflow.kerasinput_layer = tensorflow.keras.layers.Input(3)
dense_layer1 = tensorflow.keras.layers.Dense(5, activation="relu")
output_layer = tensorflow.keras.layers.Dense(1, activation="linear")model = tensorflow.keras.Sequential()
model.add(input_layer)
model.add(dense_layer1)
model.add(output_layer)
Çıktı katmanının aktivasyon fonksiyonunun linear, bunun bir regresyon problemi olduğu anlamına geldiğine dikkat edin. Bir sınıflandırma problemi için aktivasyon işlevi olabilir softmax. Bir sonraki satırda çıktı katmanı 2 nörona sahiptir (her sınıf için 1) ve softmaxaktivasyon fonksiyonunu kullanır .
output_layer = tensorflow.keras.layers.Dense(2, activation="linear")Fonksiyonel API
Fonksiyonel API durumu için, her katman normal olarak oluşturulur (Sıralı Model oluştururken yukarıda gördüğümüz gibi). Giriş katmanı dışında, sonraki her katman, önceki katmanı bir argüman olarak kabul eden bir işlev olarak kullanılır. Son olarak tensorflow.keras.Model, girdi ve çıktı katmanlarını bağımsız değişken olarak kabul eden bir sınıf örneği oluşturulur.
input_layer = tensorflow.keras.layers.Input(3)
dense_layer1 = tensorflow.keras.layers.Dense(5, activation="relu")(input_layer)
output_layer = tensorflow.keras.layers.Dense(1, activation="linear")(dense_layer1)model = tensorflow.keras.Model(inputs=input_layer, outputs=output_layer)
Keras modeli oluşturulduktan sonraki adım, KerasGAsınıfı kullanarak Keras modeli parametrelerinin ilk popülasyonunu oluşturmaktır .
pygad.kerasga.KerasGASınıfı Örnekleyin
pygad.kerasga.KerasGASınıfın bir örneğini oluşturarak , Keras modelinin parametrelerinin ilk popülasyonu oluşturulur. Sonraki kod, önceki bölümde oluşturulan Keras modelini sınıf yapıcısının modelbağımsız değişkenine iletir KerasGA.
import pygad.kerasgakeras_ga = pygad.kerasga.KerasGA(model=model,
num_solutions=10)
Sonraki bölüm, Keras modelini eğitmek için kullanılan eğitim verilerini oluşturur.
Egzersiz Verilerini Hazırlayın
Sorunun türüne (sınıflandırma veya regresyon) göre eğitim verileri hazırlanır.
1 çıktılı bir regresyon problemi için, her örneğin 3 girdiye sahip olduğu rastgele oluşturulmuş bazı eğitim verileri burada verilmiştir.
# Data inputs
data_inputs = numpy.array([[0.02, 0.1, 0.15],
[0.7, 0.6, 0.8],
[1.5, 1.2, 1.7],
[3.2, 2.9, 3.1]])# Data outputs
data_outputs = numpy.array([[0.1],
[0.6],
[1.3],
[2.5]])
Aşağıda, XOR gibi bir ikili sınıflandırma problemi için 2 girişli örnek eğitim verileri bulunmaktadır. Çıktılar, çıktı katmanı 2 nörona sahip olacak şekilde hazırlanır; Her sınıf için 1.
# XOR problem inputs
data_inputs = numpy.array([[0, 0],
[0, 1],
[1, 0],
[1, 1]])# XOR problem outputs
data_outputs = numpy.array([[1, 0],
[0, 1],
[0, 1],
[1, 0]])
Bir sonraki bölüm, regresyon ve sınıflandırma problemleri için kayıp fonksiyonunu tartışmaktadır.
Kayıp İşlevi
Kayıp işlevi, sorunun türüne göre farklılık gösterir. Bu bölümde tensorflow.keras.losses, regresyon ve sınıflandırma problemleri için Keras modülündeki bazı kayıp fonksiyonları anlatılmaktadır .
Regresyon
Bir regresyon problemi için kayıp fonksiyonları şunları içerir:
tensorflow.keras.losses.MeanAbsoluteError()tensorflow.keras.losses.MeanSquaredError()
Daha fazla bilgi için bu sayfaya göz atın .
Burada, gerçek ve tahmin edilen çıktıların bulunduğu y_trueve y_predtemsil ettiği ortalama mutlak hatayı hesaplayan bir örnek verilmiştir .
mae = tensorflow.keras.losses.MeanAbsoluteError()
loss = mae(y_true, y_pred).numpy()Sınıflandırma
Bir sınıflandırma problemi için kayıp fonksiyonları şunları içerir:
tensorflow.keras.losses.BinaryCrossentropy()ikili sınıflandırma için.tensorflow.keras.losses.CategoricalCrossentropy()çok sınıflı sınıflandırma için.
Daha fazla bilgi için bu sayfaya göz atın .
İşte ikili sınıf entropisini hesaplamak için bir örnek:
bce = tensorflow.keras.losses.BinaryCrossentropy()
loss = bce(y_true, y_pred).numpy()Kayıp fonksiyonuna göre uygunluk fonksiyonu bir sonraki bölüme göre hazırlanır.
Fitness fonksiyonu
Sınıflandırma ya da regresyon problemleri için kayıp fonksiyonları, minimizasyon fonksiyonlarıyken, genetik algoritma için uygunluk fonksiyonları maksimizasyon fonksiyonlarıdır. Dolayısıyla, uygunluk değeri, kayıp değerinin tersi olarak hesaplanır.
fitness_value = 1.0 / lossModelin uygunluk değerini hesaplamak için kullanılan adımlar aşağıdaki gibidir:
- 1-D vektöründen model parametrelerini geri yükleyin.
- Model parametrelerini ayarlayın.
- Tahminler yapın.
- Kayıp değerini hesaplayın.
- Uygunluk değerini hesaplayın.
- Uygunluk değerini döndürün.
Regresyon için Uygunluk
Aşağıdaki kod, bir regresyon problemi için PyGAD ile çalışan eksiksiz uygunluk işlevini oluşturur. PyGAD’deki uygunluk işlevi, 2 argüman alan normal bir Python işlevidir. İlki, uygunluk değerinin hesaplanacağı çözümü temsil eder. İkinci argüman, bazı durumlarda faydalı olabilecek, popülasyon içindeki çözümün indeksidir.
Uygunluk işlevine aktarılan çözüm 1 boyutlu bir vektördür. Keras modelinin parametrelerini bu vektörden geri yüklemek için pygad.kerasga.model_weights_as_matrix()kullanılır.
model_weights_matrix = pygad.kerasga.model_weights_as_matrix(model=model, weights_vector=solution)Parametreler geri yüklendikten sonra, set_weights()yöntem tarafından modelin mevcut parametreleri olarak kullanılırlar.
model.set_weights(weights=model_weights_matrix)Model, mevcut parametrelere dayanarak, predict()yöntemi kullanarak çıktıları tahmin eder .
predictions = model.predict(data_inputs)Tahmin edilen çıktılar, kayıp değerini hesaplamak için kullanılır. Ortalama mutlak hata, bir kayıp fonksiyonu olarak kullanılır.
mae = tensorflow.keras.losses.MeanAbsoluteError()Kayıp değeri 0.0 olabileceğinden 0.00000001, uygunluk değeri hesaplanırken sıfıra bölünmekten kaçınmak gibi küçük bir değer eklemek tercih edilir .
solution_fitness = 1.0 / (mae(data_outputs, predictions).numpy() + 0.00000001)Son olarak, uygunluk değeri döndürülür.
def fitness_func(solution, sol_idx):
global data_inputs, data_outputs, keras_ga, model model_weights_matrix = pygad.kerasga.model_weights_as_matrix(model=model,
weights_vector=solution) model.set_weights(weights=model_weights_matrix) predictions = model.predict(data_inputs)
mae = tensorflow.keras.losses.MeanAbsoluteError()
solution_fitness = 1.0 / (mae(data_outputs, predictions).numpy() + 0.00000001) return solution_fitness
İkili Sınıflandırma için Uygunluk
İkili bir sınıflandırma problemi için, aşağıda PyGAD ile çalışan bir uygunluk işlevi verilmiştir. Sınıflandırma probleminin ikili olduğunu varsayarak ikili çapraz entropi kaybını hesaplar.
def fitness_func(solution, sol_idx):
global data_inputs, data_outputs, keras_ga, model model_weights_matrix = pygad.kerasga.model_weights_as_matrix(model=model,
weights_vector=solution) model.set_weights(weights=model_weights_matrix) predictions = model.predict(data_inputs)
bce = tensorflow.keras.losses.BinaryCrossentropy()
solution_fitness = 1.0 / (bce(data_outputs, predictions).numpy() + 0.00000001) return solution_fitness
Sonraki bölüm, her neslin sonunda çalıştırılan bir geri arama işlevi oluşturur.
Nesil Geri Arama İşlevi (İsteğe Bağlı)
Her nesil tamamlandıktan sonra ulaşılan en son parametrelerle ilgili bazı istatistikleri hesaplamak için bir geri arama işlevi çağrılabilir. Bu adım isteğe bağlıdır ve yalnızca hata ayıklama amaçlıdır.
Oluşturma geri arama işlevi aşağıda uygulanmaktadır. PyGAD’de, bu geri çağırma işlevi, mevcut popülasyonun populationöznitelik kullanılarak getirilebildiği genetik algoritmanın örneğine atıfta bulunan bir parametreyi kabul etmelidir .
Bu işlev, mevcut nesil numarasını ve en iyi çözümün uygunluk değerini yazdırır. Bu tür bilgiler, kullanıcıyı genetik algoritmanın ilerleyişi hakkında güncel tutar.
def callback_generation(ga_instance):
print("Generation = {generation}".format(generation=ga_instance.generations_completed))
print("Fitness = {fitness}".format(fitness=ga_instance.best_solution()[1]))pygad.GASınıfın Bir Örneğini Oluşturun
PyGAD kullanarak bir Keras modelini eğitmeye yönelik bir sonraki adım, pygad.GAsınıfın bir örneğini oluşturmaktır . Bu sınıfın kurucusu, dokümantasyonda araştırılabilecek birçok argümanı kabul eder .
Sonraki kod bloğu pygad.GA, bu uygulama için minimum sayıda argüman ileterek sınıfı başlatır, bunlar:
num_generations: Nesil sayısı.num_parents_mating: Çiftleşecek ebeveyn sayısı.initial_population: Keras modelinin parametrelerinin ilk popülasyonu.fitness_func: Uygunluk işlevi.on_generation: Nesil geri arama işlevi.
Popülasyondaki çözüm sayısının önceden KerasGAsınıfın yapıcısında 10 olarak ayarlandığını unutmayın . Bu nedenle çiftleşecek ebeveyn sayısı 10'dan az olmalıdır.
num_generations = 250
num_parents_mating = 5
initial_population = keras_ga.population_weightsga_instance = pygad.GA(num_generations=num_generations,
num_parents_mating=num_parents_mating,
initial_population=initial_population,
fitness_func=fitness_func,
on_generation=callback_generation)
Sonraki bölüm, Keras modelini eğitmeye başlamak için genetik algoritmayı çalıştırır.
Genetik Algoritmayı Çalıştırın
pygad.GASınıfın örneği , run()yöntemi çağırarak çalışır .
ga_instance.run()Bu yöntemi uygulayarak PyGAD’in yaşam döngüsü bir sonraki şekle göre başlar.
Bir sonraki bölümde, eğitilmiş model hakkında bazı sonuçların nasıl çıkarılacağı tartışılmaktadır.
Fitness ve Nesil Grafiği
PyGAD plot_result(), pygad.GAsınıftaki yöntemi kullanarak uygunluk değerinin nesil başına nasıl değiştiğini gösteren bir şekil oluşturur.
ga_instance.plot_result(title="PyGAD & Keras - Iteration vs. Fitness", linewidth=4)Eğitilen Model Hakkında İstatistikler
pygad.GASınıf olarak adlandırılan bir yöntemi vardır best_solution()3 çıkışı verir:
- En iyi çözüm bulundu.
- En iyi çözümün uygunluk değeri.
- Nüfus içerisindeki en iyi çözüm endeksi.
Aşağıdaki kod best_solution()yöntemi çağırır ve bulunan en iyi çözüm hakkındaki bilgileri yazdırır.
solution, solution_fitness, solution_idx = ga_instance.best_solution()
print("Fitness value of the best solution = {solution_fitness}".format(solution_fitness=solution_fitness))
print("Index of the best solution : {solution_idx}".format(solution_idx=solution_idx))Sonra, Keras modelinin ağırlıklarını en iyi çözümden geri yükleyeceğiz. Geri yüklenen ağırlıklara dayalı olarak model, eğitim örneklerinin çıktılarını tahmin eder. Ayrıca yeni örneklerin çıktılarını da tahmin edebilirsiniz.
# Fetch the parameters of the best solution.
best_solution_weights = pygad.kerasga.model_weights_as_matrix(model=model,
weights_vector=solution)
model.set_weights(best_solution_weights)
predictions = model.predict(data_inputs)
print("Predictions : \n", predictions)Aşağıdaki kod, kaybı, yani ortalama mutlak hatayı hesaplar.
mae = tensorflow.keras.losses.MeanAbsoluteError()
abs_error = mae(data_outputs, predictions).numpy()
print("Absolute Error : ", abs_error)Tam Regresyon Kodu
Ortalama mutlak hatayı bir kayıp fonksiyonu olarak kullanan bir regresyon problemi için, işte tam kod.
import tensorflow.keras
import pygad.kerasga
import numpy
import pygaddef fitness_func(solution, sol_idx):
global data_inputs, data_outputs, keras_ga, model model_weights_matrix = pygad.kerasga.model_weights_as_matrix(model=model,
weights_vector=solution) model.set_weights(weights=model_weights_matrix) predictions = model.predict(data_inputs) mae = tensorflow.keras.losses.MeanAbsoluteError()
abs_error = mae(data_outputs, predictions).numpy() + 0.00000001
solution_fitness = 1.0 / abs_error return solution_fitnessdef callback_generation(ga_instance):
print("Generation = {generation}".format(generation=ga_instance.generations_completed))
print("Fitness = {fitness}".format(fitness=ga_instance.best_solution()[1]))input_layer = tensorflow.keras.layers.Input(3)
dense_layer1 = tensorflow.keras.layers.Dense(5, activation="relu")(input_layer)
output_layer = tensorflow.keras.layers.Dense(1, activation="linear")(dense_layer1)model = tensorflow.keras.Model(inputs=input_layer, outputs=output_layer)weights_vector = pygad.kerasga.model_weights_as_vector(model=model)keras_ga = pygad.kerasga.KerasGA(model=model,
num_solutions=10)# Data inputs
data_inputs = numpy.array([[0.02, 0.1, 0.15],
[0.7, 0.6, 0.8],
[1.5, 1.2, 1.7],
[3.2, 2.9, 3.1]])# Data outputs
data_outputs = numpy.array([[0.1],
[0.6],
[1.3],
[2.5]])num_generations = 250
num_parents_mating = 5
initial_population = keras_ga.population_weightsga_instance = pygad.GA(num_generations=num_generations,
num_parents_mating=num_parents_mating,
initial_population=initial_population,
fitness_func=fitness_func,
on_generation=callback_generation)
ga_instance.run()# After the generations complete, some plots are showed that summarize how the outputs/fitness values evolve over generations.
ga_instance.plot_result(title="PyGAD & Keras - Iteration vs. Fitness", linewidth=4)# Returning the details of the best solution.
solution, solution_fitness, solution_idx = ga_instance.best_solution()
print("Fitness value of the best solution = {solution_fitness}".format(solution_fitness=solution_fitness))
print("Index of the best solution : {solution_idx}".format(solution_idx=solution_idx))# Fetch the parameters of the best solution.
best_solution_weights = pygad.kerasga.model_weights_as_matrix(model=model,
weights_vector=solution)
model.set_weights(best_solution_weights)
predictions = model.predict(data_inputs)
print("Predictions : \n", predictions)mae = tensorflow.keras.losses.MeanAbsoluteError()
abs_error = mae(data_outputs, predictions).numpy()
print("Absolute Error : ", abs_error)
Kod tamamlandıktan sonra, sonraki şekil uygunluk değerinin nasıl arttığını gösterir. Bu, Keras modelinin doğru bir şekilde öğrendiğini gösterir.
İşte eğitimli model hakkında daha fazla ayrıntı. Öngörülen değerlerin gerçek değerlere yakın olduğuna dikkat edin. MAE 0,018'dir.
Fitness value of the best solution = 54.79189095217631
Index of the best solution : 0
Predictions :
[[0.11471477]
[0.6034051 ]
[1.3416876 ]
[2.486804 ]]
Absolute Error : 0.018250866Bir CNN Kullanarak Sınıflandırma için Tam Kod
Aşağıdaki kod, her görüntünün boyutunun olduğu 80 görüntüden oluşan bir veri kümesini sınıflandırmak için Keras kullanarak evrişimli bir sinir ağı oluşturur 100x100x3. Veri kümesinde 4 sınıf olduğu için kategorik çapraz entropi kaybının kullanıldığını unutmayın.
Eğitim verileri buradan (veri seti girişleri) ve buradan (veri seti çıktıları) indirilebilir .
import tensorflow.keras
import pygad.kerasga
import numpy
import pygaddef fitness_func(solution, sol_idx):
global data_inputs, data_outputs, keras_ga, model model_weights_matrix = pygad.kerasga.model_weights_as_matrix(model=model,
weights_vector=solution) model.set_weights(weights=model_weights_matrix) predictions = model.predict(data_inputs) cce = tensorflow.keras.losses.CategoricalCrossentropy()
solution_fitness = 1.0 / (cce(data_outputs, predictions).numpy() + 0.00000001) return solution_fitnessdef callback_generation(ga_instance):
print("Generation = {generation}".format(generation=ga_instance.generations_completed))
print("Fitness = {fitness}".format(fitness=ga_instance.best_solution()[1]))# Build the keras model using the functional API.
input_layer = tensorflow.keras.layers.Input(shape=(100, 100, 3))
conv_layer1 = tensorflow.keras.layers.Conv2D(filters=5,
kernel_size=7,
activation="relu")(input_layer)
max_pool1 = tensorflow.keras.layers.MaxPooling2D(pool_size=(5,5),
strides=5)(conv_layer1)
conv_layer2 = tensorflow.keras.layers.Conv2D(filters=3,
kernel_size=3,
activation="relu")(max_pool1)
flatten_layer = tensorflow.keras.layers.Flatten()(conv_layer2)
dense_layer = tensorflow.keras.layers.Dense(15, activation="relu")(flatten_layer)
output_layer = tensorflow.keras.layers.Dense(4, activation="softmax")(dense_layer)model = tensorflow.keras.Model(inputs=input_layer, outputs=output_layer)keras_ga = pygad.kerasga.KerasGA(model=model,
num_solutions=10)# Data inputs
data_inputs = numpy.load("dataset_inputs.npy")# Data outputs
data_outputs = numpy.load("dataset_outputs.npy")
data_outputs = tensorflow.keras.utils.to_categorical(data_outputs)num_generations = 200
num_parents_mating = 5
initial_population = keras_ga.population_weightsga_instance = pygad.GA(num_generations=num_generations,
num_parents_mating=num_parents_mating,
initial_population=initial_population,
fitness_func=fitness_func,
on_generation=callback_generation)ga_instance.run()ga_instance.plot_result(title="PyGAD & Keras - Iteration vs. Fitness", linewidth=4)# Returning the details of the best solution.
solution, solution_fitness, solution_idx = ga_instance.best_solution()
print("Fitness value of the best solution = {solution_fitness}".format(solution_fitness=solution_fitness))
print("Index of the best solution : {solution_idx}".format(solution_idx=solution_idx))# Fetch the parameters of the best solution.
best_solution_weights = pygad.kerasga.model_weights_as_matrix(model=model,
weights_vector=solution)
model.set_weights(best_solution_weights)
predictions = model.predict(data_inputs)
# print("Predictions : \n", predictions)# Calculate the categorical crossentropy for the trained model.
cce = tensorflow.keras.losses.CategoricalCrossentropy()
print("Categorical Crossentropy : ", cce(data_outputs, predictions).numpy())# Calculate the classification accuracy for the trained model.
ca = tensorflow.keras.metrics.CategoricalAccuracy()
ca.update_state(data_outputs, predictions)
accuracy = ca.result().numpy()
print("Accuracy : ", accuracy)
Sonraki şekil, fitness değerinin nesil başına nasıl değiştiğini gösterir. Uygunluk değeri arttığı sürece, daha iyi doğruluk elde etmek için nesil sayısını artırabilirsiniz.
İşte eğitilen model hakkında bazı bilgiler:
Fitness value of the best solution = 2.7462310258668805
Categorical Crossentropy : 0.3641354
Accuracy : 0.75Sonuç
Bu eğitimde, açık kaynak PyGAD kitaplığıyla genetik algoritmayı kullanarak Keras modellerini nasıl eğiteceğimizi gördük. Keras modelleri Sıralı Model veya Fonksiyonel API kullanılarak oluşturulabilir.
pygad.kerasgaModülü kullanarak, her çözümün model için farklı bir ağırlık kümesine sahip olduğu bir Keras modeli ağırlıkları ilk popülasyonu oluşturulur. Bu popülasyon daha sonra tüm nesiller tamamlanana kadar PyGAD'in yaşam döngüsüne göre gelişir.
Keras’ın arka ucu olan TensorFlow’un yüksek hızlı doğası nedeniyle PyGAD, karmaşık mimarileri kabul edilebilir bir süre içinde eğitebilir.
