http://scitechdaily.com/ibm-supercomputer-simulates-530-billion-neurons-100-trillion-synapses/
IBM'in yapmış olduğu çalışmanın haberini okuduktan sonra yapay zeka meselesi hakkında küçük bir yazı yazmaya karar verdim. Tabiki haberdeki çalışmaya nazaran bizim yapacağımız örnek çok iptidai kalmaktadır. Lakin buradaki maksadım bir şekilde meseleye giriş yapmak bilahare daha gelişmiş örneklerle konuyu izah etmek şeklinde olacaktır.
Yapay zeka çok geniş bir kavram ve bir çok alt dalları bulunmaktadır (bkz: http://en.wikipedia.org/wiki/List_of_basic_artificial_intelligence_topics). Ben burada giriş mahiyetinde Yapay Sinir Ağları (bkz: http://en.wikipedia.org/wiki/Artificial_neural_network) hususunda ileri besleme (Feed forward bkz: http://en.wikipedia.org/wiki/Feedforward_neural_network) ve geri yayılım (bkz: http://en.wikipedia.org/wiki/Back-propagation) algoritmalarını kullanarak artık klasikleşmiş ve tabiri caizse bıktırmış olan XOR örneğini gerçekleyeceğim.
Yukarıda verdiğim bağlantılara göz atarsanız algoritmanın nasıl çalıştığını kolayca anlayabilirsiniz. Bu noktada fazla bir teferruat icap etmiyor zira yapacağımız örnekteki XOR problemi 2 neron hidden layer için 1 neron da output layer için kafidir. Mühim bir not; biz bu örnekte BIAS değerini tüm neronlara ayrı ayrı vermek yerine bir kukla neron (dummy neuron, ağırlıkları ve çıktısı değişmeyen) kullanacağız.
Biraz gerçekleme (implementation) detaylarına göz atalım.
Uygulamayı Java ile yapacağız. Aslınca C gibi bir dil ile çok daha basit ve hızlı bir şekilde gerçeklenebilirdi lakin müstakbel uygulamalarımızda yapacağımız muameleler daha karmaşık olacağından bu yapı ileride bize fayda sağlayacaktır, şu anda aksi gibi görünse dahi.
Temel olarak Object-Oriented yapı:
Neuron (Class)
NN (Class)
IActivation (Interface)
SigmoidActivation (Class) -> IActivation
DummyActivation (Class) -> IActivation
Başlamdan önce belirlenmesi gereken ilk husus neronların ilk ağırlık değerleridir, burada önceden çalıştığı bilinen bir küme de seçilebilir ya da sözde rastgele değerlerde seçilebilir, neticede kötü seçilen değerler sadece sonuca ulaşma süremizi uzatacaktır. Biz rastgele değerler üreteceğiz bu yüzden programı her çalıştırdığınızda farklı bekleme süreleri ile karşılacaksınız. Ayrıca eğitim sürecinde iterasyon sayısını bir hudut koyuyoruz çünkü bazı durumlarda gelen değerler deltaW değeri sıfıra çok yaklaştığı için istenilen değere (desired value) bir türlü yaklaşılamıyor ve çok bekleme yaşanıyor. Bu sebeple azami tekerrür 3.000.000 olarak seçiyoruz, beklenen hata nispetini ise 0.005 olarak seçtim. Bu değerler tamamen keyfi olup siz de istediğiniz gibi değiştirebilirisiniz.
Kaynak kodda herhangi bir dış kütüphane kullanmadım, doğrudan derleyip çalıştırabilisiniz.
Şimdi kaynak kodumuza bir göz atalım:
// Main.java
package ann.xor;
/**
*
* @author ramazan
*/
public class Main {
public static String quantizeResult(float result) {
return Integer.toString(Math.round(result)) + " (" + Float.toString(result) + ")";
}
public static void main(String[] args) {
NN nn = new NN(5E-3f, 1.0f, 0.1f);
SigmoidActivation sa = new SigmoidActivation();
DummyActivation da = new DummyActivation();
float BIAS = -1f;
Neuron input1 = new Neuron(da, 0);
Neuron input2 = new Neuron(da, 0);
Neuron input3 = new Neuron(da, 0); // BIAS.
Neuron hidden1 = new Neuron(sa, 3);
Neuron hidden2 = new Neuron(sa, 3);
Neuron hidden3 = new Neuron(da, 3); // Dummy neuron.
Neuron output1 = new Neuron(sa, 3);
nn.addInputNeuron(input1);
nn.addInputNeuron(input2);
nn.addInputNeuron(input3);
nn.addHiddenNeuron(hidden1);
nn.addHiddenNeuron(hidden2);
nn.addHiddenNeuron(hidden3);
nn.addOutNeuron(output1);
hidden3.setDummy(true);
input3.setOutput(BIAS);
System.out.println("All inputs & weights has been set.");
System.out.println("Training has been started.");
int iteration = 0;
do {
iteration++;
input1.setOutput(0);
input2.setOutput(0);
output1.desired = 0;
nn.train();
input1.setOutput(0);
input2.setOutput(1);
output1.desired = 1;
nn.train();
input1.setOutput(1);
input2.setOutput(0);
output1.desired = 1;
nn.train();
input1.setOutput(1);
input2.setOutput(1);
output1.desired = 0;
nn.train();
if (iteration % 50000 == 0) {
System.out.println("-------------------------------");
System.out.println("Current iteration:" + iteration);
System.out.println("Current error:" + nn.getE());
System.out.println("-------------------------------");
}
} while(!nn.learnt() && iteration < 3000000);
System.out.println("Training has been completed.");
System.out.println("Total iteration: " + iteration + ", accepted error: " + nn.getE());
System.out.println("Test cases are in progress...");
input1.setOutput(1);
input2.setOutput(0);
nn.test();
System.out.println("1 XOR 0 = " + quantizeResult(nn.getOutput(0).getOutput()));
input1.setOutput(1);
input2.setOutput(1);
nn.test();
System.out.println("1 XOR 1 = " + quantizeResult(nn.getOutput(0).getOutput()));
input1.setOutput(0);
input2.setOutput(1);
nn.test();
System.out.println("0 XOR 1 = " + quantizeResult(nn.getOutput(0).getOutput()));
input1.setOutput(0);
input2.setOutput(0);
nn.test();
System.out.println("0 XOR 0 = " + quantizeResult(nn.getOutput(0).getOutput()));
}
}
// NN.java
package ann.xor;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author ramazan
*/
public class NN {
private List<neuron> inputLayer;
private List<neuron> hiddenLayer;
private List<neuron> outputLayer;
private float E;
private float e;
private float lambda;
private float nu;
public NN(float E, float lambda, float nu) {
inputLayer = new ArrayList<>();
hiddenLayer = new ArrayList<>();
outputLayer = new ArrayList<>();
this.E = E;
e = 0;
this.lambda = lambda;
this.nu = nu;
}
public void addInputNeuron(Neuron neuron) {
inputLayer.add(neuron);
}
public void addHiddenNeuron(Neuron neuron) {
hiddenLayer.add(neuron);
}
public void addOutNeuron(Neuron neuron) {
outputLayer.add(neuron);
}
public Neuron getOutput(int index) {
return outputLayer.get(index);
}
public void train() {
feedForward();
calculateError();
backPropagation();
//System.out.println("Error value: " + e);
}
public void test() {
feedForward();
}
protected void feedForward() {
for (Neuron nH : hiddenLayer) {
float inputs = 0;
for (Neuron nI : inputLayer) {
int i = inputLayer.indexOf(nI);
inputs += nI.getOutput() * nH.getWeight(i);
}
nH.setInput(inputs);
nH.activate(lambda);
}
for (Neuron nO : outputLayer) {
float inputs = 0;
for (Neuron nH : hiddenLayer) {
int i = hiddenLayer.indexOf(nH);
inputs += nH.getOutput() * nO.getWeight(i);
}
nO.setInput(inputs);
nO.activate(lambda);
}
}
protected void calculateError() {
e = 0;
for (Neuron nO : outputLayer) {
nO.error = nO.desired - nO.getOutput();
e += (float) Math.pow(nO.error, 2);
}
e = (float)Math.sqrt(e);
}
protected void backPropagation() {
for (Neuron nO : outputLayer) {
nO.calculateDelta(lambda, nO.error);
for (Neuron nH : hiddenLayer) {
int i = hiddenLayer.indexOf(nH);
nH.calculateDelta(lambda, nO.getDelta() * nO.getWeight(i));
float diff = nu * nO.getDelta() * nH.getOutput();
nO.setWeight(i, nO.getWeight(i) + diff);
}
}
for (Neuron nH : hiddenLayer) {
for (Neuron nI : inputLayer) {
int i = inputLayer.indexOf(nI);
float diff = nu * nH.getDelta() * nI.getOutput();
nH.setWeight(i, nH.getWeight(i) + diff);
}
}
}
public float getE() {
return e;
}
public boolean learnt() {
return (e < E);
}
}
// Neuron.java
package ann.xor;
import java.util.Random;
/**
*
* @author ramazan
*/
public class Neuron {
private float[] weights;
private float input;
private float output;
private IActivation activation;
private float delta;
public float desired;
public float error;
private boolean dummy;
private static final Random random = new Random();
public Neuron(IActivation activation, int weights) {
this.weights = new float[weights];
this.activation = activation;
delta = 0;
dummy = false;
error = desired = 0;
for (int i = 0; i < weights; i++) {
this.weights[i] = getRandomWeight();
}
}
protected final float getRandomWeight() {
final float r = random.nextFloat();
final float range = 2.4f / weights.length;
return (r * 2 * range) - range;
}
public float getWeight(int index) {
return weights[index];
}
public void setWeight(int index, float weight) {
if (!dummy) {
weights[index] = weight;
}
}
public float getInput() {
return input;
}
public void setInput(float input) {
this.input = input;
}
public float getOutput() {
return output;
}
public void setOutput(float output) {
this.output = output;
}
public float getDelta() {
return delta;
}
public boolean isDummy() {
return dummy;
}
public void setDummy(boolean dummy) {
this.dummy = dummy;
}
public void activate(float lambda) {
float value = input;
if (!dummy) {
value *= -lambda;
}
output = activation.activate(value);
}
public void calculateDelta(float lambda, float error) {
if (!dummy) {
delta = error * lambda * activation.derivative(output);
}
}
}
// IActivation.java
package ann.xor;
/**
*
* @author ramazan
*/
public interface IActivation {
public float activate(float input);
public float derivative(float input);
}
// SigmoidActivation.java
package ann.xor;
/**
*
* @author ramazan
*/
public class SigmoidActivation implements IActivation {
@Override
public float activate(float input) {
return (float) (1. / (1. + Math.exp(input)));
}
@Override
public float derivative(float input) {
return input * (1 - input);
}
}
// DummyActivation.java
package ann.xor;
/**
*
* @author ramazan
*/
public class DummyActivation implements IActivation {
@Override
public float activate(float input) {
return input;
}
@Override
public float derivative(float input) {
return input;
}
}
Şimdi örnek bir çıktı üretelim:
run:
All inputs & weights has been set.
Training has been started.
-------------------------------
Current iteration:50000
Current error:0.02354227
-------------------------------
-------------------------------
Current iteration:100000
Current error:0.014160486
-------------------------------
-------------------------------
Current iteration:150000
Current error:0.011045283
-------------------------------
-------------------------------
Current iteration:200000
Current error:0.009226563
-------------------------------
-------------------------------
Current iteration:250000
Current error:0.008103463
-------------------------------
-------------------------------
Current iteration:300000
Current error:0.0073397583
-------------------------------
-------------------------------
Current iteration:350000
Current error:0.006666307
-------------------------------
-------------------------------
Current iteration:400000
Current error:0.00628476
-------------------------------
-------------------------------
Current iteration:450000
Current error:0.0058559924
-------------------------------
-------------------------------
Current iteration:500000
Current error:0.0055325483
-------------------------------
-------------------------------
Current iteration:550000
Current error:0.0051981094
-------------------------------
Training has been completed.
Total iteration: 586265, accepted error: 0.004999997
Test cases are in progress...
1 XOR 0 = 1 (0.9973595)
1 XOR 1 = 0 (0.004999945)
0 XOR 1 = 1 (0.9919734)
0 XOR 0 = 0 (0.0039330246)
BUILD SUCCESSFUL (total time: 4 seconds)
Bu basit örnek ile konuyu teorik olarak okuduktan sonra pratik olarak uygulamasını görerek daha iyi anlaşılacağı kanaatindeyim. Bir sonraki yazıda, yine klasikleşmiş olan tanıma (recognition) uygulamalarından bir örnek yapabilirim veyahut farklı bir anlada mesela Multi-agent systems simulation bir çalışma olabilir. Henüz karar vermedim. :)
Umarım faydalı olmuştur, böylelikle uzunca bir aradan sonra yazı yazabilmenin huzuruyla sizlere veda ediyorum, Allah'a emanet olunuz...
