Python ile Yapay Zeka - Sinir Ağları

Sinir ağları, beynin bir bilgisayar modelini yapmaya çalışan paralel bilgi işlem cihazlarıdır. Arkasındaki temel amaç, çeşitli hesaplama görevlerini geleneksel sistemlerden daha hızlı gerçekleştirmek için bir sistem geliştirmektir. Bu görevler arasında Desen Tanıma ve Sınıflandırma, Yaklaşım, Optimizasyon ve Veri Kümeleme bulunur.

Yapay Sinir Ağları (YSA) nedir

Yapay Sinir ağı (YSA), ana teması biyolojik sinir ağları analojisinden ödünç alınan verimli bir bilgi işlem sistemidir. YSA'lar ayrıca Yapay Sinir Sistemleri, Paralel Dağıtılmış İşleme Sistemleri ve Bağlantısal Sistemler olarak adlandırılır. YSA, aralarında iletişime izin vermek için bazı modellerde birbirine bağlı geniş bir birim koleksiyonu elde eder. Bu birimler, aynı zamandanodes veya neurons, paralel çalışan basit işlemcilerdir.

Her nöron diğer nöronlarla bir connection link. Her bağlantı linki, giriş sinyali hakkında bilgiye sahip olan bir ağırlık ile ilişkilidir. Bu, nöronların belirli bir sorunu çözmesi için en yararlı bilgidir çünküweightgenellikle iletilen sinyali uyarır veya engeller. Her nöronun kendi iç durumu vardır.activation signal. Giriş sinyalleri ve aktivasyon kuralı birleştirildikten sonra üretilen çıkış sinyalleri diğer birimlere gönderilebilir.

Sinir ağlarını ayrıntılı olarak incelemek istiyorsanız, o zaman Yapay Sinir Ağı bağlantısını takip edebilirsiniz .

Yararlı Paketleri Kurmak

Python'da sinir ağları oluşturmak için, sinir ağları için güçlü bir paket kullanabiliriz. NeuroLab. Python için esnek ağ yapılandırmaları ve öğrenme algoritmaları ile temel sinir ağları algoritmalarından oluşan bir kitaplıktır. Bu paketi, komut isteminde aşağıdaki komutun yardımıyla kurabilirsiniz -

pip install NeuroLab

Anaconda ortamını kullanıyorsanız, NeuroLab'ı kurmak için aşağıdaki komutu kullanın -

conda install -c labfabulous neurolab

Sinir Ağları Oluşturmak

Bu bölümde NeuroLab paketini kullanarak Python'da bazı sinir ağları oluşturalım.

Perceptron tabanlı Sınıflandırıcı

Algılayıcılar YSA'nın yapı taşlarıdır. Perceptron hakkında daha fazla bilgi edinmek istiyorsanız, - artificial_neural_network bağlantısını takip edebilirsiniz.

Aşağıda, basit bir sinir ağı algılayıcı tabanlı sınıflandırıcı oluşturmak için Python kodunun aşamalı olarak yürütülmesi yer almaktadır -

Gerekli paketleri gösterildiği gibi içe aktarın -

import matplotlib.pyplot as plt
import neurolab as nl

Giriş değerlerini girin. Bunun denetimli öğrenmeye bir örnek olduğunu, dolayısıyla hedef değerleri de sağlamanız gerekeceğini unutmayın.

input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]

Ağı 2 giriş ve 1 nöron ile oluşturun -

net = nl.net.newp([[0, 1],[0, 1]], 1)

Şimdi ağı eğitin. Burada eğitim için Delta kuralı kullanıyoruz.

error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)

Şimdi çıktıyı görselleştirin ve grafiği çizin -

plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()

Hata metriğini kullanarak egzersiz ilerlemesini gösteren aşağıdaki grafiği görebilirsiniz -

Tek Katmanlı Yapay Sinir Ağları

Bu örnekte, çıktıyı üretmek için girdi verilerine etki eden bağımsız nöronlardan oluşan tek katmanlı bir sinir ağı oluşturuyoruz. Adlı metin dosyasını kullandığımızı unutmayın.neural_simple.txt bizim girdi olarak.

Yararlı paketleri gösterildiği gibi içe aktarın -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Veri kümesini aşağıdaki gibi yükleyin -

input_data = np.loadtxt(“/Users/admin/neural_simple.txt')

Aşağıdaki, kullanacağımız verilerdir. Bu verilerde, ilk iki sütunun özellikler ve son iki sütunun da etiketler olduğunu unutmayın.

array([[2. , 4. , 0. , 0. ],
      [1.5, 3.9, 0. , 0. ],
      [2.2, 4.1, 0. , 0. ],
      [1.9, 4.7, 0. , 0. ],
      [5.4, 2.2, 0. , 1. ],
      [4.3, 7.1, 0. , 1. ],
      [5.8, 4.9, 0. , 1. ],
      [6.5, 3.2, 0. , 1. ],
      [3. , 2. , 1. , 0. ],
      [2.5, 0.5, 1. , 0. ],
      [3.5, 2.1, 1. , 0. ],
      [2.9, 0.3, 1. , 0. ],
      [6.5, 8.3, 1. , 1. ],
      [3.2, 6.2, 1. , 1. ],
      [4.9, 7.8, 1. , 1. ],
      [2.1, 4.8, 1. , 1. ]])

Şimdi, bu dört sütunu 2 veri sütunu ve 2 etikete ayırın -

data = input_data[:, 0:2]
labels = input_data[:, 2:]

Aşağıdaki komutları kullanarak giriş verilerini çizin -

plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')

Şimdi, burada gösterildiği gibi her boyut için minimum ve maksimum değerleri tanımlayın -

dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()

Ardından, çıktı katmanındaki nöron sayısını aşağıdaki gibi tanımlayın -

nn_output_layer = labels.shape[1]

Şimdi, tek katmanlı bir sinir ağı tanımlayın -

dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)

Sinir ağını, gösterildiği gibi dönem sayısı ve öğrenme oranıyla eğitin -

error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)

Şimdi, aşağıdaki komutları kullanarak eğitim ilerlemesini görselleştirin ve planlayın -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()

Şimdi, yukarıdaki sınıflandırıcıdaki test veri noktalarını kullanın -

print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]] for item in data_test:
   print(item, '-->', neural_net.sim([item])[0])

Test sonuçlarını burada gösterildiği gibi bulabilirsiniz -

[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]

Şimdiye kadar tartışılan kodun çıktısı olarak aşağıdaki grafikleri görebilirsiniz -

Çok Katmanlı Sinir Ağları

Bu örnekte, eğitim verilerindeki temel kalıpları çıkarmak için birden fazla katmandan oluşan çok katmanlı bir sinir ağı oluşturuyoruz. Bu çok katmanlı sinir ağı bir regresör gibi çalışacaktır. Y = 2x 2 +8 denklemine göre bazı veri noktaları oluşturacağız .

Gerekli paketleri gösterildiği gibi içe aktarın -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Yukarıda belirtilen denkleme dayalı olarak bazı veri noktaları oluşturun -

min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)

Şimdi, bu veri kümesini aşağıdaki gibi yeniden şekillendirin -

data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)

Aşağıdaki komutları kullanarak giriş veri kümesini görselleştirin ve çizin -

plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')

Şimdi, iki gizli katmana sahip sinir ağını oluşturun. neurolab ile ten ilk gizli katmandaki nöronlar, six ikinci gizli katmanda ve one çıktı katmanında.

neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])

Şimdi gradyan eğitim algoritmasını kullanın -

neural_net.trainf = nl.train.train_gd

Şimdi, ağı yukarıda üretilen verileri öğrenmek amacıyla eğitin -

error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)

Şimdi, eğitim veri noktalarında sinir ağlarını çalıştırın -

output = neural_net.sim(data)
y_pred = output.reshape(num_points)

Şimdi arsa ve görselleştirme görevi -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')

Şimdi, tahmin edilen çıktıya karşı gerçek çıktıyı çizeceğiz -

x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred = neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_dense.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred, 'p')
plt.title('Actual vs predicted')
plt.show()

Yukarıdaki komutların bir sonucu olarak, aşağıda gösterildiği gibi grafikleri gözlemleyebilirsiniz -