taralino

Exkurs Quellcode

Ohne im Detail darauf einzugehen und nur für Interessierte:

Nachfolgenden findest du einen Quellcode, der verwendet werden kann, um ein neuronales Netz zu trainieren (wie im Abschnitt zuvor beschrieben).

Du kannst dort das Layout des Netzes anpassen oder aber die Parameter des genetischen Algorithmus verändern. Weitere Details dazu findest du auch hier:

Zur Referenz

Aber beachte: Je nach Wahl der Parameter kann die Trainingsphase durchaus einige Zeit in Anspruch nehmen.

Quellcode

Trainingsphase unter Verwendung eines genetischen Algorithmus.

<!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 layout = [5,8,2];

var sensor = [];


function layout_size() {
  var q = 0;
  for (var k = 1; k < layout.length; k++) q = q + (layout[k-1]+1) * layout[k];
  return q;
};

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 gameover = 0;


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

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 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)) gameover = 1;
  }
};

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

function flappy_run() {
  spiel_setup();
  while (gameover == 0) {
    simulate_mouse();
    spiel_physik();
    spiel_kollision();
    c = c + 1;
  };
  return c;
};



/***********************
  GeneticAlgorithm
***********************/

function zero_vector(n) {
  var x = new Array(n);
  for (var j = 0; j < n; j++) x[j] = 0;
  return x;
};

function zero_matrix(m, n) {
  var A = new Array(m);
  for (var i = 0; i < m; i++) A[i] = new Array(n);
  for (var i = 0; i < m; i++) for (var j = 0; j < n; j++) A[i][j] = 0;
  return A;
};

function flatten(T) {
  var w = T.weights;
  var b = T.biases;
  var u = [];
  for (var k = 0; k < w.length; k++) for (var i = 0; i < w[k].length; i++) for (var j = 0; j < w[k][i].length; j++) {
    u.push(w[k][i][j]);
  };
  for (var k = 0; k < b.length; k++) for (var i = 0; i < b[k].length; i++) {
    u.push(b[k][i]);
  };
  return u;
};

function unflatten(u, L) {
  var w = [];
  var q = 0;
  for (var k = 0; k < L.length-1; k++) {
    w.push(zero_matrix(L[k+1], L[k]));
    for (var i = 0; i < w[k].length; i++) for (var j = 0; j < w[k][i].length; j++) {
      w[k][i][j] = u[q];
      q++;
    };
  };
  var b = [];
  for (var k = 0; k < L.length-1; k++) {
    b.push(zero_vector(L[k+1]));
    for (var i = 0; i < b[k].length; i++) {
      b[k][i] = u[q];
      q++;
    };
  };
  return {layout:L, weights:w, biases:b};
};

function f(x) {
  var b = unflatten(x, layout);
  NeuralNetwork.set_data(b);
  var h = flappy_run();
  return -h;
};


var q = layout_size(); // Anzahl der Gewichte und Schwellwerte

var s = GeneticAlgorithm.vector(f, q, {iterations:10, population:100, children:40});


Console.print("Bestes Individuum:");
Console.print(s);
Console.print("Fitness:");
Console.print(f(s));


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

Vorschau Download Kopie speichern