Keras Eğitimi: Keras nedir? Nasıl Kurulur? Python [Örnek]

Keras nedir?

keras ile yazılmış bir Açık Kaynak Sinir Ağı kütüphanesidir. Python Theano veya Tensorflow'un üstünde çalışır. Modüler, hızlı ve kullanımı kolay olacak şekilde tasarlanmıştır. Google mühendisi François Chollet tarafından geliştirilmiştir. Keras düşük düzeyli hesaplamayı işlemez. Bunun yerine, bunu yapmak için "Arka Uç" adı verilen başka bir kütüphaneyi kullanır.

Keras, TensorFlow, CNTK veya Theano üzerinde çalışabilen, düşük seviyeli API için yüksek seviyeli API sarmalayıcıdır. Keras Yüksek Düzey API, model oluşturma, katmanları tanımlama veya birden fazla giriş-çıkış modeli kurma yöntemimizi yönetir. Bu seviyede Keras ayrıca modelimizi kayıp ve optimizer fonksiyonlarıyla, eğitim sürecini ise fit fonksiyonuyla derler. Keras'ta Python "arka uç" motoru tarafından işlendiğinden, hesaplamalı grafiğin oluşturulması, tensörlerin veya diğer değişkenlerin oluşturulması gibi Düşük Düzey API'yi işlemez.

Arka uç nedir?

Arka uç, Keras'ta tensör ürünleri, evrişimler ve diğer birçok şey gibi tüm düşük seviyeli hesaplamaları Tensorflow veya Theano gibi diğer kitaplıkların yardımıyla gerçekleştiren bir terimdir. Yani modellerin hesaplanmasını ve geliştirilmesini “arka uç motoru” gerçekleştirecek. Tensorflow varsayılan "arka uç motorudur" ancak bunu yapılandırmada değiştirebiliriz.

Theano, Tensorflow ve CNTK Arka Uç

Theano'nun arka ucu

Theano, Kanada'nın Quebec eyaletindeki Montreal Üniversitesi'ndeki MILA grubu tarafından geliştirilen açık kaynaklı bir projedir. Yaygın olarak kullanılan ilk çerçeveydi. Bu bir Python Numpy veya Scipy kullanarak matematiksel işlemler için çok boyutlu dizilerde yardımcı olan kütüphane. Theano daha hızlı hesaplama için GPU'ları kullanabilir, ayrıca eğimleri hesaplamak için otomatik olarak sembolik grafikler oluşturabilir. Theano web sitesinde, sayısal olarak dengesiz ifadeleri tanıyabildiğini ve bunları daha dengeli algoritmalarla hesaplayabildiğini iddia ediyor, bu dengesiz ifadelerimiz için çok yararlı.

TensorFlow'un arka ucu

Öte yandan Tensorflow, derin öğrenme çerçevesinde yükselen yıldızdır. Google'ın Brain ekibi tarafından geliştirilen bu, en popüler derin öğrenme aracıdır. Pek çok özelliği ile araştırmacılar bu çerçevenin derin öğrenme amaçlarına yönelik olarak geliştirilmesine yardımcı olmak için katkıda bulunurlar.

CNTK'nin arka ucu

Keras'ın bir diğer arka uç motoru ise The Microsoft Bilişsel Araç Takımı veya CNTK. tarafından geliştirilen açık kaynaklı bir derin öğrenme çerçevesidir. Microsoft Takım. Derin öğrenme modelini büyük ölçekte eğitmek için çoklu GPU'larda veya çoklu makinede çalışabilir. Bazı durumlarda CNTK, Tensorflow veya Theano gibi diğer çerçevelerden daha hızlı rapor edildi. Bu Keras CNN eğitiminde bir sonraki adımda Theano, TensorFlow ve CNTK'nin arka uçlarını karşılaştıracağız.

Arka Uçları Karşılaştırma

Bu iki arka uç arasındaki karşılaştırmayı bilmek için bir kıyaslama yapmamız gerekiyor. Gördüğünüz gibi Jeong-Yoon Lee'nin referans noktası3 farklı arka ucun farklı donanımlardaki performansı karşılaştırıldı. Sonuç olarak Theano'nun diğer arka uçtan daha yavaş olduğu bildiriliyor 50 kez daha yavaştır ancak doğruluk birbirine yakındır.

Başka kıyaslama testi tarafından gerçekleştirilir Jasmeet Bhatia. Bazı testlerde Theano'nun Tensorflow'tan daha yavaş olduğunu bildirdi. Ancak genel doğruluk, test edilen her ağ için neredeyse aynıdır.

Yani Theano, Tensorflow ve CTK arasında TensorFlow'un Theano'dan daha iyi olduğu açık. TensorFlow ile hesaplama süresi çok daha kısadır ve CNN diğerlerinden daha iyidir.

Bu Keras'ta bir sonraki adım Python öğreticide Keras ve TensorFlow arasındaki farkı öğreneceğiz (Keras ve Tensorflow).

Keras ve Tensorflow

parametreler keras tensör akışı
Tip Üst Düzey API Paketleyici Düşük Düzey API
karmaşa Eğer kullanımı kolay Python dil Bazı Tensorflow işlevlerini kullanmanın sözdizimini öğrenmeniz gerekir
Amaç Standart katmanlarla model oluşturmak için hızlı dağıtım Rastgele bir hesaplamalı grafik veya model katmanları oluşturmanıza olanak tanır
Tools TFDBG gibi diğer API hata ayıklama aracını kullanır Tensorboard görselleştirme araçlarını kullanabilirsiniz
Topluluk Büyük aktif topluluklar Büyük aktif topluluklar ve yaygın olarak paylaşılan kaynaklar

Keras'ın Avantajları

Hızlı Dağıtım ve Anlaşılması Kolay

Keras bir ağ modeli oluşturmakta çok hızlıdır. Birkaç satırdan oluşan basit bir ağ modeli yapmak istiyorsanız, Python Keras bu konuda sana yardımcı olabilir. Aşağıdaki Keras örneğine bakın:

from keras.models import Sequential
from keras.layers import Dense, Activation

model = Sequential()
model.add(Dense(64, activation='relu', input_dim=50)) #input shape of 50
model.add(Dense(28, activation='relu')) #input shape of 50
model.add(Dense(10, activation='softmax'))

API dostu olduğundan süreci kolayca anlayabiliyoruz. Basit bir fonksiyonla ve birden fazla parametre ayarlamaya gerek kalmadan kod yazmak.

Geniş Topluluk Desteği

Derin Öğrenme çerçeveleri için Keras'ı kullanan çok sayıda AI topluluğu var. Birçoğu kodlarının yanı sıra eğitimlerini de halka yayınlıyor.

Birden fazla Arka Uca sahip olun

Keras'ta arka uç olarak Tensorflow, CNTK ve Theano'yu seçebilirsiniz. İhtiyaçlarınıza bağlı olarak farklı projeler için farklı bir arka uç seçebilirsiniz. Her arka ucun kendine özgü bir avantajı vardır.

Platformlar Arası ve Kolay Model Dağıtımı

Desteklenen çeşitli cihaz ve platformlarla Keras'ı aşağıdaki gibi herhangi bir cihaza dağıtabilirsiniz:

  • CoreML'li iOS
  • Android Tensorflow ile Android,
  • .js destekli web tarayıcısı
  • Bulut motoru
  • Ahududu Pi

Çoklu GPU Desteği

Keras'ı tek bir GPU üzerinde eğitebilir veya aynı anda birden fazla GPU kullanabilirsiniz. Keras'ın veri paralelliği için yerleşik bir desteği olduğundan, büyük hacimli verileri işleyebilir ve eğitmek için gereken süreyi hızlandırabilir.

Keras'ın dezavantajları

Düşük seviyeli API işlenemiyor

Keras yalnızca Tensorflow, Theano veya CNTK gibi diğer üst çerçeve veya arka uç motorlarda çalışan üst düzey API'yi yönetir. Dolayısıyla, araştırma amaçlarınız için kendi soyut katmanınızı oluşturmak istiyorsanız, Keras'ın zaten önceden yapılandırılmış katmanları olduğundan, bu pek kullanışlı değildir.

Keras'ı yükleme

Bu bölümde Keras'ı yüklemek için mevcut çeşitli yöntemleri inceleyeceğiz.

Doğrudan kurulum veya Sanal Ortam

Hangisi daha iyi? Mevcut python'a doğrudan kurulum mu yoksa sanal bir ortam mı kullanıyorsunuz? Çok sayıda projeniz varsa sanal ortam kullanmanızı öneririm. Nedenini bilmek ister misin? Bunun nedeni, farklı projelerin keras kitaplığının farklı bir sürümünü kullanabilmesidir.

Mesela bir projem var Python 3.5, eski Keras-Theano arka ucuyla OpenCV 3.3 kullanıyor ancak diğer projede Keras'ı en son sürümle ve arka uç olarak bir Tensorflow ile kullanmam gerekiyor Python 3.6.6 desteği

Keras kütüphanesinin birbiriyle çatışmasını istemeyiz değil mi? Bu nedenle, projeyi belirli bir kütüphane türüyle yerelleştirmek için bir Sanal Ortam kullanıyoruz veya hesaplamamızı bizim için yapmak için Bulut Hizmeti gibi başka bir platform kullanabiliriz. Amazon İnternet servisi.

Keras'ı yükleme Amazon Web Hizmeti (AWS)

Amazon Web Servisi, araştırmacılara veya başka amaçlara yönelik Bulut Bilişim hizmeti ve ürünleri sunan bir platformdur. AWS, doğrudan internetten kullanabilmemiz için donanımlarını, ağlarını, Veritabanını vb. kiralar. Derin öğrenme amaçlı popüler AWS hizmetlerinden biri Amazon Makine Görüntüsü Derin Öğrenme Hizmeti veya DL

AWS'nin nasıl kullanılacağına ilişkin ayrıntılı talimatlar için buna bakın öğretici

AMI ile ilgili not: Aşağıdaki AMI'ye sahip olacaksınız:

Keras'ı AWS'ye yükleme

AWS Deep Learning AMI, AWS EC2 Service'te bulunan ve araştırmacıların veya uygulayıcıların Derin Öğrenme ile çalışmasına yardımcı olan sanal bir ortamdır. DLAMI, önceden yapılandırılmış CUDA, cuDNN'ye sahip küçük CPU motorlarından yüksek güçlü çoklu GPU motorlarına kadar sunar ve çeşitli derin öğrenme çerçeveleriyle birlikte gelir.

Anında kullanmak istiyorsanız Deep Learning AMI'yi seçmelisiniz çünkü popüler derin öğrenme çerçeveleri önceden yüklenmiş olarak gelir.

Ancak araştırma için özel bir derin öğrenme çerçevesi denemek istiyorsanız Derin Öğrenme Tabanı AMI'yı kurmalısınız çünkü CUDA, cuDNN, GPU sürücüleri gibi temel kitaplıklarla ve derin öğrenme ortamınızla çalışmak için gereken diğer kitaplıklarla birlikte gelir.

Keras Nasıl Kurulur Amazon SageMaker

Amazon SageMaker, derin öğrenme ağını en iyi algoritmayla eğitmenize ve dağıtmanıza yardımcı olacak bir derin öğrenme platformudur.

Yeni başlayan biri olarak bu, Keras'ı kullanmanın açık ara en kolay yöntemidir. Aşağıda Keras'ın nasıl kurulacağına ilişkin bir süreç bulunmaktadır. Amazon Adaçayı Yapıcı:

Adım 1) Aç Amazon SageMaker

İlk adımda, Aç Amazon adaçayı Konsolu açın ve Not defteri örneği oluştur'a tıklayın.

Keras'ı şuraya yükle: Amazon SageMaker

Adım 2) Ayrıntıları girin

  1. Not defterinizin adını girin.
  2. Bir IAM rolü oluşturun. Bir AMI rolü yaratacak Amazon IAM rolü biçiminde AmazonSageMaker-Yürütme Rolü-YYYYAAGG|HHmmSS.
  3. Son olarak Not defteri örneği oluştur'u seçin. Birkaç dakika sonra, Amazon Sagemaker bir dizüstü bilgisayar örneğini başlatır.

Keras'ı şuraya yükle: Amazon SageMaker

not: VPC'nizden kaynaklara erişmek istiyorsanız doğrudan internet erişimini etkin olarak ayarlayın. Aksi takdirde, bu dizüstü bilgisayar örneğinin internet erişimi olmayacak, dolayısıyla modelleri eğitmek veya barındırmak mümkün olmayacaktır.

Adım 3) Örneği başlatın

Örneği başlatmak için Aç'a tıklayın

Keras'ı şuraya yükle: Amazon SageMaker

Adım 4) Kodlamaya başlayın

In Jupyter, Yeni> conda_tensorflow_p36'ya tıklayın ve kodlamaya hazırsınız

Keras'ı şuraya yükle: Amazon SageMaker

Keras'ı Linux'a yükleyin

Keras'ı arka uç motoru olarak Tensorflow ile etkinleştirmek için önce Tensorflow'u kurmamız gerekiyor. Tensorflow'u CPU (GPU yok) ile yüklemek için bu komutu çalıştırın

pip install --upgrade tensorflow

Tensorflow için GPU desteğini etkinleştirmek istiyorsanız bu komutu kullanabilirsiniz.

pip install --upgrade tensorflow-gpu

Keras'ı Linux'a yükleyin

hadi giriş yapalım Python yazarak kurulumumuzun başarılı olup olmadığını görmek için

user@user:~$ python
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow
>>>

herhangi bir hata mesajı yoksa kurulum işlemi başarılıdır

Keras'ı yükleyin

Tensorflow kurulumunu yaptıktan sonra keras kurulumuna başlayalım. Bu komutu terminale yazın

pip install keras

Keras'ı ve tüm bağımlılıklarını yüklemeye başlayacak. Bunun gibi bir şey görmelisiniz:

Keras'ı yükleyin

Artık sistemimizde Keras yüklü!

Doğrulama

Keras'ı kullanmaya başlamadan önce, yapılandırma dosyasını açarak Keras'ımızın arka uç olarak Tensorflow kullanıp kullanmadığını kontrol etmeliyiz:

gedit ~/.keras/keras.json

buna benzer bir şey görmelisin

{
    "floatx": "float32",
    "epsilon": 1e-07,
    "backend": "tensorflow",
    "image_data_format": "channels_last"
}

görebileceğiniz gibi “arka uç” tensor akışını kullanıyor. Bu, keras'ın beklediğimiz gibi arka uç olarak Tensorflow'u kullandığı anlamına geliyor

ve şimdi yazarak terminalde çalıştırın

user@user:~$ python3
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import keras
Using TensorFlow backend.
>>> 

Keras Nasıl Kurulur Windows

Kurulumdan önce tensör akışı ve Keras'ı kurmalıyız Python, pip ve virtualenv. Bu kütüphaneleri zaten yüklediyseniz, bir sonraki adıma geçmelisiniz, aksi takdirde şunu yapın:

kurmak Python 3'ü buradan indirerek Link

Pip'i çalıştırarak yükleyin Re-Tweet

Bu komutla virtualenv'i kurun

pip3 install –U pip virtualenv

kurmak Microsoft Görsel C++ 2015 Yeniden Dağıtılabilir Güncelleme 3

Daha sonra bu betiği çalıştırın

pip3 install virtualenv

Sanal Ortam Kurulumu

Çalışma sistemini ana sistemden izole etmek için kullanılır.

virtualenv –-system-site-packages –p python3 ./venv

Ortamı etkinleştirin

.\venv\Scripts\activate

Ortam hazırlandıktan sonra Tensorflow ve Keras kurulumu Linux ile aynı kalıyor. Bu Keras ile Derin öğrenme eğitiminde bir sonraki adımda, Derin öğrenme için Keras'ın temellerini öğreneceğiz.

Derin Öğrenme için Keras Temelleri

Keras'taki ana yapı, bir ağın tam grafiğini tanımlayan Modeldir. Projeniz için ihtiyaç duyduğunuz özel bir model oluşturmak için mevcut bir modele daha fazla katman ekleyebilirsiniz.

Sıralı Modelin nasıl oluşturulacağı ve derin öğrenmede yaygın olarak kullanılan birkaç katman aşağıda açıklanmıştır

1. Sıralı Model

from keras.models import Sequential
from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout

model = Sequential()

2. Evrişimsel Katman

Bu bir Keras'tır Python 320x320x3 giriş şekline sahip, 48x3 boyutunda 3 filtreli ve bir aktivasyon fonksiyonu olarak ReLU kullanan giriş katmanı olarak evrişimli katman örneği.

input_shape=(320,320,3) #this is the input shape of an image 320x320x3
model.add(Conv2D(48, (3, 3), activation='relu', input_shape= input_shape))

başka bir tür ise

model.add(Conv2D(48, (3, 3), activation='relu'))

3. maksimumPooling Katman

Giriş gösterimini alt örneklemek için MaxPool2d'yi kullanın ve çekirdek boyutunu belirtin

model.add(MaxPooling2D(pool_size=(2, 2)))

4. Yoğun Katman

yalnızca çıktı Boyutunu belirterek Tam Bağlantılı Katman ekleme

model.add(Dense(256, activation='relu'))

5. Bırakma Katmanı

%50 olasılıkla bırakma katmanı ekleniyor

model.add(Dropout(0.5))

Derleme, Eğitim ve Değerlendirme

Modelimizi tanımladıktan sonra eğitmeye başlayalım. Ağın öncelikle kayıp fonksiyonu ve optimizer fonksiyonu ile derlenmesi gerekmektedir. Bu, ağın ağırlıklarını değiştirmesine olanak tanıyacak ve kaybı en aza indirecektir.

model.compile(loss='mean_squared_error', optimizer='adam')

Şimdi eğitime başlamak için eğitim ve doğrulama verilerini modele beslemek için fit öğesini kullanın. Bu, ağı gruplar halinde eğitmenize ve dönemleri ayarlamanıza olanak tanır.

model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))

Son adımımız modeli test verileriyle değerlendirmektir.

score = model.evaluate(x_test, y_test, batch_size=32)

Basit doğrusal regresyon kullanmayı deneyelim

import keras
from keras.models import Sequential
from keras.layers import Dense, Activation
import numpy as np
import matplotlib.pyplot as plt 
 
x = data = np.linspace(1,2,200)
y = x*4 + np.random.randn(*x.shape) * 0.3


model = Sequential()
model.add(Dense(1, input_dim=1, activation='linear'))

model.compile(optimizer='sgd', loss='mse', metrics=['mse'])

weights = model.layers[0].get_weights()
w_init = weights[0][0][0]
b_init = weights[1][0]
print('Linear regression model is initialized with weights w: %.2f, b: %.2f' % (w_init, b_init)) 


model.fit(x,y, batch_size=1, epochs=30, shuffle=False)

weights = model.layers[0].get_weights()
w_final = weights[0][0][0]
b_final = weights[1][0]
print('Linear regression model is trained to have weight w: %.2f, b: %.2f' % (w_final, b_final))

predict = model.predict(data)

plt.plot(data, predict, 'b', data , y, 'k.')
plt.show()

Verileri eğittikten sonra çıktı şu şekilde görünmelidir:

Doğrusal regresyon

başlangıç ​​ağırlığı ile

Linear regression model is initialized with weights w: 0.37, b: 0.00

ve son ağırlık

Linear regression model is trained to have weight w: 3.70, b: 0.61

Keras'ta Önceden Eğitilmiş Modellere İnce Ayar Yapma ve Bunların Nasıl Kullanılacağı

Neden İnce Ayar Modellerini kullanıyoruz ve ne zaman kullanıyoruz?

İnce ayar, önceden eğitilmiş bir modelde, parametrelerin yeni modele uyum sağlayacak şekilde ince ayar yapılması görevidir. Yeni bir model üzerinde sıfırdan eğitim almak istediğimizde, ağın tüm parametreleri bulabilmesi için büyük miktarda veriye ihtiyacımız var. Ancak bu durumda, parametrelerin önceden öğrenilmesi ve bir ağırlığa sahip olması için önceden eğitilmiş bir model kullanacağız.

Örneğin, bir sınıflandırma problemini çözmek için kendi Keras modelimizi eğitmek istiyorsak ancak elimizde sadece az miktarda veri varsa, bunu bir sınıflandırma problemini kullanarak çözebiliriz. Transfer Öğrenimi + İnce Ayar yöntemi.

Önceden eğitilmiş bir ağ ve ağırlıklar kullanarak tüm ağı eğitmemize gerek yoktur. İnce Ayar yöntemi dediğimiz görevimizi çözmek için kullanılan son katmanı eğitmeniz yeterli.

Ağ Modeli Hazırlama

Önceden eğitilmiş model için Keras'ın kütüphanesinde halihazırda bulunan çeşitli modelleri yükleyebiliriz:

  • VGG16
  • Başlangıç ​​V3
  • ResNet
  • MobilNet
  • istisna
  • InceptionResNetV2

Fakat bu süreçte model ağırlığımız olarak VGG16 ağ modelini ve imageNet'i kullanacağız. Görselleri kullanarak 8 farklı sınıf türünü sınıflandırmak için bir ağda ince ayar yapacağız. Kaggle Doğal Görüntüler Veri Kümesi

VGG16 model mimarisi

VGG16 model mimarisi

kaynak

Verilerimizi AWS S3 Bucket'e Yükleme

Eğitim sürecimiz için uçak, araba, kedi, köpek, çiçek, meyve, motosiklet ve insan gibi 8 farklı sınıftan doğal görsellerden oluşan bir resim kullanacağız. Öncelikle verilerimizi buraya yüklememiz gerekiyor. Amazon S3 Kovası.

Amazon S3 Kova

) 1 Adım S3 hesabınıza giriş yaptıktan sonra saatli olarak bir paket oluşturalım Paket Oluştur

AWS S3 Bucket'a Veri Yükleme

) 2 Adım Şimdi hesabınıza göre bir Paket Adı ve Bölgenizi seçin. Paket adının kullanılabilir olduğundan emin olun. Bu tıklamanın ardından Oluşturun.

AWS S3 Bucket'a Veri Yükleme

) 3 Adım Gördüğünüz gibi Kovanız kullanıma hazır. Ancak gördüğünüz gibi Erişim herkese açık değil, kendinize özel kalmasını istiyorsanız bu sizin için iyidir. Bu paketi Genel Erişim için Paket Özellikleri'nde değiştirebilirsiniz

AWS S3 Bucket'a Veri Yükleme

) 4 Adım Artık egzersiz verilerinizi Kovanıza yüklemeye başlıyorsunuz. Burada eğitim ve test işlemleri için resimlerden oluşan tar.gz dosyasını yükleyeceğim.

AWS S3 Bucket'a Veri Yükleme

) 5 Adım Şimdi dosyanıza tıklayın ve kopyalayın Link böylece indirebiliriz.

AWS S3 Bucket'a Veri Yükleme

Veri Hazırlama

Keras ImageData'yı kullanarak eğitim verilerimizi oluşturmamız gerekiyor.Generator.

Öncelikle S3 Bucket'ten dosyanızın bağlantısını içeren wget'i kullanarak indirmeniz gerekir.

!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz		
!tar -xzf images.tar.gz

Verileri indirdikten sonra Eğitim Sürecine başlayalım.

from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt

train_path = 'images/train/'
test_path = 'images/test/'
batch_size = 16
image_size = 224
num_class = 8


train_datagen = ImageDataGenerator(validation_split=0.3,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

Görüntü VerileriGenerator bir dizinden bir X_training verisi oluşturacaktır. Bu dizindeki alt dizin, her nesne için bir sınıf olarak kullanılacaktır. Görüntü, Y_training verileri için kategorik sınıf modu ve 16 toplu iş boyutuyla RGB renk moduyla yüklenecektir. Son olarak verileri karıştırın.

Matplotlib ile görsellerimizi çizerek rastgele görelim.

x_batch, y_batch = train_generator.next()

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
    num = np.random.randint(batch_size)
    image = x_batch[num].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.imshow(image)
plt.show()

Veri Hazırlama

Daha sonra imageNet önceden eğitilmiş ağırlık ile VGG16'dan ağ modelimizi oluşturalım. Hesaplama süresini kısaltmamıza yardımcı olmak için katmanların eğitilememesi için bu katmanları donduracağız.

Modelimizi VGG16'dan Oluşturma

import keras
from keras.models import Model, load_model
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16


#Load the VGG model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(image_size, image_size, 3))

print(base_model.summary())

    # Freeze the layers 
for layer in base_model.layers:
    layer.trainable = False
 
# # Create the model
model = keras.models.Sequential()

# # Add the vgg convolutional base model
model.add(base_model)
 
# # Add new layers
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
 
# # Show a summary of the model. Check the number of trainable parameters    
print(model.summary())

Aşağıda gördüğünüz gibi ağ modelimizin özeti. VGG16 Katmanlarından gelen bir girişten, daha sonra 2 özelliği çıkaracak 1024 Tam Bağlantılı Katman ve softmax aktivasyonuyla 8 sınıfı hesaplayacak bir çıkış katmanı ekliyoruz.

Layer (type)                 Output Shape              Param #   
=================================================================
vgg16 (Model)                (None, 7, 7, 512)         14714688  
_________________________________________________________________
flatten_1 (Flatten)          (None, 25088)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              25691136  
_________________________________________________________________
dense_2 (Dense)              (None, 1024)              1049600   
_________________________________________________________________
dense_3 (Dense)              (None, 8)                 8200      
=================================================================
Total params: 41,463,624
Trainable params: 26,748,936
Non-trainable params: 14,714,688

Eğitim

# # Compile the model
from keras.optimizers import SGD

model.compile(loss='categorical_crossentropy',
          optimizer=SGD(lr=1e-3),
          metrics=['accuracy'])

# # Start the training process
# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2)

# # #save the model
# model.save('catdog.h5')

history = model.fit_generator(
        train_generator,
        steps_per_epoch=train_generator.n/batch_size,
        epochs=10)
        
model.save('fine_tune.h5')

# summarize history for accuracy
import matplotlib.pyplot as plt

plt.plot(history.history['loss'])
plt.title('loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
plt.show()

ÇIKTILAR

Epoch 1/10
432/431 [==============================] - 53s 123ms/step - loss: 0.5524 - acc: 0.9474 
Epoch 2/10
432/431 [==============================] - 52s 119ms/step - loss: 0.1571 - acc: 0.9831
Epoch 3/10
432/431 [==============================] - 51s 119ms/step - loss: 0.1087 - acc: 0.9871
Epoch 4/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0624 - acc: 0.9926
Epoch 5/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0591 - acc: 0.9938
Epoch 6/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0498 - acc: 0.9936
Epoch 7/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0403 - acc: 0.9958
Epoch 8/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0248 - acc: 0.9959
Epoch 9/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0466 - acc: 0.9942
Epoch 10/10
432/431 [==============================] - 52s 120ms/step - loss: 0.0338 - acc: 0.9947

Eğitim

Gördüğünüz gibi kayıplarımız önemli ölçüde azaldı ve doğruluk neredeyse %100 oldu. Modelimizi test etmek için internet üzerinden rastgele görseller seçtik ve test etmek için farklı bir sınıfın bulunduğu test klasörüne koyduk.

Modelimizi Test Etme

model = load_model('fine_tune.h5')

test_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

test_generator = test_datagen.flow_from_directory(
                        directory=test_path, 
                        target_size=(image_size, image_size),
                        color_mode='rgb',
                        shuffle=False,
                        class_mode='categorical',
                        batch_size=1)

filenames = test_generator.filenames
nb_samples = len(filenames)

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows -1):
    x_batch, y_batch = test_generator.next()

    name = model.predict(x_batch)
    name = np.argmax(name, axis=-1)
    true_name = y_batch
    true_name = np.argmax(true_name, axis=-1)

    label_map = (test_generator.class_indices)
    label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
    predictions = [label_map[k] for k in name]
    true_value = [label_map[k] for k in true_name]

    image = x_batch[0].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.title(str(predictions[0]) + ':' + str(true_value[0]))
    plt.imshow(image)
plt.show()

Ve testimiz aşağıda verildiği gibidir! 1 görüntüden oluşan bir testten yalnızca 14 görüntünün yanlış tahmin edilmesi!

Test Modeli

Keras ile Yüz Tanıma Sinir Ağı

Neden Tanınmaya ihtiyacımız var?

Bir kişinin yüzünü, nesne türünü, kişinin tahmini yaşını yüzünden tanımamızı veya tanımlamamızı ve hatta o kişinin yüz ifadelerini bilmemizi kolaylaştırmak için Tanıma'ya ihtiyacımız var.

Keras ile Yüz Tanıma Sinir Ağı

Belki bir fotoğrafta arkadaşınızın yüzünü işaretlemeye çalıştığınızda, Facebook'taki özelliğin bunu sizin için yaptığını, yani arkadaşınızın yüzünü sizin önce işaretlemenize gerek kalmadan işaretlediğini fark etmişsinizdir. Bu, Facebook'un arkadaşlarımızı etiketlememizi kolaylaştırmak için uyguladığı Yüz Tanıma'dır.

Peki nasıl çalışıyor? Arkadaşımızın yüzünü her işaretlediğimizde, Facebook'un yapay zekası bunu öğrenecek ve doğru sonucu alana kadar onu tahmin etmeye çalışacak. Kendi Yüz Tanıma işlemimizi yapmak için kullanacağımız sistemin aynısı. Derin Öğrenmeyi kullanarak kendi Yüz Tanımamızı yapmaya başlayalım

Ağ Modeli

Bir VGG16 Ağ Modeli kullanacağız ancak VGGFace ağırlıklı.

VGG16 model mimarisi

Ağ Modeli

VGGFace nedir? Parkhi, Omkar M. ve diğerleri tarafından tanıtılan Derin Yüz Tanıma'nın Kera uygulamasıdır. “Derin Yüz Tanıma.” BMVC (2015). Çerçeve, ağ mimarisi olarak VGG16'yı kullanır.

VGGFace'i şu adresten indirebilirsiniz: github

from keras.applications.vgg16 import VGG16
from keras_vggface.vggface import VGGFace

face_model = VGGFace(model='vgg16', 
                weights='vggface',
                input_shape=(224,224,3)) 
face_model.summary()

Ağ özetini görebileceğiniz gibi

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0         
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792      
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928     
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0         
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856     
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584    
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0         
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168    
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0         
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160   
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0         
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0         
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0         
_________________________________________________________________
fc6 (Dense)                  (None, 4096)              102764544 
_________________________________________________________________
fc6/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc7 (Dense)                  (None, 4096)              16781312  
_________________________________________________________________
fc7/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc8 (Dense)                  (None, 2622)              10742334  
_________________________________________________________________
fc8/softmax (Activation)     (None, 2622)              0         
=================================================================
Total params: 145,002,878
Trainable params: 145,002,878
Non-trainable params: 0
_________________________________________________________________
Traceback (most recent call last):

bir şey yapacağız Transfer Öğrenimi + Küçük veri kümeleriyle eğitimi daha hızlı hale getirmek için İnce Ayar. İlk olarak, katmanların eğitilememesi için temel katmanları donduracağız.

for layer in face_model.layers:
    layer.trainable = False

daha sonra test yüzlerimizi tanımak için kendi katmanımızı ekliyoruz. Algılamak için 2 adet tam bağlantılı katman ve 5 kişilik bir çıktı katmanı ekleyeceğiz.

from keras.models import Model, Sequential
from keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation

person_count = 5

last_layer = face_model.get_layer('pool5').output

x = Flatten(name='flatten')(last_layer)
x = Dense(1024, activation='relu', name='fc6')(x)
x = Dense(1024, activation='relu', name='fc7')(x)
out = Dense(person_count, activation='softmax', name='fc8')(x)

custom_face = Model(face_model.input, out)

Ağ özetimizi görelim

Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0
_________________________________________________________________
fc6 (Dense)                  (None, 1024)              25691136
_________________________________________________________________
fc7 (Dense)                  (None, 1024)              1049600
_________________________________________________________________
fc8 (Dense)                  (None, 5)                 5125
=================================================================
Total params: 41,460,549
Trainable params: 26,745,861
Non-trainable params: 14,714,688

Yukarıda görebileceğiniz gibi,pool5 katmanından sonra, yoğun katman tarafından son tanıma için kullanılacak tek bir özellik vektörüne düzleştirilecektir.

Yüzümüzü Hazırlıyoruz

Şimdi yüzümüzü hazırlayalım. 5 ünlü kişiden oluşan bir rehber hazırladım

  • Jack Ma
  • Jason Statham
  • Johnny Depp
  • Robert Downey Jr
  • Rowan Atkinson

Her klasörde her eğitim ve değerlendirme sürecine ait 10 resim bulunmaktadır. Bu çok küçük miktarda veri ama zorluk da bu, değil mi?

Verileri hazırlamamıza yardımcı olması için Keras aracının yardımını kullanacağız. Bu işlev, veri kümesi klasöründe yinelenecek ve ardından onu eğitimde kullanılabilecek şekilde hazırlayacaktır.

from keras.preprocessing.image import ImageDataGenerator
batch_size = 5
train_path = 'data/'
eval_path = 'eval/'

train_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

valid_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='sparse',
                        color_mode='rgb')

valid_generator = valid_datagen.flow_from_directory(
    directory=eval_path,
    target_size=(224, 224),
    color_mode='rgb',
    batch_size=batch_size,
    class_mode='sparse',
    shuffle=True,
)

Modelimizi Eğitmek

Ağımızı kayıp fonksiyonu ve optimizer ile derleyerek eğitim sürecimize başlayalım. Burada, öğrenme optimize edicimiz olarak SGD'nin yardımıyla kayıp fonksiyonumuz olarak sparse_categorical_crossentropy'yi kullanıyoruz.

from keras.optimizers import SGD

custom_face.compile(loss='sparse_categorical_crossentropy',
                         optimizer=SGD(lr=1e-4, momentum=0.9),
                         metrics=['accuracy'])

history = custom_face.fit_generator(
        train_generator,
        validation_data=valid_generator,
        steps_per_epoch=49/batch_size,
        validation_steps=valid_generator.n,
        epochs=50)

custom_face.evaluate_generator(generator=valid_generator)
        
custom_face.save('vgg_face.h5')
Epoch 25/50
10/9 [==============================] - 60s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5659 - val_acc: 0.5851
Epoch 26/50
10/9 [==============================] - 59s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5638 - val_acc: 0.5809
Epoch 27/50
10/9 [==============================] - 60s 6s/step - loss: 1.4779 - acc: 0.8597 - val_loss: 1.5613 - val_acc: 0.5477
Epoch 28/50
10/9 [==============================] - 60s 6s/step - loss: 1.4755 - acc: 0.9199 - val_loss: 1.5576 - val_acc: 0.5809
Epoch 29/50
10/9 [==============================] - 60s 6s/step - loss: 1.4794 - acc: 0.9153 - val_loss: 1.5531 - val_acc: 0.5892
Epoch 30/50
10/9 [==============================] - 60s 6s/step - loss: 1.4714 - acc: 0.8953 - val_loss: 1.5510 - val_acc: 0.6017
Epoch 31/50
10/9 [==============================] - 60s 6s/step - loss: 1.4552 - acc: 0.9199 - val_loss: 1.5509 - val_acc: 0.5809
Epoch 32/50
10/9 [==============================] - 60s 6s/step - loss: 1.4504 - acc: 0.9199 - val_loss: 1.5492 - val_acc: 0.5975
Epoch 33/50
10/9 [==============================] - 60s 6s/step - loss: 1.4497 - acc: 0.8998 - val_loss: 1.5490 - val_acc: 0.5851
Epoch 34/50
10/9 [==============================] - 60s 6s/step - loss: 1.4453 - acc: 0.9399 - val_loss: 1.5529 - val_acc: 0.5643
Epoch 35/50
10/9 [==============================] - 60s 6s/step - loss: 1.4399 - acc: 0.9599 - val_loss: 1.5451 - val_acc: 0.5768
Epoch 36/50
10/9 [==============================] - 60s 6s/step - loss: 1.4373 - acc: 0.8998 - val_loss: 1.5424 - val_acc: 0.5768
Epoch 37/50
10/9 [==============================] - 60s 6s/step - loss: 1.4231 - acc: 0.9199 - val_loss: 1.5389 - val_acc: 0.6183
Epoch 38/50
10/9 [==============================] - 59s 6s/step - loss: 1.4247 - acc: 0.9199 - val_loss: 1.5372 - val_acc: 0.5934
Epoch 39/50
10/9 [==============================] - 60s 6s/step - loss: 1.4153 - acc: 0.9399 - val_loss: 1.5406 - val_acc: 0.5560
Epoch 40/50
10/9 [==============================] - 60s 6s/step - loss: 1.4074 - acc: 0.9800 - val_loss: 1.5327 - val_acc: 0.6224
Epoch 41/50
10/9 [==============================] - 60s 6s/step - loss: 1.4023 - acc: 0.9800 - val_loss: 1.5305 - val_acc: 0.6100
Epoch 42/50
10/9 [==============================] - 59s 6s/step - loss: 1.3938 - acc: 0.9800 - val_loss: 1.5269 - val_acc: 0.5975
Epoch 43/50
10/9 [==============================] - 60s 6s/step - loss: 1.3897 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.6432
Epoch 44/50
10/9 [==============================] - 60s 6s/step - loss: 1.3828 - acc: 0.9800 - val_loss: 1.5210 - val_acc: 0.6556
Epoch 45/50
10/9 [==============================] - 59s 6s/step - loss: 1.3848 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.5975
Epoch 46/50
10/9 [==============================] - 60s 6s/step - loss: 1.3716 - acc: 0.9800 - val_loss: 1.5216 - val_acc: 0.6432
Epoch 47/50
10/9 [==============================] - 60s 6s/step - loss: 1.3721 - acc: 0.9800 - val_loss: 1.5195 - val_acc: 0.6266
Epoch 48/50
10/9 [==============================] - 60s 6s/step - loss: 1.3622 - acc: 0.9599 - val_loss: 1.5108 - val_acc: 0.6141
Epoch 49/50
10/9 [==============================] - 60s 6s/step - loss: 1.3452 - acc: 0.9399 - val_loss: 1.5140 - val_acc: 0.6432
Epoch 50/50
10/9 [==============================] - 60s 6s/step - loss: 1.3387 - acc: 0.9599 - val_loss: 1.5100 - val_acc: 0.6266

Gördüğünüz gibi doğrulama doğruluğumuz %64'e kadar çıkıyor, bu az miktarda eğitim verisi için iyi bir sonuç. Modelimizin yüzler hakkında daha fazla bilgi edinebilmesi ve daha fazla doğruluk elde edebilmesi için daha fazla katman ekleyerek veya daha fazla eğitim görüntüsü ekleyerek bunu geliştirebiliriz.

Modelimizi bir test resmiyle test edelim

Test Resmi

from keras.models import load_model
from keras.preprocessing.image import load_img, save_img, img_to_array
from keras_vggface.utils import preprocess_input

test_img = image.load_img('test.jpg', target_size=(224, 224))
img_test = image.img_to_array(test_img)
img_test = np.expand_dims(img_test, axis=0)
img_test = utils.preprocess_input(img_test)
predictions = model.predict(img_test)
predicted_class=np.argmax(predictions,axis=1)

labels = (train_generator.class_indices)
labels = dict((v,k) for k,v in labels.items())
predictions = [labels[k] for k in predicted_class]
print(predictions)
['RobertDJr']

Robert Downey Jr. resmini test resmimiz olarak kullanırsak, tahmin edilen yüzün doğru olduğunu gösterir!

Canlı Kamera kullanarak tahmin!

Web kamerasından gelen bir girdiyle bunu uygulayarak becerimizi test etsek nasıl olur? Yüzümüzü bulmak için Haar Face Cascade ile OpenCV'yi kullanarak ağ modelimizin yardımıyla kişiyi tanıyabiliriz.

İlk adım sizin ve arkadaşınızın yüzlerini hazırlamaktır. Ne kadar çok veriye sahip olursak sonuç o kadar iyi olur!

Ağınızı bir önceki adımdaki gibi hazırlayın ve eğitin, eğitim tamamlandıktan sonra kameradan giriş görüntüsünü almak için bu satırı ekleyin

#Load trained model
from keras.models import load_model
from keras_vggface import utils
import cv2

image_size = 224
device_id = 0 #camera_device id 

model = load_model('my faces.h5')

#make labels according to your dataset folder 
labels = dict(fisrtname=0,secondname=1) #and so on
print(labels)

cascade_classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
camera = cv2.VideoCapture(device_id)

while camera.isOpened():
    ok, cam_frame = camera.read()
    if not ok:
        break
    
    gray_img=cv2.cvtColor(cam_frame, cv2.COLOR_BGR2GRAY)
    faces= cascade_classifier.detectMultiScale(gray_img, minNeighbors=5)

    for (x,y,w,h) in faces:
        cv2.rectangle(cam_frame,(x,y),(x+w,y+h),(255,255,0),2)
        roi_color = cam_frame [y:y+h, x:x+w]
        roi color = cv2.cvtColor(roi_color, cv2.COLOR_BGR2RGB)
        roi_color = cv2.resize(roi_color, (image_size, image_size))
        image = roi_color.astype(np.float32, copy=False)
        image = np.expand_dims(image, axis=0)
        image = preprocess_input(image, version=1) # or version=2
        preds = model.predict(image)
        predicted_class=np.argmax(preds,axis=1)

        labels = dict((v,k) for k,v in labels.items())
        name = [labels[k] for k in predicted_class]

        cv2.putText(cam_frame,str(name), 
                    (x + 10, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,255), 2)
        
    cv2.imshow('video image', cam_frame)
    key = cv2.waitKey(30)
    if key == 27: # press 'ESC' to quit
        break

camera.release()
cv2.destroyAllWindows()

Hangisi daha iyi? Keras veya Tensorflow

Keras, senaryo yazarken basitlik sunar. Anlaşılması çok zor olmadığı için doğrudan Keras ile yazmaya başlayabilir ve anlayabiliriz. Daha kullanıcı dostu ve uygulaması kolaydır, modeli çalıştırmak için çok fazla değişken oluşturmaya gerek yoktur. Dolayısıyla arka uç sürecindeki her ayrıntıyı anlamamıza gerek yok.

Öte yandan Tensorflow, isteğe bağlı bir hesaplamalı grafik veya model oluşturmak istiyorsanız esneklik ve gelişmiş işlemler sunan düşük seviyeli işlemlerdir. Tensorflow ayrıca süreci aşağıdakilerin yardımıyla görselleştirebilir: Tensör Kartı ve özel bir hata ayıklama aracı.

Dolayısıyla, çok fazla karmaşıklık olmadan derin öğrenmeyle çalışmaya başlamak istiyorsanız Keras'ı kullanın. Çünkü Keras, Tensorflow'a göre basitlik ve kullanıcı dostu, uygulaması kolay bir çözüm sunuyor. Ancak derin öğrenme projesinde veya araştırmasında kendi algoritmanızı yazmak istiyorsanız bunun yerine Tensorflow'u kullanmalısınız.

ÖZET

Şimdi bu eğitimde tartıştığımız ve yaptığımız her şeyi özetleyelim.

  • Keras, arka uç motoru yardımıyla derin öğrenme ağlarını kolaylaştırmak için kullanılan üst düzey bir API'dir.
  • Keras'ın python desteğiyle kullanımı ve anlaşılması kolaydır, bu nedenle her zamankinden daha doğal hissettirir. Derin öğrenme hakkında bilgi edinmek isteyen yeni başlayanlar ve kullanımı kolay API isteyen araştırmacılar için iyidir.
  • Kurulum işlemi kolaydır ve sanal bir ortam veya aşağıdaki gibi harici bir platform kullanabilirsiniz: AWS.
  • Keras ayrıca çeşitli ağ modelleriyle birlikte gelir; bu, önceden eğitilmiş ve kendi ağ modelimize ince ayar yapmak için mevcut modeli kullanmamızı kolaylaştırır.
  • Ayrıca, dünya çapındaki topluluk kodlarından Keras'ın derin öğrenme amacıyla kullanılmasıyla ilgili birçok eğitim ve makale bulunmaktadır.