| Operatoren |
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 x_i, dem so genannten Merkmalsvektor, folgende Berechnungsschritte aus, um die Aktivierungen z_j der versteckten Schicht zu berechnen:
n_i
----
(1) \ (1) (1)
a = / w x + b , j = 1,...,n_h
j ---- ji i j
i=1
/ (1) \
z = tanh | a | , j = 1,...,n_h
j \ j /
Die Matrix w_ji^(1) und der Vektor b_j^(1) sind dabei die Gewichte der Eingabeschicht (ersten Schicht) des MLP. Die Aktivierungen z_j der ersten Schicht werden in der versteckten Schicht (zweiten Schicht) zunächst genauso durch Linearkombinationen transformiert, wie in der ersten Schicht:
n_h
----
(2) \ (2) (2)
a = / w z + b , k = 1,...,n_o
k ---- kj j k
j=1
Dabei sind die Matrix w_kj^(2) und der Vektor b_k^(2) 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:
(2)
y = a , k = 1,...,n_o
k k
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:
1
y = ------------------ , k = 1,...,n_o
k / (2) \
1 + exp | - a |
\ k /
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:
/ (2) \
exp | a |
\ k /
y = ---------------- , k = 1,...,n_o
k n_o
---- / (2) \
\ exp | a |
/ \ l /
----
l=1
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.
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.
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
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
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
Art der Aktivierungsfunktion in der Ausgabeschicht des MLP.
Defaultwert: 'softmax'
Werteliste: 'linear', 'logistic', 'softmax'
Art der Vorverarbeitung (Transformation) der Merkmalsvektoren.
Defaultwert: 'normalization'
Werteliste: 'canonical_variates', 'none', 'normalization', 'principal_components'
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
Initialisierungswert des Zufallszahlengenerators, der zur Initialisierung des MLP mit zufälligen Werten verwendet wird.
Defaultwert: 42
Handle des MLP.
* Use the MLP for regression (function approximation)
create_class_mlp (1, NHidden, 1, 'linear', 'none', 1, 42, MLPHandle)
* Generate the training data
* D = [...]
* T = [...]
* Add the training data
for J := 0 to NData-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
clear_class_mlp (MLPHandle)
* Use the MLP for classification
create_class_mlp (NIn, NHidden, NOut, 'softmax', 'normalization', NIn,\
42, MLPHandle)
* Generate and add the training data
for J := 0 to NData-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
clear_class_mlp (MLPHandle)
Sind die Parameterwerte korrekt, dann liefert create_class_mlp den Wert 2 (H_MSG_TRUE). Gegebenenfalls wird eine Fehlerbehandlung durchgeführt.
create_class_svm, create_class_gmm, create_class_box
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
| Operatoren |