Yeni Başlayanlar için TensorFlow Eğitimi

Derin öğrenme, beynin yapısı ve işlevinden esinlenen bir algoritmalar kümesi olan makine öğrenmesinin bir alt alanıdır.

TensorFlow, Google’ın oluşturduğu ikinci makine öğrenmesi çerçevesidir ve derin öğrenme modellerini tasarlamak, inşa etmek ve eğitmek için kullanılır. TensorFlow kütüphanesini sayısal hesaplamalar için kullanabilirsiniz; bu başlı başına çok özel görünmeyebilir, ancak bu hesaplamalar veri akış grafikleriyle yapılır. Bu grafiklerde düğümler matematiksel işlemleri, kenarlar ise genellikle çok boyutlu veri dizileri veya tensörler olan ve bu kenarlar arasında iletilen verileri temsil eder.

Gördünüz mü? “TensorFlow” adı, sinir ağlarının çok boyutlu veri dizileri veya tensörler üzerinde gerçekleştirdiği işlemlerden gelir! Kelimenin tam anlamıyla tensörlerin akışıdır. Şimdilik tensörler hakkında bilmeniz gerekenler bu kadar; sonraki bölümlerde bu konuya daha derinlemesine gireceksiniz!

Bugünkü yeni başlayanlar için TensorFlow eğitimi, derin öğrenmeyi etkileşimli bir şekilde uygulamanıza giriş niteliğindedir:

Bu eğitimin not defterini buradan indirin.

Ayrıca, Python ile Derin Öğrenme kursuyla, DataCamp’in Keras eğitimi veya R ile keras eğitimi ile de ilgilenebilirsiniz.

Tensörlere Giriş

Tensörleri iyi anlamak için biraz lineer cebir ve vektör hesap bilgisine sahip olmak faydalıdır. Girişte, tensörlerin TensorFlow’da çok boyutlu veri dizileri olarak uygulandığını okudunuz; ancak tensörleri ve makine öğrenmesindeki kullanımını tam olarak kavramak için biraz daha girişe ihtiyaç olabilir.

Düzlem Vektörleri

Düzlem vektörlerine girmeden önce “vektör” kavramını kısaca gözden geçirmek iyi bir fikirdir; Vektörler, sayılardan oluşan dikdörtgen diziler olan matrislerin özel bir türüdür. Vektörler sayılardan oluşan sıralı koleksiyonlar olduğundan, genellikle sütun matrisleri olarak görülür: sadece bir sütunları ve belirli sayıda satırları vardır. Başka bir deyişle, vektörleri, yön atanan skaler büyüklükler olarak da düşünebilirsiniz.

Unutmayın: bir skaler örneği “5 metre” veya “60 m/sn” iken, bir vektör örneği “5 metre kuzey” veya “60 m/sn Doğu”dur. Bu ikisi arasındaki fark açıkça vektörün bir yöne sahip olmasıdır. Yine de, şimdiye dek gördüğünüz bu örnekler, makine öğrenmesi problemleriyle çalışırken karşılaşabileceğiniz vektörlerden uzak görünebilir. Bu normaldir; Matematiksel bir vektörün uzunluğu saf bir sayıdır: mutlak değerdir. Öte yandan yön, görelidir: bir referans yöne göre ölçülür ve birimi radyan veya derecedir. Genellikle yönün pozitif olduğunu ve referans yönden saat yönünün tersine döndüğünü varsayarsınız.

Elbette vektörleri görsel olarak oklar şeklinde gösterirsiniz; yukarıdaki resimde gördüğünüz gibi. Bu, vektörleri yönü ve uzunluğu olan oklar olarak da düşünebileceğiniz anlamına gelir. Yön, okun başıyla, uzunluk ise okun uzunluğuyla gösterilir.

Peki ya düzlem vektörleri?

Düzlem vektörleri, tensörlerin en basit kurulumudur. Yukarıda gördüğünüz sıradan vektörlere oldukça benzerler, tek farkları bir vektör uzayında bulunmalarıdır. Bunu daha iyi anlamak için bir örnekle başlayalım: 2 X 1 bir vektörünüz var. Bu, vektörün, ikişer ikişer eşleşen gerçek sayılar kümesine ait olduğu anlamına gelir. Başka bir deyişle, iki boyutlu uzayın parçasıdırlar. Bu gibi durumlarda, vektörleri (x,y) koordinat düzleminde oklar veya ışınlarla temsil edebilirsiniz.

Vektörlerin uç noktalarının orijinde (0,0) olduğu standart konumdan hareketle, vektörün ilk satırına bakarak x koordinatını, ikinci satırda ise y koordinatını elde edebilirsiniz. Elbette bu standart konum her zaman korunmak zorunda değildir: vektörler, düzlemde kendilerine paralel taşınabilir ve bu durum değişime neden olmaz.

Not benzer şekilde, boyutu 3 X 1 olan vektörler için üç boyutlu uzaydan söz edersiniz. Vektörü, vektör uzayındaki konumları gösteren oklarla üç boyutlu bir şekil olarak temsil edebilirsiniz: standart x, y ve z eksenlerinde çizilirler.

Bu vektörlere sahip olmak ve koordinat düzleminde temsil etmek güzel, ancak özünde bu vektörlere üzerlerinde işlemler yapabilmek için sahipsiniz ve bunu yapmanıza yardımcı olabilecek şeylerden biri vektörlerinizi bazlar veya birim vektörler olarak ifade etmektir.

Birim vektörler, büyüklüğü bir olan vektörlerdir. Birim vektörü genellikle şapkalı (düzeltimli) küçük bir harfle tanırsınız. Birim vektörler, 2B veya 3B bir vektörü x– ve y– eksenleri ya da z– ekseni gibi iki veya üç dik bileşenin toplamı olarak ifade etmek istediğinizde kullanışlı olur.

Ve bir vektörü, örneğin, bileşenlerin toplamı olarak ifade etmekten söz ederken, aslında bileşen vektörlerinden, yani toplamı verilen vektörü oluşturan iki veya daha fazla vektörden söz ettiğinizi görürsünüz.

İpucu: Tensörlerin ne olduğunu basit ev eşyalarıyla açıklayan bu videoyu izleyin!

Tensörler

Düzlem vektörlerinin yanında, kovektörler ve lineer operatörler de vardır ve bu üçünün ortak bir noktası bulunur: hepsi tensörlerin özel durumlarıdır. Önceki bölümde vektörün, yön atanan skaler büyüklükler olarak karakterize edildiğini hâlâ hatırlıyorsunuz. O hâlde tensör, büyüklük ve birden fazla yönle karakterize edilebilen fiziksel bir varlığın matematiksel temsilidir.

Ve tıpkı bir skalerin tek bir sayıyla, bir vektörün örneğin 3 boyutlu bir uzayda üç sayıdan oluşan bir diziyle temsil edilmesi gibi, bir tensör de 3 boyutlu bir uzayda 3^R sayıdan oluşan bir diziyle temsil edilebilir.

Bu gösterimdeki “R” tensörün rütbesini (derecesini) temsil eder: bu, 3 boyutlu bir uzayda, ikinci dereceden bir tensörün 3² yani 9 sayıyla temsil edilebileceği anlamına gelir. N boyutlu bir uzayda, skalerler yine tek bir sayı gerektirirken, vektörler N sayı ve tensörler N^R sayı gerektirir. Bu, sıklıkla skalerlerin derece 0 tensörler olduğu sözünü duymanızın nedenini açıklar: yönleri olmadığından tek bir sayıyla temsil edilebilirler.

Bunu akılda tutarak, skalerleri, vektörleri ve tensörleri tanımak ve birbirinden ayırmak nispeten kolaydır: skalerler tek bir sayıyla, vektörler sıralı bir sayı kümesiyle, tensörler ise bir sayı dizisiyle temsil edilir.

Tensörleri benzersiz kılan şey, bileşenler ve baz vektörlerin birleşimidir: baz vektörler, referans çerçeveleri arasında bir biçimde dönüşürken, bileşenler de bileşenler ile baz vektörlerin birleşimini aynı tutacak şekilde dönüşür.

TensorFlow’un Kurulumu

Artık TensorFlow hakkında daha fazla bilgi sahibi olduğunuza göre, başlayıp kütüphaneyi kurma zamanı. Burada, TensorFlow’un Python, C++, Haskell, Java, Go, Rust için API’ler sunduğunu ve R için de tensorflow adlı üçüncü taraf bir paket bulunduğunu bilmek iyi olur.

İpucu: R’de derin öğrenme paketleri hakkında daha fazla bilgi edinmek isterseniz DataCamp’in keras: R ile Derin Öğrenme Eğitimini inceleyin.

Bu eğitimde, derin öğrenme projenizin kodunu Python ile yazmanızı sağlayacak bir TensorFlow sürümü indireceksiniz. TensorFlow kurulum web sayfasında, virtualenv, pip, Docker kullanarak TensorFlow’u kurmanın en yaygın yollarını ve en güncel talimatları göreceksiniz ve son olarak kişisel bilgisayarınıza TensorFlow kurmanın diğer bazı yollarını da bulacaksınız.

Not Windows üzerinde çalışıyorsanız TensorFlow’u Conda ile de kurabilirsiniz. Ancak TensorFlow’un kurulumu topluluk tarafından desteklendiğinden, en iyisi resmî kurulum talimatlarını kontrol etmektir.

Kurulum sürecini tamamladığınıza göre, TensorFlow’u çalışma alanınıza tf kısaltmasıyla aktararak doğru şekilde kurduğunuzu iki kez kontrol etme zamanı:

import tensorflow as tf

Not yukarıdaki kod satırında kullandığınız kısaltma bir tür uzlaşımdır - Bir yandan veri bilimi projelerinde TensorFlow kullanan diğer geliştiricilerle, diğer yandan da açık kaynak TensorFlow projeleriyle tutarlı kalmanızı sağlar.

TensorFlow’a Başlarken: Temeller

Genellikle TensorFlow programlarını bir parça olarak yazar ve çalıştırırsınız; Bu, Python ile çalışırken ilk bakışta biraz çelişkili gelebilir. Ancak isterseniz, daha etkileşimli çalışmak için TensorFlow’un Interactive Session özelliğini de kullanabilirsiniz. Bu, özellikle IPython ile çalışmaya alışkınsanız kullanışlıdır.

Bu eğitim için ikinci seçeneğe odaklanacaksınız: bu, TensorFlow ile derin öğrenmeye hızlı bir başlangıç yapmanıza yardımcı olacak. Ancak daha ileri gitmeden önce, ağır işlere başlamadan önce ufak şeyler deneyelim.

Önce, bir önceki bölümde gördüğünüz gibi tensorflow kütüphanesini tf kısaltmasıyla içe aktarın. Ardından, aslında sabit olan iki değişken başlatın. constant() işlevine dört sayıdan oluşan bir dizi geçirin.

Not potansiyel olarak bir tamsayı da geçebilirsiniz, ancak çoğu zaman dizilerle çalıştığınızı göreceksiniz. Girişte gördüğünüz gibi tensörler tamamen dizilerle ilgilidir! Bu yüzden bir dizi geçtiğinizden emin olun :) Sonra, iki değişkeninizi çarpmak için multiply() kullanabilirsiniz. Sonucu result değişkeninde saklayın. Son olarak, print() işlevinin yardımıyla result’ı yazdırın.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW1wb3J0IGB0ZW5zb3JmbG93YFxuaW1wb3J0IHRlbnNvcmZsb3cgYXMgdGZcblxuIyBJbml0aWFsaXplIHR3byBjb25zdGFudHNcbngxID0gdGYuY29uc3RhbnQoWzEsMiwzLDRdKVxueDIgPSB0Zi5jb25zdGFudChbNSw2LDcsOF0pXG5cbiMgTXVsdGlwbHlcbnJlc3VsdCA9IHRmLm11bHRpcGx5KHgxLCB4MilcblxuIyBQcmludCB0aGUgcmVzdWx0XG5wcmludChyZXN1bHQpIn0=

Not Yukarıdaki DataCamp Light kod bloğunda sabitler tanımladınız. Ancak potansiyel olarak kullanabileceğiniz iki değer türü daha vardır: placeholder’lar; bunlar atanmamış değerlerdir ve oturumu çalıştırdığınızda oturum tarafından başlatılır. İsminden de anlaşılacağı gibi, oturum çalıştırıldığında her zaman beslenecek bir tensör için yalnızca bir yer tutucudur; Bir de Variables vardır; bunlar değişebilen değerlerdir. Sabitler ise muhtemelen fark ettiğiniz gibi değişmeyen değerlerdir.

Kod satırlarının sonucu, hesaplama grafiğinde soyut bir tensördür. Ancak, bekleyebileceğinizin aksine, result aslında hesaplanmaz. Sadece modeli tanımlar, ancak sonucu hesaplamak için hiçbir işlem çalıştırılmaz. Bunu yazdırma çıktısında görebilirsiniz: görmek istediğiniz gerçek sonuç (yani 30) yoktur. Bu, TensorFlow’un tembel değerlendirme (lazy evaluation) yaptığını gösterir!

Ancak sonucu görmek isterseniz, bu kodu etkileşimli bir oturumda çalıştırmanız gerekir. Bunu, aşağıdaki DataCamp Light kod bloklarında gösterildiği gibi birkaç yolla yapabilirsiniz:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW1wb3J0IGB0ZW5zb3JmbG93YCBcbmltcG9ydCB0ZW5zb3JmbG93IGFzIHRmXG5cbiMgSW5pdGlhbGl6ZSB0d28gY29uc3RhbnRzXG54MSA9IHRmLmNvbnN0YW50KFsxLDIsMyw0XSlcbngyID0gdGYuY29uc3RhbnQoWzUsNiw3LDhdKVxuXG4jIE11bHRpcGx5XG5yZXN1bHQgPSB0Zi5tdWx0aXBseSh4MSwgeDIpXG5cbiMgSW50aWFsaXplIHRoZSBTZXNzaW9uXG5zZXNzID0gdGYuU2Vzc2lvbigpXG5cbiMgUHJpbnQgdGhlIHJlc3VsdFxucHJpbnQoc2Vzcy5ydW4ocmVzdWx0KSlcblxuIyBDbG9zZSB0aGUgc2Vzc2lvblxuc2Vzcy5jbG9zZSgpIn0=

Not Aşağıdaki kod satırlarını da kullanarak etkileşimli bir Session başlatabilir, result’ı çalıştırabilir ve output yazdırıldıktan sonra Oturumu otomatik olarak kapatabilirsiniz:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW1wb3J0IGB0ZW5zb3JmbG93YFxuaW1wb3J0IHRlbnNvcmZsb3cgYXMgdGZcblxuIyBJbml0aWFsaXplIHR3byBjb25zdGFudHNcbngxID0gdGYuY29uc3RhbnQoWzEsMiwzLDRdKVxueDIgPSB0Zi5jb25zdGFudChbNSw2LDcsOF0pXG5cbiMgTXVsdGlwbHlcbnJlc3VsdCA9IHRmLm11bHRpcGx5KHgxLCB4MilcblxuIyBJbml0aWFsaXplIFNlc3Npb24gYW5kIHJ1biBgcmVzdWx0YFxud2l0aCB0Zi5TZXNzaW9uKCkgYXMgc2VzczpcbiAgb3V0cHV0ID0gc2Vzcy5ydW4ocmVzdWx0KVxuICBwcmludChvdXRwdXQpIn0=

Yukarıdaki kod bloklarında varsayılan bir Session tanımladınız, ancak seçenekler de geçebileceğinizi bilmek iyi olur. Örneğin, config argümanını belirleyebilir ve oturumunuz için yapılandırma seçenekleri eklemek üzere ConfigProto protokol tamponunu kullanabilirsiniz.

Örneğin, oturumunuza

config=tf.ConfigProto(log_device_placement=True)

eklerseniz, bir işleme atanan GPU veya CPU aygıtını günlüğe almayı sağlarsınız. Böylece, oturumda her bir işlem için hangi aygıtların kullanıldığına dair bilgiler alırsınız. Aygıt yerleşimi için yumuşak kısıtlar (soft constraints) kullandığınızda aşağıdaki yapılandırmayı da örneğin kullanabilirsiniz:

config=tf.ConfigProto(allow_soft_placement=True)

Artık TensorFlow’u kurup çalışma alanınıza aktardığınıza ve bu paketle çalışmanın temellerini gözden geçirdiğinize göre, bunu bir kenara bırakıp dikkatinizi verinize çevirme zamanı. Her zamanki gibi, sinir ağınızı modellemeye başlamadan önce verilerinizi keşfetmek ve daha iyi anlamak için zaman ayıracaksınız.

Belçika Trafik İşaretleri: Arka Plan

Trafik, genelde hepinizin aşina olduğu bir konu olsa da, başlamadan önce bu veri setine dahil olan gözlemleri kısaca gözden geçirmek zarar vermez; her şeyi anladığınızdan emin olun. Özünde, bu bölümde, bu eğitimle ilerlemek için ihtiyaç duyduğunuz alan bilgisini edineceksiniz.

Tabii, ben Belçikalı olduğum için birkaç anekdot da paylaşacağım :)

• Belçika trafik işaretleri genellikle Felemenkçe ve Fransızcadır. Bunu bilmek iyi, ancak üzerinde çalışacağınız veri seti için çok da önemli değil!
• Belçika’da altı trafik işareti kategorisi vardır: uyarı işaretleri, öncelik işaretleri, yasaklayıcı işaretler, mecburi işaretler, park etme ve yol üzerinde durma ile ilgili işaretler ve son olarak bilgi işaretleri.
• 1 Ocak 2017’de Belçika yollarından 30.000’den fazla trafik işareti kaldırıldı. Bunların hepsi hızla ilgili yasaklayıcı işaretlerdi.
• Kaldırmadan bahsetmişken, trafik işaretlerinin ezici varlığı, Belçika’da (ve genelde tüm Avrupa Birliği’nde) süregelen bir tartışma konusudur.

Verileri Yükleme ve Keşfetme

Artık biraz daha arka plan bilgisi topladığınıza göre, veri setini buradan indirmenin zamanı geldi. "BelgiumTS for Classification (cropped images)" ibaresinin yanındaki "BelgiumTSC_Training" ve "BelgiumTSC_Testing" adlı iki zip dosyasını almalısınız.

İpucu: Dosyaları indirdikten sonra (veya bu eğitimi tamamladıktan sonra indirecekseniz), indirdiğiniz verilerin klasör yapısına bir göz atın! Hem test hem de eğitim veri klasörlerinin, bu eğitimde sınıflandırma için kullanacağınız 62 trafik işareti türünü temsil eden 61 alt klasör içerdiğini göreceksiniz. Ek olarak, dosyaların .ppm yani Portable Pixmap Format uzantısına sahip olduğunu fark edeceksiniz. Trafik işaretlerinin görüntülerini indirdiniz!

Verileri çalışma alanınıza aktarmaya başlayalım. Kullanıcı Tanımlı Fonksiyon (UDF) load_data() altında görünen kod satırlarıyla başlayalım:

• Önce, ROOT_PATH’i ayarlayın. Bu yol, eğitim ve test verilerinizin bulunduğu dizindir.
• Ardından, join() işlevinin yardımıyla ROOT_PATH’inize belirli yolları ekleyebilirsiniz. Bu iki belirli yolu train_data_directory ve test_data_directory içinde saklarsınız.
• Sonrasında, load_data() işlevini çağırıp ona train_data_directory’yi geçirirsiniz.
• Şimdi, load_data() işlevi, train_data_directory içinde bulunan tüm alt dizinleri toplayarak başlar; Bunu, listeleri doğal bir şekilde oluşturan liste kavrayışı (list comprehension) yardımıyla yapar - temelde şunu söyler: train_data_directory içinde bir şey bulursan, bunun bir dizin olup olmadığını kontrol et; eğer öyleyse, onu listene ekle. Unutmayın her alt dizin bir etiketi temsil eder.
• Sonra, alt dizinler arasında döngü yapmanız gerekir. Önce iki liste başlatırsınız: labels ve images. Ardından, alt dizinlerin yollarını ve bu alt dizinlerde saklanan görüntülerin dosya adlarını toplarsınız. Sonrasında append() işlevinin yardımıyla verileri iki listeye eklersiniz.

def load_data(data_directory):
    directories = [d for d in os.listdir(data_directory) 
                   if os.path.isdir(os.path.join(data_directory, d))]
    labels = []
    images = []
    for d in directories:
        label_directory = os.path.join(data_directory, d)
        file_names = [os.path.join(label_directory, f) 
                      for f in os.listdir(label_directory) 
                      if f.endswith(".ppm")]
        for f in file_names:
            images.append(skimage.data.imread(f))
            labels.append(int(d))
    return images, labels

ROOT_PATH = "/your/root/path"
train_data_directory = os.path.join(ROOT_PATH, "TrafficSigns/Training")
test_data_directory = os.path.join(ROOT_PATH, "TrafficSigns/Testing")

images, labels = load_data(train_data_directory)

Not yukarıdaki kod bloğunda, eğitim ve test verileri "Training" ve "Testing" adlı klasörlerde yer almaktadır ve her ikisi de "TrafficSigns" adlı başka bir dizinin alt dizinleridir. Yerel bir makinede bu, "/Users/Name/Downloads/TrafficSigns" gibi görünebilir ve bu dizin içinde "Training" ve "Testing" adlı iki alt klasör bulunur.

İpucu: Python’da nasıl fonksiyon yazılacağını DataCamp’in Python Fonksiyonları Eğitimi ile gözden geçirin.

# Import the `pyplot` module of `matplotlib`
import matplotlib.pyplot as plt

# Determine the (random) indexes of the images that you want to see 
traffic_signs = [300, 2250, 3650, 4000]

# Fill out the subplots with the random images that you defined 
for i in range(len(traffic_signs)):
    plt.subplot(1, 4, i+1)
    plt.axis('off')
    plt.imshow(images[traffic_signs[i]])
    plt.subplots_adjust(wspace=0.5)

plt.show()

# Import `matplotlib`
import matplotlib.pyplot as plt

# Determine the (random) indexes of the images
traffic_signs = [300, 2250, 3650, 4000]

# Fill out the subplots with the random images and add shape, min and max values
for i in range(len(traffic_signs)):
    plt.subplot(1, 4, i+1)
    plt.axis('off')
    plt.imshow(images[traffic_signs[i]])
    plt.subplots_adjust(wspace=0.5)
    plt.show()
    print("shape: {0}, min: {1}, max: {2}".format(images[traffic_signs[i]].shape, 
                                                  images[traffic_signs[i]].min(), 
                                                  images[traffic_signs[i]].max()))

# Import the `pyplot` module as `plt`
import matplotlib.pyplot as plt 

# Get the unique labels 
unique_labels = set(labels)

# Initialize the figure
plt.figure(figsize=(15, 15))

# Set a counter
i = 1

# For each unique label,
for label in unique_labels:
    # You pick the first image for each label
    image = images[labels.index(label)]
    # Define 64 subplots 
    plt.subplot(8, 8, i)
    # Don't include axes
    plt.axis('off')
    # Add a title to each subplot 
    plt.title("Label {0} ({1})".format(label, labels.count(label)))
    # Add 1 to the counter
    i += 1
    # And you plot this first image 
    plt.imshow(image)
    
# Show the plot
plt.show()

Özellik Çıkarma

Artık verilerinizi iyice keşfettiğinize göre, kolları sıvama zamanı! Manipülasyonda herhangi bir adımı atlamadığınızdan emin olmak için keşfettiklerinizi kısaca özetleyelim:

• Görüntülerin boyutları eşit değildi;
• 62 etiket veya hedef değer var (etiketleriniz 0’dan başlayıp 61’de bittiği için);
• Trafik işareti değerlerinin dağılımı oldukça eşitsizdi; Veri setinde ağır basan işaretler arasında gerçek bir bağlantı yoktu.

Artık neyi iyileştirmeniz gerektiğine dair net bir fikriniz olduğuna göre, verilerinizi sinir ağına ya da beslemek istediğiniz başka bir modele uygun hâle getirecek şekilde manipüle etmeye başlayabilirsiniz. Önce bazı özellikleri çıkararak başlayalım - görüntüleri yeniden ölçekleyecek ve images dizisinde tutulan görüntüleri gri tonlamaya dönüştüreceksiniz. Bu renk dönüşümünü ağırlıklı olarak, şu an yanıtlamaya çalıştığınız sınıflandırma sorularında rengin daha az önem taşıması nedeniyle yapacaksınız. Ancak tespitte (detection) renk önemli bir rol oynar! Dolayısıyla o durumlarda bu dönüşümü yapmak gerekmez!

Görüntüleri Yeniden Ölçekleme

Farklı görüntü boyutlarını ele almak için görüntüleri yeniden ölçekleyeceksiniz; Bunu, görüntü işleme için bir algoritma koleksiyonu olan skimage ya da Scikit-Image kütüphanesinin yardımıyla kolayca yapabilirsiniz.

Bu durumda, size resize() işlevini sunan transform modülü işinize yarayacak; Her bir görüntüyü 28x28 piksele yeniden boyutlandırmak için (yine!) liste kavrayışını kullandığınızı göreceksiniz. Yine, listeyi oluşturma biçiminiz şu şekildedir: images dizisinde bulduğunuz her görüntü için, skimage kütüphanesinden aldığınız dönüştürme işlemini uygulayacaksınız. Son olarak sonucu images28 değişkeninde saklayacaksınız:

# Import the `transform` module from `skimage`
from skimage import transform 

# Rescale the images in the `images` array
images28 = [transform.resize(image, (28, 28)) for image in images]

Oldukça kolaydı, değil mi?

Not görüntüler artık dört boyutlu: images28’i bir diziye dönüştürür ve shape özniteliğini eklerseniz, çıktıda images28’in boyutlarının (4575, 28, 28, 3) olduğunu görürsünüz. Görüntüler 784 boyutludur (görüntüleriniz 28x28 piksel olduğu için).

Yeniden ölçekleme işleminin sonucunu, traffic_signs değişkeninin yardımıyla 4 rastgele görüntüyü çizmek için kullandığınız kodu tekrar kullanarak kontrol edebilirsiniz. Sadece images başvurularını images28 olarak değiştirmeyi unutmayın.

Sonucu burada kontrol edin:

Not yeniden ölçekleme yaptığınız için min ve max değerleriniz de değişti; Artık hepsi aynı aralıklarda görünüyor, bu da verilerinizi mutlaka normalize etmeniz gerekmediği anlamına gelir; bu gerçekten harika!

# Import `rgb2gray` from `skimage.color`
from skimage.color import rgb2gray

# Convert `images28` to an array
images28 = np.array(images28)

# Convert `images28` to grayscale
images28 = rgb2gray(images28)

import matplotlib.pyplot as plt

traffic_signs = [300, 2250, 3650, 4000]

for i in range(len(traffic_signs)):
    plt.subplot(1, 4, i+1)
    plt.axis('off')
    plt.imshow(images28[traffic_signs[i]], cmap="gray")
    plt.subplots_adjust(wspace=0.5)
    
# Show the plot
plt.show()

TensorFlow ile Derin Öğrenme

Artık verilerinizi keşfedip manipüle ettiğinize göre, TensorFlow paketinin yardımıyla sinir ağı mimarinizi kurma zamanı!

Sinir Ağını Modellemeden

Keras ile yaptığınız gibi, sinir ağınızı katman katman inşa etme zamanı.

Henüz yapmadıysanız, tensorflow’u çalışma alanınıza geleneksel tf kısaltmasıyla aktarın. Ardından, Graph()’ın yardımıyla Grafiği başlatabilirsiniz. Bu işlevi hesaplamayı tanımlamak için kullanırsınız. Not Grafik ile hiçbir şey hesaplamazsınız, çünkü herhangi bir değer tutmaz. Sadece daha sonra çalıştırmak istediğiniz işlemleri tanımlar.

Bu durumda, as_default()’un yardımıyla varsayılan bir bağlam kurarsınız; bu, belirli bu Grafiği varsayılan grafik yapan bir bağlam yöneticisi döndürür. Aynı süreçte birden fazla grafik oluşturmak istiyorsanız bu yöntemi kullanırsınız: bu işlevle, açıkça yeni bir grafik oluşturmadıkça tüm işlemlerin ekleneceği genel bir varsayılan grafiğiniz olur.

Artık grafiğinize işlemler eklemeye hazırsınız. Keras ile çalışmaktan hatırlayabileceğiniz gibi, modelinizi inşa eder ve derleme aşamasında bir kayıp işlevi, bir optimize edici ve bir metrik tanımlarsınız. TensorFlow ile çalışırken bunların tümü tek adımda gerçekleşir:

• Önce girdiler ve etiketler için placeholder’lar tanımlarsınız çünkü “gerçek” verileri henüz koymayacaksınız. Unutmayın placeholder’lar, oturumu çalıştırdığınızda oturum tarafından başlatılan atanmamış değerlerdir. Yani oturumu nihayet çalıştırdığınızda, bu placeholder’lar run() işlevine geçirdiğiniz veri kümenizin değerlerini alacaktır!
• Sonra ağı inşa edersiniz. Önce flatten() işlevinin yardımıyla girişi düzleştirerek başlarsınız; bu, gri tonlamalı görüntülerinizin şekli [None, 28, 28] iken size [None, 784] şeklinde bir dizi verir.
• Girişi düzleştirdikten sonra, [None, 62] boyutunda lojitler üreten tam bağlı bir katman oluşturursunuz. Logit, önceki katmanların ölçeklenmemiş çıktısı üzerinde çalışan ve birimlerin doğrusal olduğunu, göreli ölçeği kullanarak anlayan işlevdir.
• Çok katmanlı algılayıcıyı kurduktan sonra, kayıp işlevini tanımlayabilirsiniz. Kayıp işlevi seçimi elinizdeki göreve bağlıdır: bu durumda şunu kullanırsınız

sparse_softmax_cross_entropy_with_logits()

• Bu, logitler ve etiketler arasında seyrek softmax çapraz entropisini hesaplar. Başka bir deyişle, sınıfların birbirini dışladığı ayrık sınıflandırma görevlerinde olasılık hatasını ölçer. Bu, her girdinin tam olarak bir sınıfta olduğu anlamına gelir. Burada, bir trafik işareti yalnızca tek bir etikete sahip olabilir. Unutmayın regresyon sürekli değerleri tahmin etmek için kullanılırken, sınıflandırma verilerin ayrık değerlerini veya sınıflarını tahmin etmek için kullanılır. Bu işlevi, bir tensörün boyutları boyunca öğelerin ortalamasını hesaplayan reduce_mean() ile sarmalarsınız.
• Ayrıca bir eğitim optimize edici tanımlamak istersiniz; En popüler optimizasyon algoritmalarından bazıları Stokastik Gradyan İnişi (SGD), ADAM ve RMSprop’tur. Hangi algoritmayı seçerseniz seçin, öğrenme oranı veya momentum gibi bazı parametreleri ayarlamanız gerekir. Bu durumda, öğrenme oranını 0.001 olarak tanımladığınız ADAM optimize edicisini seçiyorsunuz.
• Son olarak, eğitime geçmeden önce yürütülecek işlemleri başlatırsınız.

# Import `tensorflow` 
import tensorflow as tf 

# Initialize placeholders 
x = tf.placeholder(dtype = tf.float32, shape = [None, 28, 28])
y = tf.placeholder(dtype = tf.int32, shape = [None])

# Flatten the input data
images_flat = tf.contrib.layers.flatten(x)

# Fully connected layer 
logits = tf.contrib.layers.fully_connected(images_flat, 62, tf.nn.relu)

# Define a loss function
loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels = y, 
                                                                    logits = logits))
# Define an optimizer 
train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)

# Convert logits to label indexes
correct_pred = tf.argmax(logits, 1)

# Define an accuracy metric
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

İlk sinir ağınızı TensorFlow ile başarıyla oluşturdunuz!

İsterseniz, az önce yazdıklarınızı hızlıca özetlemek veya kontrol etmek için (değişkenlerin çoğunun) değerlerini yazdırabilirsiniz:

print("images_flat: ", images_flat)
print("logits: ", logits)
print("loss: ", loss)
print("predicted_labels: ", correct_pred)

İpucu: “module 'pandas' has no attribute 'computation'” gibi bir hata görürseniz, komut satırında pip install --upgrade dask çalıştırarak dask paketini yükseltmeyi düşünün. Daha fazla bilgi için bu StackOverflow gönderisine bakın.

Sinir Ağını Çalıştırma

Modelinizi katman katman oluşturduğunuza göre, şimdi onu gerçekten çalıştırma zamanı! Bunu yapmak için önce, bir önceki bölümde tanımladığınız graph’ı geçirebileceğiniz Session() yardımıyla bir oturum başlatmanız gerekir. Ardından, yine bir önceki bölümde tanımladığınız init değişkeni biçimindeki başlatılmış işlemleri geçirerek run() ile oturumu çalıştırabilirsiniz.

Sonrasında, bu başlatılmış oturumu kullanarak epoch’lara veya eğitim döngülerine başlayabilirsiniz. Bu örnekte, son loss_value’u kaydedebilmek için 201’i seçiyorsunuz; Döngüde, bir önceki bölümde tanımladığınız eğitim optimize edicisini ve kayıp (veya doğruluk) metriğini oturumda çalıştırırsınız. Ayrıca modele veri beslediğiniz feed_dict argümanını da geçirirsiniz. Her 10 epoch’ta bir, modele ilişkin kayıp veya maliyet hakkında daha fazla bilgi veren bir günlük alırsınız.

TensorFlow temelleri bölümünde gördüğünüz gibi oturumu manuel olarak kapatmanıza gerek yoktur; bu sizin için yapılır. Ancak farklı bir yapı denemek isterseniz, aşağıdaki kod bloğunda olduğu gibi oturumunuzu sess olarak tanımladıysanız muhtemelen sess.close() ile yapmanız gerekecektir:

tf.set_random_seed(1234)
sess = tf.Session()

sess.run(tf.global_variables_initializer())

for i in range(201):
        print('EPOCH', i)
        _, accuracy_val = sess.run([train_op, accuracy], feed_dict={x: images28, y: labels})
        if i % 10 == 0:
            print("Loss: ", loss)
        print('DONE WITH EPOCH')

Unutmayın aşağıdaki kod parçasını da çalıştırabilirsiniz, ancak bu, tıpkı bu eğitimin girişinde gördüğünüz gibi, oturumu hemen sonrasında kapatacaktır:

tf.set_random_seed(1234)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for i in range(201):
        _, loss_value = sess.run([train_op, loss], feed_dict={x: images28, y: labels})
        if i % 10 == 0:
            print("Loss: ", loss)

Not initialize_all_variables() işlevi kullanımdan kaldırıldığından global_variables_initializer() kullanırsınız.

Artık modelinizi başarıyla eğittiniz! O kadar da zor değildi, değil mi?

Sinir Ağınızı Değerlendirme

Henüz tamamen bitmedi; Hâlâ sinir ağınızı değerlendirmeniz gerekiyor. Bu durumda, 10 rastgele görüntü seçip, tahmin edilen etiketleri gerçek etiketlerle karşılaştırarak modelinizin ne kadar iyi performans gösterdiğine dair bir fikir edinebilirsiniz.

Önce bunları yazdırabilirsiniz, ancak neden matplotlib kullanarak trafik işaretlerinin kendilerini çizip görsel bir karşılaştırma yapmayasınız?

 # Import `matplotlib`
import matplotlib.pyplot as plt
import random

# Pick 10 random images
sample_indexes = random.sample(range(len(images28)), 10)
sample_images = [images28[i] for i in sample_indexes]
sample_labels = [labels[i] for i in sample_indexes]

# Run the "correct_pred" operation
predicted = sess.run([correct_pred], feed_dict={x: sample_images})[0]
                        
# Print the real and predicted labels
print(sample_labels)
print(predicted)

# Display the predictions and the ground truth visually.
fig = plt.figure(figsize=(10, 10))
for i in range(len(sample_images)):
    truth = sample_labels[i]
    prediction = predicted[i]
    plt.subplot(5, 2,1+i)
    plt.axis('off')
    color='green' if truth == prediction else 'red'
    plt.text(40, 10, "Truth:        {0}\nPrediction: {1}".format(truth, prediction), 
             fontsize=12, color=color)
    plt.imshow(sample_images[i],  cmap="gray")

plt.show()

Ancak, yalnızca rastgele görüntülere bakmak modelinizin aslında ne kadar iyi performans gösterdiğine dair çok fazla içgörü vermez. Bu yüzden test verilerini yükleyeceksiniz.

Not eğitim boyunca başta tanımladığınız load_data() işlevini kullandığınızı unutmayın.

# Import `skimage`
from skimage import transform

# Load the test data
test_images, test_labels = load_data(test_data_directory)

# Transform the images to 28 by 28 pixels
test_images28 = [transform.resize(image, (28, 28)) for image in test_images]

# Convert to grayscale
from skimage.color import rgb2gray
test_images28 = rgb2gray(np.array(test_images28))

# Run predictions against the full test set.
predicted = sess.run([correct_pred], feed_dict={x: test_images28})[0]

# Calculate correct matches 
match_count = sum([int(y == y_) for y, y_ in zip(test_labels, predicted)])

# Calculate the accuracy
accuracy = match_count / len(test_labels)

# Print the accuracy
print("Accuracy: {:.3f}".format(accuracy))

Unutmayın TensorFlow oturumunuzu with tf.Session() as sess: ifadesiyle başlatmadıysanız, sess.close() ile oturumu kapatmayı unutmayın.

Sırada Ne Var?

Bu veri seti ve bu eğitimde bir araya getirdiğiniz model üzerinde çalışmaya devam etmek istiyorsanız, aşağıdakileri deneyin:

• Verileri modele beslemeden önce düzenlileştirilmiş LDA uygulayın. Bu, bu veri setini toplayıp analiz eden araştırmacılar tarafından yazılan orijinal makalelerden birinden gelen bir öneridir.
• Eğitimin kendisinde de dediğimiz gibi, trafik işareti görüntüleri üzerinde gerçekleştirebileceğiniz diğer veri artırma işlemlerine de bakabilirsiniz. Ek olarak, bu ağı daha da ince ayar yapmayı deneyebilirsiniz; Şu anda oluşturduğunuz ağ oldukça basitti.
• Erken durdurma: Sinir ağını eğitirken eğitim ve test hatasını takip edin. Her iki hata da düşüp birdenbire tekrar yükseldiğinde eğitimi durdurun - bu, sinir ağının eğitim verisine aşırı uymaya başladığının bir işaretidir.
• Optimize edicilerle oynayın.

Nishant Shukla tarafından yazılan Machine Learning With TensorFlow kitabına göz atmayı unutmayın.

İpucu ayrıca TensorFlow Playground ve TensorBoard’a da göz atın.

Görüntülerle çalışmaya devam etmek istiyorsanız, mutlaka DataCamp’in scikit-learn eğitimine göz atın; bu eğitim, MNIST veri setini PCA, K-Ortalamalar ve Destek Vektör Makineleri (SVM) yardımıyla ele alır. Ya da Belçika trafik işaretleri veri setini kullanan şu eğitim gibi diğer eğitimlere bakın.