Inhaltsverzeichnis für dieses Kapitel, für das gesamte Dokument;
bp/man/man1/bp.1 --- Hilfeseite mit
einer Kurzbeschreibung von bp bp/make --- Shellscript, Abkürzung
für gmake -f GnuMakefile bp/Arch.mak --- Architekturspezifische
Vereinbarungen für bp/Bp.mak bp/Bp.mak --- Regeln zum Übersetzen
von bp. bp/GnuMakefile --- Frontend für
bp/Bp.mak bp/SEQUENT/, bp/PVM/ und
bp/PARIX/ --- Kataloge in denen
zu jeder Architektur Objekt-Dateien und Programme
abgelegt werden bp/src/ --- Katalog mit Quelltexten Für die UNIX-Architekturen HP700, m68k (NeXT),
i486 (Linux), sun3, sun4 und rs6000
sind bereits Anpassungen in die Datei bp/Arch.mak aufgenommen
worden. Ist die Ausgabe des Kommandos arch nicht in dieser Menge
enthalten, so wird versucht, bp mit dem gcc
zu übersetzen.
make ?
listet alle verfügbaren Targets auf.
Die in bp/GnuMakefile gesetzte Variable XDIR
enthält den Katalog, wo das ausführbare Progamm
abgelegt wird. Voreingestellt ist
$(HOME)/bin/$(ARCH) --- für sequentielle
Programme unter UNIX $(HOME)/pvm3/bin/$(PVM_ARCH) --- für
PVM-Programme $(HOME)/parix/bin/$(ARCH) -- für
PARIX-Programme bp - ein Programm zur Simulation eines Mehrschicht-Perzeptron-Netzes (MP-Netz, feedforward multilayer perceptron), welches mit dem Backpropagation Algorithmus trainiert wird.
bp {-c <Konfiguration>}
{-r <Dateiname>}
{-q <Dateiname1> <Dateiname2>}
{-t [/s[=<alle #Epochen>]]
[/l=<Lernrate>]
[/p=<alle #Epochen>]
[/i=<Impulsrate>]
[/b]
/e=<#Epochen> | /g[=<Fehler>]
<Dateiname>}
{-l <prio> <Dateiname>}
{-w[a] <Dateiname>}
Die Reihenfolge der Parameter in der Kommandozeile ist maßgebend für die Abarbeitung.
bp -c <Topologie> legt ein MP-Netz (siehe Abbildung 3.1) an und initialisiert die Schwellwerte (bias) und Gewichte (weights) mit Zufallszahlen aus dem Intervall ]-1,1[. Die <Topologie> besitzt folgende Syntax:
<Anzahl der aktiven Schichten>: :<Anzahl der Neuronen der Eingabeschicht> :<initiale Anzahl der Neuronen der ersten verborgenen Schicht> (<maximale Anzahl der Neuronen der ersten verborgenen Schicht>) . . . :<initiale Anzahl der Neuronen der letzten verborgenen Schicht> (<maximale Anzahl der Neuronen der letzten verborgenen Schicht>) :<Anzahl der Neuronen der Ausgabeschicht>
$ bp -c "3:30:15(25):10(20):1"
initialisiert ein MP-Netz, welches 3 aktive Schichten (neben der
inaktiven Eingabeschicht) besitzt. Die Eingabeschicht
besitzt 30 Neuronen, die erste vorborgene Schicht
besitzt 15 Neuronen und kann maximal deren 25 aufnehmen.
Die zweite verborgene Schicht besitzt 10 Neuronen
und maximal 20. Die Ausgabeschicht besitzt ein Neuron.
Die Angabe einer maximalen Anzahl, verborgener Neuronen
ist für des Training mit dem MouseProp-Algorithmus
relevant (siehe Abschnitt 3.4).
()
als Metazeichen auffassen, ist man gut beraten, die
Topologie zu schützen, in dem sie zum Beispiel in
Anführungszeichen eingefaßt wird, um nicht mit der Shell in
Konflikt zu geraten. bp -r <Dateiname>
initialisiert die Schwellwerte und Gewichte eines MP-Netzes
mit den Werten aus der Datei <Dateiname>. Wurde zuvor noch
kein MP-Netz angelegt, so erledigt dies -r mit der in der
Datei abgespeicherten Topologie. Ansonsten wird überprüft,
ob die Werte mit dem bisherigen MP-Netz verträglich sind.
$ bp -r xor.mp
liest Gewichte und Schwellwerte aus der
Datei xor.mp.
stdin,
so erwartet bp -r seine Daten über die
Standardeingabe. -c oder -r benutzen;
einzige Ausnahme:
Die maximale Anzahl der Neuronen pro Schicht eines
abgespeicherten Netzes soll geändert werden. $ bp -c "2::6:3(3):1" -w small.mp $ bp -c "2::6:3(12):1" -r small.mp -w big.mp
bp -q <Dateiname1> <Dateiname2> führt eine Netzabfrage durch, d.h. gemäß der Netztopologie werden jeweils <Anzahl der Neuronen der Eingabeschicht> Werte über die Datei <Dateiname1> eingelesen, durch das Netz propagiert und <Anzahl der Neuronen der Ausgabeschicht> Werte mit Leerzeichen getrennt in die Datei <Dateiname2> geschrieben.
Die Abfrage endet mit dem Erreichen des Dateiendes von <Dateiname1> bzw. mit einem fehlgeschlagenen Leseversuch.
stdin,
so erwartet bp -q seine
Daten über die Standardeingabe. stdout,
so schreibt bp -q seine Daten in die
Standardausgabe.
bp -t [/s[=<alle #Epochen>]]
[/l=<Lernrate>]
[/p=<alle #Epochen>]
[/i=<Impulsrate>]
[/b]
/e=<#Epochen> | /g[=<Fehler>]
<Dateiname>
trainiert ein MP-Netz mit den in <Dateiname>
aufgelisteten Trainingspaaren. Das einmalige Training
aller Paare heißt Epoche. Das Training endet, falls
ein Abbruchkriterium erfüllt ist:
/e=<#Epochen>
ist wahr, wenn <#Epochen> Epochen trainiert wurden.
/g[=<Fehler>]
ist wahr, wenn die Wurzel des
mittleren quadratischen Fehlers
der Testmenge gestiegen ist
und die Differenz zum letzten Wert
größer als <Fehler> ist,
falls dieser angegeben wurde.
Standardmäßig wird der gewöhnliche Backpropagation
Algorithmus mit Online-Training
ohne Momentum/Impuls und mit einer Lernrate von
1.0 verwendet (siehe Abschnitt 3.3.4).
Die optionalen Parameter
s,l,i und b dienen dazu,
Abweichungen davon genauer zu spezifizieren.
Die Angabe von /s[=<alle #Epochen>]
veranlaßt bp dazu, während des Trainings
verborgene Neuronen aufzuspalten.
Ein schlecht trainiertes verborgenes Neuron wird
aufgespalten, in der Hoffnung, daß zwei Neuronen das zu
schaffen vermögen, was ein Neuron überfordert. Dieses
Aufspalten geschieht monoton und fehlerlokal:
Die Ergebnisse einer Abfrage bleiben unverändert
(monoton) und die Fehlerwerte der nicht betroffenen
Neuronen bleiben unverändert (fehlerlokal)
(siehe Abschnitt 3.4).
Insbesondere "erbt" ein derartig gewachsenes Netz die den "kleinen" Netzen immanente Eigenschaft zur Verallgemeinerung, welche im Normalfall mit zunehmender Anzahl an verborgenen Neuronen verschwindet.
Die Angabe von /s sorgt dafür, daß
bp in gleichmäßigen Abständen, die sich aus
<Anzahl der Epochen> DIV <Anzahl aufzuspaltender Neuronen>
ergeben, ein geeignetes Neuron ermittelt und
aufgespaltet.
Durch /s=<alle #Epochen> läßt sich
dieser Abstand explizit angeben.
Die Anzahl aufzuspaltender Neuronen ergibt sich
als Summe über alle verborgenen Schichten von
<initiale Anzahl der Neuronen> - <maximale Anzahl der Neuronen>,
welche mit der Netztopologie angegeben wird (siehe Abschnitt 6.2.3).
Durch /l=<Lernrate> wird die
zu verwendende Lernrate gesetzt.
Hierbei ist <Lernrate> ein positiver
numerischer Wert, der als Schrittweite beim
Gradientenabstieg (gradient descent) benutzt
wird. In der Regel sollte die
Lernrate möglichst klein gewählt werden,
falls die zur Verfügung stehende Zeit dies
zuläßt.
Eine Verfolgung des Fehlers während des
Trainings wird durch die Angabe von /p=<alle #Epochen>
eingeschaltet. Nach <alle #Epochen> wird
die Wurzel aus dem mittleren quadratischen Fehler
sowohl für die Trainings- als auch für die Testmenge
bestimmt und das Ergebnis in die Protokolldatei
geschrieben (siehe Abschnitt 6.2.8).
Zur Beschleunigung des Trainings
erweist es sich bei manchen Problemstellungen als
hilfreich, einen Bruchteil der letzten Gewichtsveränderung zur
momentanen hinzuzuaddieren (Impuls/Momentum).
Durch /i=<Impulsrate> wird mit Impuls
gelernt. <Impulsrate> ist ein numerischer Wert,
der den Bruchteil angibt.
Sinnvolle Werte liegen zwischen 0 und 1.
Sollen die berechneten Gewichtsänderungen erst
am Ende einer Epoche wirksam werden, so ist
/b anzugeben.
Trainingsdaten sind die Musterpaare, mit denen ein MP-Netz trainiert wird (Trainingsmenge), bzw. mit denen ein Test auf Generalisierung durchgeführt wird (Testmenge) (siehe Abschnitt 2.3.2).
Zu Beginn der Datei dürfen beliebig viele Kommentarzeilen
durch ## eingeleitet werden. Nach den
Kommentarzeilen sind folgende vier Zeilen obligatorisch:
# pairs= <Anzahl der Trainingspaare> # genpairs= <Anzahl der Testpaare> # inputsize= <Anzahl der Eingabeneuronen> # outputsize= <Anzahl der Ausgabeneuronen>
Hiernach folgen für jedes Trainingspaar jeweils
<Anzahl der Eingabeneuronen> +
<Anzahl der Ausgabeneuronen>
Werte durch Whitespaces getrennt. Soll diese Datei kompatibel mit
dem Xerion-Packet
sein, so muß nach den Werten für die Eingabeschicht
ein Komma , folgen und am Ende eines Musterpaares ein Semikolon
; stehen.
## Datei: xor.trn ## ## XOR Problem ## ## Wahrheitstabelle: ## ## | 0 1 ## --|---- ## 0 | 0 1 ## 1 | 1 0 ## # pairs= 4 # genpairs= 0 # inputsize= 2 # outputsize= 1 0 0, 0; 0 1, 1; 1 0, 1; 1 1, 0;
$ bp -c 2::2:2(2):1 -t /e=1000/l=2.0/i=0.9 xor.trn
initialisiert ein MP-Netz mit 2 Eingabeneuronen, zwei verborgenen
Neuronen und einem Ausgabeneuron. Anschließend wird es
1000 Epochen mit einer Lernrate von 2,0 und einer Impulsrate
von 0,9 mit den Musterpaaren aus der Datei xor.trn trainiert.
Der Verlauf und das Resultat einer bp Sitzung
wird in einer Protokolldatei festgehalten.
bp -l <prio> <Dateiname> legt fest,
wie ausführlich und wohin die Protokollmeldungen geschrieben
werden sollen. <prio> sollte eine der folgenden Vokabeln sein:
none
schaltet das Protokollieren ganz aus,
minimal, medium, detailed
schaltet das Protokollieren mit zunehmender Priorität ein.
Der mittels <Dateiname> spezifizierten Datei werden die Protokolldaten der momentanen Sitzung angehängt. Die Protokolldaten selbst werden als Origami-Falten {{{ }}} geschrieben.
Voreinstellung ist detailed
als Priorität und bp.log
als Name der Protokolldatei.
Es folgt eine Sitzung mit minimalem Protokoll:
{{{ Wed Aug 30 12:36:12 1995
SESSION STARTED : Wed Aug 30 12:36:12 1995
PROGRAM VERSION : $Id: bp.c,v 4.2 1995/08/30 10:11:26 dumiddel Exp $
COMMANDLINE : bp -l minimal bp.log -c 2::2:2(6):1 -r xor.ini.mp
-t /p=50/e=10000/b/s xor.trn -w xor.mp
bp.net_training: time: 1.791 s after 10000 epochs
bp.net_training: configuration: 2::2:6(6):1
bp.net_training: training_error: 0.0092954516435081
bp.net_training: test_error: 0.0000000000000000
bp.net_training: sbic: 10000 -1.1906957079849794
SESSION ENDED : Wed Aug 30 12:36:14 1995
}}}
training_error: und test_error:
stehen für die Wurzel der mittleren quadratischen
Fehlers auf Trainings- bzw. Testmenge. Im Vergleich dazu die Sitzung mit ausführlichem Protokoll:
{{{ Wed Aug 30 12:27:06 1995
SESSION STARTED : Wed Aug 30 12:27:06 1995
PROGRAM VERSION : $Id: bp.c,v 4.2 1995/08/30 10:11:26 dumiddel Exp $
COMMANDLINE : bp -l detailed bp.log -c 2::2:2(6):1 -r xor.ini.mp
-t /p=50/e=10000/b/s xor.trn -w xor.mp
bp.net_create: configuration: 2::2:2(6):1
bp.net_read: configuration: 2::2:2(6):1
bp.net_training: file: xor.trn
bp.net_training: parameters for batch learning :
bp.net_training: split: 2000
bp.net_training: eta: 1.000000
bp.net_training: alpha: 0.000000
bp.net_training: max_error: 0.000000
bp.net_training: n_epochs: 10000
bp.net_training: pairs: 4
bp.net_training: genpairs: 0
bp.net_training: err_epochs: 50
bp.net_training: epoch: 50 error: 0.4996622701079532 0.0000000000000000
bp.net_training: epoch: 100 error: 0.4992786814394997 0.0000000000000000
...
bp.net_training: epoch: 1900 error: 0.0310810413518726 0.0000000000000000
bp.net_training: epoch: 1950 error: 0.0305270988669030 0.0000000000000000
bp.net_split: splitted neuron 1 in layer 0 with osc 0.723669
bp.net_training: sbic: 2000 -1.2614548476775369
bp.net_training: epoch: 2000 error: 0.0300006604114873 0.0000000000000000
bp.net_training: epoch: 2050 error: 0.0293746319216904 0.0000000000000000
...
bp.net_training: epoch: 9950 error: 0.0093272219041370 0.0000000000000000
bp.net_training: epoch: 10000 error: 0.0092954516435081 0.0000000000000000
bp.net_training: time: 1.847 s after 10000 epochs
bp.net_training: configuration: 2::2:6(6):1
bp.net_training: training_error: 0.0092954516435081
bp.net_training: test_error: 0.0000000000000000
bp.net_training: sbic: 10000 -1.1906957079849794
bp.net_training: query: 0.008719 0.990678 0.988943 0.007774
bp.net_write: file: xor.mp
bp.net_write: configuration: 2::2:6(6):1
SESSION ENDED : Wed Aug 30 12:27:08 1995
}}}
bp -w <Dateiname>
sichert die durch Training
gewonnenen Schwellwerte und Gewichte
in der Datei <Dateiname>,
aus der sie mittels bp -r
wieder geladen werden können.
$ bp -c 2::2:2(2):1 -t /e=1000/l=2.0/i=0.9 xor.trn -w xor.mp
legt Platz für ein MP-Netz mit 2 Eingabeneuronen, zwei verborgenen
Neuronen und einem Ausgabeneuron an. Anschließend wird es
1000 Epochen mit einer Lernrate von 2,0 und einer Impulsrate
von 0,9 mit den Musterpaaren aus der Datei xor.trn trainiert.
Hiernach werden Topologie, Schwellwerte und Gewichte in
der Datei xor.mp gespeichert.
stdout,
so werden die Daten in die Standardausgabe geschrieben. Die parallelen Implementationen von bp lassen sich prinzipiell genauso bedienen wie die sequentielle. Aufruf und Optionen sind dieselben, ebenso die Ausgabedateien. Neu ist nur die Art und Weise, wie das parallele Programm unter der jeweiligen Umgebung gestartet wird.
Da unter PVM nur das parallele Batch-Training implementiert
wurde, führt ein fehlendes /b bei den Trainingsoptionen
(siehe Abschnitt 6.2.6) zu einem Programmabbruch.
Eine parallele virtuelle Maschine wird zum Beispiel durch das Kommando pvm etabliert. Danach befindet man sich in der PVM-Shell und kann Änderungen an der Konfiguration vornehmen.
Der Aufruf von bp geschieht über den Prefix
mpil in der Kommandozeile:
$mpil [<n_tasks>] bp ...
mpil ist ein PVM-Programm, welches bp
nachlädt. <n_tasks> gibt an, wieviele
bp-Tasks gestartet werden sollen. Fehlt diese Angabe,
so nimmt mpil stattdessen die Anzahl der an der
virtuellen Maschine beteiligten Rechner.
Nachdem alle bp-Tasks initialisiert wurden,
terminiert mpil.
mpil kann auch außerhalb der PVM-Shell gestartet werden, sofern es sich im Suchpfad befindet. Die PVM-Version von bp kann ausschließlich über mpil aufgerufen werden und sollte sich nicht im Suchpfad befinden.
Unter PVM ist der jeweilige Heimatkatalog das Arbeitsverzeichnis, selbst wenn das PVM-Programm aus einem anderen Katalog heraus gestartet wurde. Aus diesem Grund sind alle Dateinamen relativ zum Heimatkatalog anzugeben.
Unter PARIX sind keine Besonderheiten zu beachten.
bp läßt sich ganz gewöhnlich
über das Kommando run aufrufen. Zum Beispiel startet
$run -f1 2 2 bp.px ...
bp auf dem PowerXplorer (siehe Tabelle 4.1).
"Es sei darauf hingewiesen, daß die Benutzung dieses Produktes die Entropie im Universum erhöht. Obwohl es sich hierbei nicht um eine Straftat handelt, muß gesagt werden, daß dieser Prozeß ultimativ zum Hitzetod des Universums führt."
Aus: Journal of Irreproducible Results