train

Trainieren von flachen neuronalen Netzen

alle in Seite reduzieren

Syntax

trainedNet = train(net,X,T,Xi,Ai,EW)
[trainedNet,tr] = train(net,X,T,Xi,Ai,EW)
[trainedNet,tr] = train(net,X,T,Xi,Ai,EW,Name,Value)

Beschreibung

Diese Funktion trainiert ein flaches neuronales Netz. Verwenden Sie zum Training von Deep-Learning-Netzen (wie Faltungs-Netzen oder LSTM-Netzen) die trainnet-Funktion.

trainedNet = train(net,X,T,Xi,Ai,EW) trainiert ein Netz net gemäß net.trainFcn und net.trainParam.

Beispiel

[trainedNet,tr] = train(net,X,T,Xi,Ai,EW) gibt zudem einen Trainingsdatensatz aus.

[trainedNet,tr] = train(net,X,T,Xi,Ai,EW,Name,Value) trainiert ein Netz mit weiteren Optionen, die durch eines oder mehrere Name-Wert-Paar-Argumente angegeben werden.

Beispiel

Beispiele

alle reduzieren

Hier definieren der Eingang x und die Ziele t eine einfache Funktion, die Sie darstellen können:

x = [0 1 2 3 4 5 6 7 8];
t = [0 0.84 0.91 0.14 -0.77 -0.96 -0.28 0.66 0.99];
plot(x,t,'o')

Hier erstellt feedforwardnet ein zweischichtiges Feed-Forward-Netz. Das Netz weist eine verborgene Schicht mit zehn Neuronen auf.

net = feedforwardnet(10);
net = configure(net,x,t);
y1 = net(x)
plot(x,t,'o',x,y1,'x')

Das Netz wird trainiert und daraufhin erneut simuliert.

net = train(net,x,t);
y2 = net(x)
plot(x,t,'o',x,y1,'x',x,y2,'*')

In diesem Beispiel wird ein nichtlineares, autoregressives Open-Loop-Netz mit externem Eingang trainiert, das ein schwebendes Magnetsystem modelliert, das durch einen Regelstrom x und die vertikale Positionsantwort t des Magneten definiert ist. Die preparets-Funktion bereitet die Daten vor Training und Simulation vor. Sie erstellt die kombinierten Eingänge xo des Open-Loop-Netzes; dies enthält sowohl den externen Eingang x als auch die vorherigen Positionswerte t. Zudem bereitet die Funktion die Verzögerungszustände xi vor.

[x,t] = maglev_dataset;
net = narxnet(10);
[xo,xi,~,to] = preparets(net,x,{},t);
net = train(net,xo,to,xi);
y = net(xo,xi)

Dieses System kann zudem in Closed-Loop-Form simuliert werden.

netc = closeloop(net);
view(netc)
[xc,xi,ai,tc] = preparets(netc,x,{},t);
yc = netc(xc,xi,ai);

Wenn Sie über Hardwareressourcen verfügen, die während des Trainings nicht genutzt werden, können Sie unter Umständen durch paralleles Training Ihr Netz schneller trainieren und Datensätze verwenden, die andernfalls die Speicherkapazität überschreiten würden. Zum parallelen Training eines Netzes wird Parallel Computing Toolbox™ benötigt. Unterstützt wird nur Backpropagation-Training, kein Training für selbstorganisierende Karten.

Hier finden Training und Simulation über parallele MATLAB-Worker hinweg statt.

[X,T] = vinyl_dataset;
net = feedforwardnet(10);
net = train(net,X,T,'useParallel','yes','showResources','yes');
Y = net(X);

Verwenden Sie Composite-Werte, um die Daten manuell zu verteilen; die Ergebnisse werden ebenfalls als Composite-Wert ausgegeben. Werden die Daten beim Verteilen geladen, muss jeder Teil des Datensatzes in den RAM-Speicher passen. Die Größe des vollständigen Datensatzes ist nur durch den gesamten RAM aller Worker begrenzt.

[X,T] = vinyl_dataset;
Q = size(X,2);
Xc = Composite;
Tc = Composite;
numWorkers = numel(Xc);
ind = [0 ceil((1:numWorkers)*(Q/numWorkers))];
for i=1:numWorkers
    indi = (ind(i)+1):ind(i+1);
    Xc{i} = X(:,indi);
    Tc{i} = T(:,indi);
end
net = feedforwardnet;
net = configure(net,X,T);
net = train(net,Xc,Tc);
Yc = net(Xc);

Beachten Sie, dass im obenstehenden Beispiel die configure-Funktion verwendet wurde, um die Dimensionen und Verarbeitungseinstellungen der Netzeingänge festzulegen. Dies geschieht normalerweise automatisch, wenn die Trainingsfunktion aufgerufen wird. Werden jedoch Composite-Daten genutzt, muss dieser Schritt mit Nicht-Composite-Daten manuell durchgeführt werden.

Netze können mit einer vorhandenen Grafikkarte trainiert werden, wenn diese von Parallel Computing Toolbox unterstützt wird. Grafikkarten-Training wird aktuell nur für Backpropagation-Training, nicht für selbstorganisierende Karten unterstützt. 

[X,T] = vinyl_dataset;
net = feedforwardnet(10);
net = train(net,X,T,'useGPU','yes');
y = net(X);

Um die Daten manuell auf eine Grafikkarte zu verlegen:

[X,T] = vinyl_dataset;
Xgpu = gpuArray(X);
Tgpu = gpuArray(T);
net = configure(net,X,T);
net = train(net,Xgpu,Tgpu);
Ygpu = net(Xgpu);
Y = gather(Ygpu);

Beachten Sie, dass im obenstehenden Beispiel die „Configure“-Funktion verwendet wurde, um die Dimensionen und Verarbeitungseinstellungen der Netzeingänge festzulegen. Dies geschieht normalerweise automatisch, wenn die Trainingsfunktion aufgerufen wird. Werden jedoch gpuArray-Daten genutzt, muss dieser Schritt mit Nicht-gpuArray-Daten manuell durchgeführt werden.

Beachten Sie bei einer parallelen Verarbeitung, bei der Worker jeweils einer Grafikkarte zugewiesen sind und weitere Worker auf der CPU laufen: 

net = train(net,X,T,'useParallel','yes','useGPU','yes');
y = net(X);

Nur Worker mit eigener Grafikkarte zu verwenden, kann zu einer höheren Geschwindigkeit führen, da die Geschwindigkeit der CPU-Worker niedriger sein könnte.

net = train(net,X,T,'useParallel','yes','useGPU','only');
Y = net(X);

Hier wird ein Netz mithilfe von Checkpoints trainiert, die höchstens alle zwei Minuten gespeichert werden.

[x,t] = vinyl_dataset;
net = fitnet([60 30]);
net = train(net,x,t,'CheckpointFile','MyCheckpoint','CheckpointDelay',120);

Fällt der Computer aus, kann das letzte Netz wiederhergestellt und das Training ab diesem Punkt fortgesetzt werden. Die Checkpoint-Datei umfasst eine Strukturvariable checkpoint, die das Netz, den Trainingsdatensatz, den Dateinamen, die Uhrzeit und Nummer umfasst.

[x,t] = vinyl_dataset;
load MyCheckpoint
net = checkpoint.net;
net = train(net,x,t,'CheckpointFile','MyCheckpoint');

Eingabeargumente

alle reduzieren

Eingangsnetz, angegeben als ein network-Objekt. Um ein network-Objekt zu erstellen, verwenden Sie beispielsweise entweder feedforwardnet oder narxnet.

Netzeingänge, angegeben als eine R-mal-Q-Matrix oder ein Ni-mal-TS-Zellen-Array, wobei

  • R die Eingangsgröße,

  • Q die Batchgröße,

  • Ni = net.numInputs

  • TS die Anzahl der Zeitschritte ist.

train-Argumente können zwei Formate aufweisen: Matrizen für statische Probleme und Netze mit einem Eingang und Ausgang und Zellen-Arrays für mehrere Zeitschritte und Netze mit mehreren Eingängen und Ausgängen.

  • Das Matrixformat kann verwendet werden, wenn nur ein Zeitschritt simuliert werden muss (TS = 1). Dies ist für Netze mit nur einem Eingang und Ausgang nützlich, kann jedoch auch für Netze mit mehreren Eingängen und Ausgänge genutzt werden. Wenn das Netz über mehrere Eingänge verfügt, ist die Matrixgröße (Summe von Ri)-mal-Q.

  • Das Zellen-Array ist ein allgemeineres Format und eignet sich besser für Netze mit mehreren Eingängen und Ausgängen, da Eingangssequenzen bereitgestellt werden können. Jedes Element X{i,ts} ist eine Ri-mal-Q-Matrix, wobei Ri = net.inputs{i}.size ist.

Werden Composite-Daten verwendet, wird 'useParallel' automatisch auf 'yes' gesetzt. Die Funktion akzeptiert Composite-Daten und gibt Composite-Ergebnisse aus.

Werden gpuArray-Daten verwendet, wird 'useGPU' automatisch auf 'yes' gesetzt. Die Funktion akzeptiert gpuArray-Daten und gibt gpuArray-Ergebnisse aus.

Hinweis

Wenn eine Spalte von X mindestens ein NaN umfasst, verwendet train diese Spalte nicht für Training, Tests oder Validierung.

Ziele des Netzes, angegeben als U-mal-Q-Matrix oder No-mal-TS-Zellen-Array, wobei

  • U die Ausgangsgröße

  • Q die Batchgröße,

  • No = net.numOutputs

  • TS die Anzahl der Zeitschritte ist.

train-Argumente können zwei Formate aufweisen: Matrizen für statische Probleme und Netze mit einem Eingang und Ausgang und Zellen-Arrays für mehrere Zeitschritte und Netze mit mehreren Eingängen und Ausgängen.

  • Das Matrixformat kann verwendet werden, wenn nur ein Zeitschritt simuliert werden muss (TS = 1). Dies ist für Netze mit nur einem Eingang und Ausgang nützlich, kann jedoch auch für Netze mit mehreren Eingängen und Ausgänge genutzt werden. Wenn das Netz über mehrere Eingänge verfügt, ist die Matrixgröße (Summe von Ui)-mal-Q.

  • Das Zellen-Array ist ein allgemeineres Format und eignet sich besser für Netze mit mehreren Eingängen und Ausgängen, da Eingangssequenzen bereitgestellt werden können. Jedes Element T{i,ts} ist eine Ui-mal-Q-Matrix, wobei Ui = net.outputs{i}.size ist.

Werden Composite-Daten verwendet, wird 'useParallel' automatisch auf 'yes' gesetzt. Die Funktion akzeptiert Composite-Daten und gibt Composite-Ergebnisse aus.

Werden gpuArray-Daten verwendet, wird 'useGPU' automatisch auf 'yes' gesetzt. Die Funktion akzeptiert gpuArray-Daten und gibt gpuArray-Ergebnisse aus.

Beachten Sie, dass T optional ist und nur für Netze verwendet werden muss, die Ziele benötigen.

Hinweis

NaN-Werte in den Zielen T werden als fehlende Daten behandelt. Wenn ein Element von T NaN ist, wird dieses Element nicht für Training, Tests oder Validierung verwendet.

Anfängliche Eingangs-Verzögerungsbedingungen, angegeben als ein Ni-mal-ID-Zellen-Array oder eine R-mal-(ID*Q)-Matrix, wobei

  • ID = net.numInputDelays

  • Ni = net.numInputs

  • R die Eingangsgröße,

  • Q die Batchgröße ist.

Bei einem Zellen-Array-Eingang werden die Spalten Xi von der ältesten zur neuesten Verzögerungsbedingung sortiert: Xi{i,k} ist der Eingang i zum Zeitpunkt ts = k - ID.

Xi ist ebenfalls optional und muss nur für Netze mit Eingangs- oder Schichtverzögerungen verwendet werden.

Anfängliche Schicht-Verzögerungsbedingungen, angegeben als ein Nl-mal-LD-Zellen-Array oder eine (Summe von Si)-mal-(LD*Q)-Matrix, wobei

  • Nl = net.numLayers

  • LD = net.numLayerDelays

  • Si = net.layers{i}.size

  • Q die Batchgröße ist.

Bei einem Zellen-Array-Eingang werden die Spalten Ai von der ältesten zur neuesten Verzögerungsbedingung sortiert: Ai{i,k} ist der Schichtausgang i zum Zeitpunkt ts = k - LD.

Fehlergewichte, angegeben als ein No-mal-TS-Zellen-Array oder eine (Summe von Ui)-mal-Q-Matrix, wobei

  • No = net.numOutputs

  • TS die Anzahl der Zeitschritte ist,

  • Ui = net.outputs{i}.size

  • Q die Batchgröße ist.

Bei dem Zellen-Array-Eingang ist jedes Element EW{i,ts} eine Ui-mal-Q-Matrix, wobei

  • Ui = net.outputs{i}.size

  • Q die Batchgröße ist.

Die Fehlergewichte EW können zudem anstelle von No, TS, Ui oder Q die Größe 1 aufweisen. In diesem Fall werden die Dimensionen von EW automatisch gemäß der Ziele T erweitert. Dies ermöglicht es, die Wichtigkeit in einer beliebigen Dimension (z. B. pro Sample) einfach zu gewichten, wobei einer anderen Dimension (z. B. der Zeit, mit TS=1) dieselbe Wichtigkeit zugewiesen wird. Sind alle Dimensionen 1, beispielsweise wenn EW = {1}, werden alle Zielwerte gleich wichtig behandelt. Dies ist der Standardwert von EW.

Wie oben angegeben, können die Fehlergewichte EW dieselben Dimensionen wie die Ziele T aufweisen, oder es können mehrere Dimensionen auf 1 gesetzt werden. Wenn EW beispielsweise 1-mal-Q ist, weisen die Ziel-Samples unterschiedliche Wichtigkeit auf, jedes Element eines Samples weist jedoch dieselbe Wichtigkeit auf. Wenn EW (Summe von Ui)-mal-1 entspricht, weist jedes Ausgangselement eine andere Wichtigkeit auf, alle Samples werden jedoch gleich wichtig behandelt.

Name-Wert-Argumente

alle reduzieren

Sie können optionale Argumentpaare als Name1=Value1,...,NameN=ValueN angeben, wobei Name der Name des Arguments und Value der entsprechende Wert ist. Namen-Wert-Argumente müssen nach anderen Argumenten erscheinen, die Reihenfolge der Paare ist jedoch nicht relevant.

Verwenden Sie in Versionen vor R2021a Kommas, um jeden Namen und Wert zu trennen und setzen Sie Name in Anführungszeichen.

Beispiel: 'useParallel','yes'

Option zum Festlegen paralleler Berechnungen, angegeben als 'yes' oder 'no'.

  • 'no' – Berechnungen werden im normalen MATLAB-Thread durchgeführt. Dies ist die Standardeinstellung von 'useParallel'.

  • 'yes' – Berechnungen werden auf parallelen Workern durchgeführt, wenn ein Parallel-Pool offen ist. Ist kein Parallel-Pool offen, startet die Software einen Pool gemäß dem Standard-Clusterprofil.

Option zum Festlegen von Grafikkarten-Berechnungen, angegeben als 'yes', 'no' oder 'only'.

  • 'no' – Berechnungen werden auf der CPU durchgeführt. Dies ist die Standardeinstellung von 'useGPU'.

  • 'yes' – Berechnungen treten auf dem vorliegenden gpuDevice auf, wenn es sich um eine unterstützte Grafikkarte handelt (Anforderungen an die Grafikkarte finden Sie unter Parallel Computing Toolbox.) Wird der vorliegende gpuDevice nicht unterstützt, werden Berechnungen weiterhin auf der CPU durchgeführt. Wenn 'useParallel' ebenfalls auf 'yes' gesetzt ist und ein Parallel Pool offen ist, verwendet jeder Worker mit einer eigenen Grafikkarte diese Grafikkarte; die anderen Worker führen Berechnungen auf ihren CPU-Kernen aus.

  • 'only' – Ist kein Parallel Pool offen, ist diese Einstellung identisch zu 'yes'. Ist ein Parallel Pool offen, werden nur Worker mit eigenen Grafikkarten verwendet. Ist ein Parallel Pool offen, sind jedoch keine unterstützten Grafikkarten verfügbar, werden die Berechnungen stattdessen auf allen Worker-CPUs durchgeführt.

Option zum Anzeigen der Ressourcen, angegeben als 'yes' oder 'no'.

  • 'no' – Zeigt die genutzten Berechnungsressourcen nicht in der Befehlszeile an. Dies ist die Standardeinstellung.

  • 'yes' – Zeigt eine Zusammenfassung der tatsächlich genutzten Berechnungsressourcen in der Befehlszeile an. Die tatsächlichen Ressourcen können sich von den angeforderten Ressourcen unterscheiden, wenn eine parallele Berechnung oder Grafikkarten-Berechnung angefordert wurde, jedoch kein Parallel Pool offen ist oder keine unterstützte Grafikkarte verfügbar ist. Werden parallele Worker verwendet, wird der Berechnungsmodus jedes Workers beschrieben, einschließlich nicht verwendeter Worker im Pool.

Speicherreduzierung, angegeben als positive Ganzzahl.

Bei den meisten neuronalen Netzen ist der Standard-CPU-Berechnungsmodus für das Training ein kompilierter MEX-Algorithmus. Bei großen Netzen könnten die Berechnungen jedoch mit einem MATLAB®-Berechnungsmodus durchgeführt werden. Dies kann mithilfe von 'showResources' bestätigt werden. Wenn MATLAB verwendet wird und der Speicherbedarf ein Problem darstellen könnte, können Sie die Reduzierungsoption auf einen Wert N größer 1 setzen, um den für das Training erforderlichen temporären Speicher um den Faktor N zu reduzieren. Dies geht mit längeren Trainingszeiten einher.

Checkpoint-Datei, angegeben als Zeichenvektor.

Der Wert von 'CheckpointFile' kann auf einen Dateinamen gesetzt werden (um im aktuellen Arbeitsordner zu speichern), auf einen Dateipfad in einem anderen Ordner oder auf einen leeren String (Standardeinstellung, um Checkpoint-Saves zu deaktivieren).

Checkpoint-Verzögerung, angegeben als nicht negative Ganzzahl.

Der optionale Parameter 'CheckpointDelay' beschränkt die Frequenz der Speichervorgänge. Die Frequenz der Checkpoints zu beschränken, kann die Effizienz verbessern, indem Sie den Zeitaufwand zum Speichern von Checkpoints im Vergleich zum Zeitaufwand für Berechnungen verringern. Der Standardwert beträgt 60; dies bedeutet, dass Checkpoint-Saves höchstens einmal pro Minute durchgeführt werden. Setzen Sie den Wert von 'CheckpointDelay' auf 0, wenn Checkpoint-Saves nur einmal pro Epoche durchgeführt werden sollen.

Ausgangsargumente

alle reduzieren

Trainiertes Netz, ausgegeben als network-Objekt

Trainingsdatensatz (epoch und perf), ausgegeben als Struktur, dessen Felder von der Netz-Trainingsfunktion abhängen (net.NET.trainFcn). Der Datensatz kann die folgenden Felder umfassen:

  • Training, Datenaufteilung sowie Leistungsfunktionen und -Parameter

  • Datenaufteilungs-Indizes für Trainings-, Validierungs- und Testdatensätze

  • Datenaufteilungs-Masken für Trainings-, Validierungs- und Testdatensätze

  • Anzahl der Epochen (num_epochs) und beste Epoche (best_epoch)

  • Eine Liste der Trainingszustand-Namen (states)

  • Felder für jeden Zustandsnamen, dessen Wert über das Training hinweg aufgezeichnet wird

  • Beste Leistungen des Netzes, in jeder Epoche evaluiert: Beste Leistung beim Trainingsdatensatz (best_perf), beste Leistung beim Validierungsdatensatz (best_vperf) und beste Leistung beim Testdatensatz (best_tperf)

Algorithmen

train ruft die von net.trainFcn angegebene Funktion mit den von net.trainParam angegebenen Trainingsparameterwerten auf.

Üblicherweise wird eine Trainingsepoche als eine einzige Bereitstellung aller Eingangsvektoren in das Netz definiert. Das Netz wird daraufhin gemäß den Ergebnissen dieser Bereitstellungen aktualisiert.

Das Training wird durchgeführt, bis eine maximale Anzahl Epochen durchlaufen wurde, das Leistungsziel erreicht wurde oder eine beliebige andere Stopp-Bedingung der net.trainFcn-Funktion auftritt.

Einige Trainingsfunktionen weichen von dieser Norm ab, indem nur ein Eingangsvektor (oder eine Sequenz) pro Epoche bereitgestellt wird. Für jede Epoche wird aus konkurrenten Eingangsvektoren (oder Sequenzen) zufällig ein Eingangsvektor (oder eine Sequenz) ausgewählt. competlayer gibt Netze aus, die trainru verwenden.

Versionsverlauf

Eingeführt vor R2006a

Siehe auch

| | |