taralino

Verallgemeinerungen

Auch wenn wir damit vom biologischen Vorbild abweichen, spricht aus mathematischer Sicht nichts dagegen, die Gewichte und Schwellwerte zu verallgemeinern:

Für die Gewichte und Schwellwerte eines künstlichen neuronalen Netzes werden sämtliche (reelle) Zahlen zugelassen.

Dadurch lassen sich Beziehungen zwischen den Neuronen deutlich besser modellieren, insbesondere auch negative Abhängigkeiten. Zudem können auch die Eingangsneuronen verallgemeinert werden:

Für die Eingangsneuronen werden nicht nur die Werte 0 und 1 zugelassen, sondern auch (reelle) Zahlen zwischen 0 und 1.

Ein Beispiel, wie ein künstliches neuronales Netz damit aussehen kann, ist folgendes:

An der grundlegenden Berechnung hat sich trotz der Verallgemeinerungen aber nichts geändert:

Das Neuron mit der Kennzeichnung A ist genau dann aktiviert, falls

gilt.

Auch an der Implementierung eines neuronalen Netzes ändert sich bislang nichts.

Anwendung

Gegeben ist ein neuronales Netz samt Gewichten und Schwellwerten. Definiere die Eingangsneuronen und beobachte, wie sich die übrigen Neuronen verändern.

<!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>

var a = [0.5,0.8];
var w1 = [-0.2,1.2];
var w2 = [0.8,-0.7];
var w3 = [1.0,1.4];
var w4 = [-0.5,1.1,-1.3];
var w5 = [0.9,-1.0,0.6];
var b1 = 0.3;
var b2 = -0.1;
var b3 = 0.6;
var b4 = -1.7;
var b5 = 0.4;

function color_gradient(q) {
  var c = [26,124,208];
  var d = [66,188,66];
  return [q*c[0]+(1-q)*d[0], q*c[1]+(1-q)*d[1], q*c[2]+(1-q)*d[2]];
};

function phi(a, w, b) {
  var t = 0;
  for (var k = 0; k < a.length; k++) t += a[k]*w[k];
  return (t >= b ? 1 : 0);
};

function draw_neuron(x, y, a, b) {
  Canvas.circle(x, y, 0.6, {fill:color_gradient(a)});
  Canvas.circle(x, y, 0.4, {fill:"#ffffffcc"});
  Canvas.text(x, y, a.toFixed(2));
  if (typeof(b) == "number") {
    Canvas.circle(x-0.4, y-0.5, 0.4, {fill:"#4d576a"});
    Canvas.text(x-0.4, y-0.5, b.toFixed(2), {fill:"white"});
  };
  if (typeof(b) == "string") {
    Canvas.text(x-1.7, y, b);
  };
};

function draw_arrow(x1, y1, x2, y2, t, c) {
  Canvas.arrow(x1, y1, x2, y2);
  Canvas.circle(t*x1+(1-t)*x2, t*y1+(1-t)*y2, 0.5, {fill:"#e2e2e2"});
  Canvas.text(t*x1+(1-t)*x2, t*y1+(1-t)*y2, c.toFixed(2));
};

function draw() {
  Canvas.clear();
  draw_neuron(2, 5.5, a[0], "Neuron 1");
  draw_neuron(2, 2.5, a[1], "Neuron 2");

  var t1 = phi(a, w1, b1);
  draw_neuron(8, 7, t1, b1);
  draw_arrow(3, 5.5+0.2, 7, 7+0.2, 0.5, w1[0]);
  draw_arrow(3, 2.5+0.2, 7, 7-0.2, 0.25, w1[1]);

  var t2 = phi(a, w2, b2);
  draw_neuron(8, 4, t2, b2);
  draw_arrow(3, 5.5+0.0, 7, 4+0.2, 0.7, w2[0]);
  draw_arrow(3, 2.5+0.0, 7, 4-0.2, 0.7, w2[1]);

  var t3 = phi(a, w3, b3);
  draw_neuron(8, 1, t3, b3);
  draw_arrow(3, 5.5-0.2, 7, 1+0.2, 0.25, w3[0]);
  draw_arrow(3, 2.5-0.2, 7, 1-0.2, 0.5, w3[1]);

  var t4 = phi([t1,t2,t3], w4, b4);
  draw_neuron(14, 5.5, t4, b4);
  draw_arrow(9, 7+0.2, 13, 5.5+0.3, 0.5, w4[0]);
  draw_arrow(9, 4+0.2, 13, 5.5+0.0, 0.25, w4[1]);
  draw_arrow(9, 1+0.2, 13, 5.5-0.3, 0.75, w4[2]);

  var t5 = phi([t1,t2,t3], w5, b5);
  draw_neuron(14, 2.5, t5, b5);
  draw_arrow(9, 7-0.2, 13, 2.5+0.3, 0.75, w5[0]);
  draw_arrow(9, 4-0.2, 13, 2.5+0.0, 0.25, w5[1]);
  draw_arrow(9, 1-0.2, 13, 2.5-0.3, 0.5, w5[2]);
};

function setup() {
  Canvas.init([-1.6,16], [-0.5,8.3], {width:728, background:"lightgrey", scaling:"off"});
  Button.add("n1", "Neuron 1");
  Button.add("n2", "Neuron 2");
  draw();
};

function on_click(id) {
  for (var i = 0; i < 4; i++) {
    if (id == "n"+(i+1).toFixed(0)) {
      a[i] += 0.1;
      a[i] = (a[i] > 1.01 ? 0.0 : Math.min(a[i], 1.0));
      draw();
    };
  };
};

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

Vorschau Download Kopie speichern

Aufgabe

Bestimme die Werte der Neuronen A bis E in Abhängigkeit der gewählten Zustände der Eingangsneuronen.

Implementierung

Der Quellcode zeigt, wie das Modell mit einer beliebigen Anzahl an Schichten implementiert werden kann. Im Beispiel verwendet wird das Netzwerk samt der Gewichte und Schwellwerte aus der Abbildung oben.

<!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>

// Werte der Eingangsneuronen:

var x = [ 0.5, 0.8 ];

// Definition der Gewichte:

var w = [[
  [ -0.2,  1.2 ],
  [  0.8, -0.7 ],
  [  1.0,  1.4 ]
],[
  [ -0.5,  1.1, -1.3 ],
  [  0.9, -1.0,  0.6 ]
]];

// Definition der Schwellwerte:

var b = [
  [  0.3, -0.1,  0.6 ],
  [ -1.7,  0.4 ]
];

// Neuronales Netz auswerten:

function s(y, w) {
  var h = 0;
  for (var j = 0; j < y.length; j = j+1) h = h + y[j]*w[j];
  return h;
};

function f(y, w, b) {
  var m = b.length;
  var h = new Array(m);
  for (var i = 0; i < m; i = i+1) h[i] = (s(y, w[i]) >= b[i] ? 1 : 0);
  return h;
};

var t = x;
for (var k = 0; k < w.length; k = k+1) t = f(t, w[k], b[k]);

// Ergebnisausgabe:

Console.print("Eingangsneuronen:");
Console.print(x);
Console.print("Ausgangsneuronen:");
Console.print(t);

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

Vorschau Download Kopie speichern