1. Genel Bakış
Bu eğitim, TensorFlow 2.2 için güncellendi.
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 öğrencilerini meşgul eden 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 1 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.
2. Google Colaboratory hızlı başlangıç
Bu laboratuvarda Google Colaboratory kullanılır ve sizin tarafınızda herhangi bir kurulum yapılması gerekmez. Uygulamayı 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 bunları çift tıklayabilirsiniz ancak genellikle çok ilginç 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.
3. Nöral ağı eğitme
Ö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ın yer aldığı 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 bu veri kümesinde 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 değer yükselir.
Sol tarafta "kayıp" gösterilir. Eğitimi yönlendirmek için, sistemin rakamları ne kadar kötü tanıdığını gösteren bir "kayıp" 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 kullanılabilir. Bir 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 oran, 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.
4. [INFO]: neural networks 101
Özet
Bir sonraki paragraftaki kalın harflerle yazılmış 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 piksellik gri tonlamalı görüntülerdir. Bunları sınıflandırmanın en basit yolu, 28x28=784 pikseli 1 katmanlı bir sinir ağının girişleri 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. Bunlar ilk başta rastgele değerlerle başlatılır.
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 bir 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 adını verirsek 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 kendi önyargısını (sabit) 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ınlama" adı verilen bir sihir kullanarak bunu basit bir artı işaretiyle yazacağız.
Son olarak, "softmax" gibi bir aktivasyon fonksiyonu (aşağıda açıklanmıştır) 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çimi olacaktır.
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 etkinleştirme işlevinden geçirir.
En popüler etkinleştirme işlevine Doğrusal Birim Düzeltmesi 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 bu değerler olasılık olarak yorumlanabilir.
Etkinleştirmeden önceki son katmanın çıktısı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)
Sinir 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 etkili olanıdır. 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 işlemin, çapraz entropinin minimum olduğu bir noktada birleşeceği umulur ancak bu minimumun benzersiz olduğunu garanti eden bir şey yoktur.
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 faydası 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 yine de 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 maksimum değerde 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 tüm yönlerde minimum değildir. (Resim ilişkilendirmesi 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 algoritmanın yakınlaşmasına yardımcı olursunuz. "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" adı verilir.
etiketler: denetimli sınıflandırma sorununda "sınıflar" veya doğru yanıtlar için kullanılan başka bir ad
Öğrenme hızı: 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"den 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 çalışan, en büyük bileşen ile diğer tüm bileşenler arasındaki farkı artıran ve aynı zamanda 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.
5. Koda geçelim
Çalışma not defterine dönelim ve bu kez kodu okuyalım.
Bu not defterindeki tüm hücreleri inceleyelim.
"Parametreler" hücresi
Grup 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.
"visualization utilities [RUN ME]****" hücresi
Bu hücrede, ilgi çekici olmayan görselleştirme kodu var. 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, MNIST veri kümesini veri dosyalarından 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 hızında veri işlem hatları başlıklı eğitime göz atabilirsiniz. Şimdilik temel bilgiler şunlardır:
MNIST veri kümesindeki resimler ve etiketler (doğru cevaplar) 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ımlıyoruz. 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 görüntü, 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.io.decode_raw(tf_bytestring, tf.uint8)
image = tf.cast(image, tf.float32)/256.0
image = tf.reshape(image, [28*28])
return image
Bu işlevi .map kullanarak veri kümesine uygularız ve bir resim veri kümesi elde ederiz:
imagedataset = imagedataset.map(read_image, num_parallel_calls=16)
Etiketler için de aynı türde okuma ve kod çözme işlemlerini yaparız. Ayrıca, .zip resimleri ve etiketleri birlikte kullanırız:
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 gerekli tüm hizmet işlevlerine 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 kümesi üzerinde birden çok kez (birden çok dönem) eğitim yapacağız. .batch, birden fazla resmi ve etiketi bir mini toplu iş halinde bir araya getirir. 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. Başlangıçta burada 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ğunda 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 kayıp fonksiyonu 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, test amacıyla 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 işlevi, numpy kitaplığında bu işlemi yapar.
axis=1 parametresinin neden gerekli olduğunu anlamak için lütfen 128 resimlik bir grubu işlediğimizi ve bu nedenle modelin 128 olasılık vektörü döndürdüğünü unutmayın. Çıkış tensörünün şekli [128, 10] olur. Her resim için döndürülen 10 olasılıkta 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.
6. Katman ekleme
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 aktivasyon işlevi softmax olduğundan son katmanda bu işlevi kullanmaya devam ediyoruz. Ancak ara katmanlarda en klasik etkinleştirme işlevini (sigmoid) kullanırı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.
Kaybın da çok yüksek olduğu anlaşılıyor. Doğru olmayan bir şeyler var.
7. Derin ağlar için özel bakım
80'li ve 90'lı yıllarda insanların tasarladığı şekliyle nöral ağları deneyimlediniz. Bu nedenle, fikirden vazgeçerek 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şteki nedenlerden dolayı 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 net bir sıfır olmayan gradyan veren başka nöronlar olur ve 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 optimizasyon aracı 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 bir üstel fonksiyon olan ve hiçbir zaman sıfır olmayan softmax'tan gelir. Bu nedenle güvende olursunuz.
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ıra en yakın değerdir ve çapraz entropi çöker.
Neyse ki Keras bu işlemi hallettiği ve sayısal kararlılığı sağlamak ve korkulan NaN'lerden kaçınmak 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ü aşağıda bulabilirsiniz:
8. Öğrenme hızının azalması
Belki daha hızlı eğitme yöntemini 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ğrisi de yukarı aşağı 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şem. 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.
9. Dropout, fazla uyum
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 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 olmaması şaşırtıcı değildir. Doğrulama kaybı düşmeyi bırakır ve hatta bazen tekrar yükselir.
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 ortaya çıkar (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 dropout 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ğın, tüm eğitim resimlerimizi depolayabileceği ve ardından bunları desen eşleştirme yoluyla tanıyabileceği kadar çok nöronumuz olduğunu düşünün. Gerçek dünya verilerinde tamamen başarısız olurdu. 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 yaptıysanız, serbestlik derecelerinin sınırlandırıldığı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. Deneyelim.
Takılırsanız bu noktada çözümü aşağıda bulabilirsiniz:
10. [INFO] convolutional networks
Özet
Bir sonraki paragraftaki kalın harflerle yazılmış 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 görüntüyü 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ı, resim üzerinde her iki yönde de kayar ("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. Buna, giriş resmindeki R, G, B kanallarına benzer şekilde "çıkış 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'dir.
- Maksimum havuzlama: MAX işlemini uygulayan bir kayan pencere (genellikle 2x2 yamalarda, her 2 pikselde bir tekrarlanır)
Resim: Hesaplama penceresinin 3 piksel kaydırılması, daha az çıktı değeriyle sonuçlanır. Adımlı evrişimler veya maksimum havuzlama (2 adımlık bir adımla kayan 2x2 pencereli maksimum) veri küpünü yatay boyutlarda küçültmenin bir yoludur.
Son katman
Son evrişimli katmandan sonra veriler "küp" şeklindedir. Son yoğun katmana iki şekilde beslenebilir.
Birincisi, veri küpünü vektöre düzleştirip softmax katmanına aktarmaktır. Bazen softmax katmanından önce yoğun bir katman bile ekleyebilirsiniz. Bu, 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şturmanın maliyeti 0 ağırlıktır. Keras'ta bunun için bir katman vardır: tf.keras.layers.GlobalAveragePooling2D().
Eldeki sorun için bir evrişimli ağ oluşturmak üzere sonraki bölüme geçin.
11. Evrişimli ağ
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ğlanacaktır:
İkinci ve üçüncü evrişimli katmanların iki adımlı olduğunu unutmayın. Bu nedenle, çıkış değerlerinin sayısı 28x28'den 14x14'e, ardından 7x7'ye düşer.
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. Bu resimleri tekrar 28x28x1 boyutunda (gri tonlamalı resimler için 1 kanal) olacak şekilde yeniden şekillendirmemiz gerekir:
tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1))
Bu satırı, şimdiye kadar kullandığınız tf.keras.layers.Input katmanı yerine 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ı? Çok yaklaştınız... ancak doğrulama kaybı eğrisine bakın. Bu durum size tanıdık geliyor mu?
Tahminlere de göz atın. İlk kez, 10.000 test rakamının çoğunun artık doğru şekilde tanındığını görürsünüz. 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ü aşağıda bulabilirsiniz:
12. Tekrar bırakma
Ö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 deneyelim mi?
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 nöral ağın mimarisindeyken fazla uyumlu 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.
13. Toplu normalleştirme
Son olarak, toplu normalleştirme eklemeyi deneyelim.
Teoride böyle olsa da pratikte 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 bir düzenleyicidir. Genellikle kullandığınız bırakma miktarını azaltabilir, hatta hiç kullanmayabilirsiniz.
Çözüm not defterinde% 99,5 eğitim çalıştırması vardır:
14. Güçlü donanımlarda bulutta eğitme: AI Platform
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 önce 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ı yükleyin ( GCP SDK'sını buradan yükleyebilirsiniz).
- 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).
15. Tebrikler!
İlk nöral ağınızı oluşturup% 99 doğruluk oranına 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 bulutta dağıtılmış bir altyapıda ç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örnerTwitter: 
Bu laboratuvardaki tüm karikatür resimlerinin telif hakkı: alexpokusay / 123RF stok fotoğrafları