Tensorflow ile Sınıflandırma için Sinir Ağı

Bu makale, Veri Bilimi Blogathon

Bu yazıda, bir sınıflandırma problemini çözmek için TensorFlow ile sinir ağı modelleri kuracağım. Tensorflow'da bir sınıflandırma problemine nasıl yaklaşabileceğimizi birlikte keşfedelim. Ama öncelikle, şu soruları yanıtlayabildiğimizden emin olmak istiyorum:

ağ nedir?

Bir sinir ağının temel amacı, bir veri kümesindeki özellikler arasındaki ilişkiyi bulmaya çalışmaktır ve insan beyninin çalışmasını taklit eden bir dizi algoritmadan oluşur. Sinir ağındaki bir "nöron", bilgileri belirli bir mimariye göre toplayan ve sınıflandıran matematiksel bir işlevdir.

Sınıflandırma Nedir?

Sınıflandırma problemi, bir şeyin bir sınıfa ait olup olmadığını tahmin etmeyi içerir. Yani bunu yaparken bir şeyin öyle ya da böyle olduğunu görmeye çalışıyoruz.

Sınıflandırma Türleri

• Bir kişinin şeker hastası olup olmadığını tahmin etmek istediğinizi varsayalım. Bu tür bir durumla karşı karşıyaysanız, iki olasılık var, değil mi? buna denir İkili Sınıflandırma.
• Bir fotoğrafın oyuncak mı, insan mı yoksa kedi mi olduğunu belirlemek istediğinizi varsayalım, değil mi? buna denir Çok Sınıflı Sınıflandırma çünkü ikiden fazla seçenek var.
• Bir makaleye hangi kategorilerin atanması gerektiğine karar vermek istediğinizi varsayalım. Öyle ise denir Çok Etiketli Sınıflandırma, çünkü bir makaleye birden fazla kategori atanmış olabilir. Açıklamamızı bu yazı üzerinden yapalım. Bu makaleye “Derin Öğrenme, TensorFlow, Sınıflandırma” vb. kategoriler atayabiliriz.

Artık ilerleyebiliriz çünkü üzerinde çalışacağımız problem hakkında ortak bir anlayışa sahibiz. Yani, kodlama zamanı. Umarım bunları benimle birlikte yazıyorsunuzdur çünkü daha iyi olmanın, daha az hata yapmanın tek yolu daha fazla kod yazmaktır.

Kullanacağımız kitaplıkları içe aktarmaya başlıyoruz:

numpy'yi np olarak içe aktar pandaları pd olarak içe aktar matplotlib.pyplot'u plt olarak içe aktar tensorflow'u tf olarak içe aktar print(tf.__version__)

Veri Kümesi Oluşturma

Üzerinde çalışılacak bir veri kümesi oluşturmanın zamanı geldi:

sklearn.datasets'ten make_circles örneklerini içe aktarın = 1000 X, y = make_circles(örnekler, gürültü = 0.03, rastgele_durum = 42)

Baskı (x >> [[0.75424625 0.23148074] [-0.75615888 0.15325888] [-0.81539193 0.17328203] ... [-0.13690036 -0.81001183] [0.67036156] ...

yazdır(y) >> [1 1 1 1 0 1 1 1 1 0]

Tamam, veri setimizi daha detaylı gördük ama hala onun hakkında bir şey bilmiyoruz değil mi? Bu nedenle burada önemli bir adım verilerle bir olmaktır ve bunu yapmanın en iyi yolu görselleştirmedir.

daire = pd.DataFrame({ 'X0' : X[:, 0], 'X1' : X[:, 1], 'etiket' : y}) daire.head()

Burada bir soru ortaya çıkıyor, ne tür etiketlerle uğraşıyoruz?

circle.label.value_counts() >> 1 500 0 500 Ad: etiket, dtip: int64

Görünüşe göre uğraşıyoruz ikili sınıflandırma problemi, çünkü 2 etiketimiz var(0 ve 1).

plt.scatter(X[:,0], X[:,1], c = y, cmap = plt.cm.RdYlBu)

Yukarıda belirttiğim gibi, verilerle bir tane elde etmenin en iyi yolu görselleştirmedir. Şimdi arsa, ne tür bir model oluşturmamız gerektiğini kendisi söylüyor. Mavi noktaları kırmızı noktalardan ayırt edebilen bir model kuracağız.

Herhangi bir sinir ağı modeli oluşturmadan önce girdi ve çıktı özelliklerimizin şekillerini kontrol etmeliyiz. aynı olmalılar!

print(X.shape, y.shape) print(len(X), len(y)) >> (1000, 2) (1000,) 1000 1000

Her özellik için aynı miktarda değere sahibiz, ancak X'in şekli farklı mı? Neden? Niye? Hadi kontrol edelim.

X[0], y[0] >> (dizi([0.75424625, 0.23148074]), 1)

Tamam, 2 y için 1 X özelliğimiz var. Böylece sorunsuz bir şekilde ilerleyebiliriz.

Tensorflow ile Sınıflandırma İçin Yapay Sinir Ağını Modelleme Adımları

TensorFlow'da bir model oluşturmak için sabit aşamalar vardır:

• model oluşturma – İşlevsel veya Sıralı API'yi kullanarak bir Sinir Ağının katmanlarını bir araya getirin
• Bir model derlemek – bir modelin performansının nasıl ölçüleceğini ve nasıl iyileştirileceğini tanımlama (kayıp fonksiyonu ve optimize edici)
• Bir modun takılmasıl – bir modelin verilerdeki kalıpları bulmasına izin vermek

Sıralı API'yi kullanacağız. Öyleyse başlayalım

tf.random.set_seed(42)

model_1 = tf.keras.Sequential([tf.keras.layers.Dense(1)])

 optimizer = tf.keras.optimizers.SGD(), #SGD, Stokastik Gradient Descent metrikleri = ['doğruluk']) model_1.fit(X, y, epochs = 5) anlamına gelir

>> Epoch 1/5 32/32 [===============================] - 1s 1ms/adım - kayıp: 2.8544 - doğruluk: 0.4600 Epoch 2/5 32/32 [=============================] - 0s 2ms/adım - kayıp : 0.7131 - doğruluk: 0.5430 Epoch 3/5 32/32 [============================] - 0s 2ms/adım - kayıp: 0.6973 - doğruluk: 0.5090 Epoch 4/5 32/32 [=============================] - 0s 2ms /adım - kayıp: 0.6950 - doğruluk: 0.5010 Epoch 5/5 32/32 [============================] - 0s 1ms/adım - kayıp: 0.6942 - doğruluk: 0.4830

Modelin doğruluğu yaklaşık %50'dir, bu da temel olarak modelin yalnızca tahminde bulunduğu anlamına gelir, hadi onu daha uzun süre eğitmeye çalışalım

model_1.fit(X, y, epochs = 200, ayrıntılı = 0) #eğitim prosedürünü kaldırmak için ayrıntılı = 0 olarak ayarladık) model_1.evaluate(X, y)

>> 32/32 [==============================] - 0s 1ms/adım - kayıp: 0.6935 - doğruluk: 0.5000 [0.6934829950332642, 0.5]

200 çağdan sonra bile, hala tahmin ediyormuş gibi performans gösteriyor Sonraki adım, daha fazla katman eklemek ve daha uzun süre eğitim vermek.

tf.random.set_seed(42)

model_2 = tf.keras.Sequential([ tf.keras.layers.Dense(1), tf.keras.layers.Dense(1) ]) model_2.compile(kayıp = tf.keras.losses.BinaryCrossentropy(), iyileştirici = tf.keras.optimizers.SGD(), metrics = ['accuracy']) model_2.fit(X, y, epochs = 100, ayrıntılı = 0)

 model_2.değerlendir(X,y)

>> 32/32 [==============================] - 0s 1ms/adım - kayıp: 0.6933 - doğruluk: 0.5000 [0.6933314800262451, 0.5]

Yine de ufak bir değişiklik bile yok, bir şeyler ters gidiyor gibi.

Tensorflow ile Sinir Ağını Sınıflandırma Modeli İçin İyileştirme

Bir modeli farklı aşamalarda geliştirmenin farklı yolları vardır:

• Bir model oluşturma – daha fazla katman ekleyin, gizli birimlerin (nöronların) sayısını artırın, her katmanın aktivasyon fonksiyonlarını değiştirin
• Bir model derleme – farklı optimizasyon işlevlerini deneyin, örneğin SGD() yerine Adam() kullanın.
• Bir modelin takılması – çağ sayısını artırabiliriz

deneyelim daha fazla nöron ekle ve deneyin Adem iyileştirici

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # 100 yoğun nöron ekle tf.keras.layers.Dense(10), # 10 nöronlu başka bir katman ekle tf.keras.layers.Dense (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(), metrics=['accuracy']) model_3.fit(X, y, epochs) =100, ayrıntılı=0)

model_3.evaluate(X,y) >> 32/32 [=============================] - 0s 1ms/adım - kayıp: 0.6980 - doğruluk: 0.5080 [0.6980254650115967, 0.5080000162124634]

Hala iyileşmiyor! Neyin yanlış gittiğini görmek için verileri görselleştirelim.

Sinir Ağı modelini görselleştirin

Modelimizin tahminlerini görselleştirmek için plot_decision_boundary() işlevi yaratacağız, bu işlev:

• Eğitilmiş bir modeli, özellikleri ve etiketleri alır
• Farklı X değerlerinden oluşan bir ağ ızgarası oluşturun.
• Meshgrid genelinde tahminler yapar.
• Tahminleri çizgi ile çizer.

Not:  Bu işlev iki kaynaktan uyarlanmıştır:

CS231n Makine öğrenimi temelleri ile yapılmıştır 

def plot_decision_boundary(model, X, y): # Çizimin eksen sınırlarını tanımlayın ve bir ağ ızgarası oluşturun x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1 y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1 xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np .linspace(y_min, y_max, 100)) # X değerleri oluşturun (bunların hepsini tahmin edeceğiz) x_in = np.c_[xx.ravel(), yy.ravel()] # Eğitilenleri kullanarak tahminler yapın model y_pred = model.predict(x_in) # Çoklu sınıfı kontrol et

 if len(y_pred[0]) > 1: print("çok sınıflı sınıflandırma yapıyor...") # Tahminlerimizi y_pred = np.argmax(y_pred, eksen=1) çizmeye hazır hale getirmek için yeniden şekillendirmemiz gerekiyor). xx.shape) başka: print("ikili sınıflandırma yapılıyor...") y_pred = np.round(y_pred).reshape(xx.shape) # Çizim karar sınırı plt.contourf(xx, yy, y_pred, cmap=plt. cm.RdYlBu, alpha=0.7) plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu) plt.xlim(xx.min( ), xx.max()) plt.ylim(yy.min(), yy.max()) plot_decision_boundary(model_3, X, y)

İşte burada! Yine görselleştirme bize neyin yanlış olduğunu ve ne yapılması gerektiğini gösteriyor? Modelimiz veriler üzerinden düz bir çizgi çizmeye çalışıyor, ancak verilerimiz düz bir çizgi ile ayrılamaz. Sınıflandırma sorunumuzda eksik olan bir şey mi var? Ne olduğunu?

Bu doğrusal olmama! Doğrusal olmayan bazı doğrulara ihtiyacımız var. Şimdi kafanız karışabilir, daha önce böyle bir işlev görmediğinizi düşünüyorsanız yanılıyorsunuz çünkü gördünüz. Bunları görsel olarak görelim. Görselleştirme her zaman daha iyi çalışır!

Neural Network'te kullanabileceğimiz bazı aktivasyon fonksiyonları var, örneğin Relu, sigmoid. biraz oluşturalım oyuncak tensör ve üzerindeki bu işlevleri kontrol edin.

Sinir Ağları için Aktivasyon Fonksiyonları

A = tf.cast(tf.range(-12,12), tf.float32) print(A) >> tf.Tensor( [-12. -11. -10. -9. -8. -7. - 6. -5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.], şekil=(24,), dtipi=float32)

Bakalım oyuncak tensörümüz nasıl görünüyor?

plt.plot(A)

Böyle görünüyor, düz bir çizgi! 

Şimdi tensörümüze ne yaptıklarını görmek için aktivasyon fonksiyonlarını yeniden oluşturalım.

sigmoid:

def sigmoid(x): dönüş 1 / (1 + tf.exp(-x)) sigmoid(A) plt.plot(sigmoid(A))

Düz olmayan bir çizgi!

ReLu:

def relu(x): tf.maximum(0,x) döndürür plt.plot(relu(A))

Düz olmayan bir çizgi daha!

Artık lineer olmayan aktivasyon fonksiyonlarını gördünüz ve işimize yarayacak olanlar bunlar, model lineer aktivasyon fonksiyonları ile lineer olmayan bir veri setinde hiçbir şey öğrenemez! Bunu öğrendiysek artık verilerimizi eğitim ve test setlerine ayırmanın ve güçlü modeller kurmanın zamanı geldi.

X_train, y_train = X[:800], y[:800] X_test, y_test = X[800:], y[800:] X_train.shape, X_test.shape >>(((800, 2), (200, 2) ))

tf.random.set_seed(42)

model_4 = tf.keras.Sequential([ tf.keras.layers.Dense(4, aktivasyon = 'relu'), #onu "tf.keras.activations.relu" da düzeltebiliriz tf.keras.layers.Dense(4) , aktivasyon = 'relu'), tf.keras.layers.Dense(1, aktivasyon = 'sigmoid') ]) model_4.compile( kayıp= tf.keras.losses.binary_crossentropy, optimizer = tf.keras.optimizers.Adam( lr = 0.01), metrikler = ['doğruluk']) model_4.fit(X_train, y_train, epochs = 25, ayrıntılı = 0)

Modeli değerlendirin

kayıp, doğruluk = model_4.evaluate(X_test, y_test) print(f' Test setindeki model kaybı: {loss}') print(f' Test setindeki model doğruluğu: {100*doğruluk}')

>> 7/7 [===============================] - 0s 2ms/adım - kayıp: 0.1247 - doğruluk: 1.0000 Test setindeki model kaybı: 0.1246885135769844 Test setindeki model doğruluğu: 100.0

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("Tren") plot_decision_boundary(model_4, X=X_train, y=y_train) plt.subplot(1, 2, 2) plt.title("Test") plot_decision_boundary(model_4, X=X_test, y=y_test) plt.show()

Gelin bu yazımızda nelerden bahsettiğimize kısaca bir göz atalım. Birlikte, TensorFlow ile Neural Network'te bir sınıflandırma görevine nasıl yaklaşacağımıza baktık. İlk aklımıza gelen şekilde 3 model oluşturduk ve görselleştirme yardımıyla nerede yanıldığımızı anladık, lineerliği, nonlineerliği araştırdık ve sonunda genelleştirilmiş bir model kurmayı başardık. Tüm bu kodlar ve izlediğim adımlarla göstermeye çalıştığım şey, hiçbir şeyin yüzde 100 doğru veya sabit olmadığı, her şeyin her gün değişmeye devam ettiğiydi. Hangi tür verilerde hangi sorunla karşılaşabileceğinizi tahmin etmek ve hangi kombinasyonların daha iyi sonuç verdiğini görmek için çok daha fazla kod yazmanız ve deneyim kazanmanız yeterli.

Umarım makale size biraz yardımcı olmuştur ve bazı katkılar sağlamıştır.

Bu makalede gösterilen medya, Analytics Vidhya'ya ait değildir ve Yazarın takdirine bağlı olarak kullanılır.

İlgili bağlantılar

Kaynak: https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/