1. Genel Bakış
Bu eğitim, Tensorflow 2.2 için güncellendi.
Bu codelab'de, elle yazılmış rakamları tanıyan bir nöral ağ oluşturmayı ve eğitmeyi öğreneceksiniz. Bu süreçte, nöral ağınızı% 99 doğruluk oranına ulaşacak şekilde geliştirirken, derin öğrenme uzmanlarının modellerini verimli bir şekilde eğitmek için kullandıkları ticaret araçlarını da keşfedeceksiniz.
Bu codelab'de, 60.000 etiketli basamaktan oluşan MNIST veri kümesi kullanılmaktadır. Bu veri kümesi,neredeyse yirmi yıldır doktora yapan akademik çalışmaların önemli bir kısmını oluşturur. Sorunu 100 satırdan daha az Python / TensorFlow koduyla çözeceksiniz.
Neler öğreneceksiniz?
- Nöral ağ nedir ve nasıl eğitilir
- tf.keras kullanarak temel 1 katmanlı nöral ağ oluşturma
- Daha fazla katman nasıl eklenir?
- Öğrenme oranı programı oluşturma
- Konvolüsyonel nöral ağlar nasıl oluşturulur?
- Normalleştirme tekniklerinin kullanımı: ayrılma, toplu normalleştirme
- Fazla uyumlu olan nedir?
Gerekenler
Sadece bir tarayıcı. Bu atölye tamamen Google Colaboratory ile gerçekleştirilebilir.
Geri bildirim
Bu laboratuvarda bir eksiklik görürseniz veya bir şeylerin iyileştirilmesi gerektiğini düşünüyorsanız lütfen bize bildirin. Geri bildirimleri GitHub sorunları [geri bildirim bağlantısı] üzerinden ele alıyoruz.
2. Google Colaboratory hızlı başlangıç kılavuzu
Bu laboratuvarda Google Colaboratory kullanılır ve sizin herhangi bir kurulum yapmanız gerekmez. Bu uygulamayı Chromebook'tan çalıştırabilirsiniz. Lütfen aşağıdaki dosyayı açın ve Colab not defterleri hakkında bilgi edinmek için hücreleri yürütün.
Ek talimatlar aşağıda verilmiştir:
GPU arka ucu seçin
Colab menüsünde Çalışma zamanı > Çalışma zamanı türünü değiştirin ve ardından GPU'yu seçin. Çalışma zamanı bağlantısı ilk çalıştırma sırasında otomatik olarak kurulur. Alternatif olarak, düğmesini tıklayın.
Not defteri yürütme
Bir hücreyi tıklayıp Üst Karakter-ENTER tuşlarını kullanarak hücreleri tek tek yürütün. Not defterinin tamamını da Çalışma zamanı > Tümünü çalıştır
İçindekiler
Tüm not defterlerinin bir içindekiler tablosu vardır. Soldaki siyah oku kullanarak açabilirsiniz.
Gizli hücreler
Bazı hücrelerde yalnızca başlık gösterilir. Bu, Colab'e özel bir not defteri özelliğidir. Üzerlerini çift tıklayarak içindeki kodu görebilirsiniz, ancak bu durum genellikle pek de ilgi çekici değildir. Genellikle işlevleri destekler veya görselleştirme yapar. İçerideki işlevlerin tanımlanması için bu hücreleri yine de çalıştırmanız gerekir.
3. Nöral ağ eğitme
Önce bir nöral ağ trenini izleyeceğiz. Lütfen aşağıdaki not defterini açın ve tüm hücreleri inceleyin. Henüz koda dikkat etmeyin, bunu daha sonra açıklamaya başlayacağız.
Not defterini yürütürken görselleştirmelere odaklanın. Açıklamalar için aşağıya bakın.
Eğitim verileri
Her resmin neyi temsil ettiğini bilebilmemiz için (0 ile 9 arasında bir sayı) etiketlenmiş, elle yazılmış rakamlardan oluşan bir veri kümemiz bulunuyor. Not defterinde bir alıntı görürsünüz:
Oluşturacağımız nöral ağ, 10 sınıfındaki (0, .., 9) elle yazılmış rakamları sınıflandıracak. Sınıflandırmanın iyi çalışması için doğru değere sahip olması gereken dahili parametreleri temel alır. Bu "doğru değer" "etiketli veri kümesi" gerektiren bir eğitim sürecinden geçer doğru cevapları içeren bir özet seçin.
Eğitilmiş nöral ağın iyi performans gösterip göstermediğini nasıl anlarız? Ağı test etmek için eğitim veri kümesini kullanmak hile olacaktır. Eğitim sırasında veri kümesini birkaç kez görmüştür ve kesinlikle veri kümesi üzerinde de çok iyi performans göstermektedir. "Gerçek dünyayı" değerlendirmek için, eğitimde daha önce görülmemiş başka bir etiketli veri kümesine ihtiyacımız var. daha iyi performans gösterir. "Doğrulama veri kümesi" olarak adlandırılır
Eğitim
Eğitim ilerledikçe, aynı anda yalnızca bir eğitim verisi grubu oluşturulur, dahili model parametreleri güncellenir ve model, elle yazılmış rakamları tanıma konusunda giderek daha iyi hale gelir. Bunu eğitim grafiğinde görebilirsiniz:
Sağ tarafta, "doğruluk" doğru tanınan basamakların yüzdesidir. Eğitim ilerledikçe bu oran da artıyor. Bu iyi bir şey.
Sol tarafta "kayıp" görülebilir. Eğitimi devam ettirmek için bir "kayıp" işlevine göz atın ve bu değeri en aza indirmeye çalışın. Burada, eğitim ilerledikçe kaybın hem eğitimde hem de doğrulama verilerinde düştüğünü görüyorsunuz. Bu iyi bir şey. Bu, nöral ağın öğrenme aşamasında olduğunu gösterir.
X ekseni, "epochs" (dönem) sayısını gösterir. iterasyonlar ile yürütüldüğü anlamına gelir.
Tahminler
Model eğitildiğinde, elle yazılmış rakamları tanımak için modeli kullanabiliriz. Bir sonraki görselleştirmede,bu özelliğin yerel yazı tiplerinden (ilk satır) oluşturulan birkaç rakam ve ardından doğrulama veri kümesinin 10.000 basamağı üzerinde ne kadar iyi performans gösterdiği gösterilir. Tahmin edilen sınıf, yanlışsa her rakamın altında kırmızı renkte görünür.
Gördüğünüz gibi bu ilk model pek iyi değil ancak yine de bazı rakamları doğru şekilde tanıyor. Nihai doğrulama doğruluğu% 90 civarındadır. Bu oran, kullanmaya başladığımız basit model için o kadar da kötü olmasa da 10.000 doğrulama basamağının 1.000'ini gözden kaçırdığı anlamına gelir. Bu bilgiden daha fazlası gösterilebilir. Bu nedenle tüm yanıtlar yanlış (kırmızı) görünür.
Tensörler
Veriler matrisler halinde depolanır. 28x28 piksellik gri tonlamalı bir resim, 28x28 boyutundaki iki boyutlu bir matrise sığar. Ancak renkli resimler 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 de [128, 28, 28, 3] boyutlarında dört boyutlu bir tablo gerekiyor.
Bu çok boyutlu tablolara "tensör" adı verilir ve boyutların listesi, tabloların "şekilleri"dir.
4. [BİLGİ]: nöral ağlar 101
Özet
Bir sonraki paragrafta yer alan kalın yazı tipindeki tüm terimleri zaten biliyorsanız bir sonraki alıştırmaya geçebilirsiniz. Derin öğrenmeye yeni başlıyorsanız hoş geldiniz. Lütfen okumaya devam edin.
Keras, bir dizi katman olarak oluşturulan modeller için Sequential API'yi sunmaktadır. Örneğin, üç yoğun katman kullanan bir resim 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 elle yazılmış rakamlar, 28x28 piksellik gri tonlamalı resimlerdir. Bunları sınıflandırmak için en basit yaklaşım, 28x28=784 piksel değerini 1 katmanlı bir nöral ağ için giriş olarak kullanmaktır.
Bir nöral ağdaki her "nöron", tüm girişlerinin ağırlıklı bir toplamını yapar ve "önyargı" adı verilen bir sabit tutar ekler ve daha sonra, sonucu doğrusal olmayan bir "etkinleştirme işlevi" üzerinden iletir. "Ağırlıklar" ve "ön yargılar", eğitim aracılığıyla belirlenecek parametrelerdir. Başlangıçta rastgele değerlerle başlatılır.
Yukarıdaki resimde, rakamları 10 sınıfa (0 - 9) sınıflandırmak istediğimiz için 10 çıkış nöronuna sahip 1 katmanlı bir nöral ağı temsil etmektedir.
Matris çarpım işlemiyle
Bir resim koleksiyonunu işleyen nöral ağ katmanı, matris çarpım işlemiyle şu şekilde gösterilebilir:
W ağırlık matrisindeki ilk ağırlıklar sütununu kullanarak, ilk resmin tüm piksellerinin ağırlıklı toplamını hesaplarız. Bu toplam, ilk nörona karşılık gelir. İkinci ağırlık sütununda ise aynı işlemi ikinci nöron için de tekrarlıyoruz ve bu şekilde 10. nörona kadar devam ediyoruz. Daha sonra, kalan 99 resim için bu işlemi tekrarlayabiliriz. 100 görüntümüzü içeren matrise X adını verirsek, 10 nöronumuzun 100 görüntü üzerinde hesaplanan ağırlıklı toplamlarının tamamı X.W, yani bir matris çarpımı olur.
Artık her nöron kendi ön yargısını (sabit bir değer) eklemelidir. Elimizde 10 nöron olduğundan 10 yanlılık sabit değerimiz var. 10 değerine sahip bu vektöre b adını vereceğiz. Önceden hesaplanan matrisin her satırına eklenmelidir. "Yayın" adı verilen sihirli bir dokunuşla bunu basit bir artı işaretiyle yazacağız.
Son olarak, "softmax" gibi bir aktivasyon fonksiyonu uygularız (aşağıda açıklanmıştır) ve 100 görüntüye uygulanmış 1 katmanlı nöral ağı tanımlayan formülü elde edin:
Keras'ta
Keras gibi üst seviye nöral ağ kitaplıklarında bu formülü uygulamamıza gerek yoktur. Bununla birlikte, nöral ağ katmanının bir dizi çarpma ve ekleme işleminden ibaret olduğunun anlaşılması önemlidir. Keras'ta yoğun katman şu şekilde yazılır:
tf.keras.layers.Dense(10, activation='softmax')
Derinlere dalın
Nöral ağ katmanları zinciri oluşturmak önemsizdir. İ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ışındaki tek fark, aktivasyon fonksiyonunun seçilmesi olacaktır.
Etkinleştirme işlevleri: relu, softmax ve sigmoid
Genelde "relu" bölümünü aktivasyon fonksiyonu. Sınıflandırıcıdaki son katman "softmax" türünü kullanır etkinleştirme.
Aynı şekilde, bir "nöron" tüm girişlerinin ağırlıklı bir toplamını hesaplar, buna "önyargı" adı verilen bir değer ekler ve aktivasyon işlevi aracılığıyla sonucu iletir.
Doğrulanmış Doğrusal Birim için en popüler etkinleştirme işlevi "RELU" olarak adlandırılır. Yukarıdaki grafikte de görebileceğiniz gibi çok basit bir fonksiyondur.
Nöral ağlarda geleneksel etkinleştirme işlevi "sigmoid" ancak "relu" idi hemen hemen her yerde daha iyi yakınlaşma özelliklerine sahip olduğu görüldü ve artık tercih ediliyor.
Sınıflandırma için Softmax etkinleştirme
Nöral ağımızın son katmanında 10 nöron bulunuyor, çünkü elle yazılmış rakamları 10 sınıfa (0,..9) ayırmak istiyoruz. Bu basamağın 0, 1, 2 vb. olma olasılığını temsil eden 0 ile 1 arasında 10 sayı çıkarması gerekir. Bunun için son katmanda "softmax" adlı bir etkinleştirme işlevi kullanacağız.
Bir vektöre softmax uygulamak, her bir elemanın üstel değerinin alınması ve ardından vektör, genellikle "L1" değerine bölünerek normalleştirilir. normalleştirilmiş değerlerin toplamı 1'e eşit olması ve olasılıklar olarak yorumlanabilmesi için normalleştirilmiş değerlerin toplamıdır.
Etkinleştirmeden önceki son katmanın çıktısı bazen "logits" olarak adlandırılır. Bu vektör L = [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9] ise:
Çapraz entropi kaybı
Nöral ağımız artık giriş görüntülerinden tahminler ürettiğine göre, bunların ne kadar iyi olduğunu, yani ağın bize bildirdiği bilgiler ile doğru yanıtlar arasındaki mesafeyi, yani genellikle "etiketler"i ölçmemiz gerekir. Veri kümesindeki tüm görüntüler 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" en etkili olandır. Bunu hatamız veya "kayıp" olarak adlandıracağız işlev:
Gradyan inişi
"Eğitim" nöral ağ aslında çapraz entropi kayıp işlevini en aza indirmek amacıyla ağırlıkları ve yanlılıkları ayarlamak için eğitim görüntülerini ve etiketleri kullanmayı ifade eder. İşleyiş şekline bakalım.
Çapraz entropi, eğitim görüntüsünün ağırlıklarının, sapmalarının, piksellerinin ve bilinen sınıfının bir fonksiyonudur.
Tüm ağırlıklara ve tüm sapmalara göre çapraz entropinin kısmi türevlerini hesaplarsak, belirli bir görüntü, etiket ve ağırlıkların ve yanlılığın mevcut değeri için hesaplanan bir "gradyan" elde ederiz. Milyonlarca ağırlığa ve sapmaya sahip olabileceğimizi, bu nedenle gradyanı hesaplamanın çok büyük bir iş olduğunu unutmayın. Neyse ki TensorFlow bunu bizim için yapıyor. Bir renk geçişinin matematiksel özelliği, "yukarı" işaret etmesidir. Çapraz entropinin düşük olduğu yere gitmek istediğimizden ters yönde ilerliyoruz. Ağırlıkları ve sapmaları gradyanın bir kısmına göre güncelleriz. Daha sonra, bir eğitim döngüsünde sonraki eğitim görüntüsü ve etiketi gruplarını kullanarak aynı şeyi tekrar tekrar yaparız. Bunun, çapraz entropinin minimum düzeyde olduğu bir yere yaklaşacağını umuyoruz, ancak bu minimum değerin benzersiz olduğunu hiçbir şey garanti etmemektedir.
Küçük baskı ve ivme
Renk geçişinizi tek bir örnek resim üzerinde hesaplayıp ağırlıkları ve sapmaları hemen güncelleyebilirsiniz. Ancak, örneğin 128 resimden oluşan bir grup üzerinde bunu yaptığınızda, farklı örnek resimlerin uyguladığı kısıtlamaları daha iyi temsil eden ve dolayısıyla çözüme daha hızlı yaklaşma olasılığı yüksek bir gradyan elde edilir. Mini grubun boyutu ayarlanabilir bir parametredir.
Bazen "olasılıksal gradyan inişi" olarak da adlandırılan bu teknik daha pragmatik bir faydası da var: Gruplarla çalışmak daha büyük matrislerle çalışmak anlamına geliyor. Bunların GPU ve TPU'larda optimize edilmesi genellikle daha kolay.
Ancak yakınsaklık yine de biraz kaotik olabilir ve gradyan vektörü sıfır olsa bile durabilir. Bu, minimum değer bulduğumuz anlamına mı geliyor? Her zaman değil Gradyan bileşeni minimum veya maksimum sıfır olabilir. Milyonlarca öğe içeren bir gradyan vektöründe, hepsi sıfırsa, her sıfırın bir minimum değere karşılık gelme ve hiçbirinin bir maksimum noktaya ulaşma olasılığı oldukça küçüktür. Birçok boyutu olan bir alanda, eyer noktaları oldukça yaygındır ve bunlarla yetinmek istemeyiz.
Çizim: Eyer noktası. Gradyan 0'dır, ancak tüm yönlerde minimum değer değildir. (Resim atfı Wikimedia: Yazan: Nicoguaro - Kendi eseri, CC BY 3.0)
Çözüm, optimizasyon algoritmasına bir hız eklemektir. Böylece, algoritma durmadan bağlı noktaların ötesine geçebilir.
Sözlük
toplu veya mini toplu: Eğitim, her zaman eğitim verisi ve etiket grupları üzerinde gerçekleştirilir. Bu, algoritmanın yakınlaşmasına yardımcı olur. "Toplu" boyut, 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 genellikle kullanılan özel bir kayıp işlevi.
yoğun katman: Her nöronun bir önceki katmandaki tüm nöronlara bağlı olduğu bir nöron katmanı.
özellikler: Bir nöral ağın girişleri bazen "özellikler" olarak adlandırılır. İyi tahminler elde etmek için veri kümesinin hangi bölümlerinin (veya parça kombinasyonlarının) bir nöral ağa besleneceğini bulma sanatına "özellik mühendisliği" denir.
labels: "sınıflar" için başka bir ad veya doğru cevapları içeren gözetimli
öğrenme hızı: Ağırlıkların ve sapmaların, eğitim döngüsündeki her iterasyonda güncellendiği gradyanın oranı.
logits: Aktivasyon işlevi uygulanmadan önce bir nöron katmanının çıktılarına "logit" adı verilir. Terim, "mantıksal fonksiyon"dan gelir "sigmoid işlevi" olarak da bilinir. eskiden en popüler aktivasyon fonksiyonuydu. "Lojistik fonksiyondan önce nöron çıkışları" kısaltılmıştı "logits" olarak değiştirildi.
loss: 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 ağırlık ekler ve sonucu bir aktivasyon işlevi aracılığıyla iletir.
tek sıcak kodlama: 5 üzerinden 3. sınıf, 5 öğeden oluşan bir vektör olarak kodlanır. 3'üncü olan (1) hariç tüm sıfırlar kullanılır.
relu: Düzeltilmiş doğrusal birim. Nöronlar için popüler bir aktivasyon fonksiyonu.
sigmoid: Eskiden popüler olan ve özel durumlarda yararlı olan başka bir etkinleştirme işlevidir.
softmax: Bir vektör üzerinde etki eden, en büyük bileşen ile diğer bileşenler arasındaki farkı artıran ve vektörü, olasılıkların vektörü olarak yorumlanabilmesi için toplam 1 olacak şekilde normalleştiren özel bir aktivasyon fonksiyonu. Sınıflandırıcılarda son adım olarak kullanılır.
tensor: Bir "tensor" bir matrise benzer ancak rastgele sayıda boyuta sahiptir. 1 boyutlu tensör bir vektördür. 2 boyutlu tensör, bir matristir. 3, 4, 5 veya daha fazla boyutlu tensörleriniz de olabilir.
5. Şimdi koda geçelim
Çalışma not defterine dönelim. Bu kez kodu okuyalım.
Şimdi 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ığı için adresleri gs:// ile başlar.
Hücre "İçe Aktarma"
TensorFlow ve görselleştirmeler için matplotlib de dahil olmak üzere gerekli tüm Python kitaplıkları buraya aktarılır.
"görselleştirme yardımcı programları [RUN ME]****" hücresi
Bu hücrede ilginç olmayan görselleştirme kodu var. Varsayılan olarak daraltılmıştır ancak vaktiniz olduğunda kodu açabilir ve çift tıklayarak koda bakabilirsiniz.
"tf.data.Dataset: dosyaları ayrıştır, eğitim ve doğrulama veri kümelerini hazırla"
Bu hücrede, veri dosyalarından MNIST veri kümesini yüklemek için tf.data.Dataset API kullanıldı. Bu hücrede çok fazla vakit geçirmenize gerek yoktur. tf.data.Dataset API ile ilgileniyorsanız TPU hızında veri ardışık düzenleri hakkında bilgi veren bir eğitici içeriği inceleyin. Şu an için temel bilgiler şunlardır:
MNIST veri kümesinden alınan görüntüler ve etiketler (doğru yanıtlar) 4 dosyada sabit uzunluktaki kayıtlarda depolanır. Dosyalar özel sabit kayıt işleviyle yüklenebilir:
imagedataset = tf.data.FixedLengthRecordDataset(image_filename, 28*28, header_bytes=16)
Artık resim baytlarından oluşan bir veri kümemiz var. Şifrelerinin resim haline getirilmesi gerekir. Bunu yapmak için bir fonksiyon tanımlarız. Resim sıkıştırılmadığından, işlevin herhangi bir kodu çözmesi gerekmez (decode_raw aslında hiçbir şey yapmaz). Daha sonra resim 0 ile 1 arasında kayan nokta değerlerine dönüştürülür. Burada 2D bir resim olarak yeniden şekillendirebiliriz, ancak aslında bunu 28*28 boyutunda düz bir piksel dizisi olarak tutarız, çünkü ilk yoğun katmanımızın beklediği şey budur.
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 yardımıyla veri kümesine uygulayıp görüntülerden oluşan bir veri kümesi elde ederiz:
imagedataset = imagedataset.map(read_image, num_parallel_calls=16)
Etiketler için aynı tür okuma ve kod çözme işlemlerini gerçekleştiririz ve resimleri ve etiketleri birlikte .zip:
dataset = tf.data.Dataset.zip((imagedataset, labelsdataset))
Artık çiftlerden (görüntü, etiket) oluşan bir veri kümemiz var. Modelimizin beklentisi budur. Henüz tam olarak bu özelliği 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ı program işlevlerine sahiptir:
.cache, veri kümesini RAM'de önbelleğe alır. Bu, çok küçük bir veri kümesi olduğu için ç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 konuda birden çok kez (birkaç dönem) eğitim vereceğiz. .batch, birden çok resmi ve etiketi bir mini grup halinde bir araya getirir. Son olarak .prefetch, mevcut grubun GPU üzerinde 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 eğitmek için kullanmaya hazırız.
"Keras Modeli" hücresi
Tüm modellerimiz düz katman dizileri şeklinde olacağından bunları oluşturmak için tf.keras.Sequential stilini kullanabiliriz. Başlangıçta burada tek yoğun bir katmandır. Elle yazılmış rakamları 10 sınıfa sınıflandırdığımız için 10 nörona sahip. "softmax" kullanıyor etkinleştirilecektir. Çünkü bu, sınıflandırıcıdaki son katmandır.
Keras modelinin girişlerinin şeklini de bilmesi gerekir. Bunu tanımlamak için tf.keras.layers.Input kullanılabilir. 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ı, model.compile işlevi kullanılarak Keras'ta yapılır. Burada temel optimize ediciyi 'sgd' (Stokastik Gradyan İnişi) kullanıyoruz. Sınıflandırma modeli için Keras'ta 'categorical_crossentropy' adlı bir çapraz entropi kayıp işlevi gerekir. Son olarak, modelden doğru şekilde sınıflandırılmış resimlerin yüzdesi olan 'accuracy' metriğini hesaplamasını isteriz.
Keras, oluşturduğunuz modelin ayrıntılarını yazdıran çok güzel bir model.summary() yardımcı programını sunar. Tür 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ımlanır) ekledi.
"Modeli eğitin ve doğrulayın" hücresi
Eğitim, model.fit çağrısıyla ve hem eğitim hem de doğrulama veri kümelerini ileterek gerçekleşir. Varsayılan olarak Keras, 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ölyede, dinamik olarak güncellenen eğitim grafiği de bu şekilde uygulandı.
"Tahminleri görselleştir" hücresi
Model eğitildikten sonra model.predict() öğesini ç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. Sinir ağının, son "softmax" değeri için 10 olasılık içeren bir vektör döndürdüğünü unutmayın. Etiketi elde etmek için hangi olasılığın en yüksek olduğunu bulmamız gerekir. Bunu Numpy kitaplığındaki np.argmax yapıyor.
axis=1 parametresinin neden gerekli olduğunu anlamak için, 128 görüntüden oluşan bir grup 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] şeklindedir. Her bir görüntü için döndürülen 10 olasılık üzerinden argmax değerini hesaplıyoruz, bu nedenle axis=1 (ilk eksen 0'dır).
Bu basit model zaten rakamların% 90'ını tanır. Fena değil, ancak şimdi bunu önemli ölçüde iyileştireceksiniz.
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 uygun olan softmax'ı son katmanda aktivasyon işlevi olarak tutuyoruz. Ancak ara katmanlarda en klasik aktivasyon fonksiyonu olan sigmoid'i kullanacağız:
Örneğin, modeliniz şöyle 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')
])
"Özet"i inceleme belirir. Artık en az 10 kat daha fazla parametreye sahip. Bundan 10 kat daha iyi olmalıdır! Ama bir sebepten dolayı ...
Ölüm sonucu çatıya da vurmuş gibi görünüyor. Bir sorun var.
7. Derin ağlar için özel bakım
İnsanların 80'ler ve 90'larda nöral ağları tasarladığı gibi, kısa bir süre önce de nöral ağları deneyimlediniz. Peki, bu fikri bırakıp "yapay zeka kışı"nı başlatmış olmalarına ne dersiniz? Gerçekten de, siz katmanlar ekledikçe nöral ağların birleşmesi gittikçe zorlaşıyor.
Çok sayıda katmanı olan (bugün 20, 50, hatta bugün 100 tane) derin nöral ağların çok iyi çalıştığı ortaya çıktı. Ancak bu ağların yakınlaşmasını sağlamak için birkaç matematiksel kirli numara vardı. Bu basit numaraların keşfedilmesi, 2010'larda derin öğrenmenin yeniden doğuşunun nedenlerinden biri.
RELU etkinleştirme
Sigmoid etkinleştirme işlevi aslında derin ağlarda oldukça sorunludur. 0 ile 1 arasındaki tüm değerleri sıkıştırır. Bunu tekrar tekrar yaptığınızda nöron çıkışları ve gradyanları tamamen yok olabilir. Geçmişten alınmış olsa da modern ağlar RELU'yu (Doğrulanmış Doğrusal Birim) kullanır. Bu da aşağıdaki gibi görünür:
Diğer yandan, eğlencenin sağ tarafında en azından 1'in bir türevi vardır. RELU aktivasyonuyla, bazı nöronlardan gelen gradyanlar sıfır olsa bile, her zaman sıfır olmayan, net bir gradyan veren diğerleri olacaktır ve eğitim iyi bir hızda devam edebilir.
Daha iyi bir optimize edici
Buradaki gibi çok yüksek boyutlu alanlarda (ağırlık ve eğilim 10 bin sırasıyla ; "ağır noktaları") sık olduğunu görebilirsiniz. Bunlar, yerel minimum olmayan ancak gradyanın yine de sıfır olduğu ve gradyan inişi optimize edicinin orada takıldığı noktalardır. TensorFlow, belirli bir düzeyde eylemsizlikle çalışan ve eğim noktalarını güvenli bir şekilde geçmeye hazır olanların da dahil olduğu eksiksiz bir optimizasyon aracı yelpazesine sahiptir.
Rastgele başlatmalar
Eğitimden önce ağırlıklarla ilgili önyargıları ilk kullanıma hazırlama sanatı başlı başına bir araştırma alanıdır ve bu konuda çok sayıda makale yayınlanmıştır. Keras'ta kullanılabilen tüm başlatıcılara buradan göz atabilirsiniz. Neyse ki Keras, varsayılan olarak doğru şeyi yapıyor ve neredeyse her durumda en iyi olan 'glorot_uniform' başlatıcıyı kullanıyor.
Bir şey yapmanız gerekmez, çünkü Keras zaten doğru olanı yapar.
Nalan ???
Çapraz entropi formülü, bir logaritma içerir ve log(0) Bir Sayı Değildir (NaN, tercih ederseniz sayısal bir kilitlenmedir). Çapraz entropi girişi 0 olabilir mi? Giriş, temelde üstel olan softmax'tan gelir ve üstel hiçbir zaman sıfır değildir. Dolayısıyla güvendeyiz.
Gerçekten mi? Matematiğin muhteşem dünyasında güvende olurduk, ancak bilgisayar dünyasında, float32 biçiminde temsil edilen exp(-150), alçak bir şekilde SIFIR değerine ve entropiler arası çökmelere karşılık gelir.
Neyse ki burada da herhangi bir şey yapmanız gerekmez. Çünkü Keras bu konuyla ilgilenir ve sayısal kararlılığı sağlamak ve korkunç NaN'lerden kaçınmak için özellikle dikkatli bir şekilde softmax ve ardından çapraz entropiyi hesaplar.
Başarılı mı?
Artık% 97 doğruluk oranına ulaşırsınız. Bu atölyenin hedefi% 99'un çok üzerinde. Bu nedenle devam edelim.
Sorun yaşıyorsanız şu anda çözümü burada bulabilirsiniz:
8. Öğrenme hızındaki azalma
Belki daha hızlı eğitmeyi deneyebiliriz. Adam optimize edicide varsayılan öğrenme hızı 0,001'dir. Bunu artırmaya çalışalım.
Daha hızlı olmak pek işe yaramıyor gibi görünüyor. Tüm bu ses neden oluyor?
Eğitim eğrileri gerçekten çok karmaşıktı ve her iki doğrulama eğrisine de bakıyorlar: Yukarı, aşağı sıçrayıyorlar. Bu da çok hızlı gittiğimiz anlamına geliyor. Önceki hızımıza dönebiliriz ama daha iyi bir yol var.
Hızlı başlamak ve öğrenme hızını katlanarak azaltmak iyi bir çözümdür. Keras'ta bu işlemi tf.keras.callbacks.LearningRateScheduler geri araması ile 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 öğesini kullanmayı unutmayın. Bunu model.fit içindeki geri çağırmalar listesine ekleyin:
model.fit(..., callbacks=[plot_training, lr_decay_callback])
Bu küçük değişiklik olağanüstü bir etkiye sahip. Gürültünün büyük kısmının ortadan kalktığını ve test doğruluğunun kesintisiz bir şekilde% 98'in üzerinde olduğunu görüyorsunuz.
9. Ayrılma, fazla uyum
Modelin şu anda yakınlaştığı anlaşılıyor. Hatta bu konuyu daha ayrıntılı olarak ele alalım.
İşe yarıyor mu?
Pek değil. Doğruluk hâlâ% 98'de kaldı ve doğrulama kaybına bakın. Yükselişte! Öğrenme algoritması yalnızca eğitim verileri üzerinde çalışır ve eğitim kaybını buna göre optimize eder. Doğrulama verilerini hiçbir zaman görmez. Bu nedenle, bir süre sonra çalışmasının artık doğrulama kaybı üzerinde bir etkisinin olmaması, veri kaybının durduğu ve hatta bazen geri döndüğü için şaşırtıcı değildir.
Bu, modelinizin gerçek dünyadaki tanıma özelliklerini hemen etkilemez, ancak çok sayıda yineleme çalıştırmanızı engeller ve genellikle eğitimin artık olumlu bir etkisinin olmadığını gösterir.
Bu kopukluk genellikle "fazlasıyla uyumlu" olarak adlandırılır ve gördüğümüzde "dropout" adlı bir normalleştirme tekniği uygulamayı deneyebilirsiniz. Bırakma tekniği, her eğitim iterasyonunda rastgele nöronlar vurur.
İşe yaradı mı?
Gürültü tekrar ortaya çıkıyor (durumun işleyiş şekli göz önüne alındığında şaşırtıcı olmayan bir şekilde). Doğrulama kaybı artık artmıyor gibi görünüyor, ancak genel olarak ayrılmazlığa kıyasla daha yüksek. Doğrulama doğruluğu biraz azaldı. Bu oldukça üzücü bir sonuç.
Ayrılma oranı doğru çözüm değil ya da "fazlasıyla uyuyor" olabilir. daha karmaşık bir kavramdır ve bazı nedenleri "ayrılmaya" uygun değildir düzeltilsin mi?
"Fazla uyumlu" nedir? Fazla uyum, bir nöral ağ "kötü" olduğunda eğitim örneklerinde işe yarayan ancak gerçek dünyadaki verilerde pek işe yaramayacak şekilde öğrenmeye başlar. Ayrılma gibi, öğrenmeyi daha iyi öğrenmeye zorlayabilecek normalleştirme teknikleri vardır. Ancak aşırıya kaçmanın kökleri de vardır.
Temel fazla sığdırma, bir sinir ağının mevcut problem için çok fazla serbestlik derecesine sahip olmasıyla ortaya çıkar. Çok sayıda nöronumuz olduğunu düşünün. Ağımız tüm eğitim resimlerimizi bu nöronlarda depolayabiliyor ve ardından kalıp eşleştirmeyle bu nöronları tanıyabiliyor. Gerçek verilere göre tamamen başarısız olur. Bir nöral ağ, eğitim sırasında öğrendiklerini genellemeye zorlanması için bir şekilde kısıtlı olmalıdır.
Çok az eğitim veriniz varsa küçük bir ağ bile bu verileri özünde öğrenebilir ve "birbirine sığdırma" ifadesini görürsünüz. Genel anlamda, nöral ağları eğitmek için her zaman çok fazla veriye ihtiyacınız vardır.
Son olarak, kitabın serbestlik derecelerinin kısıtlı olduğundan, veri kesintisi uygulandığından ve çok miktarda veriyle eğitildiğinden emin olmak için farklı ağ boyutlarında denemeler yaptıysanız, hâlâ hiçbir şeyin iyileştirilemeyeceğini düşündüğünüz bir performans düzeyinde takılıp kalabilirsiniz. Bu, nöral ağınızın şu anki şekliyle, buradaki örnekte olduğu gibi verilerinizden daha fazla bilgi çıkaramayacağı anlamına gelir.
Tek bir vektör halinde birleştirilmiş olarak resimlerimizi nasıl kullandığımızı hatırlıyor musunuz? Bu gerçekten kötü bir fikirdi. Elle yazılmış rakamlar şekillerden oluşur ve pikselleri düzleştirdiğimizde şekil bilgilerini sildik. Bununla birlikte, şekil bilgisinden yararlanabilen bir tür nöral ağ vardır: konvolüsyonel ağlar. Şimdi bunları deneyelim.
Sorun yaşıyorsanız şu anda çözümü burada bulabilirsiniz:
10. [INFO] konvolüsyonlu ağlar
Özet
Bir sonraki paragrafta yer alan kalın yazı tipindeki tüm terimleri zaten biliyorsanız bir sonraki alıştırmaya geçebilirsiniz. Konvolüsyonel nöral ağlarla yeni başlıyorsanız lütfen okumaya devam edin.
Çizim: Bir resmi, her biri 4x4x3=48 öğrenilebilir ağırlıklardan oluşan art arda iki filtreyle filtreleme.
Basit bir konvolüsyonel nöral ağ Keras'ta şöyle 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')
])
Konvolüsyonel ağ katmanında, bir "nöron" yalnızca resmin küçük bir bölgesinde, hemen üzerindeki piksellerin ağırlıklı bir toplamını yapar. Normal yoğun bir katmandaki bir nöronun yaptığı gibi, bir eğilim ekler ve toplamı bir aktivasyon fonksiyonu aracılığıyla iletir. Daha sonra bu işlem, aynı ağırlıklar kullanılarak resmin tamamında tekrarlanır. Yoğun katmanlarda her nöronun kendi ağırlıkları olduğunu unutmayın. Burada tek bir "yama" resimdeki ağırlıkların her iki yönde ("büyütme") kaydığını gösterir. Çıkış, resimde piksel sayısı kadar değere sahiptir (yine de kenarlarda bazı dolgu yapılması gerekir). Bu bir filtreleme işlemidir. Yukarıdaki çizimde, 4x4x3=48 ağırlıklardan oluşan bir filtre kullanılmaktadır.
Ancak 48 ağırlık yeterli olmayacaktır. Daha fazla serbestlik derecesi eklemek için aynı işlemi yeni bir ağırlık grubuyla tekrarlarız. Bu işlem yeni bir filtre çıktıları kümesi oluşturur. Buna "kanal" diyelim. giriş resmindeki R,G,B kanallarına benzeterek çıktıların performansını görebilirsiniz.
İki (veya daha fazla) ağırlık kümesi, yeni bir boyut eklenerek tek bir tensör olarak toplanabilir. Bu şekilde, konvolüsyonlu bir katman için ağırlık tensörünün genel şeklini elde ederiz. Giriş ve çıkış kanallarının sayısı parametre olduğundan, konvolüsyonel katmanları yığmaya ve zincirlemeye başlayabiliriz.
Çizim: konvolüsyonel nöral ağ "küpleri" dönüştürüyor başka "küplere" açısından son derece önemlidir.
Sıralı konvolüsyon, maksimum havuz hızı
Evrimleri 2 veya 3 adımla yaparak elde edilen veri küpünü yatay boyutlarında da küçültebiliriz. Bunu iki şekilde yapabilirsiniz:
- Aşamalı konvolüsyon: Yukarıdaki gibi ancak adımı 1'den büyük olan kayan bir filtre
- Maks. havuz: MAX işlemini uygulayan bir kayan pencere (genellikle 2x2 yamalarda, her 2 pikselde bir tekrarlanır)
Çizim: Hesaplama penceresinin 3 piksel kaydırılması daha az çıkış değerine neden olur. Katmanlı kıvrımlar veya maksimum havuz (2x2 kaydırılan 2x2 pencere için en fazla) veri küpünü yatay boyutlarda daraltmanın bir yoludur.
Son katman
Son konvolüsyonel katmandan sonra, veriler bir "küp" biçimindedir. Gemini'ı son yoğun katmandan geçirmenin iki yolu vardır.
İlki, veri küpünü bir vektör olarak düzleştirmek ve ardından bunu 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 pahalı olabilir. Konvolüsyonel bir ağın ucundaki yoğun bir katman, tüm nöral ağın ağırlığının yarısından fazlasını içerebilir.
Pahalı bir yoğun katman kullanmak yerine, gelen veriyi "küp" olarak bölerek ayırabilir, değerlerinin ortalamasını alıp bunları bir softmax etkinleştirme işleviyle besleyebiliriz. Sınıflandırma başlığını oluşturmanın bu şekilde maliyeti 0 ağırlıktır. Keras'ta bunun için bir katman bulunur: tf.keras.layers.GlobalAveragePooling2D().
Mevcut sorun için konvolüsyonlu bir ağ oluşturmak üzere sonraki bölüme geçin.
11. Konvolüsyonel ağ
El yazısıyla yazılan rakam tanıma için konvolüsyonel bir ağ oluşturalım. En üstte, en alttaki geleneksel softmax okuma katmanımız olan üç konvolüsyon katmanı kullanacağız ve bunları tamamen bağlantılı tek bir katmanla bağlayacağız:
İkinci ve üçüncü kıvrımlı katmanların ise çıkış değerlerinin sayısını neden 28x28'den 14x14'e, sonra da 7x7'ye düşürdüklerini açıklayan iki adım olduğuna dikkat edin.
Keras kodunu yazalım.
Birinci konvolüsyon katmanından önce özel dikkat gösterilmesi gerekir. Gerçekten de 3D bir "küp" ancak veri kümemiz şimdiye kadar yoğun katmanlar için ayarlandı ve resimlerin tüm pikselleri bir vektör olarak düzleştirildi. Bunları tekrar 28x28x1 resimler olacak şekilde yeniden şekillendirmemiz gerekiyor (gri tonlamalı resimler için 1 kanal):
tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1))
Şimdiye kadar sahip olduğunuz tf.keras.layers.Input katmanı yerine bu satırı kullanabilirsiniz.
Keras'ta "relu" etkin konvolüsyonel katmanın söz dizimi şöyledir:
tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu')
Aşamalı evrişim için şöyle yazarsınız:
tf.keras.layers.Conv2D(kernel_size=6, filters=24, padding='same', activation='relu', strides=2)
Bir veri küpünü yoğun bir katman tarafından kullanılabilecek şekilde bir vektör olarak düzeltmek için:
tf.keras.layers.Flatten()
Yoğun katman için de söz dizimi değişmemiştir:
tf.keras.layers.Dense(200, activation='relu')
Modeliniz% 99 doğruluk engelini aştı mı? Çok az kaldı... doğrulama kaybı eğrisine bakın. Zil çalıyor mu?
Tahminlere de bakın. İlk kez, 10.000 test basamağının çoğunun artık doğru bir şekilde tanındığını göreceksiniz. Yanlış algılamaların yalnızca 41⁄2'si kaldı (10.000 satırın 110 basamağı)
Sorun yaşıyorsanız şu anda çözümü burada bulabilirsiniz:
12. Tekrar bırakma
Önceki eğitim, aşırı uyumayla ilgili açık belirtiler sergiliyor (ve hâlâ% 99 doğruluk altında kalıyor). Bırakmayı tekrar deneyelim mi?
Bu sefer nasıldı?
Ayrılma sürecinin bu kez işe yaradığı anlaşılıyor. Doğrulama kaybı artık artmıyor ve nihai doğruluk oranı %99'un çok üzerinde olmalıdır. Tebrikler!
Ayrılmayı ilk kez denediğimizde, aslında sorun nöral ağın mimarisinde olmasına rağmen aşırı uyum sağlayan bir sorunumuz olduğunu düşünmüştük. Konvolüsyonel katmanlar olmadan daha ileriye gidemezdik ve bu konuda kesintinin yapabileceği bir şey yok.
Bu defa, sorunun nedeni aşırı uyum sağlamakmış gibi görünüyor ve ayrılma gerçekten yardımcı oldu. Eğitim ve doğrulama kaybı eğrileri arasında kopukluğun artmasına ve doğrulama kaybının artmasına yol açabilecek birçok şeyin olduğunu unutmayın. Fazla sığdırma (serbestlik derecesinin çok fazla olması, ağ tarafından kötü kullanılması) bunlardan yalnızca biridir. Veri kümeniz çok küçükse veya nöral ağınızın mimarisi yeterli değilse kayıp eğrilerinde benzer bir davranış görebilirsiniz ancak ayrılma eğrisi yardımcı olmaz.
13. Toplu normalleştirme
Son olarak, toplu normalleştirme eklemeyi deneyelim.
Teori budur, uygulamada birkaç kuralı hatırlayın:
Şimdi kitap başına oynayalım ve sonuncusu hariç her nöral ağ katmanına bir toplu norm katmanı ekleyelim. Son "softmax"a eklemeyin katmanıdır. Orada faydalı 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 şu anda nasıl?
Biraz değişiklik yapıp (BATCH_SIZE=64, öğrenme hızındaki azalma parametresi 0,666, yoğun katman 0,3'teki ayrılma oranı) ve şansınızı denemeden %99,5'e ulaşabilirsiniz. Öğrenme hızı ve ayrılma düzenlemeleri "en iyi uygulamalar" doğrultusunda gerçekleştirildi toplu norm kullanmak için:
- Toplu norm, nöral ağların birleşmesine yardımcı olur ve genellikle daha hızlı eğitim almanızı sağlar.
- Toplu norm, bir normalleştiricidir. Genellikle kullandığınız ayrılma miktarını azaltabilir, hatta ayrılmayı hiç kullanmamayı tercih edebilirsiniz.
Çözüm not defterinde% 99,5 eğitim çalıştırması vardır:
14. Güçlü donanımlarla bulutta eğitim: 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ında bulabilirsiniz. Bu bölümü çalıştırabilmeniz için önce bir Google Cloud hesabı oluşturmanız ve faturalandırmayı etkinleştirmeniz gerekir. Laboratuvarı tamamlamak için gereken kaynaklar birkaç ABD dolarından az olmalıdır (GPU'da eğitim süresinin 1 saat olduğu varsayılır). Hesabınızı hazırlamak için:
- Bir Google Cloud Platform projesi oluşturun ( http://cloud.google.com/console).
- Faturalandırmayı etkinleştir.
- GCP komut satırı araçlarını yükleyin ( GCP SDK'sını burada bulabilirsiniz).
- Bir Google Cloud Storage paketi oluşturun (
us-central1bölgesine yerleştirin). Eğitim kodunu hazırlamak ve eğitilen 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, neyi etkinleştireceğinizi belirten hata mesajları alırsınız).
15. Tebrikler!
İlk nöral ağınızı oluşturdunuz ve% 99 doğruluk oranına kadar eğittiniz. Bu süreçte öğrenilen teknikler, MNIST veri kümesine özgü değildir. Aslında nöral ağlarla çalışırken yaygın bir şekilde kullanılmaktadır. veda hediyesi olarak hazır mısınız? kartını çizgi film sürümü olarak kullanın. Öğrendiklerinizi hatırlamak için bu aracı kullanabilirsiniz:
Sonraki adımlar
- Tamamen bağlı ve evrişimli ağlardan sonra yinelenen nöral ağlara göz atmanız gerekir.
- Google Cloud, eğitiminizi veya çıkarımınızı bulutta dağıtılmış bir altyapı üzerinde çalıştırmak için AI Platform'u sunar.
- Son olarak, geri bildirimlere değer veriyoruz. Bu laboratuvarda bir eksiklik görürseniz veya bir şeylerin iyileştirilmesi gerektiğini düşünüyorsanız 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 çizgi film resimleri telif hakkı: alexpokusay / 123RF stok fotoğrafları