taralino

Neuronales Netz

Um einer Künstlichen Intelligenz das Spielen beizubringen, verwenden wir ein neuronales Netz bestehend aus fünf Eingangsneuronen, einer verborgenen Schicht mit acht Neuronen sowie zwei Ausgangsneuronen:

Dieses neuronale Netz wird in jedem Simulationsschritt ausgewertet (60 Mal pro Sekunde), wobei wir gleich besprechen, welche Informationen die Eingangsneuronen bereitstellen. Die Ausgangsschicht hingegen ist einfacher zu verstehen:

Das Ausgangsneuron mit dem größeren Wert entscheidet, ob der Vogel im aktuellen Simulationsschritt flattern soll oder nicht.

Entscheidend dabei sind aber natürlich die Werte der fünf Eingangsneuronen. Diese enthalten Informationen über den horizontalen und vertikalen Abstand zum Mittelpunkt M des nächsten Hindernisses sowie über die Geschwindigkeit des Vogels in y-Richtung:

Die Werte zum vertikalen Abstand sowie zur Geschwindigkeit können positiv und negativ sein. Um das Vorzeichen zu beschreiben, wählen wir daher jeweils zwei Eingangsneuronen und verwenden zusammenfassend folgende Definition der fünf Eingangsneuronen:

1	Horizontaler Abstand zwischen Vogel und Punkt M (Länge der Strecke A)
2	Vertikaler Abstand zwischen Vogel und Punkt M (Länge der Strecke B, falls Vogel unterhalb von M)
3	Vertikaler Abstand zwischen Vogel und Punkt M (Länge der Strecke B, falls Vogel oberhalb von M)
4	Betrag der Geschwindigkeit in y-Richtung (falls Geschwindigkeit negativ)
5	Betrag der Geschwindigkeit in y-Richtung (falls Geschwindigkeit positiv)

Entsprechend ist immer eines der beiden Eingangsneuronen 2 und 3 sowie eines der beiden Eingangsneuronen 4 und 5 gleich 0.

Es ist zu beachten, dass alle fünf Eingangsneuronen auf einen Wert zwischen 0 und 1 zu skalieren sind.

Die einzelnen Eingangsneuronen werden bei derartigen Anwendungen auch als Sensoren bezeichnet, da sie Informationen über die Umgebung liefern.

Anwendung

Veranschaulichung der Sensoren (bei 20 Simulationsschritten pro Sekunde). Der Wertebereich der Sensoren ist bereits auf 0 bis 1 skaliert.

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <script src="taralino.js"></script>
</head>
<body>
<script>

/***********************
  NeuralNetwork
***********************/

var sensor = [];

var layout = [5,8,2];

var T = {
layout:[5,8,2],
weights:[[[0.68,6.54,4.20,-0.19,-1.40],[2.69,-4.76,-2.58,8.56,-8.97],[-1.54,3.45,-4.02,-2.96,-0.52],[-12.39,-8.28,9.91,1.92,-4.47],[9.34,-11.11,11.35,-3.14,-10.25],[-5.63,-2.80,-4.67,-18.47,-5.80],[-4.30,-8.35,1.18,-7.14,1.06],[-7.69,-0.72,10.65,-5.15,7.68]],[[1.58,-2.62,7.98,-0.08,-6.40,1.76,-2.20,-4.22],[0.32,-1.38,-1.82,-0.69,3.77,3.41,3.08,1.15]]],
biases:[[3.50,2.32,-2.87,-2.61,-0.42,-0.58,0.99,-0.18],[-0.11,-1.85]]
};

NeuralNetwork.set_data(T);

function update_sensor() {
  sensor = [];
  var h = 1e6;
  var i = -1;
  for (var k = 0; k < an; k++) if ((H[k][0] > x) && (H[k][0]-x < h)) {
    h = H[k][0]-x;
    i = k;
  }
  sensor.push(h/ax);
  var t = y-(H[i][1]+H[i][2])/2;
  sensor.push(t < 0 ? -t/60 : 0);
  sensor.push(t > 0 ? t/60 : 0);
  sensor.push(v < 0 ? Math.min(1,-v/2) : 0);
  sensor.push(v > 0 ? Math.min(1,v/2) : 0);
};



/***********************
  Flappy Game
***********************/

// Spieler
var x = 20; // x-Position
var y = 20; // y-Position
var r = 3; // Radius
var v = 0; // Geschwindigkeit in y-Richtung

// Hindernisse
var ar = 4; // Radius (halbe Breite) der Hindernisse
var ax = 40; // Abstand zwischen Hindernissen in x-Richtung
var ay = 30; // Vertikale Luecke in Hindernissen
var an = 6; // Anzahl der Hindernisse
var H = []; // Datenfeld der Hindernisse

// Zaehler
var c = 0;
var cmax = 0;


function spiel_setup() {
  y = 20;
  v = 0;
  ay = 30;
  c = 0;
  H = [];
  for (var k = 0; k < an; k++) {
    var h = random(15,45);
    H.push([60+k*ax, h-ay/2, h+ay/2]);
  }
};

function setup() {
  spiel_setup();
  Canvas.init([0,100], [-10,60], {width:600, background:"lightgrey"});
  Animation.init({fps:20});
  Button.add("a","Pause");
  Button.add("b","Weiter");
};

function on_click(id) {
  if (id == "a") Animation.stop();
  if (id == "b") Animation.start();
};

function spiel_physik() {
  // Spieler
  v = v - 0.08;
  y = y + v;
  if (y < 0) v = 1.4;
  if (y > 60) y = 60;
  // Hindernisse
  for (var k = 0; k < an; k++) {
    H[k][0] = H[k][0] - 0.5;
    if (H[k][0] < -10) {
      ay = ay*0.99;
      var h = random(15,45);
      H[k] = [H[k][0] + an*ax, h-ay/2, h+ay/2];
    }
  }
};

function sensor_zeichnen() {
  update_sensor();
  Canvas.line(x, y, x+sensor[0]*ax, y);
  Canvas.circle(x+sensor[0]*ax, y, 1.6);
  Canvas.text(x+sensor[0]*ax, y-0.2, "1", {fill:"white"});
  if (sensor[1] > 0) {
    Canvas.line(x, y, x, y+sensor[1]*60);
    Canvas.circle(x, y+sensor[1]*60, 1.6);
    Canvas.text(x, y+sensor[1]*60-0.2, "2", {fill:"white"});
  }
  if (sensor[2] > 0) {
    Canvas.line(x, y, x, y-sensor[2]*60);
    Canvas.circle(x, y-sensor[2]*60, 1.6);
    Canvas.text(x, y-sensor[2]*60-0.2, "3", {fill:"white"});
  }
  if (sensor[3] > 0) {
    Canvas.line(x-5, y, x-5, y-sensor[3]*12);
    Canvas.circle(x-5, y-sensor[3]*12, 1.6);
    Canvas.text(x-5, y-sensor[3]*12-0.2, "4", {fill:"white"});
  }
  if (sensor[4] > 0) {
    Canvas.line(x-5, y, x-5, y+sensor[4]*12);
    Canvas.circle(x-5, y+sensor[4]*12, 1.6);
    Canvas.text(x-5, y+sensor[4]*12-0.2, "5", {fill:"white"});
  }
  Canvas.text( 6, 57, sensor[0].toFixed(2), {align:"left"});
  Canvas.text( 6, 53, sensor[1].toFixed(2), {align:"left"});
  Canvas.text( 6, 49, sensor[2].toFixed(2), {align:"left"});
  Canvas.text( 6, 45, sensor[3].toFixed(2), {align:"left"});
  Canvas.text( 6, 41, sensor[4].toFixed(2), {align:"left"});
  Canvas.circle(3, 57, 1.6);
  Canvas.circle(3, 53, 1.6);
  Canvas.circle(3, 49, 1.6);
  Canvas.circle(3, 45, 1.6);
  Canvas.circle(3, 41, 1.6);
  Canvas.text(3, 57-0.2, "1", {fill:"white"});
  Canvas.text(3, 53-0.2, "2", {fill:"white"});
  Canvas.text(3, 49-0.2, "3", {fill:"white"});
  Canvas.text(3, 45-0.2, "4", {fill:"white"});
  Canvas.text(3, 41-0.2, "5", {fill:"white"});
};

function spiel_zeichnen() {
  Canvas.clear();
  // Spieler
  Canvas.circle(x, y, r, {fill:"yellow"});
  // Hindernisse
  for (var k = 0; k < an; k++) {
    Canvas.circle(H[k][0], H[k][1], ar, {fill:"green"});
    Canvas.rect(H[k][0], H[k][1]-50, 2*ar, 100, {fill:"green"});
    Canvas.circle(H[k][0], H[k][2], ar, {fill:"green"});
    Canvas.rect(H[k][0], H[k][2]+50, 2*ar, 100, {fill:"green"});
    Canvas.dot(H[k][0], (H[k][1]+H[k][2])/2);
  }
  // Sensor
  sensor_zeichnen();
  // Zaehler
  c = c + 1;
  if (c > cmax) cmax = c;
};

function abstand_punkt_linie(x, y, z, y1, y2) {
  // Annahme: y1 <= y2
  if (y <= y1) return Math.sqrt((x-z)*(x-z) + (y-y1)*(y-y1));
  if (y >= y2) return Math.sqrt((x-z)*(x-z) + (y-y2)*(y-y2));
  return Math.abs(x-z);
};

function spiel_kollision() {
  for (var k = 0; k < an; k++) {
    var b1 = abstand_punkt_linie(x, y, H[k][0], H[k][1]-100, H[k][1]);
    var b2 = abstand_punkt_linie(x, y, H[k][0], H[k][2], H[k][2]+100);
    if ((b1 < r+ar) || (b2 < r+ar)) spiel_setup();
  }
};

function loop() {
  simulate_mouse();
  spiel_physik();
  spiel_zeichnen();
  spiel_kollision();
};

function simulate_mouse() {
  update_sensor();
  var k = NeuralNetwork.evaluate(sensor, {output:"index"});
  if (k == 0) v = 1.4;
};


</script>
</body>
</html>

Vorschau Download Kopie speichern