KI entwirft.
Der Mensch verantwortet. Belegbar durch Ergebnisse — nicht durch Versprechen. AI designs.
Humans take responsibility. Proven by results — not by promises.

Rekonstruktion aus der Erinnerung — die Originaldisketten sind verschollen. Stil und Umfang entsprechen der damaligen Arbeit. 10.000 Epochen bedeuteten auf dem Atari ST: starten, warten, hoffen — heute ein Wimpernschlag.
Grundlage: Rumelhart, Hinton & Williams — Learning representations by back-propagating errors, Nature 323 (1986). Reconstructed from memory — the original disks are lost. Style and scope match the work of that era. On the Atari ST, 10,000 epochs meant: start, wait, hope — today, the blink of an eye.
Based on: Rumelhart, Hinton & Williams — Learning representations by back-propagating errors, Nature 323 (1986).

program Backprop1986;

{
  Einfaches neuronales Netz
  im Stil von 1986 / Atari ST Turbo Pascal

  XOR-Lernbeispiel
}

uses
  crt;

const
  InputNodes  = 2;
  HiddenNodes = 2;
  OutputNodes = 1;
  Patterns    = 4;

  LearningRate = 0.5;

type
  VectorInput  = array[1..InputNodes] of real;
  VectorHidden = array[1..HiddenNodes] of real;
  VectorOutput = array[1..OutputNodes] of real;

var
  Inputs  : array[1..Patterns] of VectorInput;
  Targets : array[1..Patterns] of VectorOutput;

  Hidden : VectorHidden;
  Output : VectorOutput;

  Wih : array[1..InputNodes,1..HiddenNodes] of real;
  Who : array[1..HiddenNodes,1..OutputNodes] of real;

  HiddenError : VectorHidden;
  OutputError : VectorOutput;

  i,j,k,p,epoch : integer;

function Sigmoid(x : real) : real;
begin
  Sigmoid := 1.0 / (1.0 + exp(-x));
end;

procedure InitWeights;
begin
  randomize;

  for i := 1 to InputNodes do
    for j := 1 to HiddenNodes do
      Wih[i,j] := random - 0.5;

  for j := 1 to HiddenNodes do
    for k := 1 to OutputNodes do
      Who[j,k] := random - 0.5;
end;

procedure ForwardPass(p : integer);
var
  sum : real;
begin
  { Input -> Hidden }
  for j := 1 to HiddenNodes do
  begin
    sum := 0.0;
    for i := 1 to InputNodes do
      sum := sum + Inputs[p][i] * Wih[i,j];
    Hidden[j] := Sigmoid(sum);
  end;

  { Hidden -> Output }
  for k := 1 to OutputNodes do
  begin
    sum := 0.0;
    for j := 1 to HiddenNodes do
      sum := sum + Hidden[j] * Who[j,k];
    Output[k] := Sigmoid(sum);
  end;
end;

procedure BackwardPass(p : integer);
begin
  { Output Fehler }
  for k := 1 to OutputNodes do
  begin
    OutputError[k] :=
      (Targets[p][k] - Output[k]) *
      Output[k] * (1.0 - Output[k]);
  end;

  { Hidden Fehler }
  for j := 1 to HiddenNodes do
  begin
    HiddenError[j] :=
      Who[j,1] * OutputError[1] *
      Hidden[j] * (1.0 - Hidden[j]);
  end;

  { Hidden -> Output Gewichte }
  for j := 1 to HiddenNodes do
    for k := 1 to OutputNodes do
      Who[j,k] := Who[j,k] +
        LearningRate * OutputError[k] * Hidden[j];

  { Input -> Hidden Gewichte }
  for i := 1 to InputNodes do
    for j := 1 to HiddenNodes do
      Wih[i,j] := Wih[i,j] +
        LearningRate * HiddenError[j] * Inputs[p][i];
end;

procedure InitTrainingData;
begin
  { XOR }
  Inputs[1][1] := 0; Inputs[1][2] := 0; Targets[1][1] := 0;
  Inputs[2][1] := 0; Inputs[2][2] := 1; Targets[2][1] := 1;
  Inputs[3][1] := 1; Inputs[3][2] := 0; Targets[3][1] := 1;
  Inputs[4][1] := 1; Inputs[4][2] := 1; Targets[4][1] := 0;
end;

begin
  clrscr;

  InitTrainingData;
  InitWeights;

  writeln('Training gestartet...');
  writeln;

  for epoch := 1 to 10000 do
    for p := 1 to Patterns do
    begin
      ForwardPass(p);
      BackwardPass(p);
    end;

  writeln('Training abgeschlossen.');
  writeln;

  for p := 1 to Patterns do
  begin
    ForwardPass(p);
    writeln(
      Inputs[p][1]:0:0,' XOR ',
      Inputs[p][2]:0:0,' = ',
      Output[1]:0:4
    );
  end;

  readln;
end.