create_class_mlp — Erzeugen eines mehrschichtigen Perzeptrons zur Klassifikation oder
Regression.
create_class_mlp( : : NumInput, NumHidden, NumOutput, OutputFunction, Preprocessing, NumComponents, RandSeed : MLPHandle)
create_class_mlp erzeugt ein neuronales Netz in Form eines
mehrschichtigen Perzeptrons (engl.: multilayer perceptron, MLP),
welches zur Klassifikation oder Regression (Funktionsapproximation)
verwendet werden kann, je nachdem, wie OutputFunction
gesetzt wird. Das MLP besitzt drei Schichten: eine Eingabeschicht
mit NumInput Eingabevariablen (Einheiten, Neuronen), eine
versteckte Schicht mit NumHidden Einheiten und eine
Ausgabeschicht mit NumOutput Ausgabevariablen. Das MLP
führt mit den Eingabedaten , dem so genannten
Merkmalsvektor, folgende Berechnungsschritte aus, um die
Aktivierungen der versteckten Schicht zu berechnen:
Die Matrix und der Vektor
sind dabei die Gewichte der
Eingabeschicht (ersten Schicht) des MLP. Die Aktivierungen
der ersten Schicht werden in der versteckten
Schicht (zweiten Schicht) zunächst genauso durch
Linearkombinationen transformiert, wie in der ersten Schicht:
Dabei sind die Matrix und der Vektor
die Gewichte der zweiten Schicht des MLP.
Durch Setzen von OutputFunction kann die
Aktivierungsfunktion der Ausgabeschicht festgelegt werden. Für
OutputFunction = 'linear' werden die Daten
einfach kopiert:
Diese Art der Aktivierungsfunktion sollte bei Regressionsaufgaben
(Funktionsapproximation) verwendet werden. Diese
Aktivierungsfunktion eignet sich nicht für Klassifikationsaufgaben.
Für OutputFunction = 'logistic' werden die
Aktivierungen wie folgt berechnet:
Diese Art der Aktivierungsfunktion sollte bei
Klassifikationsaufgaben verwendet werden, bei denen mehrere
(NumOutput) unabhängige logische Attribute als Ausgabe
auftreten können. Dies kommt nur bei sehr wenigen
Klassifikationsaufgaben vor.
Für OutputFunction = 'softmax' werden die
Aktivierungen wie folgt berechnet:
Diese Art der Aktivierungsfunktion sollte bei üblichen
Klassifikationsaufgaben verwendet werden, bei denen mehrere
(NumOutput), sich gegenseitig ausschließende Klassen
auftreten. Insbesondere muss OutputFunction =
'softmax' bei der Klassifikation von Pixeldaten mit
classify_image_class_mlp verwendet werden.
Mit den Parametern Preprocessing und NumComponents
kann eine Vorverarbeitung der Merkmalsvektoren festgelegt werden.
Für Preprocessing = 'none' werden die
Merkmalsvektoren ohne Änderung an das MLP übergeben.
NumComponents wird hier ignoriert.
Für alle anderen Werte von Preprocessing wird aus dem
Trainingsdatensatz eine Transformation der Merkmale berechnet, die
sowohl beim Training als auch bei der späteren Klassifikation oder
Auswertung dazu verwendet wird, die Merkmalsvektoren zu
transformieren.
Für Preprocessing = 'normalization' werden die
Merkmalsvektoren normalisiert, indem der Mittelwert der
Trainingsvektoren von den Merkmalsvektoren abgezogen wird und die
dadurch entstehenden Merkmalsvektoren durch die Standardabweichung
der jeweiligen Komponente der Trainingsvektoren geteilt wird. Die
transformierten Merkmalsvektoren haben also einen Mittelwert von 0
und eine Standardabweichung von 1 in jeder Komponente. Die
Normalisierung ändert die Länge des Merkmalsvektors nicht.
NumComponents wird hier ignoriert. Diese Transformation
empfiehlt sich bei allen Daten, in denen die Mittelwerte und
Standardabweichungen der Merkmalsvektoren sich stark von 0 bzw. 1
unterscheiden oder bei denen die Komponenten der Daten nicht in
denselben Einheiten gemessen werden (z.B., falls einige der Daten
Grauwertmerkmale und andere Regionenmerkmale sind, oder falls
z.B. Regionenmerkmale wie 'circularity' (Einheit: Skalar) und 'area'
(Einheit: Quadratpixel) gemischt werden). In diesem Fall benötigt
das Trainieren des MLP typischerweise weniger Iterationen als ohne
Normalisierung.
Für Preprocessing = 'principal_components'
werden die Merkmalsvektoren einer Hauptachsentransformation
(principal component analysis) unterzogen. Die
Hauptachsentransformation normalisiert zunächst die
Merkmalsvektoren (s.o.). Danach wird eine orthogonale
Transformation (eine Rotation im Merkmalsraum) berechnet, die die
Trainingsvektoren dekorreliert. Nach der Transformation ist der
Mittelwert der Trainingsvektoren 0 und die Kovarianzmatrix der
Trainingsvektoren ist eine Diagonalmatrix. Die Transformation wird
so bestimmt, dass die transformierten Merkmale, die die größte
Variationsbreite aufweisen, als erstes in dem transformierten
Merkmalsvektor stehen. Dadurch kann erreicht werden, dass die
letzten Komponenten des Merkmalsvektors, die typischerweise stark
vom Rauschen beeinflusst werden, ohne großen Informationsverlust
weggelassen werden können. Mit NumComponents wird
festgelegt, wie viele der transformierten Komponenten verwendet
werden sollen. Es können bis zu NumInput Komponenten
selektiert werden. Mit Hilfe von get_prep_info_class_mlp
kann der Informationsgehalt der einzelnen transformierten
Komponenten bestimmt werden, und somit NumComponents
einfacher bestimmt werden. Wie die Normalisierung empfiehlt sich
diese Transformation, wenn die Merkmalsvektoren Mittelwerte und
Standardabweichungen haben, die sich stark von 0 bzw. 1
unterscheiden oder bei denen die Komponenten der Merkmalsvektoren
nicht in denselben Einheiten gemessen werden, und wenn zusätzlich
zu erwarten ist, dass die Merkmale stark korreliert sind.
Im Gegensatz zu den obigen drei Transformationen, welche für
beliebige Typen des MLP verwendet werden können, kann die durch
Preprocessing = 'canonical_variates' (kanonische
Merkmale) spezifizierte Transformation nur verwendet werden, falls
das MLP als Klassifikator mit OutputFunction =
'softmax' verwendet wird. In diesem Fall wird eine
Transformation bestimmt, die die Trainingsvektoren zuerst
normalisiert und dann im Mittel über alle Klassen dekorreliert.
Gleichzeitig werden in den transformierten Trainingsvektoren die
Mittelwerte der einzelnen Klassen möglichst weit separiert. Wie
bei Preprocessing = 'principal_components'
werden die transformierten Komponenten nach Informationsgehalt
sortiert, so dass transformierte Merkmale mit wenig
Informationsgehalt weggelassen werden können. Bei kanonischen
Merkmalen können höchstens min(NumOutput - 1,
NumInput) Merkmale selektiert werden. Auch hier kann
mit get_prep_info_class_mlp der Informationsgehalt der
einzelnen transformierten Komponenten bestimmt werden. Wie die
Hauptachsentransformation können die kanonischen Merkmale dazu
verwendet werden, die Datenmenge ohne großen Informationsverlust zu
verringern, wobei zusätzlich noch die Trennbarkeit der Daten nach
der Datenreduktion optimiert wird.
Für die letzten zwei Transformationsarten
('principal_components' und 'canonical_variates')
bestimmt NumComponents die Anzahl der Einheiten in der
Eingabeschicht, während NumInput die Dimensionalität der
Eingabedaten (Länge des untransformierten Merkmalsvektors)
bestimmt. Dadurch wird die Anzahl der Eingabevariablen des MLP
geringer, und daher kann typischerweise auch die Anzahl der
versteckten Einheiten des MLP geringer gewählt werden, wodurch sich
normalerweise die Trainingszeit und die Evaluierungs- und
Klassifikationszeit verringert.
Normalerweise sollte NumHidden in der Größenordnung von
NumInput und NumOutput gewählt werden. In vielen
Fällen führen auch viel kleinere Werte von NumHidden
schon zu sehr guten Klassifikationsergebnissen. Wenn
NumHidden zu groß gewählt wird, besteht die Gefahr, dass
das MLP sich an die Trainingsdaten überanpasst, was zu schlechten
Generalisierungseigenschaften führt, d.h. das MLP lernt die
Trainingsdaten sehr gut, liefert aber auf unbekannten Daten keine
besonders guten Ergebnisse.
create_class_mlp initialisiert die oben beschriebenen
Gewichte mit Zufallszahlen. Damit die Ergebnisse des Trainierens
des MLP mit train_class_mlp reproduzierbar werden, wird in
RandSeed der Initialisierungswert des
Zufallszahlengenerators angegeben. Falls das Training einen relativ
hohen Fehler zurückliefert, kann eventuell durch eine andere Wahl
von RandSeed und durch erneutes Trainieren ein kleinerer
Trainingsfehler erreicht werden.
Nachdem das MLP erzeugt wurde, werden typischerweise mit
add_sample_class_mlp oder read_samples_class_mlp
Trainingsdaten zum Netz hinzugefügt und das MLP mit
train_class_mlp trainiert. Daraufhin kann das MLP mit
write_class_mlp abgespeichert werden. Alternativ können
auch sofort nach dem Training Daten mit evaluate_class_mlp
bewertet werden oder (für OutputFunction =
'softmax') mit classify_class_mlp klassifiziert
werden.
Das Training des MLPs führt im Normalfall zu relativ scharfen
Grenzen zwischen den unterschiedlichen Klassen, d.h. die Konfidenz
für eine Klasse fällt von nahe 1 (innerhalb der Region einer Klasse)
auf nahe 0 (innerhalb der Region einer anderen Klasse) innerhalb
eines schmalen „Bandes“ im Merkmalsraum. Falls die Klassen sich
nicht überlappen, erfolgt dieser Übergang an einem geeigneten Ort
zwischen den Klassen; falls sich die Klassen überlappen, erfolgt
dieser Übergang an einem geeigneten Ort im Überlappungsbereich der
Klassen. Dieser scharfe Übergang ist in vielen Anwendungen
erwünscht. In einigen Anwendungen ist hingegen ein glatterer
Übergang zwischen verschiedenen Klassen wünschenswert (d.h. ein
Übergang in einem breiteren „Band“ im Merkmalsraum), um ein
gewisses Niveau an Unsicherheit in der Region zwischen den Klassen
auszudrücken. Weiterhin kann es, wie oben beschrieben,
wünschenswert sein, eine Überanpassung des MLPs an die
Trainingsdaten zu verhindern. Zu diesem Zweck kann das MLP mit
set_regularization_params_class_mlp regularisiert werden.
Ein wie oben definiertes MLP besitzt keine inhärente Fähigkeit zur
Neuheitserkennung, d.h. es klassifiziert zufällige Merkmalsvektoren
in eine der Klassen mit einer Konfidenz nahe 1 (außer der zufällige
Merkmalsvektor liegt zufälligerweise ein einer Region des
Merkmalsraums, in dem sich die Trainingsdaten von zwei Klassen
überlappen). In einigen Anwendungen ist es jedoch wünschenswert,
Merkmalsvektoren zurückzuweisen, die nicht nahe an irgendeiner
Klasse liegen, wobei „Nähe“ über die Distanz des Merkmalsvektors
zu der Menge der Merkmalsvektoren in den Trainingsdaten definiert
ist. Um das MLP mit der Fähigkeit zur Neuheitserkennung
auszustatten, d.h. um Merkmalsvektoren zurückweisen zu können, die
zu keiner Klasse gehören, kann eine explizite Rückweisungsklasse
erzeugt werden, indem NumOutput auf die Anzahl der
tatsächlichen Klassen plus 1 gesetzt wird. Danach kann
set_rejection_params_class_mlp verwendet werden, um
train_class_mlp so zu konfigurieren, dass automatisch
Trainingsdaten für diese Rüchweisungsklasse erzeugt werden.
Die Kombination der Regularisierung mit der automatischen Erzeugung
einer Rückweisungsklasse ist in vielen Anwendungen nützlich, da sie
einen glatten Übergang zwischen den tatsächlichen Klassen sowie von
den tatsächlichen Klassen zur Rückweisungsklasse erzeugt. Dies
spiegelt die Anforderungen dieser Anwendungen wieder, dass nur
Merkmalsvektoren innerhalb des Bereichs des Merkmalsraums, der den
Trainingsdaten entspricht, eine Konfidenz nahe 1 erhalten sollen,
während zufällige Merkmalsvektoren, die zu keiner Klasse gehören,
eine Konfidenz nahe 0 erhalten sollen, und dass Übergänge zwischen
den Klassen glatt sein sollen, was eine zunehmende Unsicherheit
wiederspiegelt, je weiter ein Merkmalsverktor von der jeweiligen
Klasse entfernt liegt. Insbesondere haben OCR-Anwendungen manchmal
diese Anforderung (siehe create_ocr_class_mlp).
Ein Vergleich zwischen MLP und Support-Vektor-Maschinen (SVM) (siehe
create_class_svm) zeigt typischerweise, dass SVMs generell
schneller traniert werden, insbesondere bei großen
Trainingsdatensätzen, und eine leicht verbesserte Erkennungsrate
haben. Das MLP weist schnellere Klassifikationszeiten auf und
sollte daher in zeitkritischen Anwendungen verwendet werden. Es ist
zu beachten, dass der Vergleich von optimal abgestimmten Parametern
ausgeht.
Dieser Operator liefert ein Handle zurück. Es ist zu beachten, dass der Zustand einer Instanz dieses Handletyps durch bestimmte Operatoren geändert werden kann, obwohl das Handle als Eingabeparameter in diesen Operatoren verwendet wird.
NumInput (input_control) integer → (integer)
Anzahl der Eingabevariablen (Merkmale) des MLP.
Defaultwert: 20
Wertevorschläge: 1, 2, 3, 4, 5, 8, 10, 15, 20, 30, 40, 50, 60, 70, 80, 90, 100
Restriktion: NumInput >= 1
NumHidden (input_control) integer → (integer)
Anzahl der versteckten Einheiten des MLP.
Defaultwert: 10
Wertevorschläge: 1, 2, 3, 4, 5, 8, 10, 15, 20, 30, 40, 50, 60, 70, 80, 90, 100, 120, 150
Restriktion: NumHidden >= 1
NumOutput (input_control) integer → (integer)
Anzahl der Ausgabevariablen (Klassen) des MLP.
Defaultwert: 5
Wertevorschläge: 1, 2, 3, 4, 5, 8, 10, 15, 20, 30, 40, 50, 60, 70, 80, 90, 100, 120, 150
Restriktion: NumOutput >= 1
OutputFunction (input_control) string → (string)
Art der Aktivierungsfunktion in der Ausgabeschicht des MLP.
Defaultwert: 'softmax'
Werteliste: 'linear', 'logistic', 'softmax'
Preprocessing (input_control) string → (string)
Art der Vorverarbeitung (Transformation) der Merkmalsvektoren.
Defaultwert: 'normalization'
Werteliste: 'canonical_variates', 'none', 'normalization', 'principal_components'
NumComponents (input_control) integer → (integer)
Parameter der Vorverarbeitung: Anzahl der
transformierten Merkmale (ignoriert bei
Preprocessing = 'none' und
Preprocessing = 'normalization').
Defaultwert: 10
Wertevorschläge: 1, 2, 3, 4, 5, 8, 10, 15, 20, 30, 40, 50, 60, 70, 80, 90, 100
Restriktion: NumComponents >= 1
RandSeed (input_control) integer → (integer)
Initialisierungswert des Zufallszahlengenerators, der zur Initialisierung des MLP mit zufälligen Werten verwendet wird.
Defaultwert: 42
MLPHandle (output_control) class_mlp → (handle)
Handle des MLP.
* Use the MLP for regression (function approximation)
create_class_mlp (1, NumHidden, 1, 'linear', 'none', 1, 42, MLPHandle)
* Generate the training data
* D = [...]
* T = [...]
* Add the training data
for J := 0 to NumData-1 by 1
add_sample_class_mlp (MLPHandle, D[J], T[J])
endfor
* Train the MLP
train_class_mlp (MLPHandle, 200, 0.001, 0.001, Error, ErrorLog)
* Generate test data
* X = [...]
* Compute the output of the MLP on the test data
for J := 0 to N-1 by 1
evaluate_class_mlp (MLPHandle, X[J], Y)
endfor
* Use the MLP for classification
create_class_mlp (NumIn, NumHidden, NumOut, 'softmax', \
'normalization', NumIn, 42, MLPHandle)
* Generate and add the training data
for J := 0 to NumData-1 by 1
* Generate training features and classes
* Data = [...]
* Class = [...]
add_sample_class_mlp (MLPHandle, Data, Class)
endfor
* Train the MLP
train_class_mlp (MLPHandle, 100, 1, 0.01, Error, ErrorLog)
* Use the MLP to classify unknown data
for J := 0 to N-1 by 1
* Extract features
* Features = [...]
classify_class_mlp (MLPHandle, Features, 1, Class, Confidence)
endfor
Sind die Parameterwerte korrekt, dann liefert
create_class_mlp den Wert 2 (H_MSG_TRUE). Gegebenenfalls wird eine
Fehlerbehandlung durchgeführt.
add_sample_class_mlp,
set_regularization_params_class_mlp,
set_rejection_params_class_mlp
read_dl_classifier,
create_class_svm,
create_class_gmm
clear_class_mlp,
train_class_mlp,
classify_class_mlp,
evaluate_class_mlp
Christopher M. Bishop: „Neural Networks for Pattern Recognition“;
Oxford University Press, Oxford; 1995.
Andrew Webb: „Statistical Pattern Recognition“; Arnold, London;
1999.
Foundation