| 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 , dem so genannten Merkmalsvektor, folgende Berechnungsschritte aus, um die Aktivierungen der versteckten Schicht zu berechnen:
Durch Setzen von OutputFunction kann die Aktivierungsfunktion der Ausgabeschicht festgelegt werden. Für OutputFunction = 'linear' werden die Daten einfach kopiert:
Für OutputFunction = 'logistic' werden die Aktivierungen wie folgt berechnet:
Für OutputFunction = 'softmax' werden die Aktivierungen wie folgt berechnet:
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.
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, 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
clear_class_mlp (MLPHandle)
* 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
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.
add_sample_class_mlp, set_regularization_params_class_mlp, set_rejection_params_class_mlp
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
| Operatoren |