Bu codelab'de, el yazısıyla yazılmış rakamları tanıyan bir nöral ağı nasıl oluşturacağınızı ve eğiteceğinizi öğreneceksiniz. Bu süreçte, sinir ağınızı% 99 doğruluk elde edecek şekilde geliştirirken derin öğrenme uzmanlarının modellerini verimli bir şekilde eğitmek için kullandığı araçları da keşfedeceksiniz.
Bu codelab'de, yaklaşık yirmi yıldır doktora öğrencilerinin üzerinde çalıştığı 60.000 etiketli rakamdan oluşan bir koleksiyon olan MNIST veri kümesi kullanılmaktadır. Bu problemi 100 satırdan az Python / TensorFlow koduyla çözeceksiniz.
Neler öğreneceksiniz?
- Nöral ağ nedir ve nasıl eğitilir?
- tf.keras kullanarak temel bir tek katmanlı sinir ağı oluşturma
- Daha fazla katman ekleme
- Öğrenme hızı planı oluşturma
- Evrişimli nöral ağlar oluşturma
- Düzenlileştirme tekniklerini kullanma: bırakma, toplu normalleştirme
- Aşırı uyum nedir?
İhtiyacınız olanlar
Yalnızca bir tarayıcı. Bu atölye çalışması tamamen Google Colaboratory ile yapılabilir.
Geri bildirim
Bu laboratuvarda yanlış bir şey görürseniz veya iyileştirilmesi gerektiğini düşünürseniz lütfen bize bildirin. Geri bildirimleri GitHub sorunları [geri bildirim bağlantısı] üzerinden ele alıyoruz.
Bu laboratuvarda Google Colaboratory kullanılır ve sizin tarafınızda herhangi bir kurulum yapılması gerekmez. Bu aracı Chromebook'ta çalıştırabilirsiniz. Lütfen aşağıdaki dosyayı açın ve hücreleri çalıştırarak Colab not defterleri hakkında bilgi edinin.
Ek talimatlar aşağıda verilmiştir:
GPU arka ucu seçme
Colab menüsünde Çalışma zamanı > Çalışma zamanı türünü değiştir'i ve ardından GPU'yu seçin. Çalışma zamanına bağlantı ilk yürütmede otomatik olarak gerçekleşir veya sağ üst köşedeki "Bağlan" düğmesini kullanabilirsiniz.
Not defteri yürütme
Bir hücreyi tıklayıp Üst Karakter+ENTER tuşlarını kullanarak hücreleri teker teker çalıştırın. Ayrıca Çalışma zamanı > Tümünü çalıştır seçeneğini kullanarak not defterinin tamamını çalıştırabilirsiniz.
İçindekiler
Tüm not defterlerinde içindekiler tablosu bulunur. Sol taraftaki siyah oku kullanarak açabilirsiniz.
Gizli hücreler
Bazı hücrelerde yalnızca başlık gösterilir. Bu, Colab'e özgü bir not defteri özelliğidir. İçindeki kodu görmek için bu dosyalara çift tıklayabilirsiniz ancak bu kodlar genellikle çok ilgi çekici değildir. Genellikle destek veya görselleştirme işlevleri. İçerideki işlevlerin tanımlanması için bu hücreleri yine de çalıştırmanız gerekir.
Öncelikle bir sinir ağının eğitilmesini izleyeceğiz. Lütfen aşağıdaki not defterini açıp tüm hücreleri çalıştırın. Şimdilik koda dikkat etmeyin. Daha sonra açıklamaya başlayacağız.
Not defterini çalıştırırken görselleştirmelere odaklanın. Açıklamalar için aşağıya bakın.
Eğitim verileri
Her resmin neyi temsil ettiğini (ör. 0 ile 9 arasında bir sayı) bilmemiz için etiketlenmiş, el yazısıyla yazılmış rakamlardan oluşan bir veri kümemiz var. Not defterinde bir alıntı görürsünüz:
Oluşturacağımız sinir ağı, el yazısıyla yazılmış rakamları 10 sınıfa (0, .., 9) ayırır. Bu işlem, sınıflandırmanın iyi çalışması için doğru değere sahip olması gereken dahili parametrelere göre yapılır. Bu "doğru değer", resimler ve ilişkili doğru yanıtları içeren bir "etiketli veri kümesi" gerektiren bir eğitim süreciyle öğrenilir.
Eğitilmiş sinir ağının iyi performans gösterip göstermediğini nasıl anlarız? Ağı test etmek için eğitim veri kümesini kullanmak hile yapmakla eşdeğerdir. Bu veri kümesini eğitim sırasında birden çok kez görmüş ve kesinlikle çok iyi performans göstermiştir. Ağın "gerçek dünya" performansını değerlendirmek için eğitim sırasında hiç görülmemiş başka bir etiketlenmiş veri kümesine ihtiyacımız var. Buna "doğrulama veri kümesi" denir.
Eğitim
Eğitim ilerledikçe, her seferinde bir eğitim verisi grubu olmak üzere dahili model parametreleri güncellenir ve model, el yazısıyla yazılmış rakamları tanımada giderek daha iyi hale gelir. Bu bilgiyi eğitim grafiğinde görebilirsiniz:
Sağ taraftaki "doğruluk" değeri, doğru tanınan rakamların yüzdesidir. Eğitim ilerledikçe bu oran artar.
Solda "kayıp" değerini görebiliriz. Eğitimi yönlendirmek için, sistemin rakamları ne kadar kötü tanıdığını gösteren bir "loss" işlevi tanımlayacak ve bunu en aza indirmeye çalışacağız. Burada gördüğünüz gibi, eğitim ilerledikçe hem eğitim hem de doğrulama verilerindeki kayıp azalıyor. Bu iyi bir durumdur. Bu, nöral ağın öğrendiği anlamına gelir.
X ekseni, tüm veri kümesindeki "dönemlerin" veya yinelemelerin sayısını gösterir.
Tahminler
Model eğitildiğinde, el yazısıyla yazılmış rakamları tanımak için kullanabiliriz. Sonraki görselleştirme,yerel yazı tiplerinden oluşturulan birkaç basamakta (ilk satır) ve ardından doğrulama veri kümesinin 10.000 basamağında nasıl performans gösterdiğini gösterir. Tahmin edilen sınıf, her rakamın altında görünür. Yanlışsa kırmızı renkte gösterilir.
Gördüğünüz gibi, bu ilk model çok iyi olmasa da bazı rakamları doğru şekilde tanıyor. Son doğrulama doğruluğu yaklaşık% 90'dır. Bu, başlangıçta kullandığımız basit model için çok kötü olmasa da 10.000 doğrulama rakamından 1.000'inin kaçırıldığı anlamına gelir. Bu sayı, gösterilebilecek yanıt sayısından çok daha fazla olduğu için tüm yanıtlar yanlış (kırmızı) görünür.
Tensörler
Veriler matrislerde depolanır. 28x28 piksellik bir gri tonlamalı resim, 28x28 boyutlu iki boyutlu bir matrise sığar. Ancak renkli bir resim için daha fazla boyuta ihtiyacımız var. Piksel başına 3 renk değeri (kırmızı, yeşil, mavi) olduğundan [28, 28, 3] boyutlarında üç boyutlu bir tablo gerekir. 128 renkli resimden oluşan bir grubu depolamak için [128, 28, 28, 3] boyutlarında dört boyutlu bir tablo gerekir.
Bu çok boyutlu tablolara "tensörler", boyutlarının listesine ise "şekil" denir.
Özet
Bir sonraki paragrafta kalın olarak belirtilen tüm terimleri biliyorsanız bir sonraki alıştırmaya geçebilirsiniz. Derin öğrenmeye yeni başlıyorsanız hoş geldiniz. Lütfen okumaya devam edin.
Keras, katman dizisi olarak oluşturulan modeller için Sequential API'yi sunar. Örneğin, üç yoğun katman kullanan bir görüntü sınıflandırıcı, Keras'ta şu şekilde yazılabilir:
model = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=[28, 28, 1]),
tf.keras.layers.Dense(200, activation="relu"),
tf.keras.layers.Dense(60, activation="relu"),
tf.keras.layers.Dense(10, activation='softmax') # classifying into 10 classes
])
# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
optimizer='adam',
loss= 'categorical_crossentropy',
metrics=['accuracy']) # % of correct answers
# train the model
model.fit(dataset, ... )
Tek bir yoğun katman
MNIST veri kümesindeki el yazısıyla yazılmış rakamlar, 28x28 piksel boyutunda gri tonlamalı resimlerdir. Bunları sınıflandırmanın en basit yolu, 28x28=784 pikseli tek katmanlı bir sinir ağı için giriş olarak kullanmaktır.
Bir nöral ağdaki her "nöron", tüm girişlerinin ağırlıklı toplamını alır, "önyargı" adı verilen bir sabiti ekler ve ardından sonucu doğrusal olmayan bir "aktivasyon fonksiyonu" aracılığıyla besler. "Ağırlıklar" ve "eğilimler", eğitim yoluyla belirlenecek parametrelerdir. İlk başta rastgele değerlerle başlatılırlar.
Yukarıdaki resimde, rakamları 10 sınıfa (0-9) ayırmak istediğimiz için 10 çıkış nöronlu 1 katmanlı bir nöral ağ gösterilmektedir.
Matris çarpımıyla
Bir resim koleksiyonunu işleyen nöral ağ katmanının matris çarpımıyla nasıl gösterilebileceği aşağıda açıklanmıştır:
Ağırlık matrisi W'daki ilk ağırlık sütununu kullanarak ilk resmin tüm piksellerinin ağırlıklı toplamını hesaplarız. Bu toplam, ilk nörona karşılık gelir. Ağırlıkların ikinci sütununu kullanarak ikinci nöron için de aynı işlemi yaparız ve bu işlem 10. nörona kadar devam eder. Ardından, kalan 99 resim için işlemi tekrarlayabiliriz. 100 resmimizi içeren matrise X dersek 100 resim üzerinde hesaplanan 10 nöronumuzun tüm ağırlıklı toplamları basitçe X.W, yani bir matris çarpımıdır.
Her nöron artık sabit bir değer olan önyargısını eklemelidir. 10 nöronumuz olduğundan 10 önyargı sabiti vardır. Bu 10 değerlik vektöre b adını vereceğiz. Daha önce hesaplanan matrisin her satırına eklenmelidir. "Yayın" adı verilen bir sihir kullanarak bunu basit bir artı işaretiyle yazacağız.
Son olarak, örneğin "softmax" (aşağıda açıklanmıştır) gibi bir aktivasyon fonksiyonu uygularız ve 100 görüntüye uygulanan 1 katmanlı bir sinir ağını açıklayan formülü elde ederiz:
Keras'ta
Keras gibi üst düzey sinir ağı kitaplıkları sayesinde bu formülü uygulamamız gerekmeyecek. Ancak bir sinir ağı katmanının yalnızca bir dizi çarpma ve toplama işleminden oluştuğunu anlamak önemlidir. Keras'ta yoğun bir katman şu şekilde yazılır:
tf.keras.layers.Dense(10, activation='softmax')Derine inin
Nöral ağ katmanlarını zincirlemek kolaydır. İlk katman, piksellerin ağırlıklı toplamlarını hesaplar. Sonraki katmanlar, önceki katmanların çıkışlarının ağırlıklı toplamlarını hesaplar.
Nöron sayısının dışında tek fark, etkinleştirme işlevinin seçimidir.
Etkinleştirme işlevleri: relu, softmax ve sigmoid
Genellikle son katman hariç tüm katmanlar için "relu" etkinleştirme işlevini kullanırsınız. Bir sınıflandırıcıdaki son katman "softmax" etkinleştirmesini kullanır.
Yine bir "nöron", tüm girişlerinin ağırlıklı toplamını hesaplar, "bias" adı verilen bir değer ekler ve sonucu aktivasyon işlevinden geçirir.
En popüler etkinleştirme işlevine, Doğrultulmuş Doğrusal Birim için "RELU" adı verilir. Yukarıdaki grafikte de görebileceğiniz gibi bu çok basit bir fonksiyondur.
Sinir ağlarındaki geleneksel etkinleştirme işlevi "sigmoid" idi ancak "relu" işlevinin neredeyse her yerde daha iyi yakınsama özelliklerine sahip olduğu gösterildi ve artık tercih ediliyor.
Sınıflandırma için Softmax etkinleştirme
El yazısıyla yazılmış rakamları 10 sınıfa (0,..9) ayırmak istediğimiz için nöral ağımızın son katmanında 10 nöron bulunur. Bu rakamın 0, 1, 2 vb. olma olasılığını gösteren 0 ile 1 arasında 10 sayı çıkışı vermelidir. Bunun için son katmanda "softmax" adlı bir etkinleştirme işlevi kullanacağız.
Bir vektöre softmax uygulamak için her öğenin üstel değeri alınır ve ardından vektör normalleştirilir.Normalleştirme işlemi genellikle vektörün "L1" normuna (yani mutlak değerlerin toplamına) bölünmesiyle yapılır. Böylece normalleştirilmiş değerlerin toplamı 1 olur ve olasılık olarak yorumlanabilir.
Etkinleştirmeden önceki son katmanın çıkışına bazen "logits" adı verilir. Bu vektör L = [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9] ise:
Çapraz entropi kaybı (Cross-entropy loss)
Nöral ağımız artık giriş resimlerinden tahminler ürettiğine göre, bu tahminlerin ne kadar iyi olduğunu (yani ağın bize söyledikleri ile doğru cevaplar arasındaki mesafeyi) ölçmemiz gerekiyor. Bu mesafeye genellikle "etiketler" adı verilir. Veri kümesindeki tüm resimler için doğru etiketlere sahip olduğumuzu unutmayın.
Herhangi bir mesafe işe yarar ancak sınıflandırma sorunları için "çapraz entropi mesafesi" olarak adlandırılan mesafe en etkilidir. Buna hata veya "kayıp" işlevimiz diyeceğiz:
Gradyan inişi
Nöral ağı "eğitmek" aslında çapraz entropi kayıp fonksiyonunu en aza indirmek için ağırlıkları ve önyargıları ayarlamak üzere eğitim resimlerini ve etiketlerini kullanmak anlamına gelir. İşleyiş şekli şöyledir:
Çapraz entropi, ağırlıkların, önyargıların, eğitim görüntüsünün piksellerinin ve bilinen sınıfının bir fonksiyonudur.
Çapraz entropinin tüm ağırlıklar ve tüm sapmalarla ilgili kısmi türevlerini hesaplarsak belirli bir resim, etiket ve ağırlıkların ve sapmaların mevcut değeri için hesaplanan bir "gradyan" elde ederiz. Milyonlarca ağırlık ve önyargı olabileceği için gradyanı hesaplamanın çok fazla iş gerektireceğini unutmayın. Neyse ki TensorFlow bu işi bizim için yapar. Bir gradyanın matematiksel özelliği "yukarı"yı göstermesidir. Çapraz entropinin düşük olduğu yere gitmek istediğimiz için ters yönde ilerliyoruz. Ağırlıkları ve önyargıları gradyanın bir kısmı kadar güncelleriz. Ardından, eğitim döngüsünde bir sonraki eğitim resimleri ve etiket gruplarını kullanarak aynı işlemi tekrar tekrar yaparız. Bu minimumun benzersiz olduğunu garanti eden bir şey olmasa da bu işlemin, çapraz entropinin minimum olduğu bir noktada birleşeceği umulur.
Mini toplu işleme ve momentum
Gradyanınızı yalnızca bir örnek resim üzerinde hesaplayıp ağırlıkları ve önyargıları hemen güncelleyebilirsiniz. Ancak bunu örneğin 128 resimlik bir grup üzerinde yapmak, farklı örnek resimlerin getirdiği kısıtlamaları daha iyi temsil eden bir gradyan sağlar ve bu nedenle çözüme daha hızlı ulaşma olasılığı daha yüksektir. Mini toplu işin boyutu ayarlanabilir bir parametredir.
Bazen "stokastik gradyan inişi" olarak da adlandırılan bu tekniğin daha pratik bir avantajı vardır: Gruplarla çalışmak, daha büyük matrislerle çalışmak anlamına da gelir ve bunlar genellikle GPU'larda ve TPU'larda optimize edilmesi daha kolaydır.
Ancak yakınsama hâlâ biraz kaotik olabilir ve gradyan vektörü tamamen sıfırsa durabilir. Bu, minimum bir değer bulduğumuz anlamına mı geliyor? Her zaman değil Bir renk geçişi bileşeni minimum veya maksimumda sıfır olabilir. Milyonlarca öğeden oluşan bir gradyan vektöründe, tüm öğeler sıfırsa her sıfırın bir minimuma ve hiçbirinin bir maksimum noktaya karşılık gelme olasılığı oldukça düşüktür. Çok boyutlu bir uzayda eyer noktaları oldukça yaygındır ve bu noktalarda durmak istemeyiz.
Resim: Eyer noktası. Eğim 0'dır ancak her yönde minimum değildir. (Resim atfı Wikimedia: Nicoguaro - Own work, CC BY 3.0)
Çözüm, optimizasyon algoritmasına biraz ivme kazandırmaktır. Böylece algoritma, durmadan eyer noktalarını geçebilir.
Sözlük
Toplu veya mini toplu: Eğitim her zaman toplu eğitim verileri ve etiketleri üzerinde gerçekleştirilir. Bu sayede algoritma yakınlaşır. "Toplu iş" boyutu genellikle veri tensörlerinin ilk boyutudur. Örneğin, [100, 192, 192, 3] şeklindeki bir tensör, piksel başına üç değer (RGB) içeren 192x192 piksellik 100 resim içerir.
Çapraz entropi kaybı: Sınıflandırıcılarda sıklıkla kullanılan özel bir kayıp işlevi.
Yoğun katman: Her nöronun önceki katmandaki tüm nöronlara bağlı olduğu bir nöron katmanı.
Özellikler: Nöral ağın girişlerine bazen "özellikler" denir. İyi tahminler elde etmek için bir veri kümesinin hangi bölümlerinin (veya bölüm kombinasyonlarının) bir nöral ağa besleneceğini belirleme sanatına "özellik mühendisliği" denir.
Etiketler: Denetimli sınıflandırma sorununda "sınıflar" veya doğru yanıtlar için kullanılan başka bir ad
Öğrenme oranı: Ağırlıkların ve yanlılıkların eğitim döngüsünün her yinelemesinde güncellendiği gradyanın kesri.
logits: Bir nöron katmanının, etkinleştirme işlevi uygulanmadan önceki çıkışlarına "logits" adı verilir. Bu terim, bir zamanlar en popüler etkinleştirme işlevi olan "sigmoid işlevi" olarak da bilinen "lojistik işlev"ten gelir. "Neuron outputs before logistic function" (Lojistik işlevden önceki nöron çıkışları) ifadesi "logits" (logitler) olarak kısaltıldı.
kayıp: Nöral ağ çıkışlarını doğru yanıtlarla karşılaştıran hata işlevi
Nöron: Girişlerinin ağırlıklı toplamını hesaplar, bir önyargı ekler ve sonucu bir aktivasyon fonksiyonu aracılığıyla besler.
One-hot kodlama: 5 sınıftan 3. sınıf, 5 öğeli bir vektör olarak kodlanır. 3. öğe 1 olmak üzere diğer tüm öğeler sıfırdır.
relu: doğrultulmuş doğrusal birim. Nöronlar için popüler bir etkinleştirme işlevi.
sigmoid: Bir zamanlar popüler olan ve özel durumlarda hâlâ kullanışlı olan başka bir etkinleştirme işlevi.
softmax: Bir vektör üzerinde işlem yapan, en büyük bileşen ile diğer tüm bileşenler arasındaki farkı artıran ve vektörü olasılık vektörü olarak yorumlanabilmesi için toplamı 1 olacak şekilde normalleştiren özel bir etkinleştirme işlevi. Sınıflandırıcılarda son adım olarak kullanılır.
tensor: "Tensor", matrise benzer ancak rastgele sayıda boyuta sahiptir. 1 boyutlu tensörler vektördür. 2 boyutlu tensör bir matristir. Daha sonra 3, 4, 5 veya daha fazla boyuta sahip tensörleriniz olabilir.
Çalışma not defterine dönelim ve bu kez kodu okuyalım.
Bu not defterindeki tüm hücreleri inceleyelim.
"Parametreler" hücresi
Toplu iş boyutu, eğitim dönemlerinin sayısı ve veri dosyalarının konumu burada tanımlanır. Veri dosyaları, Google Cloud Storage (GCS) paketinde barındırıldığından adresleri gs:// ile başlar.
"İçe aktarmalar" hücresi
TensorFlow ve görselleştirmeler için matplotlib dahil olmak üzere gerekli tüm Python kitaplıkları buraya aktarılır.
"Görselleştirme yardımcı programları [ÇALIŞTIR]" hücresi
Bu hücre, ilginç olmayan görselleştirme kodu içeriyor. Bu bölüm varsayılan olarak daraltılmış durumdadır ancak çift tıklayarak açabilir ve kodu inceleyebilirsiniz.
"tf.data.Dataset: dosyaları ayrıştırın ve eğitim ile doğrulama veri kümelerini hazırlayın" hücresi
Bu hücre, veri dosyalarından MNIST veri kümesini yüklemek için tf.data.Dataset API'sini kullanır. Bu hücrede çok fazla zaman harcamanıza gerek yoktur. tf.data.Dataset API'siyle ilgileniyorsanız TPU-speed data pipelines (TPU hızında veri işlem hatları) başlıklı eğitime göz atabilirsiniz. Şu an için temel bilgiler şunlardır:
MNIST veri kümesindeki resimler ve etiketler (doğru yanıtlar) 4 dosyada sabit uzunluklu kayıtlar halinde depolanır. Dosyalar, özel sabit kayıt işleviyle yüklenebilir:
imagedataset = tf.data.FixedLengthRecordDataset(image_filename, 28*28, header_bytes=16)Artık görüntü baytlarından oluşan bir veri kümemiz var. Bunların resimlere dönüştürülmesi gerekir. Bunu yapmak için bir işlev tanımlarız. Görüntü sıkıştırılmadığı için işlevin herhangi bir şeyi kod çözmesi gerekmez (decode_raw temelde hiçbir şey yapmaz). Ardından, resim 0 ile 1 arasında değişen kayan nokta değerlerine dönüştürülür. Burada 2 boyutlu bir resim olarak yeniden şekillendirebiliriz ancak başlangıçtaki yoğun katmanımız bunu beklediği için 28*28 boyutunda düz bir piksel dizisi olarak tutarız.
def read_image(tf_bytestring):
image = tf.decode_raw(tf_bytestring, tf.uint8)
image = tf.cast(image, tf.float32)/256.0
image = tf.reshape(image, [28*28])
return imageBu işlevi .map kullanarak veri kümesine uyguluyoruz ve görüntülerin yer aldığı bir veri kümesi elde ediyoruz:
imagedataset = imagedataset.map(read_image, num_parallel_calls=16)Etiketler için de aynı türde okuma ve kod çözme işlemleri yaparız. Ayrıca, .zip resimleri ve etiketleri birlikte:
dataset = tf.data.Dataset.zip((imagedataset, labelsdataset))Artık (resim, etiket) çiftlerinden oluşan bir veri kümemiz var. Modelimiz bunu bekler. Bu özelliği henüz eğitim işlevinde kullanmaya hazır değiliz:
dataset = dataset.cache()
dataset = dataset.shuffle(5000, reshuffle_each_iteration=True)
dataset = dataset.repeat()
dataset = dataset.batch(batch_size)
dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)tf.data.Dataset API, veri kümelerini hazırlamak için gereken tüm yardımcı işlevlere sahiptir:
.cache veri kümesini RAM'de önbelleğe alır. Bu, küçük bir veri kümesi olduğundan çalışacaktır. .shuffle, 5.000 öğelik bir arabellek ile karıştırır. Eğitim verilerinin iyi karıştırılması önemlidir. .repeat veri kümesini döngüye alır. Bu veri üzerinde birden çok kez (birden çok dönem) eğitim yapacağız. .batch, birden fazla resmi ve etiketi bir araya getirerek mini bir eşleşme oluşturur. Son olarak, .prefetch, mevcut grup GPU'da eğitilirken bir sonraki grubu hazırlamak için CPU'yu kullanabilir.
Doğrulama veri kümesi de benzer şekilde hazırlanır. Artık bir model tanımlamaya ve bu veri kümesini kullanarak modeli eğitmeye hazırız.
"Keras Modeli" hücresi
Tüm modellerimiz, katmanların düz sıraları şeklinde olacak. Bu nedenle, bunları oluşturmak için tf.keras.Sequential stilini kullanabiliriz. Burada başlangıçta tek bir yoğun katman vardır. El yazısıyla yazılmış rakamları 10 sınıfa ayırdığımız için 10 nöronu vardır. Bir sınıflandırıcıdaki son katman olduğundan "softmax" etkinleştirmesini kullanır.
Keras modelinin de girişlerinin şeklini bilmesi gerekir. tf.keras.layers.Input kullanılarak tanımlanabilir. Burada giriş vektörleri, 28*28 uzunluğundaki piksel değerlerinin düz vektörleridir.
model = tf.keras.Sequential(
[
tf.keras.layers.Input(shape=(28*28,)),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='sgd',
loss='categorical_crossentropy',
metrics=['accuracy'])
# print model layers
model.summary()
# utility callback that displays training curves
plot_training = PlotTraining(sample_rate=10, zoom=1)Modelin yapılandırılması, Keras'ta model.compile işlevi kullanılarak yapılır. Burada temel optimize edici 'sgd' (Stokastik Gradyan İnişi) kullanıyoruz. Sınıflandırma modeli için Keras'ta 'categorical_crossentropy' olarak adlandırılan bir çapraz entropi kaybı işlevi gerekir. Son olarak, modelden doğru sınıflandırılmış resimlerin yüzdesi olan 'accuracy' metriğini hesaplamasını istiyoruz.
Keras, oluşturduğunuz modelin ayrıntılarını yazdıran çok kullanışlı bir model.summary() yardımcı programı sunar. İlgili eğitmeniniz, eğitim sırasında çeşitli eğitim eğrilerini gösterecek olan PlotTraining yardımcı programını ("görselleştirme yardımcı programları" hücresinde tanımlanmıştır) ekledi.
"Modeli eğitme ve doğrulama" hücresi
Eğitim, model.fit çağrılarak ve hem eğitim hem de doğrulama veri kümeleri iletilerek gerçekleştirilir. Keras, varsayılan olarak her dönemin sonunda bir doğrulama turu çalıştırır.
model.fit(training_dataset, steps_per_epoch=steps_per_epoch, epochs=EPOCHS,
validation_data=validation_dataset, validation_steps=1,
callbacks=[plot_training])Keras'ta geri çağırmaları kullanarak eğitim sırasında özel davranışlar eklemek mümkündür. Bu atölye çalışmasında, dinamik olarak güncellenen eğitim planı bu şekilde uygulanmıştır.
"Tahminleri görselleştirin" hücresi
Model eğitildikten sonra model.predict() işlevini çağırarak modelden tahmin alabiliriz:
probabilities = model.predict(font_digits, steps=1)
predicted_labels = np.argmax(probabilities, axis=1)Burada, yerel yazı tiplerinden oluşturulmuş bir dizi basılı rakam hazırladık. Nöral ağın, son "softmax" işleminden 10 olasılıklı bir vektör döndürdüğünü unutmayın. Etiketi almak için hangi olasılığın en yüksek olduğunu bulmamız gerekir. np.argmax from the numpy library does that.
axis=1 parametresinin neden gerekli olduğunu anlamak için 128 resimlik bir grubun işlendiğini ve bu nedenle modelin 128 olasılık vektörü döndürdüğünü hatırlatırız. Çıkış tensörünün şekli [128, 10] olur. Her resim için döndürülen 10 olasılık arasında argmax hesaplıyoruz. Bu nedenle axis=1 (ilk eksen 0'dır).
Bu basit model, rakamların% 90'ını tanıyor. Fena değil ama artık bunu önemli ölçüde iyileştireceksin.
Tanıma doğruluğunu artırmak için nöral ağa daha fazla katman ekleyeceğiz.
Sınıflandırma için en iyi sonuçları veren işlev olduğu için son katmanda aktivasyon işlevi olarak softmax'ı kullanmaya devam ediyoruz. Ancak ara katmanlarda en klasik aktivasyon işlevini (sigmoid) kullanacağız:
Örneğin, modeliniz şu şekilde görünebilir (virgülleri unutmayın, tf.keras.Sequential virgülle ayrılmış bir katman listesi alır):
model = tf.keras.Sequential(
[
tf.keras.layers.Input(shape=(28*28,)),
tf.keras.layers.Dense(200, activation='sigmoid'),
tf.keras.layers.Dense(60, activation='sigmoid'),
tf.keras.layers.Dense(10, activation='softmax')
])Modelinizin "özetine" bakın. Şimdi en az 10 kat daha fazla parametreye sahip. 10 kat daha iyi olmalı. Ancak nedense bu durum geçerli değil.
The loss seems to have shot through the roof too. Doğru olmayan bir şeyler var.
80'li ve 90'lı yıllarda insanların tasarladığı şekliyle nöral ağları deneyimlediniz. Bu nedenle, fikirden vazgeçip sözde "yapay zeka kışını" başlatmaları şaşırtıcı değildir. Gerçekten de katman ekledikçe nöral ağların yakınsaması giderek zorlaşır.
Birkaç matematiksel hileyle yakınsamaları sağlandığı takdirde, çok katmanlı (günümüzde 20, 50 hatta 100 katmanlı) derin sinir ağlarının gerçekten iyi çalıştığı ortaya çıktı. Bu basit püf noktalarının keşfi, 2010'larda derin öğrenmenin yeniden canlanmasının nedenlerinden biridir.
RELU etkinleştirme
Sigmoid etkinleştirme işlevi, derin ağlarda aslında oldukça sorunludur. 0 ile 1 arasındaki tüm değerleri sıkıştırır ve bunu tekrar tekrar yaptığınızda nöron çıkışları ve bunların gradyanları tamamen kaybolabilir. Bu, geçmişte kullanıldığı için bahsedilmiştir ancak modern ağlarda RELU (Rectified Linear Unit) kullanılır. RELU şu şekildedir:
Öte yandan ReLU'nun türevi en azından sağ tarafında 1'dir. RELU etkinleştirme ile bazı nöronlardan gelen gradyanlar sıfır olsa bile her zaman sıfır olmayan net bir gradyan veren başka nöronlar olacağından eğitim iyi bir hızda devam edebilir.
Daha iyi bir optimize edici
Buradaki gibi çok yüksek boyutlu uzaylarda (10.000 civarında ağırlık ve önyargı var) "eyer noktaları" sık görülür. Bunlar yerel minimum olmayan ancak gradyanın yine de sıfır olduğu ve gradyan inişi optimizasyon aracının orada takılı kaldığı noktalardır. TensorFlow'da, bir miktar ataletle çalışan ve eyer noktalarını güvenli bir şekilde geçenler de dahil olmak üzere çok çeşitli optimize ediciler bulunur.
Rastgele başlatmalar
Eğitimden önce ağırlık önyargılarını başlatma sanatı, kendi başına bir araştırma alanıdır ve bu konuda çok sayıda makale yayınlanmıştır. Keras'ta bulunan tüm başlatıcıları burada inceleyebilirsiniz. Neyse ki Keras, varsayılan olarak doğru olanı yapar ve neredeyse tüm durumlarda en iyi olan 'glorot_uniform' başlatıcıyı kullanır.
Keras doğru işlemi yaptığından sizin yapmanız gereken bir şey yoktur.
NaN ???
Çapraz entropi formülünde logaritma bulunur ve log(0) bir sayı değildir (NaN). Çapraz entropi giriş değeri 0 olabilir mi? Giriş, temelde üstel bir fonksiyon olan ve hiçbir zaman sıfır olmayan softmax'tan gelir. Bu nedenle güvende olduğumuzu düşünüyoruz.
Gerçekten mi? Matematiğin güzel dünyasında güvende olurduk ancak bilgisayar dünyasında, float32 biçiminde gösterilen exp(-150) değeri sıfır olarak kabul edilir ve çapraz entropi çöker.
Neyse ki Keras bu işlemi hallettiği ve sayısal kararlılığı sağlamak ve korkulan NaN'leri önlemek için çapraz entropiyi takiben softmax'ı özellikle dikkatli bir şekilde hesapladığı için burada da yapmanız gereken bir şey yok.
Başarılı mı?
Artık% 97 doğruluk oranına ulaşmanız gerekir. Bu atölye çalışmasındaki hedefimiz% 99'un çok üzerine çıkmak. Bu nedenle devam edelim.
Takılırsanız bu noktada çözüm şudur:
Belki daha hızlı eğitme yöntemleri deneyebiliriz. Adam optimize edicisindeki varsayılan öğrenme hızı 0,001'dir. Bu sınırı artırmayı deneyelim.
Daha hızlı gitmek pek yardımcı olmuyor ve bu gürültü de neyin nesi?
Eğitim eğrileri çok gürültülü ve her iki doğrulama eğrisine de bakıldığında yukarı ve aşağı doğru hareket ediyor. Bu, çok hızlı ilerlediğimiz anlamına gelir. Önceki hızımıza dönebiliriz ancak daha iyi bir yol var.
İyi çözüm, hızlı bir başlangıç yapmak ve öğrenme hızını üstel olarak azaltmaktır. Keras'ta bunu tf.keras.callbacks.LearningRateScheduler geri çağırma işleviyle yapabilirsiniz.
Kopyalayıp yapıştırmak için kullanışlı kod:
# lr decay function
def lr_decay(epoch):
return 0.01 * math.pow(0.6, epoch)
# lr schedule callback
lr_decay_callback = tf.keras.callbacks.LearningRateScheduler(lr_decay, verbose=True)
# important to see what you are doing
plot_learning_rate(lr_decay, EPOCHS)Oluşturduğunuz lr_decay_callback kullanmayı unutmayın. model.fit içindeki geri çağırma listesine ekleyin:
model.fit(..., callbacks=[plot_training, lr_decay_callback])Bu küçük değişikliğin etkisi muhteşemdir. Gürültünün büyük ölçüde ortadan kalktığını ve test doğruluğunun artık sürekli olarak% 98'in üzerinde olduğunu görürsünüz.
Model şu anda iyi bir şekilde yakınsıyor. Daha da ayrıntıya inmeye çalışalım.
Bu bilgiler yardımcı oldu mu?
Hayır, doğruluk oranı hâlâ% 98'de takılı kalmış durumda ve doğrulama kaybına bakın. Yükseliyor. Öğrenme algoritması yalnızca eğitim verileri üzerinde çalışır ve eğitim kaybını buna göre optimize eder. Hiçbir zaman doğrulama verilerini görmediği için bir süre sonra çalışmasının doğrulama kaybı üzerinde etkisi kalmaması, doğrulama kaybının düşmeyi bırakması ve hatta bazen tekrar yükselmesi şaşırtıcı değildir.
Bu durum, modelinizin gerçek dünyadaki tanıma özelliklerini hemen etkilemez ancak birçok yineleme çalıştırmanızı engeller ve genellikle eğitimin artık olumlu bir etkisi olmadığının işaretidir.
Bu bağlantı kesilmesine genellikle "aşırı uyum" denir. Bunu gördüğünüzde "dropout" adı verilen bir düzenlileştirme tekniği uygulamayı deneyebilirsiniz. Bırakma tekniği, her eğitim yinelemesinde rastgele nöronlar kullanır.
İşe yaradı mı?
Gürültü yeniden görünür (kesintinin işleyiş şekli göz önüne alındığında bu durum şaşırtıcı değildir). Doğrulama kaybı artık artmıyor ancak genel olarak bırakma olmadan elde edilen değerden daha yüksek. Doğrulama doğruluğu biraz düştü. Bu sonuç oldukça hayal kırıklığı yaratıcı.
Dropout'un doğru çözüm olmadığı veya "aşırı uyum"un daha karmaşık bir kavram olduğu ve nedenlerinden bazılarının "dropout" düzeltmesine uygun olmadığı anlaşılıyor.
"Aşırı uyum" nedir? Aşırı uyum, bir sinir ağının "kötü" bir şekilde öğrenmesiyle ortaya çıkar. Bu durumda ağ, eğitim örnekleri için iyi sonuçlar verir ancak gerçek dünya verilerinde aynı başarıyı gösteremez. Dropout gibi düzenleme teknikleri, modelin daha iyi bir şekilde öğrenmesini sağlayabilir ancak aşırı uyumun daha derin kökleri vardır.
Temel aşırı uyum, bir nöral ağın söz konusu sorun için çok fazla serbestlik derecesine sahip olduğunda meydana gelir. Ağda, eğitim görüntülerimizin tamamını depolayabileceğimiz ve ardından bunları desen eşleştirme yoluyla tanıyabileceğimiz kadar çok nöron olduğunu düşünün. Gerçek dünyadaki verilerde tamamen başarısız olur. Bir nöral ağ, eğitim sırasında öğrendiklerini genellemeye zorlanması için bir şekilde kısıtlanmalıdır.
Çok az eğitim veriniz varsa küçük bir ağ bile bu verileri ezberleyebilir ve "aşırı uyum" sorunuyla karşılaşırsınız. Genel olarak, nöral ağları eğitmek için her zaman çok fazla veriye ihtiyacınız vardır.
Son olarak, her şeyi doğru şekilde yaptıysanız, serbestlik derecelerinin kısıtlandığından emin olmak için farklı ağ boyutlarıyla denemeler yaptıysanız, bırakma uyguladıysanız ve çok sayıda veri üzerinde eğitim yaptıysanız yine de performans seviyesinde takılıp kalabilirsiniz. Bu durumda, performansı iyileştirecek hiçbir şey yokmuş gibi görünebilir. Bu, mevcut şekliyle sinir ağınızın, buradaki örneğimizde olduğu gibi verilerinizden daha fazla bilgi çıkaramadığı anlamına gelir.
Resimlerimizi tek bir vektörde birleştirerek nasıl kullandığımızı hatırlıyor musunuz? Bu gerçekten kötü bir fikirdi. El yazısıyla yazılmış rakamlar şekillerden oluşur ve pikselleri düzleştirirken şekil bilgilerini atarız. Ancak şekil bilgilerinden yararlanabilen bir tür nöral ağ vardır: evrişimli ağlar. Bunları deneyelim.
Takılırsanız bu noktada çözüm şudur:
Özet
Bir sonraki paragrafta kalın olarak belirtilen tüm terimleri biliyorsanız bir sonraki alıştırmaya geçebilirsiniz. Evrişimli sinir ağlarını kullanmaya yeni başlıyorsanız lütfen okumaya devam edin.
Resim: Her biri 4x4x3=48 öğrenilebilir ağırlıktan oluşan iki ardışık filtreyle bir resmi filtreleme.
Basit bir evrişimli sinir ağı Keras'ta şu şekilde görünür:
model = tf.keras.Sequential([
tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1)),
tf.keras.layers.Conv2D(kernel_size=3, filters=12, activation='relu'),
tf.keras.layers.Conv2D(kernel_size=6, filters=24, strides=2, activation='relu'),
tf.keras.layers.Conv2D(kernel_size=6, filters=32, strides=2, activation='relu'),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(10, activation='softmax')
])
Bir evrişimli ağ katmanında, bir "nöron" yalnızca görüntünün küçük bir bölgesinde, hemen üstündeki piksellerin ağırlıklı toplamını yapar. Normal bir yoğun katmandaki nöron gibi, bir önyargı ekler ve toplamı bir etkinleştirme işlevi aracılığıyla besler. Bu işlem daha sonra aynı ağırlıklar kullanılarak tüm görüntüde tekrarlanır. Yoğun katmanlarda her nöronun kendi ağırlıkları olduğunu unutmayın. Burada, ağırlıkların tek bir "yama"sı, görüntünün üzerinde her iki yönde de kayar (bir "evrişim"). Çıkışta, resimdeki piksel sayısı kadar değer bulunur (ancak kenarlarda biraz dolgu gerekir). Bu bir filtreleme işlemidir. Yukarıdaki resimde 4x4x3=48 ağırlık filtresi kullanılıyor.
Ancak 48 ağırlık yeterli olmayacaktır. Daha fazla serbestlik derecesi eklemek için aynı işlemi yeni bir ağırlık grubuyla tekrarlıyoruz. Bu işlem, yeni bir filtre çıkışı grubu oluşturur. Giriş görüntüsündeki R, G, B kanallarına benzer şekilde, buna "çıktı kanalı" diyelim.
İki (veya daha fazla) ağırlık kümesi, yeni bir boyut eklenerek tek bir tensör olarak toplanabilir. Bu, bir evrişimli katman için ağırlık tensörünün genel şeklini verir. Giriş ve çıkış kanallarının sayısı parametre olduğundan, evrişimli katmanları yığmaya ve zincirlemeye başlayabiliriz.
Resim: Evrişimli bir nöral ağ, veri "küplerini" başka veri "küplerine" dönüştürüyor.
Adımlı evrişimler, maksimum havuzlama
Evrişimleri 2 veya 3 adımlık bir adımla gerçekleştirerek elde edilen veri küpünü yatay boyutlarında da küçültebiliriz. Bunu yapmanın iki yaygın yolu vardır:
- Adımlı evrişim: Yukarıdaki gibi kayan bir filtre ancak adımı >1
- Maksimum havuzlama: MAX işlemini uygulayan kayan pencere (genellikle 2x2 yamalarda, her 2 pikselde bir tekrarlanır)
Resim: Hesaplama penceresinin 3 piksel kaydırılması daha az çıkış değeriyle sonuçlanır. Adımlı evrişimler veya maksimum havuzlama (2 adımlık bir adımla kayan 2x2 pencerede maksimum) veri küpünü yatay boyutlarda küçültmenin bir yoludur.
Son katman
Son evrişimli katmandan sonra veriler "küp" şeklindedir. Bu verileri son yoğun katmana aktarmanın iki yolu vardır.
Birincisi, veri küpünü vektöre düzleştirip softmax katmanına beslemektir. Bazen softmax katmanından önce yoğun bir katman bile ekleyebilirsiniz. Bu yöntem, ağırlık sayısı açısından maliyetli olabilir. Bir evrişimli ağın sonundaki yoğun katman, tüm nöral ağın ağırlıklarının yarısından fazlasını içerebilir.
Pahalı bir yoğun katman kullanmak yerine, gelen veri "küpünü" sınıf sayımız kadar parçaya bölebilir, değerlerini ortalayabilir ve bunları bir softmax etkinleştirme işlevinden geçirebiliriz. Sınıflandırma başlığını bu şekilde oluşturmak 0 ağırlık maliyetine sahiptir. Keras'ta bunun için bir katman vardır: tf.keras.layers.GlobalAveragePooling2D().
Söz konusu sorun için evrişimli ağ oluşturmak üzere sonraki bölüme geçin.
El yazısıyla yazılmış rakamları tanımak için bir evrişimli ağ oluşturalım. En üstte üç evrişimli katman, en altta geleneksel softmax okuma katmanımız kullanılacak ve bunlar tam bağlantılı bir katmanla bağlanacak:
İkinci ve üçüncü evrişimli katmanların iki adımlı olduğunu fark edin. Bu, çıkış değerlerinin sayısını 28x28'den 14x14'e ve ardından 7x7'ye düşürmelerinin nedenidir.
Keras kodunu yazalım.
İlk evrişimli katmandan önce özel dikkat gerekir. Aslında, 3 boyutlu bir veri "küpü" bekleniyor ancak veri kümemiz şu ana kadar yoğun katmanlar için ayarlandı ve görüntülerin tüm pikselleri bir vektörde düzleştirildi. Bunları tekrar 28x28x1 boyutunda resimler (gri tonlamalı resimler için 1 kanal) haline getirmemiz gerekir:
tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1))Şimdiye kadar kullandığınız tf.keras.layers.Input katmanı yerine bu satırı kullanabilirsiniz.
Keras'ta "relu" etkinleştirilmiş bir evrişimli katmanın söz dizimi şöyledir:
tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu')Adımlı bir evrişim için şunu yazarsınız:
tf.keras.layers.Conv2D(kernel_size=6, filters=24, padding='same', activation='relu', strides=2)Yoğun bir katman tarafından kullanılabilmesi için bir veri küpünü vektöre düzleştirmek üzere:
tf.keras.layers.Flatten()Yoğun katman için söz dizimi değişmedi:
tf.keras.layers.Dense(200, activation='relu')Modeliniz% 99 doğruluk sınırını aştı mı? Neredeyse... ancak doğrulama kaybı eğrisine bakın. Bu durum size tanıdık geliyor mu?
Tahminlere de göz atın. İlk kez çalıştırdığınızda 10.000 test rakamının çoğunun artık doğru şekilde tanındığını görmelisiniz. Yalnızca yaklaşık 4,5 satır yanlış algılama kaldı (10.000 basamaktan yaklaşık 110'u)
Takılırsanız bu noktada çözüm şudur:
Önceki eğitimde aşırı uyumun net işaretleri görülüyor (ve doğruluk oranı hâlâ% 99'un altında). Tekrar dropout'u denemeli miyiz?
Bu sefer nasıl geçti?
Bu sefer dropout işe yaradı. Doğrulama kaybı artık artmıyor ve nihai doğruluk %99'un çok üzerinde olmalıdır. Tebrikler!
Dropout'u ilk uygulamaya çalıştığımızda, aslında sorun sinir ağının mimarisindeyken aşırı uyum sorunu olduğunu düşündük. Evrişimli katmanlar olmadan daha ileri gidemezdik ve bu konuda dropout'un yapabileceği hiçbir şey yoktu.
Bu sefer, sorunun nedeninin aşırı uyum olduğu ve bırakma işleminin gerçekten yardımcı olduğu anlaşılıyor. Doğrulama kaybının artmasıyla birlikte eğitim ve doğrulama kaybı eğrileri arasında bağlantı kopmasına neden olabilecek birçok şey olduğunu unutmayın. Aşırı uyum (çok fazla serbestlik derecesi, ağ tarafından kötü kullanılıyor) bunlardan yalnızca biridir. Veri kümeniz çok küçükse veya sinir ağınızın mimarisi yeterli değilse kayıp eğrilerinde benzer bir davranış görebilirsiniz ancak bırakma bu durumda yardımcı olmaz.
Son olarak, toplu normalleştirme eklemeyi deneyelim.
Teoride durum bu şekildedir. Pratikte ise yalnızca birkaç kuralı hatırlamanız yeterlidir:
Şimdilik kurallara uyalım ve son katman hariç her sinir ağı katmanına bir toplu normalleştirme katmanı ekleyelim. Son "softmax" katmanına eklemeyin. Bu durumda yararlı olmaz.
# Modify each layer: remove the activation from the layer itself.
# Set use_bias=False since batch norm will play the role of biases.
tf.keras.layers.Conv2D(..., use_bias=False),
# Batch norm goes between the layer and its activation.
# The scale factor can be turned off for Relu activation.
tf.keras.layers.BatchNormalization(scale=False, center=True),
# Finish with the activation.
tf.keras.layers.Activation('relu'),Doğruluk oranı şu anda nasıl?
Küçük bir ayarlama (BATCH_SIZE=64, öğrenme hızı azalma parametresi 0,666, yoğun katmanda bırakma oranı 0,3) ve biraz da şansla %99,5'e ulaşabilirsiniz. Öğrenme hızı ve bırakma ayarlamaları, toplu normalleştirme kullanmayla ilgili "en iyi uygulamalar" dikkate alınarak yapıldı:
- Toplu normalleştirme, nöral ağların yakınlaşmasına yardımcı olur ve genellikle daha hızlı eğitmenizi sağlar.
- Toplu normalleştirme, düzenleyici bir tekniktir. Genellikle kullandığınız bırakma miktarını azaltabilir veya hiç kullanmayabilirsiniz.
Çözüm not defterinde% 99,5 eğitim çalıştırması vardır:
Kodun buluta hazır sürümünü GitHub'daki mlengine klasöründe ve Google Cloud AI Platform'da çalıştırma talimatlarını bulabilirsiniz. Bu bölümü çalıştırabilmek için Google Cloud hesabı oluşturmanız ve faturalandırmayı etkinleştirmeniz gerekir. Laboratuvarı tamamlamak için gereken kaynaklar birkaç dolardan az olmalıdır (bir GPU'da 1 saatlik eğitim süresi varsayılarak). Hesabınızı hazırlamak için:
- Google Cloud Platform projesi oluşturun (http://cloud.google.com/console).
- Faturalandırmayı etkinleştirin.
- GCP komut satırı araçlarını (GCP SDK'sını buradan) yükleyin.
- Bir Google Cloud Storage paketi oluşturun (
us-central1bölgesine yerleştirin). Bu paket, eğitim kodunu hazırlamak ve eğitilmiş modelinizi depolamak için kullanılır. - Gerekli API'leri etkinleştirin ve gerekli kotaları isteyin (eğitim komutunu bir kez çalıştırdığınızda etkinleştirmeniz gerekenleri belirten hata mesajları alırsınız).
İlk nöral ağınızı oluşturup% 99 doğruluk oranına ulaşana kadar eğittiniz. Bu süreçte öğrenilen teknikler MNIST veri kümesine özgü değildir. Aslında sinir ağlarıyla çalışırken yaygın olarak kullanılırlar. Veda hediyesi olarak, laboratuvarın "özet" kartını karikatür versiyonuyla paylaşıyoruz. Bu özelliği, öğrendiklerinizi hatırlamak için kullanabilirsiniz:
Sonraki adımlar
- Tam bağlantılı ve evrişimli ağlardan sonra tekrarlayan sinir ağlarına göz atmanız gerekir.
- Eğitim veya çıkarım işlemlerinizi dağıtılmış bir altyapıda bulutta çalıştırmak için Google Cloud, AI Platform'u sunar.
- Son olarak, geri bildirimlerinizi öğrenmekten memnuniyet duyarız. Bu laboratuvarda yanlış bir şey görürseniz veya iyileştirilmesi gerektiğini düşünürseniz lütfen bize bildirin. Geri bildirimleri GitHub sorunları [geri bildirim bağlantısı] üzerinden ele alıyoruz.
Yazar: Martin Görner Twitter: @martin_gorner |
|
Bu laboratuvardaki tüm karikatür resimlerinin telif hakkı: alexpokusay / 123RF stok fotoğrafları