train_class_mlpT_train_class_mlpTrainClassMlpTrainClassMlptrain_class_mlp (Operator)

Name

train_class_mlpT_train_class_mlpTrainClassMlpTrainClassMlptrain_class_mlp — Trainieren eines mehrschichtigen Perzeptrons.

Signatur

train_class_mlp( : : MLPHandle, MaxIterations, WeightTolerance, ErrorTolerance : Error, ErrorLog)

Herror T_train_class_mlp(const Htuple MLPHandle, const Htuple MaxIterations, const Htuple WeightTolerance, const Htuple ErrorTolerance, Htuple* Error, Htuple* ErrorLog)

void TrainClassMlp(const HTuple& MLPHandle, const HTuple& MaxIterations, const HTuple& WeightTolerance, const HTuple& ErrorTolerance, HTuple* Error, HTuple* ErrorLog)

double HClassMlp::TrainClassMlp(Hlong MaxIterations, double WeightTolerance, double ErrorTolerance, HTuple* ErrorLog) const

static void HOperatorSet.TrainClassMlp(HTuple MLPHandle, HTuple maxIterations, HTuple weightTolerance, HTuple errorTolerance, out HTuple error, out HTuple errorLog)

double HClassMlp.TrainClassMlp(int maxIterations, double weightTolerance, double errorTolerance, out HTuple errorLog)

def train_class_mlp(mlphandle: HHandle, max_iterations: int, weight_tolerance: float, error_tolerance: float) -> Tuple[float, Sequence[float]]

Beschreibung

train_class_mlptrain_class_mlpTrainClassMlpTrainClassMlpTrainClassMlptrain_class_mlp trainiert das durch MLPHandleMLPHandleMLPHandleMLPHandleMLPHandlemlphandle angegebene mehrschichtige Perzeptron (MLP). Bevor das MLP trainiert werden kann, müssen mit add_sample_class_mlpadd_sample_class_mlpAddSampleClassMlpAddSampleClassMlpAddSampleClassMlpadd_sample_class_mlp oder read_samples_class_mlpread_samples_class_mlpReadSamplesClassMlpReadSamplesClassMlpReadSamplesClassMlpread_samples_class_mlp alle zum Training zu verwendenden Trainingsmuster in dem MLP abgespeichert werden. Falls nach dem Training neue zusätzliche Trainingsmuster zum Trainieren verwendet werden sollen, muss ein neues MLP mit create_class_mlpcreate_class_mlpCreateClassMlpCreateClassMlpCreateClassMlpcreate_class_mlp erzeugt werden, bei dem wiederum alle zum Training zu verwendenden Trainingsmuster (also die ursprünglichen und die zusätzlich zu verwendenden) abgespeichert werden. Hierbei empfiehlt sich die Verwendung von write_samples_class_mlpwrite_samples_class_mlpWriteSamplesClassMlpWriteSamplesClassMlpWriteSamplesClassMlpwrite_samples_class_mlp und read_samples_class_mlpread_samples_class_mlpReadSamplesClassMlpReadSamplesClassMlpReadSamplesClassMlpread_samples_class_mlp. Ein Nachtrainieren mit neuen Trainingsmustern ist programmtechnisch zwar nicht verboten, führt aber typischerweise nicht zu guten Ergebnissen, da das Training eines MLP ein komplexes nichtlineares Optimierungsproblem ist, und das mehrmalige Trainieren mit neuen Trainingsdaten mit hoher Wahrscheinlichkeit dazu führt, dass die Optimierung in einem lokalen Minimum steckenbleibt.

Falls eine Rückweisungsklasse mittels set_rejection_params_class_mlpset_rejection_params_class_mlpSetRejectionParamsClassMlpSetRejectionParamsClassMlpSetRejectionParamsClassMlpset_rejection_params_class_mlp spezifiziert wurde, werden vor dem eigentlichen Training die Trainingsdaten für die Rückweisungsklasse erzeugt.

Beim Training wird der Fehler, den das MLP auf den gespeicherten Trainingsdaten erzielt, durch ein nichtlineares Optimierungsverfahren minimiert. Falls das MLP mittels set_regularization_params_class_mlpset_regularization_params_class_mlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpset_regularization_params_class_mlp regularisiert wurde, wird ein zusätzlicher Gewichtsstrafterm berücksichtigt. Dadurch werden die bei create_class_mlpcreate_class_mlpCreateClassMlpCreateClassMlpCreateClassMlpcreate_class_mlp beschriebenen Gewichte des MLP bestimmt. Falls mittels set_regularization_params_class_mlpset_regularization_params_class_mlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpset_regularization_params_class_mlp eine automatische Bestimmung der Regularisierungsparameter spezifiziert wurde, werden auch diese Parameter optimiert. Wie bei set_regularization_params_class_mlpset_regularization_params_class_mlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpset_regularization_params_class_mlp beschrieben, benötigt das Training eines MLPs bei gleichzeitiger Bestimmung der Regularisierungsparameter signifikant mehr Zeit als das Training eines unregularisierten MLPs oder eines MLPs mit festen Regularisierungsparametern.

Als Startwerte werden die Gewichte von create_class_mlpcreate_class_mlpCreateClassMlpCreateClassMlpCreateClassMlpcreate_class_mlp auf zufällige Werte gesetzt, um mit hoher Wahrscheinlichkeit zu ermöglichen, dass die Optimierung zum globalen Minimum der Fehlerfunktion konvergiert. Nichtsdestotrotz kann es eventuell dazu kommen, dass mit den durch RandSeed in create_class_mlpcreate_class_mlpCreateClassMlpCreateClassMlpCreateClassMlpcreate_class_mlp festgelegten Werten ein relativ hoher Fehler als optimaler Wert bestimmt wird, d.h., dass die Optimierung in einem lokalen Minimum steckenbleibt. Falls vermutet werden kann, dass dies passiert ist, sollte ein neues Netz mit einem anderen Wert für RandSeed erzeugt werden, um zu überprüfen, ob ein signifikant kleinerer Fehler erzeugt werden kann.

Die Parameter MaxIterationsMaxIterationsMaxIterationsMaxIterationsmaxIterationsmax_iterations, WeightToleranceWeightToleranceWeightToleranceWeightToleranceweightToleranceweight_tolerance und ErrorToleranceErrorToleranceErrorToleranceErrorToleranceerrorToleranceerror_tolerance dienen der Steuerung des nichtlinearen Optimierungsverfahrens. Es ist zu beachten, dass diese Parameter sich auf ein Training innerhalb eines Schrittes der Evidenzprozedur beziehen, falls mittels set_regularization_params_class_mlpset_regularization_params_class_mlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpset_regularization_params_class_mlp eine automatische Bestimmung der Regularisierungsparameter spezifiziert wurde. MaxIterationsMaxIterationsMaxIterationsMaxIterationsmaxIterationsmax_iterations spezifiziert die maximale Anzahl von Iterationen des Optimierungsverfahrens. In der Praxis sollten Werte zwischen 100 und 200 ausreichend für die meisten Probleme sein. WeightToleranceWeightToleranceWeightToleranceWeightToleranceweightToleranceweight_tolerance spezifiziert eine Schwelle für die Änderung der Gewichte pro Iteration. Dabei wird der Betrag der Änderung der Gewichte aufsummiert. Dieser Wert hängt also von der Anzahl der Gewichte im MLP und der Größe der Gewichte ab, welche wiederum von der Skalierung der Eingabedaten abhängt. Typischerweise sollten hier Werte zwischen 0.00001 und 1 vorgegeben werden. ErrorToleranceErrorToleranceErrorToleranceErrorToleranceerrorToleranceerror_tolerance spezifiziert eine Schwelle für die Änderung des Fehlerwertes pro Iteration. Hier hängt der Wert von der Anzahl der Trainingsdaten und der Anzahl der Ausgabevariablen ab. Auch hier sollten typischerweise Werte zwischen 0.00001 und 1 vorgegeben werden. Die Optimierung wird beendet, falls die Gewichtsänderung in einer Iteration unter WeightToleranceWeightToleranceWeightToleranceWeightToleranceweightToleranceweight_tolerance und die Änderung des Fehlers unter ErrorToleranceErrorToleranceErrorToleranceErrorToleranceerrorToleranceerror_tolerance liegt. Spätestens nach MaxIterationsMaxIterationsMaxIterationsMaxIterationsmaxIterationsmax_iterations Iterationen wird die Optimierung aber auf jeden Fall beendet. Es ist zu beachten, dass je nach Größe des MLP und der Anzahl der Trainingsmuster das Trainieren zwischen wenigen Sekunden und einigen Stunden dauern kann.

Als Ausgabe liefert train_class_mlptrain_class_mlpTrainClassMlpTrainClassMlpTrainClassMlptrain_class_mlp in ErrorErrorErrorErrorerrorerror den Fehler mit den optimalen Gewichten des MLP auf den Trainingsdaten zurück. Außerdem wird in ErrorLogErrorLogErrorLogErrorLogerrorLogerror_log der Fehler des MLP pro Iteration zurückgeliefert. Somit ist ErrorErrorErrorErrorerrorerror der letzte Wert von ErrorLogErrorLogErrorLogErrorLogerrorLogerror_log. Der Verlauf des Fehlers in ErrorLogErrorLogErrorLogErrorLogerrorLogerror_log kann dazu verwendet werden, zu entscheiden, ob ein nochmaliges Training des MLP mit train_class_mlptrain_class_mlpTrainClassMlpTrainClassMlpTrainClassMlptrain_class_mlp mit denselben Trainingsdaten ohne das MLP neu zu erzeugen sinnvoll ist. Als Funktion betrachtet sollte ErrorLogErrorLogErrorLogErrorLogerrorLogerror_log am Anfang steil abfallen und zum Ende hin sehr flach werden. Falls ErrorLogErrorLogErrorLogErrorLogerrorLogerror_log am Ende noch relativ steil ist, ist normalerweise ein erneuter Aufruf von train_class_mlptrain_class_mlpTrainClassMlpTrainClassMlpTrainClassMlptrain_class_mlp sinnvoll. Es ist zu beachten, dass dieser Mechanismus nicht dazu verwendet werden sollte, das MLP jeweils mit MaxIterationsMaxIterationsMaxIterationsMaxIterationsmaxIterationsmax_iterations = 1 (oder anderen sehr kleinen Werten von MaxIterationsMaxIterationsMaxIterationsMaxIterationsmaxIterationsmax_iterations) zu trainieren, da dadurch die Anzahl der nötigen Iterationen erheblich steigt. Falls mittels set_regularization_params_class_mlpset_regularization_params_class_mlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpset_regularization_params_class_mlp eine automatische Bestimmung der Regularisierungsparameter spezifiziert wurde, beziehen sich ErrorErrorErrorErrorerrorerror und ErrorLogErrorLogErrorLogErrorLogerrorLogerror_log auf das letzte Training, das innerhalb der Evidenzprozedur ausgeführt wurde. Falls der Fehlerverlauf innerhalb der einzelnen Iterationen der Evidenzprozedur beobachtet werden soll, muss die äußere Iteration der Evidenzprozedur explizit, wie bei set_regularization_params_class_mlpset_regularization_params_class_mlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpset_regularization_params_class_mlp beschrieben, implementiert werden.

Ausführungsinformationen

Dieser Operator modifiziert den Zustand des folgenden Eingabeparameters:

Während der Ausführung dieses Operators muss der Zugriff auf den Wert dieses Parameters synchronisiert werden, wenn er über mehrere Threads hinweg verwendet wird.

Parameter

MLPHandleMLPHandleMLPHandleMLPHandleMLPHandlemlphandle (input_control, Zustand wird modifiziert)  class_mlp HClassMlp, HTupleHHandleHTupleHtuple (handle) (IntPtr) (HHandle) (handle)

Handle des MLP.

MaxIterationsMaxIterationsMaxIterationsMaxIterationsmaxIterationsmax_iterations (input_control)  integer HTupleintHTupleHtuple (integer) (int / long) (Hlong) (Hlong)

Maximale Anzahl von Iterationen des Optimierungsverfahrens.

Defaultwert: 200

Wertevorschläge: 20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 220, 240, 260, 280, 300

WeightToleranceWeightToleranceWeightToleranceWeightToleranceweightToleranceweight_tolerance (input_control)  real HTuplefloatHTupleHtuple (real) (double) (double) (double)

Schwellenwert für den Unterschied der Gewichte des MLP zwischen zwei Iterationen des Optimierungsverfahrens.

Defaultwert: 1.0

Wertevorschläge: 1.0, 0.1, 0.01, 0.001, 0.0001, 0.00001

Restriktion: WeightTolerance >= 1.0e-8

ErrorToleranceErrorToleranceErrorToleranceErrorToleranceerrorToleranceerror_tolerance (input_control)  real HTuplefloatHTupleHtuple (real) (double) (double) (double)

Schwellenwert für den Unterschied des mittleren Fehlers des MLP auf den Trainingsdaten zwischen zwei Iterationen des Optimierungsverfahrens.

Defaultwert: 0.01

Wertevorschläge: 1.0, 0.1, 0.01, 0.001, 0.0001, 0.00001

Restriktion: ErrorTolerance >= 1.0e-8

ErrorErrorErrorErrorerrorerror (output_control)  real HTuplefloatHTupleHtuple (real) (double) (double) (double)

Mittlerer Fehler des MLP auf den Trainingsdaten.

ErrorLogErrorLogErrorLogErrorLogerrorLogerror_log (output_control)  real-array HTupleSequence[float]HTupleHtuple (real) (double) (double) (double)

Mittlerer Fehler des MLP auf den Trainingsdaten pro Iteration des Optimierungsverfahrens.

Beispiel (HDevelop)

* Train an MLP
create_class_mlp (NumIn, NumHidden, NumOut, 'softmax', \
                  'normalization', 1, 42, MLPHandle)
read_samples_class_mlp (MLPHandle, 'samples.mtf')
train_class_mlp (MLPHandle, 100, 1, 0.01, Error, ErrorLog)
write_class_mlp (MLPHandle, 'classifier.mlp')

Ergebnis

Sind die Parameterwerte korrekt, dann liefert train_class_mlptrain_class_mlpTrainClassMlpTrainClassMlpTrainClassMlptrain_class_mlp den Wert TRUE. Gegebenenfalls wird eine Fehlerbehandlung durchgeführt.

Falls train_class_mlptrain_class_mlpTrainClassMlpTrainClassMlpTrainClassMlptrain_class_mlp den Fehler 9211 (Matrix ist nicht positiv definit) bei Preprocessing = 'canonical_variates'"canonical_variates""canonical_variates""canonical_variates""canonical_variates""canonical_variates" zurückliefert, bedeutet dies typischerweise, dass für die verschiedenen Klassen zu wenige Trainingsmuster gespeichert worden sind.

Vorgänger

add_sample_class_mlpadd_sample_class_mlpAddSampleClassMlpAddSampleClassMlpAddSampleClassMlpadd_sample_class_mlp, read_samples_class_mlpread_samples_class_mlpReadSamplesClassMlpReadSamplesClassMlpReadSamplesClassMlpread_samples_class_mlp, set_regularization_params_class_mlpset_regularization_params_class_mlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpSetRegularizationParamsClassMlpset_regularization_params_class_mlp

Nachfolger

evaluate_class_mlpevaluate_class_mlpEvaluateClassMlpEvaluateClassMlpEvaluateClassMlpevaluate_class_mlp, classify_class_mlpclassify_class_mlpClassifyClassMlpClassifyClassMlpClassifyClassMlpclassify_class_mlp, write_class_mlpwrite_class_mlpWriteClassMlpWriteClassMlpWriteClassMlpwrite_class_mlp, create_class_lut_mlpcreate_class_lut_mlpCreateClassLutMlpCreateClassLutMlpCreateClassLutMlpcreate_class_lut_mlp

Alternativen

train_dl_classifier_batchtrain_dl_classifier_batchTrainDlClassifierBatchTrainDlClassifierBatchTrainDlClassifierBatchtrain_dl_classifier_batch, read_class_mlpread_class_mlpReadClassMlpReadClassMlpReadClassMlpread_class_mlp

Siehe auch

create_class_mlpcreate_class_mlpCreateClassMlpCreateClassMlpCreateClassMlpcreate_class_mlp

Literatur

Christopher M. Bishop: „Neural Networks for Pattern Recognition“; Oxford University Press, Oxford; 1995.
Andrew Webb: „Statistical Pattern Recognition“; Arnold, London; 1999.

Modul

Foundation