Perceptron
Bir algılayıcı girdileri ikili olarak sınıflandırmak için kullanılır. Algılayıcı x girdi vektörünü alır, x'e karşılık gelen w ağırlık vektörü ile çarpar ve sonra bunu bir bias (sapma) b'ye ekler. Daha sonra elde edilen toplamımızın 0'dan büyük olup olmadığını belirlemek için bir aktivasyon fonksiyonu kullanır. Ve son olarak, 1 veya 0 olarak sınıflandırılır.
AND kapısının davranışını taklit etmek için bir algılayıcıyı kullabilir. Algılayıcının AND tablosundaki girdileri doğru bir şekilde sınıflandırması için ağırlık vektörü w'nin ve bias b'nin değerleri belirlenir.
Etiketli veriler kullanılarak algılayıcımızın, çıktı tahmini doğru mu belirlenebilir ve daha sonra ağırlık ve sapma buna göre ayarlanabilir. Algılayıcıyı tanımlamak için kullanılan iki formül:
f(x) = 1 if w · x + b > 0
0 otherwise w <- w + (y - f(x)) * x
Sınıflandırma, geçmiş gözlemlere dayalı olarak yeni örneklerin kategorik sınıflarını tahmin eden, denetimli öğrenmenin bir alt kategorisidir.
- Sebastian Raschka, Vahid Mirjalili, Python Makine Öğrenmesi - 2. Baskı.
Denetimli öğrenme, öğrenme verilerinin etiketlendiği Makine Öğreniminin bir alt kategorisidir, yani algılayıcıyı eğitmek için kullanılan örneklerin her biri için, çıktı ileri düzeyde bilinmektedir.
Bir algılayıcının ne tür problemler için yararlı olduğunu değerlendirirken, verilen girdilerin özelliklerine bağlı olarak, çıktının iki kategoriden birine ait olup olmadığını tahmin etmek istediğimiz görevler için iyi olduğunu söyleyebiliriz.
Bu görevlere ikili sınıflandırma görevleri denir. Gerçek dünyadaki örneklerine e-posta spam filtrelemesi, arama sonucu dizine ekleme, tıbbi değerlendirmeler, finansal tahminler ve neredeyse ikili olarak sınıflandırılabilen her şey dahildir.
AND Kapısı:
A B | AND--- ---|-----1 1 | 11 0 | 00 1 | 00 0 | 0
Kod:
import numpy as np
class Perceptron(object):
def __init__(self, no_of_inputs, threshold=100, learning_rate=0.01):
self.threshold = threshold
self.learning_rate = learning_rate
self.weights = np.zeros(no_of_inputs + 1)
def predict(self, inputs):
summation = np.dot(inputs, self.weights[1:]) + self.weights[0]
if summation > 0:
activation = 1
else:
activation = 0
return activation
def train(self, training_inputs, labels):
for _ in range(self.threshold):
for inputs, label in zip(training_inputs, labels):
prediction = self.predict(inputs)
self.weights[1:] += self.learning_rate * (label - prediction) * inputs
self.weights[0] += self.learning_rate * (label - prediction)
Satır satır inceleyelim:
import numpy as np
numpy vektörler oluşturmamızı sağlar ve bize hem doğrusal cebir fonksiyonlarını hem de onunla birlikte kullanmak için python listesine benzer fonksiyonlar verir.
class Perceptron(object):
Burada yeni bir Perceptron sınıfı oluşturuyoruz. Bu, algılayıcımızı ağırlıklarını öğrendikten ve atadıktan sonra kullanmak için durumu korumamıza izin verecektir.
def __init__(self, no_of_inputs, threshold=100, learning_rate=0.01):
no_of_inputs, kaç ağırlık öğrenmemiz gerektiğini belirlemek için kullanılır.
threshold, öğrenme algoritmamızın tekrarlayacağı döngülerin sayısıdır ve varsayılan olarak 100'dür.
learning_rate, eğitim verilerimiz aracılığıyla her adımda ağırlıklarımızdaki değişimin büyüklüğünü belirlemek için kullanılır ve varsayılan olarak 0,01'dir.
threshold ve learning_rate değişkenleriyle, algılayıcı öğrenme kuralımızın verimliliğini değiştirmek için oynanabilir, İsteğe bağlı parametreler olduğundan çalışma zamanında denenebilirler.
self.threshold = threshold
self.learning_rate = learning_rate
Bu iki satır, değişkenlere threshold ve learning_rate değişkenlerini atar.
self.weights = np.zeros(no_of_inputs + 1)
Burada ağırlık vektörünüzü başlatırız. np.zeros(n), n adet 0 içeren bir vektör oluşturur. no_of_inputs (girdi sayısı) artı 1 ile bias’ımızı ağırlık vektörüne taşıyoruz. Bu sapma (bias), ağırlık vektörünüzün + 1'i ve sapma ağırlığı olarak adlandırılır.
def predict(self, inputs):
Bu metot f(x) = 1 if w · x + b > 0 : 0 otherwise algoritmasını barındırır.
Predict metodu, argüman olarak no_of_inputs parametresine eşit boyutta sayısal bir dizi/vektör alır. (inputs)
summation = np.dot(inputs, self.weights[1:]) + self.weights[0]
Burası, numpy dot çarpım işlevinin devreye girdiği yerdir ve tam olarak beklediğimiz gibi çalışır. np.dot(a, b) == a · b. Nokta çarpımının yalnızca her iki vektör de eşit boyutta olması durumunda çalıştığını hatırlamak önemlidir. [1, 2, 3] · [1, 2, 3, 4] geçersiz olur. Burada işler biraz zorlaşıyor, çünkü self.weight vektörümüze bias için ekstra bir boyut ekledik.
İki seçeneğimiz var, ya girişler (inputs) vektörümüzün başına 1 ekleyebiliriz, ya da girişlerin ve self.weights vektörünün nokta çarpımının ilk değerini “remove” ile kaldırıp self.weights vektörünün ilk değerini nokta çarpıma ekleyebilriz. Her iki şekilde de çalışır.
Daha sonra sonucu summation değişkeninde saklarız.
if summation > 0:
activation = 1
else:
activation = 0
return activation
Bu bizim adım (step) fonksiyonumuz. Yukarıdan gelen toplam 0'dan büyükse, activation değişkenine 1 atarız, aksi takdirde activation = 0 olur, sonra bu değeri döndürürüz.
Geçici değişken activation'a ihtiyacımız yok, ancak şimdilik hedef açık olmak.
def train(self, training_inputs, labels):
Daha sonra, iki argüman alan train yöntemini tanımlarız: training_inputs ve labels.
training_inputs, predict metodu tarafından girdi olarak kullanılacak numpy vektörlerinden oluşan bir liste olması beklenir.
Etiketlerin (labels) training_inputs listesindeki girdilerin her biri için beklenen çıktı değerleri olması beklenir.
Esasen, training_inputs[n] 'deki girdi vektörü, labes[n]'de beklenen çıktıya sahiptir, bu nedenle len(training_inputs) == len(labels).
for _ in range(self.threshold):
Bu, altındaki kod bloğunun, eşik (threshold) değişkenine eşit sayıda çalıştırılacağı bir döngü oluşturur. Varsayılan olarak 100 döngüdür. Bir yineleyici değişkeni kullanmadığımız için, _ olarak ayarladı.
for inputs, label in zip(training_inputs, labels):
Bu satırda üç önemli adım var:
- Yinelenebilir bir nesne oluşturmak için training_inputs ve labels’i bir araya getiriyoruz (zip).
- Yeni nesnenin içinde dolaşıyoruz.
- Yineleme yaparken, training_inputs listesindeki her öğeyi inputs değişkeninde ve labels’deki öğelerin her birini label değişkeninde saklarız.
Bu satırdan sonraki kod bloğunda, label'da, inputs değişkeninde saklanan giriş vektörünün beklenen çıktısı bulunur.
prediction = self.predict(inputs)
Burada, inputs vektörünü daha önce tanımladığımız predict metoduna geçiririz ve sonucu prediction (tahmin) değişkeninde saklarız.
self.weights[1:] += self.learning_rate * (label - prediction) * inputs
Bu hemen hemen tüm öğrenme kuralının uygulamasıdır:
w <- w + α(y — f(x))x
Hatayı, label – prediction ile buluruz, daha sonra bunu self.learning_rate'imizle ve inputs vektörümüzle çarparız, bu sonucu weights vektörüne ekleriz (bias ağırlığı kaldırılmış olarak) ve tekrar self.weights[1:]’de saklarız.
self.weights[0]’ın bizim bias ağırlığımız olduğunu unutmayın, bu nedenle farklı boyutlarda oldukları için doğrudan self.weights ve inputs vektörlerini ekleyemeyiz.
Bununla ilgili bahsettiğimiz birkaç seçenek vardı, ama bence en açık olanı, sadece self.weights[0]’daki bias ağırlığını kaldırıp oluşan vektörü göz önünde bulundurarak, yaptığımız şeyi taklit etmektir.
Bias’ı görmezden gelemeyiz:
self.weights[0] += self.learning_rate * (label - prediction)
Bias’ı diğer ağırlıklarla aynı şekilde güncelliyoruz, ancak inputs vektörü ile çarpmıyoruz.
Sonuç olarak Python'da basit bir algılayıcı uygulayabildik!
Kullanım
Son olarak AND logic uygulayarak tamamlayalım.
import numpy as np
from perceptron import Perceptron
İlk olarak, vektörlerimizi oluşturabilmemiz için numpy'yi ve yeni algılayıcımızı içe aktarırız.
training_inputs = []
training_inputs.append(np.array([1, 1]))
training_inputs.append(np.array([1, 0]))
training_inputs.append(np.array([0, 1]))
training_inputs.append(np.array([0, 0]))
Sonra, eğitim verilerimizi üretiyoruz. Bu girişler, training_inputs adı verilen bir dizi numpy array’de saklanan AND doğruluk tablosundaki A ve B sütunlarıdır.
labels = np.array([1, 0, 0, 0])
Burada, beklenen çıktıları veya etiketleri, temsil etmesi gereken girdi diziniyle aynı hizada olduğundan emin olarak label değişkeninde saklarız.
perceptron = Perceptron(2)
Yeni bir perceptron oluşturuyoruz, sadece 2 argümanını geçiyoruz, bu nedenle varsayılan threshold = 100 ve learning_rate=0.01 olarak kalıyor. Böyle büyük bir eşiğin ve böyle küçük bir öğrenme oranının muhtemelen gerekli olmadığını unutmayın, bu yüzden en verimli olanı bulmak için oyun oynamaktan çekinmeyin! Learning_rate = 10 ya da threshold = 2 olursa ne olur?
perceptron.train(training_inputs, labels)
Şimdi perceptron.train'i çağırarak ve training_inputs ve label'larımızı ileterek perceptronu eğitiyoruz.
Bu oldukça hızlı bir şekilde bitmelidir. 100 döngü olmasına rağmen, eğitim verilerimiz çok küçük ve numpy çok verimli!
inputs = np.array([1, 1])
perceptron.predict(inputs)
# => 1
inputs = np.array([0, 1])
perceptron.predict(inputs)
# => 0
Bu kadar! Şimdi, algılayıcımızı bir logic AND olarak kullanmaya başlayabiliriz!
Algılayıcımızı dört girdi ile eğitmiş olmamız biraz tuhaf görünebilir, bu dört girişi sınıflandırmak için buna ihtiyacımız var. Tüm algılayıcılar bu işe yarar mı? Hayır! Unutmayın, algılayıcılar neredeyse her türlü ikili olarak sınıflandırma için kullanılabilir (bazı istisnalar olsa da).
Eğitim girdilerinden birini kaldırırsanız ne olur? İkisi kaldırıldı mı? [1, 1] girdisini kaldırabiliyor musunuz? Algılayıcıyı başka hangi mantık operatörleri üzerinde eğitebilirsiniz? Daha fazla girdi eklersek ne olur?
Sonuç
AND uygulamamızı sonuçlandırdık, şimdi öğrendiğimiz her şeyi özetlemek için iyi bir zaman. Algılayıcılar ilk kez 1957'de Frank Rosenblatt tarafından Cornell Havacılık Laboratuarı'nda yayınlandı. İki sınıf arasında bir karar sınırı belirlemek için denetimli öğrenmeyi kullanarak yapay nöronun girdi özelliklerinin her biri için ağırlıkları otomatik olarak belirleyebilecek bir kural önerdi.
Algılayıcı, bir girdi özelliği vektörünün ve ağırlık vektörünün nokta çarpımını bularak ve bu sayıyı, 0'dan büyük sayılar için 1 veya aksi halde 0 döndürecek bir adım fonksiyonundan geçirerek girdileri sınıflandırır.
f(x) = 1 if w · x + b > 0 0 otherwise
Ağırlıkları belirlemek için Perceptron Öğrenme Kuralı:
- Mevcut ağırlıklara ve girdilere dayalı bir çıktı tahmin eder
- Beklenen çıktıyla veya etiketle karşılaştırır
- Tahmin != Etiket ise ağırlıklarını günceller
- Döngü eşiğine ulaşılana kadar tekrarlanır
Her yineleme sırasında ağırlıkları güncellemek için:
- Tahmini etiketten çıkararak hatayı bulur
- Hatayı ve öğrenme oranını çarpar
- Sonucu girişlerle çarpar
- Elde edilen vektörü ağırlık vektörüne ekler
Yorumlar
Yorum Gönder