PyBrain - Hızlı Kılavuz

Pybrain, python kullanılarak uygulanan Makine öğrenimi için açık kaynaklı bir kitaplıktır. Kütüphane size ağları eğitmek ve test etmek için ağlar, veri kümeleri, eğitmenler için bazı kullanımı kolay eğitim algoritmaları sunar.

Pybrain'in resmi belgelerine göre tanımı aşağıdaki gibidir -

PyBrain, Python için modüler bir Makine Öğrenimi Kitaplığıdır. Amacı, Makine Öğrenimi Görevleri için esnek, kullanımı kolay ancak yine de güçlü algoritmalar ve algoritmalarınızı test etmek ve karşılaştırmak için önceden tanımlanmış çeşitli ortamlar sunmaktır.

PyBrain, Python Tabanlı Güçlendirmeli Öğrenme, Yapay Zeka ve Sinir Ağı Kitaplığı'nın kısaltmasıdır. Aslında, önce ismini bulduk ve daha sonra bu oldukça açıklayıcı "Backronym" i tersine mühendislik uyguladık.

Pybrain'in Özellikleri

Aşağıdakiler Pybrain'in özellikleridir -

Ağlar

Bir ağ modüllerden oluşur ve bağlantılar kullanılarak bağlanırlar. Pybrain, İleri Besleme Ağı, Tekrarlayan Ağ vb. Gibi sinir ağlarını destekler.

feed-forward networkdüğümler arasındaki bilgilerin ileri yönde hareket ettiği ve asla geriye gitmeyeceği bir sinir ağıdır. Feed Forward ağı, yapay sinir ağında bulunan ağlar arasında ilk ve en basit olanıdır.

Bilgi giriş düğümlerinden, gizli düğümlerin yanında ve daha sonra çıkış düğümüne iletilir.

Recurrent NetworksFeed Forward Network'e benzer; tek fark, her adımda verileri hatırlamak zorunda olmasıdır. Her adımın geçmişi kaydedilmelidir.

Veri kümeleri

Veri kümeleri, ağları test etmek, doğrulamak ve eğitmek için verilecek verilerdir. Kullanılacak veri kümesinin türü, Makine Öğrenimi ile yapacağımız görevlere bağlıdır. Pybrain'in desteklediği en yaygın kullanılan veri kümeleri şunlardır:SupervisedDataSet ve ClassificationDataSet.

SupervisedDataSet - Aşağıdaki alanlardan oluşur input ve target. Bir veri setinin en basit şeklidir ve esas olarak denetimli öğrenme görevleri için kullanılır.

ClassificationDataSet- Esas olarak sınıflandırma problemlerini çözmek için kullanılır. Alırinput, targetalan ve ayrıca verilen hedeflerin otomatik olarak yedeklenmesi olan "sınıf" adı verilen ekstra bir alan. Örneğin, çıktı 1 veya 0 olacaktır veya çıktı verilen girdiye dayalı değerlerle birlikte gruplanacaktır, yani ya belirli bir sınıfa girecektir.

Eğitimci

Bir ağ, yani sinir ağı oluşturduğumuzda, kendisine verilen eğitim verilerine göre eğitim alacaktır. Artık ağın doğru eğitilip eğitilmediği, o ağda test edilen test verilerinin tahminine bağlı olacaktır. Pybrain Training'deki en önemli kavram BackpropTrainer ve TrainUntilConvergence'ın kullanılmasıdır.

BackpropTrainer - Denetlenen veya ClassificationDataSet veri kümesine (potansiyel olarak sıralı) göre bir modülün parametrelerini, hataları geri yayarak (zaman içinde) eğiten bir eğiticidir.

TrainUntilConvergence − Modülü yakınlaşana kadar veri setinde eğitmek için kullanılır.

Araçlar

Pybrain, paketi içe aktararak bir ağ oluşturmaya yardımcı olabilecek araç modülleri sunar: pybrain.tools.shortcuts.buildNetwork

Görselleştirme

Test verileri pybrain kullanılarak görselleştirilemez. Ancak Pybrain, veriyi görselleştirmek için Mathplotlib gibi diğer çerçevelerle çalışabilir.

Pybrain'in Avantajları

Pybrain'in avantajları:

  • Pybrain, Makine Öğrenimini öğrenmek için açık kaynaklı ücretsiz bir kütüphanedir. Makine Öğrenimi ile ilgilenen yeni başlayanlar için iyi bir başlangıçtır.

  • Pybrain, uygulamak için python kullanır ve bu, Java / C ++ gibi dillere kıyasla geliştirme sürecini hızlandırır.

  • Pybrain, verileri görselleştirmek için diğer python kütüphaneleriyle kolayca çalışır.

  • Pybrain, Feed-Forward Network, Recurrent Networks, Neural Networks gibi popüler ağlar için destek sunar.

  • Pybrain'de veri kümelerini yüklemek için .csv ile çalışmak çok kolaydır. Ayrıca başka bir kitaplıktaki veri kümelerinin kullanılmasına da izin verir.

  • Pybrain eğitmenleri kullanılarak verilerin eğitimi ve test edilmesi kolaydır.

Pybrain'in Sınırlamaları

Pybrain, karşılaşılan herhangi bir sorun için daha az yardım sunar. Tarihinde cevaplanmamış bazı sorgular varstackoverflow ve üzerinde Google Group.

Pybrain'in İş Akışı

Pybrain belgelerine göre, makine öğreniminin akışı aşağıdaki şekilde gösterilmektedir -

Başlangıçta, ön işlemeden sonra Pybrain ile kullanılabilecek ham verilerimiz var.

Pybrain'in akışı, eğitimli ve test verilerine bölünmüş veri kümeleriyle başlar.

  • ağ oluşturulur ve veri seti ve ağ eğitmene verilir.

  • Eğitmen ağdaki verileri eğitir ve çıktıları eğitimli hata ve görselleştirilebilen doğrulama hatası olarak sınıflandırır.

  • test edilen veriler, çıktının eğitilmiş verilerle eşleşip eşleşmediğini görmek için doğrulanabilir.

Terminoloji

Makine öğrenimi için Pybrain ile çalışırken dikkate alınması gereken önemli terimler vardır. Bunlar aşağıdaki gibidir -

Total Error- Ağ eğitildikten sonra gösterilen hatayı ifade eder. Hata her yinelemede değişmeye devam ederse, yineleme arasında sabit bir hata göstermeye başlayana kadar çözülmesi için hala zamana ihtiyacı olduğu anlamına gelir. Sabit hata numaralarını göstermeye başladığında, ağın yakınsadığı ve uygulanan herhangi bir ek eğitimden bağımsız olarak aynı kalacağı anlamına gelir.

Trained data - Pybrain ağını eğitmek için kullanılan verilerdir.

Testing data - Eğitimli Pybrain ağını test etmek için kullanılan verilerdir.

Trainer- Bir ağ, yani sinir ağı oluşturduğumuzda, kendisine verilen eğitim verilerine göre eğitim alacaktır. Artık ağın doğru eğitilip eğitilmediği, o ağda test edilen test verilerinin tahminine bağlı olacaktır. Pybrain Training'deki en önemli kavram BackpropTrainer ve TrainUntilConvergence'ın kullanılmasıdır.

BackpropTrainer - Denetlenen veya ClassificationDataSet veri kümesine (potansiyel olarak sıralı) göre bir modülün parametrelerini, hataları geri yayarak (zaman içinde) eğiten bir eğiticidir.

TrainUntilConvergence - Modülü yakınlaşana kadar veri setinde eğitmek için kullanılır.

Layers - Katmanlar, temelde bir ağın gizli katmanlarında kullanılan bir dizi işlevdir.

Connections- Bir bağlantı, bir katmana benzer şekilde çalışır; tek fark, verileri bir ağdaki bir düğümden diğerine kaydırmasıdır.

Modules - Modüller, giriş ve çıkış tamponlarından oluşan ağlardır.

Supervised Learning- Bu durumda, bir girdi ve çıktıya sahibiz ve girdiyi çıktıyla eşlemek için bir algoritma kullanabiliriz. Algoritma, verilen ve üzerinde yinelenen eğitim verileri üzerinde öğrenmek için yapılır ve algoritma doğru veriyi tahmin ettiğinde yineleme süreci durur.

Unsupervised- Bu durumda, girdimiz var ama çıktıyı bilmiyoruz. Denetimsiz öğrenmenin rolü, verilen verilerle mümkün olduğunca eğitilmektir.

Bu bölümde PyBrain'in kurulumu üzerinde çalışacağız. PyBrain ile çalışmaya başlamak için önce Python'u kurmamız gerekiyor. Bu yüzden aşağıdakiler üzerinde çalışacağız -

  • Python'u yükleyin
  • PyBrain'i yükleyin

Python'u Yükleme

Python'u kurmak için Python resmi sitesine gidin: www.python.org/downloads aşağıda gösterildiği gibi ve Windows, Linux / Unix ve macOS için mevcut olan en son sürüme tıklayın. Python'u yanınızda bulunan 64 veya 32 bit işletim sisteminize göre indirin.

İndirdikten sonra, .exe dosyasını açın ve python'u sisteminize kurmak için adımları izleyin.

Python paket yöneticisi, yani pip de yukarıdaki kurulumla birlikte varsayılan olarak kurulacaktır. Sisteminizde global olarak çalışmasını sağlamak için, python'un konumunu PATH değişkenine doğrudan ekleyin, aynı şey kurulumun başlangıcında gösterilir ve ADD to PATH yazan onay kutusunu işaretlemeyi hatırlayın. Kontrol etmeyi unutursanız, PATH'a eklemek için lütfen aşağıda verilen adımları izleyin.

PATH konumuna ekle

PATH'e eklemek için aşağıdaki adımları izleyin -

  • Bilgisayar simgesine sağ tıklayın ve özellikler -> Gelişmiş Sistem Ayarları'na tıklayın.

  • Ekranı aşağıda gösterildiği gibi gösterecektir.

  • Yukarıda gösterildiği gibi Ortam Değişkenlerine tıklayın. Ekranı aşağıda gösterildiği gibi gösterecektir.

Yol'u seçin ve Düzenle düğmesine tıklayın, python'unuzun konum yolunu sonuna ekleyin. Şimdi python sürümünü kontrol edelim.

Python sürümü kontrol ediliyor

Aşağıdaki kod, Python sürümünü kontrol etmemize yardımcı olur -

E:\pybrain>python --version
Python 3.7.3

PyBrain Kurulumu

Python'u kurduğumuza göre, Pybrain'i kuracağız. Pybrain deposunu aşağıda gösterildiği gibi klonlayın -

git clone git://github.com/pybrain/pybrain.git

C:\pybrain>git clone git://github.com/pybrain/pybrain.git
Cloning into 'pybrain'...
remote: Enumerating objects: 2, done.
remote: Counting objects: 100% (2/2), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 12177 (delta 0), reused 0 (delta 0), pack-reused 12175
Receiving objects: 100% (12177/12177), 13.29 MiB | 510.00 KiB/s, done.
Resolving deltas: 100% (8506/8506), done.

Şimdi gerçekleştir cd pybrain ve aşağıdaki komutu çalıştırın -

python setup.py install

Bu komut pybrain'i sisteminize kuracaktır.

Bittiğinde, pybrain'in kurulu olup olmadığını kontrol etmek için komut satırı istemini açın ve aşağıda gösterildiği gibi python yorumlayıcısını başlatın -

C:\pybrain\pybrain>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Aşağıdaki kodu kullanarak ithal pybrain ekleyebiliriz -

>>> import pybrain
>>>

Import pybrain herhangi bir hata olmadan çalışıyorsa, pybrain'in başarıyla kurulmuş olduğu anlamına gelir. Pybrain ile çalışmaya başlamak için artık kodunuzu yazabilirsiniz.

PyBrain, Python ile Makine Öğrenimi için geliştirilmiş bir kütüphanedir. Makine Öğreniminde bazı önemli kavramlar vardır ve bunlardan biri Ağlardır. Bir ağ modüllerden oluşur ve bağlantılar kullanılarak bağlanırlar.

Basit bir sinir ağının düzeni aşağıdaki gibidir -

Pybrain, İleri Besleme Ağı, Tekrarlayan Ağ, vb. Gibi sinir ağlarını destekler.

Bir feed-forward networkdüğümler arasındaki bilgilerin ileri yönde hareket ettiği ve asla geriye gitmeyeceği bir sinir ağıdır. Feed Forward ağı, yapay sinir ağında bulunan ağlar arasında ilk ve en basit olanıdır. Bilgi giriş düğümlerinden, gizli düğümlerin yanında ve daha sonra çıkış düğümüne iletilir.

İşte basit bir ileri beslemeli ağ düzeni.

Dairelerin modüller olduğu söylenir ve oklu çizgiler modüllere bağlantıdır.

Düğümler A, B, C ve D giriş düğümleridir

H1, H2, H3, H4 gizli düğümlerdir ve O çıktıdır.

Yukarıdaki ağda 4 giriş düğümümüz, 4 gizli katmanımız ve 1 çıkışımız var. Şemada gösterilen çizgi sayısı, eğitim sırasında ayarlanan modeldeki ağırlık parametrelerini gösterir.

Recurrent NetworksFeed Forward Network'e benzer, tek farkı her adımda verileri hatırlaması gerektiğidir. Her adımın geçmişi kaydedilmelidir.

İşte Tekrarlayan Ağın basit bir Düzeni -

Bir ağ modüllerden oluşur ve bunlar bağlantılar kullanılarak bağlanır. Bu bölümde şunları öğreneceğiz -

  • Ağ Oluşturun
  • Ağı Analiz Et

Ağ Oluşturma

Kodumuzu çalıştırmak için python yorumlayıcı kullanacağız. Pybrain'de bir ağ oluşturmak için kullanmalıyızbuildNetwork api aşağıda gösterildiği gibi -

C:\pybrain\pybrain>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>>
>>> from pybrain.tools.shortcuts import buildNetwork
>>> network = buildNetwork(2, 3, 1)
>>>

BuildNetwork () kullanarak bir ağ oluşturduk ve parametreler 2, 3, 1'dir, bu da ağın 2 giriş, 3 gizli ve bir tek çıkıştan oluştuğu anlamına gelir.

Aşağıda ağın ayrıntıları, yani Modüller ve Bağlantılar -

C:\pybrain\pybrain>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> from pybrain.tools.shortcuts import buildNetwork
>>> network = buildNetwork(2,3,1)
>>> print(network)
FeedForwardNetwork-8
   Modules:
   [<BiasUnit 'bias'>, <LinearLayer 'in'>, <SigmoidLayer 'hidden0'>,
<LinearLay er 'out'>]
   Connections:
   [<FullConnection 'FullConnection-4': 'hidden0' -> 'out'>, <FullConnection 'F
ullConnection-5': 'in' -> 'hidden0'>, <FullConnection 'FullConnection-6': 'bias'
-< 'out'>, <FullConnection 'FullConnection-7': 'bias' -> 'hidden0'>]
>>>

Modüller Katmanlardan oluşur ve Bağlantı FullConnection Nesnelerinden yapılır. Dolayısıyla modüllerin ve bağlantıların her biri yukarıda gösterildiği gibi adlandırılmıştır.

Ağı Analiz Etme

Modül katmanlarına ve bağlantılarına, adlarına aşağıdaki şekilde başvurarak tek tek erişebilirsiniz -

>>> network['bias']
<BiasUnit 'bias'>
>>> network['in']
<LinearLayer 'in'>

Veri kümeleri, ağları test etmek, doğrulamak ve eğitmek için verilecek bir girdi verileridir. Kullanılacak veri kümesinin türü, Makine Öğrenimi ile yapacağımız görevlere bağlıdır. Bu bölümde, aşağıdakilere bir göz atacağız -

  • Veri Kümesi Oluşturma
  • Veri Kümesine Veri Ekleme

Öncelikle bir Veri Kümesinin nasıl oluşturulacağını öğreneceğiz ve veri kümesini verilen girdi ile test edeceğiz.

Veri Kümesi Oluşturma

Bir veri kümesi oluşturmak için pybrain veri kümesi paketini kullanmamız gerekir: pybrain.datasets.

Pybrain, aşağıdaki gibi veri kümesi sınıflarını destekler SupervisedDataset, SequentialDataset, ClassificationDataSet. KullanacağızSupervisedDataset Kullanılacak veri kümesi, kullanıcının uygulamaya çalıştığı makine öğrenimi görevine bağlıdır.SupervisedDataset en basit olanıdır ve biz de burada aynısını kullanacağız.

Bir SupervisedDataset datasetparametre girdisine ve hedefe ihtiyaç duyar. Aşağıda gösterildiği gibi bir XOR doğruluk tablosu düşünün -

Bir B A ÖZELVEYA B
0 0 0
0 1 1
1 0 1
1 1 0

Verilen girdiler 2 boyutlu bir dizi gibidir ve 1 çıktı elde ederiz. Yani burada girdi boyut olur ve hedef çıktı ise çıktı 1'dir. Yani bizim veri setimize gidecek girdiler 2,1 olacaktır.

createdataset.py

from pybrain.datasets import SupervisedDataSet
sds = SupervisedDataSet(2, 1)
print(sds)

Yukarıdaki python createdataset.py kodunu çalıştırdığımızda elde ettiğimiz şey budur -

C:\pybrain\pybrain\src>python createdataset.py
input: dim(0, 2)
[]
target: dim(0, 1)
[]

Yukarıda gösterildiği gibi boyut 2 girdisini ve boyut 1 hedefini görüntüler.

Veri Kümesine Veri Ekleme

Şimdi örnek verileri veri kümesine ekleyelim.

createdataset.py

from pybrain.datasets import SupervisedDataSet
sds = SupervisedDataSet(2, 1)
xorModel = [
   [(0,0), (0,)],
   [(0,1), (1,)],
   [(1,0), (1,)],
   [(1,1), (0,)],
]
for input, target in xorModel:
sds.addSample(input, target)
print("Input is:")
print(sds['input'])
print("\nTarget is:")
print(sds['target'])

Aşağıda gösterildiği gibi bir XORModel dizisi oluşturduk -

xorModel = [
   [(0,0), (0,)],
   [(0,1), (1,)],
   [(1,0), (1,)],
   [(1,1), (0,)],
]

Veri kümesine veri eklemek için, girdi ve hedefi alan addSample () yöntemini kullanıyoruz.

AddSample'ye veri eklemek için, aşağıda gösterildiği gibi xorModel dizisi üzerinden döngü yapacağız -

for input, target in xorModel:
   sds.addSample(input, target)

Çalıştırdıktan sonra, elde ettiğimiz çıktı şu:

python createdataset.py

C:\pybrain\pybrain\src>python createdataset.py
Input is:
[[0. 0.]
[0. 1.]
[1. 0.]
[1. 1.]]
Target is:
[[0.]
[1.]
[1.]
[0.]]

Girdi ve hedef ayrıntılarını, aşağıda gösterildiği gibi yalnızca girdi ve hedef dizini kullanarak oluşturulan veri kümesinden alabilirsiniz -

print(sds['input'])
print(sds[‘target’])

Veri kümeleri, ağları test etmek, doğrulamak ve eğitmek için verilecek verilerdir. Kullanılacak veri kümesinin türü, makine öğrenimi ile yapacağımız görevlere bağlıdır. Bu bölümde çeşitli veri kümesi türlerini tartışacağız.

Aşağıdaki paketi ekleyerek veri setiyle çalışabiliriz -

pybrain.dataset

Denetlenen Veri Kümesi

Denetlenen Veri Kümesi aşağıdaki alanlardan oluşur: input ve target. Bir veri setinin en basit şeklidir ve esas olarak denetimli öğrenme görevleri için kullanılır.

Bunu kodda nasıl kullanabileceğiniz aşağıdadır -

from pybrain.datasets import SupervisedDataSet

SupervisedDataSet'te bulunan yöntemler aşağıdaki gibidir -

addSample (inp, hedef)

Bu yöntem, yeni bir girdi ve hedef örneği ekleyecektir.

splitWithProportion (oran = 0.10)

Bu, veri setlerini iki bölüme ayıracaktır. İlk kısım, girdi olarak verilen veri setinin% 'sine sahip olacaktır, yani giriş .10 ise, o zaman veri setinin% 10'u ve verilerin% 90'ıdır. Orana seçiminize göre karar verebilirsiniz. Bölünmüş veri kümeleri, ağınızı test etmek ve eğitmek için kullanılabilir.

copy() - Veri kümesinin derin bir kopyasını döndürür.

clear() - Veri kümesini temizleyin.

saveToFile (dosya adı, format = Yok, ** kwargs)

Nesneyi dosya adına göre verilen dosyaya kaydedin.

Misal

İşte SupervisedDataset kullanan çalışan bir örnek -

testnetwork.py

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure import TanhLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer

# Create a network with two inputs, three hidden, and one output
nn = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)

# Create a dataset that matches network input and output sizes:
norgate = SupervisedDataSet(2, 1)

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

# Add input and target values to dataset
# Values for NOR truth table
nortrain.addSample((0, 0), (1,))
nortrain.addSample((0, 1), (0,))
nortrain.addSample((1, 0), (0,))
nortrain.addSample((1, 1), (0,))

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, norgate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
   trainer.train()
trainer.testOnData(dataset=nortrain, verbose = True)

Çıktı

Yukarıdaki programın çıktısı aşağıdaki gibidir -

python testnetwork.py

C:\pybrain\pybrain\src>python testnetwork.py
Testing on data:
('out: ', '[0.887 ]')
('correct:', '[1 ]')
error: 0.00637334
('out: ', '[0.149 ]')
('correct:', '[0 ]')
error: 0.01110338
('out: ', '[0.102 ]')
('correct:', '[0 ]')
error: 0.00522736
('out: ', '[-0.163]')
('correct:', '[0 ]')
error: 0.01328650
('All errors:', [0.006373344564625953, 0.01110338071737218, 0.005227359234093431
, 0.01328649974219942])
('Average error:', 0.008997646064572746)
('Max error:', 0.01328649974219942, 'Median error:', 0.01110338071737218)

Sınıflandırma Veri Kümesi

Bu veri kümesi, esas olarak sınıflandırma problemleriyle ilgilenmek için kullanılır. Girdi, hedef alan ve ayrıca verilen hedeflerin otomatik bir yedeklemesi olan "sınıf" adı verilen ekstra bir alan alır. Örneğin, çıktı 1 veya 0 olacaktır veya çıktı verilen girdiye dayalı değerlerle birlikte gruplanacaktır, yani belirli bir sınıfa girecektir.

İşte kodda nasıl kullanabileceğiniz -

from pybrain.datasets import ClassificationDataSet
Syntax
// ClassificationDataSet(inp, target=1, nb_classes=0, class_labels=None)

ClassificationDataSet üzerinde kullanılabilen yöntemler aşağıdaki gibidir -

addSample(inp, target) - Bu yöntem, yeni bir girdi ve hedef örneği ekleyecektir.

splitByClass() - Bu yöntem iki yeni veri kümesi verecektir, ilk veri kümesinde seçilen sınıf (0..nClasses-1), ikincisinde kalan örnekler olacaktır.

_convertToOneOfMany() - Bu yöntem, eski hedefleri bir alan sınıfı olarak koruyarak hedef sınıfları 1-of-k temsiline dönüştürür.

İşte çalışan bir örnek ClassificationDataSet.

Misal

from sklearn import datasets
import matplotlib.pyplot as plt
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from numpy import ravel
digits = datasets.load_digits()
X, y = digits.data, digits.target
ds = ClassificationDataSet(64, 1, nb_classes=10)

for i in range(len(X)):
ds.addSample(ravel(X[i]), y[i])
test_data_temp, training_data_temp = ds.splitWithProportion(0.25)
test_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, test_data_temp.getLength()):
test_data.addSample( test_data_temp.getSample(n)[0], test_data_temp.getSample(n)[1] )
training_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, training_data_temp.getLength()):
training_data.addSample( training_data_temp.getSample(n)[0], training_data_temp.getSample(n)[1] )
test_data._convertToOneOfMany()
training_data._convertToOneOfMany()
net = buildNetwork(training_data.indim, 64, training_data.outdim, outclass=SoftmaxLayer)
trainer = BackpropTrainer(
   net, dataset=training_data, momentum=0.1,learningrate=0.01,verbose=True,weightdecay=0.01
)
trnerr,valerr = trainer.trainUntilConvergence(dataset=training_data,maxEpochs=10)
plt.plot(trnerr,'b',valerr,'r')
plt.show()
trainer.trainEpochs(10)
print('Percent Error on testData:',percentError(trainer.testOnClassData(dataset=test_data), test_data['class']))

Yukarıdaki örnekte kullanılan veri kümesi bir rakam veri kümesidir ve sınıflar 0-9 arasındadır, bu nedenle 10 sınıf vardır. Girdi 64, hedef 1 ve sınıflar, 10.

Kod, ağı veri kümesiyle eğitir ve eğitim hatası ve doğrulama hatası için grafiği çıkarır. Ayrıca aşağıdaki gibi test verileri üzerinde yüzde hata verir -

Çıktı

Total error: 0.0432857814358
Total error: 0.0222276374185
Total error: 0.0149012052174
Total error: 0.011876985318
Total error: 0.00939854792853
Total error: 0.00782202445183
Total error: 0.00714707652044
Total error: 0.00606068893793
Total error: 0.00544257958975
Total error: 0.00463929281336
Total error: 0.00441275665294
('train-errors:', '[0.043286 , 0.022228 , 0.014901 , 0.011877 , 0.009399 , 0.007
   822 , 0.007147 , 0.006061 , 0.005443 , 0.004639 , 0.004413 ]')
('valid-errors:', '[0.074296 , 0.027332 , 0.016461 , 0.014298 , 0.012129 , 0.009
   248 , 0.008922 , 0.007917 , 0.006547 , 0.005883 , 0.006572 , 0.005811 ]')
Percent Error on testData: 3.34075723830735

Bu bölümde, Pybrain veri kümeleriyle çalışmak için verileri nasıl elde edeceğimizi öğreneceğiz.

En sık kullanılanlar veri kümeleridir -

  • Sklearn kullanma
  • CSV dosyasından

Sklearn kullanma

Sklearn kullanma

İşte sklearn'dan veri kümelerinin ayrıntılarını içeren bağlantı:https://scikit-learn.org/stable/datasets/index.html

Sklearn'dan veri kümelerinin nasıl kullanılacağına dair birkaç örnek:

Örnek 1: load_digits ()

from sklearn import datasets
from pybrain.datasets import ClassificationDataSet
digits = datasets.load_digits()
X, y = digits.data, digits.target
ds = ClassificationDataSet(64, 1, nb_classes=10)
for i in range(len(X)):
ds.addSample(ravel(X[i]), y[i])

Örnek 2: load_iris ()

from sklearn import datasets
from pybrain.datasets import ClassificationDataSet
digits = datasets.load_iris()
X, y = digits.data, digits.target
ds = ClassificationDataSet(4, 1, nb_classes=3)
for i in range(len(X)):
ds.addSample(X[i], y[i])

CSV dosyasından

Ayrıca csv dosyasındaki verileri aşağıdaki gibi kullanabiliriz -

İşte xor doğruluk tablosu için örnek veriler: datasettest.csv

Veri kümesi için .csv dosyasından verileri okumak için çalışan örnek aşağıda verilmiştir.

Misal

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure import TanhLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
import pandas as pd

print('Read data...')
df = pd.read_csv('data/datasettest.csv',header=0).head(1000)
data = df.values

train_output = data[:,0]
train_data = data[:,1:]

print(train_output)
print(train_data)

# Create a network with two inputs, three hidden, and one output
nn = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)

# Create a dataset that matches network input and output sizes:
_gate = SupervisedDataSet(2, 1)

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
for i in range(0, len(train_output)) :
   _gate.addSample(train_data[i], train_output[i])

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, _gate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
   trainer.train()
trainer.testOnData(dataset=_gate, verbose = True)

Panda, örnekte gösterildiği gibi csv dosyasından veri okumak için kullanılır.

Çıktı

C:\pybrain\pybrain\src>python testcsv.py
Read data...
[0 1 1 0]
[
   [0 0]
   [0 1]
   [1 0]
   [1 1]
]
Testing on data:
('out: ', '[0.004 ]')
('correct:', '[0 ]')
error: 0.00000795
('out: ', '[0.997 ]')
('correct:', '[1 ]')
error: 0.00000380
('out: ', '[0.996 ]')
('correct:', '[1 ]')
error: 0.00000826
('out: ', '[0.004 ]')
('correct:', '[0 ]')
error: 0.00000829
('All errors:', [7.94733477723902e-06, 3.798267582566822e-06, 8.260969076585322e
-06, 8.286246525558165e-06])
('Average error:', 7.073204490487332e-06)
('Max error:', 8.286246525558165e-06, 'Median error:', 8.260969076585322e-06)

Şimdiye kadar, nasıl bir ağ ve bir veri kümesi oluşturulacağını gördük. Veri kümeleri ve ağlarla birlikte çalışmak için bunu eğitmenlerin yardımıyla yapmalıyız.

Aşağıda, oluşturulan ve daha sonra eğitmenler kullanılarak eğitilen ve test edilen ağa bir veri kümesinin nasıl ekleneceğini görmek için çalışan bir örnek verilmiştir.

testnetwork.py

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure import TanhLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer

# Create a network with two inputs, three hidden, and one output
nn = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)

# Create a dataset that matches network input and output sizes:
norgate = SupervisedDataSet(2, 1)

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

# Add input and target values to dataset
# Values for NOR truth table
nortrain.addSample((0, 0), (1,))
nortrain.addSample((0, 1), (0,))
nortrain.addSample((1, 0), (0,))
nortrain.addSample((1, 1), (0,))

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, norgate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
trainer.train()
trainer.testOnData(dataset=nortrain, verbose = True)

Ağı ve veri kümesini test etmek için BackpropTrainer'a ihtiyacımız var. BackpropTrainer, bir modülün parametrelerini denetlenen bir veri kümesine göre (potansiyel olarak sıralı) hataları geri yayarak (zaman içinde) eğiten bir eğiticidir.

2 sınıf veri kümesi oluşturduk - SupervisedDataSet. Aşağıdaki NOR veri modelini kullanıyoruz -

Bir B A NOR B
0 0 1
0 1 0
1 0 0
1 1 0

Yukarıdaki veri modeli, ağı eğitmek için kullanılır.

norgate = SupervisedDataSet(2, 1)
# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

Test etmek için kullanılan veri kümesi aşağıdadır -

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

Eğitmen şu şekilde kullanılır -

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, norgate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
   trainer.train()

Veri setini test etmek için aşağıdaki kodu kullanabiliriz -

trainer.testOnData(dataset=nortrain, verbose = True)

Çıktı

python testnetwork.py

C:\pybrain\pybrain\src>python testnetwork.py
Testing on data:
('out: ', '[0.887 ]')
('correct:', '[1 ]')
error: 0.00637334
('out: ', '[0.149 ]')
('correct:', '[0 ]')
error: 0.01110338
('out: ', '[0.102 ]')
('correct:', '[0 ]')
error: 0.00522736
('out: ', '[-0.163]')
('correct:', '[0 ]')
error: 0.01328650
('All errors:', [0.006373344564625953, 0.01110338071737218, 0.005227359234093431
, 0.01328649974219942])
('Average error:', 0.008997646064572746)
('Max error:', 0.01328649974219942, 'Median error:', 0.01110338071737218)

Çıkışı kontrol ederseniz, test verileri neredeyse sağladığımız veri kümesiyle eşleşir ve dolayısıyla hata 0,008'dir.

Şimdi test verilerini değiştirelim ve ortalama bir hata görelim. Çıkışı aşağıda gösterildiği gibi değiştirdik -

Test etmek için kullanılan veri kümesi aşağıdadır -

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (0,))
norgate.addSample((0, 1), (1,))
norgate.addSample((1, 0), (1,))
norgate.addSample((1, 1), (0,))

Şimdi test edelim.

Çıktı

python testnework.py

C:\pybrain\pybrain\src>python testnetwork.py
Testing on data:
('out: ', '[0.988 ]')
('correct:', '[0 ]')
error: 0.48842978
('out: ', '[0.027 ]')
('correct:', '[1 ]')
error: 0.47382097
('out: ', '[0.021 ]')
('correct:', '[1 ]')
error: 0.47876379
('out: ', '[-0.04 ]')
('correct:', '[0 ]')
error: 0.00079160
('All errors:', [0.4884297811030845, 0.47382096780393873, 0.47876378995939756, 0
.0007915982149002194])
('Average error:', 0.3604515342703303)
('Max error:', 0.4884297811030845, 'Median error:', 0.47876378995939756)

Hatayı 0.36 olarak alıyoruz, bu da test verilerimizin eğitilen ağ ile tamamen eşleşmediğini gösteriyor.

Bu bölümde, verileri eğiteceğimiz ve eğitilmiş verilerdeki hataları test edeceğimiz bir örnek göreceğiz.

Eğitmenlerden yararlanacağız -

BackpropTrainer

BackpropTrainer, bir modülün parametrelerini denetlenen veya ClassificationDataSet veri kümesine (potansiyel olarak sıralı) göre hataları geri yayarak (zaman içinde) eğiten eğiticidir.

TrainUntilConvergence

Modülü, yakınsayıncaya kadar veri setinde eğitmek için kullanılır.

Bir sinir ağı oluşturduğumuzda, kendisine verilen eğitim verilerine göre eğitim alacak.Şimdi ağın doğru eğitilip eğitilmediği o ağda test edilen test verilerinin tahminine bağlı olacak.

Adım adım bir sinir ağı oluşturacak ve eğitim hatalarını, test hatalarını ve doğrulama hatalarını tahmin edecek çalışan bir örnek görelim.

Ağımızı Test Etmek

Ağımızı test etmek için izleyeceğimiz adımlar aşağıdadır -

  • Gerekli PyBrain ve diğer paketleri içe aktarma
  • Sınıflandırma Veri Kümesi Oluşturun
  • Veri kümelerini test verileri olarak% 25 ve eğitimli veriler olarak% 75 bölme
  • Test verilerini ve Eğitilen verileri ClassificationDataSet olarak geri dönüştürme
  • Bir Sinir Ağı Oluşturmak
  • Ağı Eğitmek
  • Hata ve doğrulama verilerini görselleştirme
  • Test verisi için yüzde Hata

Step 1

Gerekli PyBrain ve diğer paketleri içe aktarma.

İhtiyacımız olan paketler aşağıda gösterildiği gibi ithal edilmektedir -

from sklearn import datasets
import matplotlib.pyplot as plt
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from numpy import ravel

Step 2

Sonraki adım, ClassificationDataSet oluşturmaktır.

Veri kümeleri için, sklearn veri kümelerinden veri kümelerini aşağıda gösterildiği gibi kullanacağız -

Aşağıdaki bağlantıda sklearn'daki load_digits veri kümelerine bakın -

https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html#sklearn.datasets.load_digits

digits = datasets.load_digits()
X, y = digits.data, digits.target

ds = ClassificationDataSet(64, 1, nb_classes=10) 
# we are having inputs are 64 dim array and since the digits are from 0-9 the 
classes considered is 10.

for i in range(len(X)):
   ds.addSample(ravel(X[i]), y[i]) # adding sample to datasets

Step 3

Veri kümelerini test verisi olarak% 25 ve eğitimli veri olarak% 75 bölmek -

test_data_temp, training_data_temp = ds.splitWithProportion(0.25)

Dolayısıyla burada, 0.25 değerine sahip splitWithProportion () adlı veri kümesinde bir yöntem kullandık, veri kümesini test verileri olarak% 25 ve eğitim verileri olarak% 75'e bölecek.

Step 4

Test verilerini ve Eğitilen verileri ClassificationDataSet olarak geri dönüştürme.

test_data = ClassificationDataSet(64, 1, nb_classes=10)
for n in range(0, test_data_temp.getLength()):
   test_data.addSample( test_data_temp.getSample(n)[0], test_data_temp.getSample(n)[1] )
training_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, training_data_temp.getLength()):

training_data.addSample( 
   training_data_temp.getSample(n)[0], training_data_temp.getSample(n)[1] 
)
test_data._convertToOneOfMany()
training_data._convertToOneOfMany()

Veri kümesinde splitWithProportion () yönteminin kullanılması, veri kümesini denetlenen veri kümesine dönüştürür, böylece veri kümesini yukarıdaki adımda gösterildiği gibi yeniden sınıflandırma veri kümesine dönüştüreceğiz.

Step 5

Sonraki adım bir Sinir Ağı oluşturmaktır.

net = buildNetwork(training_data.indim, 64, training_data.outdim, outclass=SoftmaxLayer)

Girdi ve çıkışın eğitim verilerinden kullanıldığı bir ağ oluşturuyoruz.

Step 6

Ağı Eğitmek

Şimdi önemli olan kısım, ağı aşağıda gösterildiği gibi veri kümesi üzerinde eğitmektir -

trainer = BackpropTrainer(net, dataset=training_data, 
momentum=0.1,learningrate=0.01,verbose=True,weightdecay=0.01)

BackpropTrainer () yöntemini ve oluşturulan ağ üzerinde veri kümesini kullanıyoruz.

Step 7

Bir sonraki adım, hatanın görselleştirilmesi ve verilerin doğrulanmasıdır.

trnerr,valerr = trainer.trainUntilConvergence(dataset=training_data,maxEpochs=10)
plt.plot(trnerr,'b',valerr,'r')
plt.show()

Eğitim verilerinde trainUntilConvergence adlı bir yöntem kullanacağız ve bu yöntem 10'lu çağlar için birleşecek. Aşağıda gösterildiği gibi çizdiğimiz eğitim hatası ve doğrulama hatasını döndürecektir. Mavi çizgi eğitim hatalarını ve kırmızı çizgi doğrulama hatasını gösterir.

Yukarıdaki kodun yürütülmesi sırasında alınan toplam hata aşağıda gösterilmektedir -

Total error: 0.0432857814358
Total error: 0.0222276374185
Total error: 0.0149012052174
Total error: 0.011876985318
Total error: 0.00939854792853
Total error: 0.00782202445183
Total error: 0.00714707652044
Total error: 0.00606068893793
Total error: 0.00544257958975
Total error: 0.00463929281336
Total error: 0.00441275665294
('train-errors:', '[0.043286 , 0.022228 , 0.014901 , 0.011877 , 0.009399 , 0.007
822 , 0.007147 , 0.006061 , 0.005443 , 0.004639 , 0.004413 ]')
('valid-errors:', '[0.074296 , 0.027332 , 0.016461 , 0.014298 , 0.012129 , 0.009
248 , 0.008922 , 0.007917 , 0.006547 , 0.005883 , 0.006572 , 0.005811 ]')

Hata 0,04'te başlar ve daha sonra her çağ için azalır, bu da ağın eğitildiği ve her dönem için daha iyi hale geldiği anlamına gelir.

Step 8

Test verisi hatası için yüzde

Aşağıda gösterildiği gibi percentError yöntemini kullanarak yüzde hatasını kontrol edebiliriz -

print('Percent Error on 
   testData:',percentError(trainer.testOnClassData(dataset=test_data), 
   test_data['class']))

Percent Error on testData - 3,34075723830735

Hata yüzdesini alıyoruz, yani% 3.34, bu da sinir ağının% 97 doğru olduğu anlamına geliyor.

Kodun tamamı aşağıdadır -

from sklearn import datasets
import matplotlib.pyplot as plt
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from numpy import ravel
digits = datasets.load_digits()
X, y = digits.data, digits.target

ds = ClassificationDataSet(64, 1, nb_classes=10)

for i in range(len(X)):
   ds.addSample(ravel(X[i]), y[i])

test_data_temp, training_data_temp = ds.splitWithProportion(0.25)
test_data = ClassificationDataSet(64, 1, nb_classes=10)
for n in range(0, test_data_temp.getLength()):
   test_data.addSample( test_data_temp.getSample(n)[0], test_data_temp.getSample(n)[1] )
training_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, training_data_temp.getLength()):
   training_data.addSample( 
      training_data_temp.getSample(n)[0], training_data_temp.getSample(n)[1] 
   )
test_data._convertToOneOfMany()
training_data._convertToOneOfMany()

net = buildNetwork(training_data.indim, 64, training_data.outdim, outclass=SoftmaxLayer)
trainer = BackpropTrainer(
   net, dataset=training_data, momentum=0.1,
   learningrate=0.01,verbose=True,weightdecay=0.01
)
trnerr,valerr = trainer.trainUntilConvergence(dataset=training_data,maxEpochs=10)
plt.plot(trnerr,'b',valerr,'r')
plt.show()

trainer.trainEpochs(10)
print('Percent Error on testData:',percentError(
   trainer.testOnClassData(dataset=test_data), test_data['class']
))

İleri beslemeli bir ağ, düğümler arasındaki bilgilerin ileri yönde hareket ettiği ve asla geriye gitmeyeceği bir sinir ağıdır. Feed Forward ağı, yapay sinir ağında bulunan ağlar arasında ilk ve en basit olanıdır. Bilgi giriş düğümlerinden, gizli düğümlerin yanında ve daha sonra çıkış düğümüne iletilir.

Bu bölümde nasıl yapılacağını tartışacağız -

  • İleri Beslemeli Ağlar Oluşturun
  • FFN'ye Bağlantı ve Modüller Ekleme

Feed Forward Ağı Oluşturma

Seçtiğiniz python IDE'sini, yani PyCharm'ı kullanabilirsiniz. Bunda, kodu yazmak için Visual Studio Code kullanıyoruz ve aynısını terminalde çalıştıracağız.

İleri besleme ağı oluşturmak için, onu şuradan içe aktarmamız gerekir: pybrain.structure aşağıda gösterildiği gibi -

ffn.py

from pybrain.structure import FeedForwardNetwork
network = FeedForwardNetwork()
print(network)

Ffn.py'yi aşağıda gösterildiği gibi çalıştırın -

C:\pybrain\pybrain\src>python ffn.py
FeedForwardNetwork-0
Modules:
[]
Connections:
[]

Feedforward ağına herhangi bir modül ve bağlantı eklemedik. Dolayısıyla ağ, Modüller ve Bağlantılar için boş diziler gösterir.

Modüller ve Bağlantılar Ekleme

Öncelikle girdi, gizli, çıktı katmanları oluşturacağız ve aynısını aşağıda gösterildiği gibi modüllere ekleyeceğiz -

ffy.py

from pybrain.structure import FeedForwardNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
network = FeedForwardNetwork()

#creating layer for input => 2 , hidden=> 3 and output=>1
inputLayer = LinearLayer(2)
hiddenLayer = SigmoidLayer(3)
outputLayer = LinearLayer(1)

#adding the layer to feedforward network
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)

print(network)

Çıktı

C:\pybrain\pybrain\src>python ffn.py
FeedForwardNetwork-3
Modules:
[]
Connections:
[]

Hala modülleri ve bağlantıları boş alıyoruz. Aşağıda gösterildiği gibi oluşturulan modüllere bağlantı sağlamamız gerekiyor -

Giriş, gizli ve çıkış katmanları arasında bir bağlantı oluşturduğumuz ve ağa bağlantı eklediğimiz kod.

ffy.py

from pybrain.structure import FeedForwardNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
from pybrain.structure import FullConnection
network = FeedForwardNetwork()

#creating layer for input => 2 , hidden=> 3 and output=>1
inputLayer = LinearLayer(2)
hiddenLayer = SigmoidLayer(3)
outputLayer = LinearLayer(1)

#adding the layer to feedforward network
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)

#Create connection between input ,hidden and output
input_to_hidden = FullConnection(inputLayer, hiddenLayer)
hidden_to_output = FullConnection(hiddenLayer, outputLayer)

#add connection to the network
network.addConnection(input_to_hidden)
network.addConnection(hidden_to_output)

print(network)

Çıktı

C:\pybrain\pybrain\src>python ffn.py
FeedForwardNetwork-3
Modules:
[]
Connections:
[]

Hala modülleri ve bağlantıları alamıyoruz. Şimdi son adımı ekleyelim, yani sortModules () yöntemini aşağıda gösterildiği gibi eklememiz gerekiyor -

ffy.py

from pybrain.structure import FeedForwardNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
from pybrain.structure import FullConnection
network = FeedForwardNetwork()

#creating layer for input => 2 , hidden=> 3 and output=>1
inputLayer = LinearLayer(2)
hiddenLayer = SigmoidLayer(3)
outputLayer = LinearLayer(1)

#adding the layer to feedforward network
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)

#Create connection between input ,hidden and output
input_to_hidden = FullConnection(inputLayer, hiddenLayer)
hidden_to_output = FullConnection(hiddenLayer, outputLayer)

#add connection to the network
network.addConnection(input_to_hidden)
network.addConnection(hidden_to_output)
network.sortModules()

print(network)

Çıktı

C:\pybrain\pybrain\src>python ffn.py
FeedForwardNetwork-6
Modules:
[<LinearLayer 'LinearLayer-3'gt;, <SigmoidLayer 'SigmoidLayer-7'>, 
   <LinearLayer 'LinearLayer-8'>]
Connections:
[<FullConnection 'FullConnection-4': 'SigmoidLayer-7' -> 'LinearLayer-8'>, 
   <FullConnection 'FullConnection-5': 'LinearLayer-3' -> 'SigmoidLayer-7'>]

Artık feedforwardnetwork için modülleri ve bağlantı ayrıntılarını görebiliyoruz.

Yinelenen Ağlar, yalnızca her adımda verileri hatırlamanız gerekmesi dışında, ileri beslemeli ağ ile aynıdır. Her adımın geçmişi kaydedilmelidir.

Nasıl yapılacağını öğreneceğiz -

  • Tekrarlayan Bir Ağ Oluşturun
  • Modül ve Bağlantı Ekleme

Tekrarlayan Bir Ağ Oluşturma

Tekrarlayan ağ oluşturmak için, aşağıda gösterildiği gibi RecurrentNetwork sınıfını kullanacağız -

rn.py

from pybrain.structure import RecurrentNetwork
recurrentn = RecurrentNetwork()
print(recurrentn)

python rn.py

C:\pybrain\pybrain\src>python rn.py
RecurrentNetwork-0
Modules:
[]
Connections:
[]
Recurrent Connections:
[]

Tekrarlayan ağ için Tekrarlayan Bağlantılar adlı yeni bir bağlantı görebiliriz. Şu anda mevcut veri yok.

Şimdi katmanları oluşturup modüllere ekleyelim ve bağlantılar oluşturalım.

Modül ve Bağlantı Ekleme

Katmanlar, yani girdi, gizli ve çıktı oluşturacağız. Katmanlar, giriş ve çıkış modülüne eklenecektir. Daha sonra, giriş için gizli, çıkış için gizli ve gizli ile gizli arasında tekrarlayan bir bağlantı oluşturacağız.

Modüller ve bağlantılar içeren Tekrarlayan ağın kodu burada.

rn.py

from pybrain.structure import RecurrentNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
from pybrain.structure import FullConnection
recurrentn = RecurrentNetwork()

#creating layer for input => 2 , hidden=> 3 and output=>1
inputLayer = LinearLayer(2, 'rn_in')
hiddenLayer = SigmoidLayer(3, 'rn_hidden')
outputLayer = LinearLayer(1, 'rn_output')

#adding the layer to feedforward network
recurrentn.addInputModule(inputLayer)
recurrentn.addModule(hiddenLayer)
recurrentn.addOutputModule(outputLayer)

#Create connection between input ,hidden and output
input_to_hidden = FullConnection(inputLayer, hiddenLayer)
hidden_to_output = FullConnection(hiddenLayer, outputLayer)
hidden_to_hidden = FullConnection(hiddenLayer, hiddenLayer)

#add connection to the network
recurrentn.addConnection(input_to_hidden)
recurrentn.addConnection(hidden_to_output)
recurrentn.addRecurrentConnection(hidden_to_hidden)
recurrentn.sortModules()

print(recurrentn)

python rn.py

C:\pybrain\pybrain\src>python rn.py
RecurrentNetwork-6
Modules:
[<LinearLayer 'rn_in'>, <SigmoidLayer 'rn_hidden'>, 
   <LinearLayer 'rn_output'>]
Connections:
[<FullConnection 'FullConnection-4': 'rn_hidden' -> 'rn_output'>, 
   <FullConnection 'FullConnection-5': 'rn_in' -> 'rn_hidden'>]
Recurrent Connections:
[<FullConnection 'FullConnection-3': 'rn_hidden' -> 'rn_hidden'>]

Yukarıdaki çıktıda Modülleri, Bağlantıları ve Tekrarlayan Bağlantıları görebiliriz.

Şimdi aşağıda gösterildiği gibi etkinleştirme yöntemini kullanarak ağı etkinleştirelim -

rn.py

Daha önce oluşturulmuş olana aşağıdaki kodu ekleyin -

#activate network using activate() method
act1 = recurrentn.activate((2, 2))
print(act1)

act2 = recurrentn.activate((2, 2))
print(act2)

python rn.py

C:\pybrain\pybrain\src>python rn.py
[-1.24317586]
[-0.54117783]

Pybrain'de eğitmenler kullanarak bir ağı nasıl eğiteceğimizi gördük. Bu bölümde, bir ağı eğitmek için Pybrain'de bulunan optimizasyon algoritmalarını kullanacağız.

Örnekte, aşağıda gösterildiği gibi içe aktarılması gereken GA optimizasyon algoritmasını kullanacağız -

from pybrain.optimization.populationbased.ga import GA

Misal

Aşağıda, GA optimizasyon algoritması kullanan bir eğitim ağının çalışan bir örneğini bulabilirsiniz -

from pybrain.datasets.classification import ClassificationDataSet
from pybrain.optimization.populationbased.ga import GA
from pybrain.tools.shortcuts import buildNetwork

# create XOR dataset
ds = ClassificationDataSet(2)
ds.addSample([0., 0.], [0.])
ds.addSample([0., 1.], [1.])
ds.addSample([1., 0.], [1.])
ds.addSample([1., 1.], [0.])
ds.setField('class', [ [0.],[1.],[1.],[0.]])

net = buildNetwork(2, 3, 1)
ga = GA(ds.evaluateModuleMSE, net, minimize=True)

for i in range(100):
net = ga.learn(0)[0]

print(net.activate([0,0]))
print(net.activate([1,0]))
print(net.activate([0,1]))
print(net.activate([1,1]))

Çıktı

Girişler için ağdaki etkinleştirme yöntemi, aşağıda gösterildiği gibi çıkışla neredeyse eşleşir -

C:\pybrain\pybrain\src>python example15.py
[0.03055398]
[0.92094839]
[1.12246157]
[0.02071285]

Katmanlar, temelde bir ağın gizli katmanlarında kullanılan bir dizi işlevdir.

Bu bölümde katmanlarla ilgili aşağıdaki ayrıntıları inceleyeceğiz -

  • Katmanı anlamak
  • Pybrain kullanarak Katman Oluşturma

Katmanları anlama

Aşağıdaki gibi katmanları kullandığımız örnekleri daha önce görmüştük -

  • TanhLayer
  • SoftmaxLayer

TanhLayer kullanarak örnek

Aşağıda, bir ağ oluşturmak için TanhLayer'ı kullandığımız bir örnek bulunmaktadır -

testnetwork.py

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure import TanhLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer

# Create a network with two inputs, three hidden, and one output
nn = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)

# Create a dataset that matches network input and output sizes:
norgate = SupervisedDataSet(2, 1)

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

# Add input and target values to dataset
# Values for NOR truth table
nortrain.addSample((0, 0), (1,))
nortrain.addSample((0, 1), (0,))
nortrain.addSample((1, 0), (0,))
nortrain.addSample((1, 1), (0,))

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, norgate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
   trainer.train()
trainer.testOnData(dataset=nortrain, verbose = True)

Çıktı

Yukarıdaki kodun çıktısı aşağıdaki gibidir -

python testnetwork.py

C:\pybrain\pybrain\src>python testnetwork.py
Testing on data:
('out: ', '[0.887 ]')
('correct:', '[1 ]')
error: 0.00637334
('out: ', '[0.149 ]')
('correct:', '[0 ]')
error: 0.01110338
('out: ', '[0.102 ]')
('correct:', '[0 ]')
error: 0.00522736
('out: ', '[-0.163]')
('correct:', '[0 ]')
error: 0.01328650
('All errors:', [0.006373344564625953, 0.01110338071737218, 
   0.005227359234093431, 0.01328649974219942])
('Average error:', 0.008997646064572746)
('Max error:', 0.01328649974219942, 'Median error:', 0.01110338071737218)

SoftMaxLayer kullanma örneği

Aşağıda, bir ağ oluşturmak için SoftmaxLayer kullandığımız bir örnek bulunmaktadır -

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure.modules import SoftmaxLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer

# Create a network with two inputs, three hidden, and one output
nn = buildNetwork(2, 3, 1, bias=True, hiddenclass=SoftmaxLayer)

# Create a dataset that matches network input and output sizes:
norgate = SupervisedDataSet(2, 1)

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

# Add input and target values to dataset
# Values for NOR truth table
nortrain.addSample((0, 0), (1,))
nortrain.addSample((0, 1), (0,))
nortrain.addSample((1, 0), (0,))
nortrain.addSample((1, 1), (0,))

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, norgate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
trainer.train()
trainer.testOnData(dataset=nortrain, verbose = True)

Çıktı

Çıktı aşağıdaki gibidir -

C:\pybrain\pybrain\src>python example16.py
Testing on data:
('out: ', '[0.918 ]')
('correct:', '[1 ]')
error: 0.00333524
('out: ', '[0.082 ]')
('correct:', '[0 ]')
error: 0.00333484
('out: ', '[0.078 ]')
('correct:', '[0 ]')
error: 0.00303433
('out: ', '[-0.082]')
('correct:', '[0 ]')
error: 0.00340005
('All errors:', [0.0033352368788838365, 0.003334842961037291, 
   0.003034328685718761, 0.0034000458892589056])
('Average error:', 0.0032761136037246985)
('Max error:', 0.0034000458892589056, 'Median error:', 0.0033352368788838365)

Pybrain'de Katman Oluşturma

Pybrain'de kendi katmanınızı aşağıdaki gibi oluşturabilirsiniz -

Bir katman oluşturmak için kullanmanız gerekir NeuronLayer class tüm katman türlerini oluşturmak için temel sınıf olarak.

Misal

from pybrain.structure.modules.neuronlayer import NeuronLayer
class LinearLayer(NeuronLayer):
   def _forwardImplementation(self, inbuf, outbuf):
      outbuf[:] = inbuf
   def _backwardImplementation(self, outerr, inerr, outbuf, inbuf):
      inerr[:] = outer

Bir Katman oluşturmak için iki yöntem uygulamamız gerekir: _forwardImplementation () ve _backwardImplementation () .

The _forwardImplementation() takes in 2 arguments inbufve Scipy dizileri olan outbuf. Boyutu, katmanların girdi ve çıktı boyutlarına bağlıdır.

_BackwardImplementation () verilen giriş ile ilgili çıkışının türevinin hesaplanması için kullanılır.

Pybrain'de bir katman uygulamak için katman sınıfının iskeleti budur -

from pybrain.structure.modules.neuronlayer import NeuronLayer
class NewLayer(NeuronLayer):
   def _forwardImplementation(self, inbuf, outbuf):
      pass
   def _backwardImplementation(self, outerr, inerr, outbuf, inbuf):
      pass

Katman olarak ikinci dereceden bir polinom işlevi uygulamak istemeniz durumunda, bunu aşağıdaki gibi yapabiliriz -

Bir polinom fonksiyonumuz olduğunu düşünün -

f(x) = 3x2

Yukarıdaki polinom fonksiyonunun türevi aşağıdaki gibi olacaktır -

f(x) = 6 x

Yukarıdaki polinom işlevi için son katman sınıfı aşağıdaki gibi olacaktır -

testlayer.py

from pybrain.structure.modules.neuronlayer import NeuronLayer
class PolynomialLayer(NeuronLayer):
   def _forwardImplementation(self, inbuf, outbuf):
      outbuf[:] = 3*inbuf**2
   def _backwardImplementation(self, outerr, inerr, outbuf, inbuf):
      inerr[:] = 6*inbuf*outerr

Şimdi aşağıda gösterildiği gibi oluşturulan katmandan yararlanalım -

testlayer1.py

from testlayer import PolynomialLayer
from pybrain.tools.shortcuts import buildNetwork
from pybrain.tests.helpers import gradientCheck

n = buildNetwork(2, 3, 1, hiddenclass=PolynomialLayer)
n.randomize()

gradientCheck(n)

GradientCheck () katmanın iyi çalışıp çalışmadığını test edecek. Katmanın gradientCheck (n) için kullanıldığı ağı geçmemiz gerekiyor. Katman iyi çalışıyorsa çıktıyı "Perfect Gradient" olarak verecektir.

Çıktı

C:\pybrain\pybrain\src>python testlayer1.py
Perfect gradient

Bir bağlantı, bir katmana benzer şekilde çalışır; tek fark, verileri bir ağdaki bir düğümden diğerine kaydırmasıdır.

Bu bölümde, şunları öğreneceğiz -

  • Bağlantıları Anlamak
  • Bağlantılar Oluşturma

Bağlantıları Anlamak

İşte bir ağ oluştururken kullanılan bağlantıların çalışan bir örneği.

Misal

ffy.py

from pybrain.structure import FeedForwardNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
from pybrain.structure import FullConnection

network = FeedForwardNetwork()

#creating layer for input => 2 , hidden=> 3 and output=>1
inputLayer = LinearLayer(2)
hiddenLayer = SigmoidLayer(3)
outputLayer = LinearLayer(1)

#adding the layer to feedforward network
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)

#Create connection between input ,hidden and output
input_to_hidden = FullConnection(inputLayer, hiddenLayer)
hidden_to_output = FullConnection(hiddenLayer, outputLayer)

#add connection to the network
network.addConnection(input_to_hidden)
network.addConnection(hidden_to_output)
network.sortModules()

print(network)

Çıktı

C:\pybrain\pybrain\src>python ffn.py
FeedForwardNetwork-6
Modules:
[<LinearLayer 'LinearLayer-3'>, <SigmoidLayer 'SigmoidLayer-7'>, 
   <LinearLayer 'LinearLayer-8'>]
Connections:
[<FullConnection 'FullConnection-4': 'SigmoidLayer-7' -> 'LinearLayer-8'>, 
   <FullConnection 'FullConnection-5': 'LinearLayer-3' -> 'SigmoidLayer-7'>]

Bağlantılar Oluşturma

Pybrain'de aşağıda gösterildiği gibi bağlantı modülünü kullanarak bağlantılar oluşturabiliriz -

Misal

connect.py

from pybrain.structure.connections.connection import Connection
class YourConnection(Connection):
   def __init__(self, *args, **kwargs):
      Connection.__init__(self, *args, **kwargs)
   def _forwardImplementation(self, inbuf, outbuf):
      outbuf += inbuf
   def _backwardImplementation(self, outerr, inerr, inbuf):
      inerr += outer

Bir bağlantı oluşturmak için 2 yöntem vardır - _forwardImplementation () ve _backwardImplementation () .

_ForwardImplementation () , gelen modülünün çıkış tamponu ile çağrılır girdi_tamponu ve adı giden modülünün giriş tamponu çıktı_tamponu . Girdi_tamponu giden modülü eklenir çıktı_tamponu'nda .

_BackwardImplementation () olarak adlandırılır outerr , inerr ve girdi_tamponu . Giden modül hatası, _backwardImplementation () içindeki gelen modül hatasına eklenir .

Şimdi kullanalım YourConnection bir ağda.

testconnection.py

from pybrain.structure import FeedForwardNetwork
from pybrain.structure import LinearLayer, SigmoidLayer
from connect import YourConnection

network = FeedForwardNetwork()

#creating layer for input => 2 , hidden=> 3 and output=>1
inputLayer = LinearLayer(2)
hiddenLayer = SigmoidLayer(3)
outputLayer = LinearLayer(1)

#adding the layer to feedforward network
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)

#Create connection between input ,hidden and output
input_to_hidden = YourConnection(inputLayer, hiddenLayer)
hidden_to_output = YourConnection(hiddenLayer, outputLayer)

#add connection to the network
network.addConnection(input_to_hidden)
network.addConnection(hidden_to_output)
network.sortModules()

print(network)

Çıktı

C:\pybrain\pybrain\src>python testconnection.py
FeedForwardNetwork-6
Modules:
[<LinearLayer 'LinearLayer-3'>, <SigmoidLayer 'SigmoidLayer-7'>, 
   <LinearLayer 'LinearLayer-8'>]
Connections:
[<YourConnection 'YourConnection-4': 'LinearLayer-3' -> 'SigmoidLayer-7'>, 
   <YourConnection 'YourConnection-5': 'SigmoidLayer-7' -> 'LinearLayer-8'>]

Takviyeli Öğrenme (RL), Makine Öğreniminin önemli bir parçasıdır. Pekiştirmeli öğrenme, aracının çevreden gelen girdilere dayalı olarak davranışını öğrenmesini sağlar.

Takviye sırasında birbirleriyle etkileşime giren bileşenler aşağıdaki gibidir -

  • Environment
  • Agent
  • Task
  • Experiment

Takviyeli Öğrenmenin düzeni aşağıda verilmiştir -

RL'de, aracı yinelemeli olarak çevre ile konuşur. Temsilci, her yinelemede ödülün bulunduğu bir gözlem alır. Daha sonra eylemi seçer ve ortama gönderir. Her yinelemede ortam yeni bir duruma geçer ve her seferinde alınan ödül kaydedilir.

RL temsilcisinin amacı, olabildiğince çok ödül toplamaktır. Yineleme arasında, aracının performansı, iyi bir şekilde davranan temsilcinin performansı ile karşılaştırılır ve performans farkı, ödül veya başarısızlığa yol açar. RL temel olarak robot kontrolü, asansör, telekomünikasyon, oyunlar vb. Gibi problem çözme görevlerinde kullanılır.

Pybrain'de RL ile nasıl çalışılacağına bir göz atalım.

Labirent üzerinde çalışacağız environment1'in bir duvar ve 0'ın bir boş alan olduğu 2 boyutlu numpy dizisi kullanılarak temsil edilecektir. Temsilcinin sorumluluğu, serbest sahayı geçmek ve hedef noktasını bulmaktır.

İşte labirent ortamıyla çalışmanın adım adım akışı.

Aşama 1

İhtiyacımız olan paketleri aşağıdaki kodla içe aktarın -

from scipy import *
import sys, time
import matplotlib.pyplot as pylab # for visualization we are using mathplotlib

from pybrain.rl.environments.mazes import Maze, MDPMazeTask
from pybrain.rl.learners.valuebased import ActionValueTable
from pybrain.rl.agents import LearningAgent
from pybrain.rl.learners import Q, QLambda, SARSA #@UnusedImport
from pybrain.rl.explorers import BoltzmannExplorer #@UnusedImport
from pybrain.rl.experiments import Experiment
from pybrain.rl.environments import Task

Adım 2

Aşağıdaki kodu kullanarak labirent ortamını oluşturun -

# create the maze with walls as 1 and 0 is a free field
mazearray = array(
   [[1, 1, 1, 1, 1, 1, 1, 1, 1],
   [1, 0, 0, 1, 0, 0, 0, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 1, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 0, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 1, 1]]
)
env = Maze(mazearray, (7, 7)) # create the environment, the first parameter is the 
maze array and second one is the goal field tuple

Aşama 3

Bir sonraki adım, Aracı oluşturmaktır.

Ajan, RL'de önemli bir rol oynar. GetAction () ve integrateObservation () yöntemlerini kullanarak labirent ortamıyla etkileşime girecektir.

Temsilcinin bir denetleyicisi (durumları eylemlerle eşleştirecek) ve bir öğrencisi vardır.

PyBrain'deki kontrolör, girişin durum olduğu ve bunları eyleme dönüştürdüğü bir modül gibidir.

controller = ActionValueTable(81, 4)
controller.initialize(1.)

ActionValueTable2 girdiye ihtiyaç duyar, yani durum ve eylem sayısı. Standart labirent ortamında 4 eylem vardır: kuzey, güney, doğu, batı.

Şimdi bir öğrenci yaratacağız. Aracı ile birlikte kullanılacak öğrenci için SARSA () öğrenme algoritmasını kullanacağız.

learner = SARSA()
agent = LearningAgent(controller, learner)

4. adım

Bu adım, Ortama Ajan eklemektir.

Aracıyı ortama bağlamak için görev adı verilen özel bir bileşene ihtiyacımız var. Bir rolütask çevredeki hedefi ve temsilcinin eylemler için nasıl ödül kazandığını aramaktır.

Çevrenin kendi görevi vardır. Kullandığımız Labirent ortamında MDPMazeTask görevi bulunmaktadır. MDP kısaltması“markov decision process”yani, ajan labirentteki konumunu bilir. Çevre, görevin bir parametresi olacaktır.

task = MDPMazeTask(env)

Adım 5

Ortama aracı ekledikten sonraki adım, bir Deney oluşturmaktır.

Şimdi, görevi ve aracıyı birbiriyle koordine edebilmemiz için deneyi oluşturmamız gerekiyor.

experiment = Experiment(task, agent)

Şimdi, deneyi aşağıda gösterildiği gibi 1000 kez çalıştıracağız -

for i in range(1000):
   experiment.doInteractions(100)
   agent.learn()
   agent.reset()

Aşağıdaki kod yürütüldüğünde ortam, aracı ve görev arasında 100 kez çalışacaktır -

experiment.doInteractions(100)

Her yinelemeden sonra, temsilciye hangi bilgilerin ve ödülün aktarılması gerektiğine karar veren göreve yeni bir durum verir. For döngüsü içindeki aracıyı öğrenip sıfırladıktan sonra yeni bir tablo çizeceğiz.

for i in range(1000):
   experiment.doInteractions(100)
   agent.learn()
   agent.reset()
   pylab.pcolor(table.params.reshape(81,4).max(1).reshape(9,9))
   pylab.savefig("test.png")

İşte tam kod -

Misal

maze.py

from scipy import *
import sys, time
import matplotlib.pyplot as pylab

from pybrain.rl.environments.mazes import Maze, MDPMazeTask
from pybrain.rl.learners.valuebased import ActionValueTable
from pybrain.rl.agents import LearningAgent
from pybrain.rl.learners import Q, QLambda, SARSA #@UnusedImport
from pybrain.rl.explorers import BoltzmannExplorer #@UnusedImport
from pybrain.rl.experiments import Experiment
from pybrain.rl.environments import Task

# create maze array
mazearray = array(
   [[1, 1, 1, 1, 1, 1, 1, 1, 1],
   [1, 0, 0, 1, 0, 0, 0, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 0, 1, 0, 1],
   [1, 0, 0, 1, 0, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 1, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 0, 1],
   [1, 0, 0, 0, 0, 0, 0, 0, 1],
   [1, 1, 1, 1, 1, 1, 1, 1, 1]]
)
env = Maze(mazearray, (7, 7))

# create task
task = MDPMazeTask(env)

#controller in PyBrain is like a module, for which the input is states and 
convert them into actions.
controller = ActionValueTable(81, 4)
controller.initialize(1.)

# create agent with controller and learner - using SARSA()
learner = SARSA()

# create agent
agent = LearningAgent(controller, learner)

# create experiment
experiment = Experiment(task, agent)

# prepare plotting
pylab.gray()
pylab.ion()

for i in range(1000):
experiment.doInteractions(100)

agent.learn()
agent.reset()

pylab.pcolor(controller.params.reshape(81,4).max(1).reshape(9,9))
pylab.savefig("test.png")

Çıktı

python maze.py

Boş alandaki renk her yinelemede değiştirilecektir.

Artık bir ağın nasıl kurulacağını ve eğitileceğini biliyoruz. Bu bölümde, ağı nasıl oluşturup kaydedeceğimizi ve gerektiğinde ağı nasıl kullanacağımızı anlayacağız.

Ağı Kaydet ve Kurtar

Pybrain aracından NetworkWriter ve NetworkReader'ı, yani pybrain.tools.customxml'i kullanacağız.

İşte aynısının çalışan bir örneği -

from pybrain.tools.shortcuts import buildNetwork
from pybrain.tools.customxml import NetworkWriter
from pybrain.tools.customxml import NetworkReader

net = buildNetwork(2,1,1)
NetworkWriter.writeToFile(net, 'network.xml')
net = NetworkReader.readFrom('network.xml')

Ağ, network.xml içine kaydedilir.

NetworkWriter.writeToFile(net, 'network.xml')

XML'yi gerektiğinde okumak için aşağıdaki kodu kullanabiliriz -

net = NetworkReader.readFrom('network.xml')

İşte oluşturulan network.xml dosyası -

<?xml version="1.0" ?>
<PyBrain>
   <Network class="pybrain.structure.networks.feedforward.FeedForwardNetwork" name="FeedForwardNetwork-8">
      <name val="'FeedForwardNetwork-8'"/>
      <Modules>
         <LinearLayer class="pybrain.structure.modules.linearlayer.LinearLayer" inmodule="True" name="in">
            <name val="'in'"/>
            <dim val="2"/>
         </LinearLayer>
         
         <LinearLayer class="pybrain.structure.modules.linearlayer.LinearLayer" name="out" outmodule="True">
            <name val="'out'"/>
            <dim val="1"/>
         </LinearLayer>
         
         <BiasUnit class="pybrain.structure.modules.biasunit.BiasUnit" name="bias">
            <name val="'bias'"/>
         </BiasUnit>
         
         <SigmoidLayer class="pybrain.structure.modules.sigmoidlayer.SigmoidLayer" name="hidden0">
            <name val="'hidden0'"/>
            <dim val="1"/>
         </SigmoidLayer>
      </Modules>
      
      <Connections>
         <FullConnection class="pybrain.structure.connections.full.FullConnection" name="FullConnection-6">
            <inmod val="bias"/>
            <outmod val="out"/>
            <Parameters>[1.2441093186965146]</Parameters>
         </FullConnection>
         
         <FullConnection class="pybrain.structure.connections.full.FullConnection" name="FullConnection-7">
            <inmod val="bias"/>
            <outmod val="hidden0"/>
            <Parameters>[-1.5743530012126412]</Parameters>
         </FullConnection>
         
         <FullConnection class="pybrain.structure.connections.full.FullConnection" name="FullConnection-4">
            <inmod val="in"/>
            <outmod val="hidden0"/>
            <Parameters>[-0.9429546042034236, -0.09858196752687162]</Parameters>
         </FullConnection>
         
         <FullConnection class="pybrain.structure.connections.full.FullConnection" name="FullConnection-5">
            <inmod val="hidden0"/>
            <outmod val="out"/>
            <Parameters>[-0.29205472354634304]</Parameters>
         </FullConnection>
      </Connections>
      
   </Network>
</PyBrain>

API

Aşağıda, bu eğitim boyunca kullandığımız API'lerin bir listesi bulunmaktadır.

Ağlar için

  • activate(input)- Parametreyi, yani test edilecek değeri alır. Verilen girdiye göre sonucu geri döndürecektir.

  • activateOnDataset(dataset) - Verilen veri kümesi üzerinde yineleme yapacak ve çıktıyı döndürecektir.

  • addConnection(c) - Ağa bağlantı ekler.

  • addInputModule(m) - Ağa verilen modülü ekler ve giriş modülü olarak işaretler.

  • addModule(m) - Verilen modülü ağa ekler.

  • addOutputModule(m) - Modülü ağa ekler ve bir çıkış modülü olarak işaretler.

  • reset() - Modülleri ve ağı sıfırlar.

  • sortModules()- Dahili olarak sıralayarak ağı aktivasyona hazırlar. Aktivasyondan önce çağrılması gerekir.

Denetlenen Veri Kümeleri için

  • addSample(inp, target) - Yeni bir girdi ve hedef örneği ekler.

  • splitWithProportion(proportion=0.5) - Veri kümesini iki bölüme ayırır, ilk bölüm orantı bölümü verilerini içerir ve sonraki küme kalan bölümü içerir.

Eğitmenler için

trainUntilConvergence(dataset=None, maxEpochs=None, verbose=None, continueEpochs=10, validationProportion=0.25)- Modülü yakınlaşana kadar veri setinde eğitmek için kullanılır. Veri kümesi verilmemişse, başlangıçta kullanılan eğitimli veri kümesini eğitmeye çalışacaktır.

Bu bölümde, PyBrain kullanılarak yürütülen tüm olası örnekler listelenmiştir.

örnek 1

NOR Truth Table ile çalışmak ve doğruluğu test etmek.

from pybrain.tools.shortcuts import buildNetwork
from pybrain.structure import TanhLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer

# Create a network with two inputs, three hidden, and one output
nn = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)

# Create a dataset that matches network input and output sizes:
norgate = SupervisedDataSet(2, 1)

# Create a dataset to be used for testing.
nortrain = SupervisedDataSet(2, 1)

# Add input and target values to dataset
# Values for NOR truth table
norgate.addSample((0, 0), (1,))
norgate.addSample((0, 1), (0,))
norgate.addSample((1, 0), (0,))
norgate.addSample((1, 1), (0,))

# Add input and target values to dataset
# Values for NOR truth table
nortrain.addSample((0, 0), (1,))
nortrain.addSample((0, 1), (0,))
nortrain.addSample((1, 0), (0,))
nortrain.addSample((1, 1), (0,))

#Training the network with dataset norgate.
trainer = BackpropTrainer(nn, norgate)

# will run the loop 1000 times to train it.
for epoch in range(1000):
   trainer.train()
trainer.testOnData(dataset=nortrain, verbose = True)

Çıktı

C:\pybrain\pybrain\src>python testnetwork.py
Testing on data:
('out: ', '[0.887 ]')
('correct:', '[1 ]')
error: 0.00637334
('out: ', '[0.149 ]')
('correct:', '[0 ]')
error: 0.01110338
('out: ', '[0.102 ]')
('correct:', '[0 ]')
error: 0.00522736
('out: ', '[-0.163]')
('correct:', '[0 ]')
error: 0.01328650
('All errors:', [0.006373344564625953, 0.01110338071737218, 
   0.005227359234093431, 0.01328649974219942])
('Average error:', 0.008997646064572746)
('Max error:', 0.01328649974219942, 'Median error:', 0.01110338071737218)

Örnek 2

Veri kümeleri için, sklearn veri kümelerinden veri kümelerini aşağıda gösterildiği gibi kullanacağız: sklearn'dan load_digits veri kümelerine bakın: scikit-learn.org

0-9 arasında tahmin edilecek rakamlar gibi 10 sınıfı vardır.

X'teki toplam giriş verisi 64'tür.

from sklearn import datasets
import matplotlib.pyplot as plt

from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from numpy import ravel

digits = datasets.load_digits()
X, y = digits.data, digits.target
ds = ClassificationDataSet(64, 1, nb_classes=10) ) 

# we are having inputs are 64 dim array and since the digits are from 0-9 
the classes considered is 10.

for i in range(len(X)):
ds.addSample(ravel(X[i]), y[i]) # adding sample to datasets
test_data_temp, training_data_temp = ds.splitWithProportion(0.25) 

#Splitting the datasets 25% as testdata and 75% as trained data
# Using splitWithProportion() method on dataset converts the dataset to 
#superviseddataset, so we will convert the dataset back to classificationdataset 
#as shown in above step.
test_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, test_data_temp.getLength()):
test_data.addSample( test_data_temp.getSample(n)[0], test_data_temp.getSample(n)[1] )
training_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, training_data_temp.getLength()):
training_data.addSample( 
   training_data_temp.getSample(n)[0], training_data_temp.getSample(n)[1] 
)
test_data._convertToOneOfMany()
training_data._convertToOneOfMany()
net = buildNetwork(
   training_data.indim, 64, training_data.outdim, outclass=SoftmaxLayer
)
#creating a network wherein the input and output are used from the training data.
trainer = BackpropTrainer(
   net, dataset=training_data, momentum=0.1,learningrate=0.01,verbose=True,weightdecay=0.01
)
#Training the Network
trnerr,valerr = trainer.trainUntilConvergence(dataset=training_data,maxEpochs=10)

#Visualizing the error and validation data
plt.plot(trnerr,'b',valerr,'r')
plt.show()
trainer.trainEpochs(10)
print('Percent Error on testData:',percentError(
   trainer.testOnClassData(dataset=test_data), test_data['class']
))

Çıktı

Total error: 0.0432857814358
Total error: 0.0222276374185
Total error: 0.0149012052174
Total error: 0.011876985318
Total error: 0.00939854792853
Total error: 0.00782202445183
Total error: 0.00714707652044
Total error: 0.00606068893793
Total error: 0.00544257958975
Total error: 0.00463929281336
Total error: 0.00441275665294
('train-errors:', '[0.043286 , 0.022228 , 0.014901 , 0.011877 , 0.009399 , 0.007
   822 , 0.007147 , 0.006061 , 0.005443 , 0.004639 , 0.004413 ]')
('valid-errors:', '[0.074296 , 0.027332 , 0.016461 , 0.014298 , 0.012129 , 0.009
   248 , 0.008922 , 0.007917 , 0.006547 , 0.005883 , 0.006572 , 0.005811 ]')
Percent Error on testData: 3.34075723830735