train

Addestra una rete neurale superficiale

comprimi tutto nella pagina

Sintassi

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)

Descrizione

Questa funzione addestra una rete neurale superficiale. Per l'addestramento delle reti di Deep Learning (come le reti convoluzionali o le reti LSTM), utilizzare la funzione trainnet.

trainedNet = train(net,X,T,Xi,Ai,EW) addestra una rete net in base a net.trainFcn e net.trainParam.

esempio

[trainedNet,tr] = train(net,X,T,Xi,Ai,EW) restituisce anche un record di addestramento.

[trainedNet,tr] = train(net,X,T,Xi,Ai,EW,Name,Value) addestra una rete con ulteriori opzioni specificate da una o più coppie di argomenti nome-valore.

esempio

Esempi

comprimi tutto

Qui, gli input x e i target t definiscono una semplice funzione che può essere tracciata:

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')

Qui, feedforwardnet crea una rete feed-forward a due livelli. La rete ha un livello nascosto con dieci neuroni.

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

La rete viene addestrata e poi risimulata.

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

Questo esempio addestra una rete nonlineare-autoregressiva open loop con input esterno, per modellare un sistema di magneti levitati definito da una corrente di controllo x e dalla risposta della posizione verticale t del magnete, quindi simula la rete. La funzione preparets prepara i dati prima dell'addestramento e della simulazione. Crea gli input combinati della rete open loop xo, che comprende sia l’input esterno x sia i valori precedenti della posizione t. Prepara inoltre gli stati di ritardo xi.

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

Questo stesso sistema può essere simulato anche in forma closed loop.

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

Se si dispone di risorse hardware che non vengono utilizzate durante l'addestramento, tramite l'addestramento in parallelo potrebbe essere possibile addestrare la rete più rapidamente e utilizzare un set di dati che altrimenti non rientrerebbe nella memoria. L'addestramento di una rete in parallelo richiede Parallel Computing Toolbox™ ed è supportato solo per l'addestramento per retropropagazione, non per le mappe auto-organizzanti.

In questo caso, l'addestramento e la simulazione avvengono tra worker MATLAB paralleli.

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

Utilizzare i valori composti per distribuire i dati manualmente e ottenere i risultati come valori composti. Mentre ciascuna parte del set di dati deve essere contenuta nella RAM, se i dati vengono caricati man mano che vengono distribuiti, l'intero set di dati è limitato solo dalla RAM totale di tutti i worker.

[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);

Si noti che nell'esempio qui sopra, la funzione configure è stata utilizzata per impostare le dimensioni e le impostazioni di elaborazione degli input della rete. Questo normalmente avviene automaticamente quando si chiama addestra, ma quando si forniscono dati composti questo passaggio deve essere eseguito manualmente con dati non composti.

Le reti possono essere addestrate utilizzando il dispositivo GPU corrente, se è supportato da Parallel Computing Toolbox. L'addestramento su GPU è attualmente supportato solo per l'addestramento per retropropagazione, non per le mappe auto-organizzanti. 

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

Per inserire manualmente i dati in una GPU:

[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);

Si noti che nell'esempio qui sopra, la funzione configura è stata utilizzata per impostare le dimensioni e le impostazioni di elaborazione degli input della rete. Generalmente, questo avviene automaticamente quando si chiama addestra, ma quando si forniscono dati gpuArray questo passaggio deve essere eseguito manualmente con dati non gpuArray.

Per l'esecuzione in parallelo, con ciascun worker assegnato a una GPU diversa e unica, con ulteriori worker in esecuzione sulla CPU: 

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

L’utilizzo di soli worker con GPU uniche potrebbe risultare in una velocità maggiore, poiché i worker della CPU potrebbero restare indietro.

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

In questo caso, la rete viene addestrata con checkpoint salvati a una frequenza non superiore a una volta ogni due minuti.

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

Dopo un guasto al computer, la rete più recente può essere recuperata e utilizzata per continuare l'addestramento dal punto di interruzione per guasto. Il file del checkpoint comprende una variabile di struttura checkpoint, che comprende la rete, il record di addestramento, il nome del file, l'ora e il numero.

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

Argomenti di input

comprimi tutto

Rete di input, specificata come un oggetto network. Per creare un oggetto network, utilizzare ad esempio feedforwardnet o narxnet.

Input di rete, specificati come una matrice R per Q o un array di celle Ni per TS, dove

  • R è la dimensione di input

  • Q è la dimensione del batch

  • Ni = net.numInputs

  • TS è il numero fasi temporali

Gli argomenti train possono avere due formati: matrici per problemi statici e reti con input e output singoli e array di celle per fasi temporali multiple e reti a input e output multipli.

  • Il formato matrice può essere utilizzato se si desidera simulare solo una fase temporale (TS = 1). Risulta utile per le reti che hanno solo un input e un output, ma può essere utilizzato anche per le reti che hanno più input e più output. Quando la rete è a input multipli, la dimensione della matrice è (somma di Ri) per Q.

  • Il formato dell’array di celle è più generale e opportuno per le reti a input e output multipli, in quanto consente di presentare sequenze di input. Ciascun elemento X{i,ts} è una matrice Ri per Q, dove Ri = net.inputs{i}.size.

Se si utilizzano dati composti, 'useParallel' viene impostato automaticamente su 'yes'. La funzione considera dati composti e restituisce risultati composti.

Se si utilizzano dati gpuArray, 'useGPU' viene impostato automaticamente su 'yes'. La funzione considera dati gpuArray e restituisce risultati gpuArray

Nota

Se la colonna di X comprende almeno un NaN, train non utilizza quella colonna per l'addestramento, il test o la convalida.

Target della rete, specificati come una matrice U per Q o un array di celle No per TS, dove

  • U è la dimensione di output

  • Q è la dimensione del batch

  • No = net.numOutputs

  • TS è il numero fasi temporali

Gli argomenti train possono avere due formati: matrici per problemi statici e reti con input e output singoli e array di celle per fasi temporali multiple e reti a input e output multipli.

  • Il formato matrice può essere utilizzato se si desidera simulare solo una fase temporale (TS = 1). Risulta utile per le reti che hanno solo un input e un output, ma può essere utilizzato anche per le reti che hanno più input e più output. Quando la rete è a input multipli, la dimensione della matrice è (somma di Ui) per Q.

  • Il formato dell’array di celle è più generale e opportuno per le reti a input e output multipli, in quanto consente di presentare sequenze di input. Ciascun elemento T{i,ts} è una matrice Ui per Q, dove Ui = net.outputs{i}.size.

Se si utilizzano dati composti, 'useParallel' viene impostato automaticamente su 'yes'. La funzione considera dati composti e restituisce risultati composti.

Se si utilizzano dati gpuArray, 'useGPU' viene impostato automaticamente su 'yes'. La funzione considera dati gpuArray e restituisce risultati gpuArray

Si noti che T è opzionale e deve essere utilizzato solo per le reti che richiedono dei target.

Nota

Qualsiasi valore NaN nei target T è trattato come un dato mancante. Se un elemento di T è NaN, tale elemento non è utilizzato per l’addestramento, il test e la convalida.

Condizioni iniziali del ritardo di input, specificate come un array di celle Ni per ID o una matrice R per (ID*Q), dove

  • ID = net.numInputDelays

  • Ni = net.numInputs

  • R è la dimensione di input

  • Q è la dimensione del batch

Per l’input dell’array di celle, le colonne di Xi sono ordinate dalla condizione di ritardo più vecchia alla più recente: Xi{i,k} è l’input i al momento ts = k - ID.

Anche Xi è opzionale e deve essere utilizzato solo per le reti che presentano ritardi di input o del livello.

Condizioni iniziali del ritardo del livello, specificate come un array di celle Nl per LD o una matrice (somma di Si) per (LD*Q), dove

  • Nl = net.numLayers

  • LD = net.numLayerDelays

  • Si = net.layers{i}.size

  • Q è la dimensione del batch

Per l’input dell’array di celle, le colonne di Ai sono ordinate dalla condizione di ritardo più vecchia alla più recente: Ai{i,k} è l’output del livello i al momento ts = k - LD.

Pesi dell’errore, specificati come un array di celle No per TS o una matrice (somma di Ui) per Q, dove

  • No = net.numOutputs

  • TS è il numero fasi temporali

  • Ui = net.outputs{i}.size

  • Q è la dimensione del batch

Per l’input dell’array di celle, ciascun elemento EW{i,ts} è una matrice Ui per Q, dove

  • Ui = net.outputs{i}.size

  • Q è la dimensione del batch

I pesi dell’errore EW possono anche avere una dimensione pari a 1 al posto di tutti o qualsiasi No, TS, Ui o Q. In questo caso, EW viene automaticamente esteso in dimensione per corrispondere ai target T. Questo consente di ponderare l'importanza in qualsiasi dimensione in modo appropriato (come per il campione), mantenendone la stessa importanza in un’altra (come il tempo, con TS=1). Se tutte le dimensioni sono pari a 1, ad esempio se EW = {1}, tutti i valori target vengono trattati con la stessa importanza. Quello è il valore predefinito di EW.

Come visto sopra, i pesi dell’errore EW possono avere le stesse dimensioni dei target T oppure avere alcune dimensioni impostate su 1. Ad esempio, se EW è 1xQ, i campioni del target avranno un’importanza diversa, ma ciascun elemento in un campione avrà la stessa importanza. Se EW è la (somma di Ui)x1, ogni elemento di output avrà un’importanza diversa, mentre tutti i campioni saranno trattati con la stessa importanza.

Argomenti nome-valore

comprimi tutto

Specificare coppie opzionali di argomenti come Name1=Value1,...,NameN=ValueN, dove Name è il nome dell’argomento e Value è il valore corrispondente. Gli argomenti nome-valore devono comparire dopo gli altri argomenti, ma l'ordine delle coppie non ha importanza.

Prima della R2021a, utilizzare le virgole per separare ogni nome e valore e racchiudere Name tra virgolette.

Esempio 'useParallel','yes'

Opzione per specificare calcoli paralleli, specificata come 'yes' o 'no'.

  • 'no': i calcoli vengono eseguiti su un normale thread MATLAB. Questa è l’impostazione predefinita di 'useParallel'.

  • 'yes': i calcoli vengono eseguiti su worker paralleli se un pool parallelo è aperto. In caso di assenza di un pool parallelo aperto, il software ne avvia uno utilizzando il profilo cluster predefinito.

Opzione per specificare calcoli GPU, specificata come 'yes', 'no' o 'only'.

  • 'no': i calcoli vengono eseguiti sulla CPU. Questa è l’impostazione predefinita di 'useGPU'.

  • 'yes': i calcoli vengono eseguiti sull’attuale gpuDevice se si tratta di una GPU supportata (vedere Parallel Computing Toolbox per i requisiti della GPU). Se l’attuale gpuDevice non è supportata, i calcoli restano sulla CPU. Se anche 'useParallel' è 'yes' e un pool parallelo è aperto, allora ogni worker con una GPU unica utilizza quella GPU, mentre gli altri worker eseguono i calcoli sui rispettivi core delle proprie CPU.

  • 'only': se nessun pool parallelo è aperto, allora questa impostazione è uguale a 'yes'. Se un pool parallelo è aperto, vengono utilizzati solo i worker con GPU uniche. Tuttavia, se un pool parallelo è aperto, ma non sono disponibili GPU supportate, i calcoli ritornano a essere eseguiti su tutte le CPU dei worker.

Opzione per mostrare le risorse, specificata come 'yes' o 'no'.

  • 'no': non visualizza le risorse di calcolo utilizzate alla riga di comando. Questa è l’impostazione predefinita.

  • 'yes': mostra alla riga di comando un riepilogo delle risorse di calcolo effettivamente utilizzate. Le risorse effettive possono differire da quelle richieste se viene richiesto il calcolo in parallelo o su GPU, ma un pool parallelo non è aperto o una GPU supportata non è disponibile. Quando vengono utilizzati i worker in parallelo, viene descritta la modalità di calcolo di ciascun worker, compresi quelli del pool che non vengono utilizzati.

Riduzione della memoria, specificata come un numero intero positivo.

Per la maggior parte delle reti neurali, la modalità di calcolo predefinita per l'addestramento della CPU è un algoritmo MEX compilato. Tuttavia, per le reti di grandi dimensioni i calcoli potrebbero essere eseguiti con una modalità di calcolo MATLAB®. Questo può essere confermato utilizzando 'showResources'. Se si utilizza MATLAB e la memoria costituisce un problema, impostando l'opzione di riduzione su un valore N maggiore di 1, si riduce gran parte della memoria temporanea necessaria per l’addestramento di un fattore N, in cambio di tempi di addestramento più lunghi.

File del checkpoint, specificato come un vettore di carattere.

Il valore per 'CheckpointFile' può essere impostato su un nome di file da salvare nella cartella di lavoro corrente, su un percorso di file in un'altra cartella o su una stringa vuota per disabilitare i salvataggi dei checkpoint (il valore predefinito).

Ritardo del checkpoint, specificato come un intero non negativo.

Il parametro opzionale 'CheckpointDelay' limita la frequenza dei salvataggi. La limitazione della frequenza dei checkpoint può migliorare l'efficienza, mantenendo basso il tempo di salvataggio dei checkpoint rispetto al tempo impiegato per i calcoli. Il valore predefinito è 60, ad indicare che i salvataggi dei checkpoint non avvengono più di una volta al minuto. Impostare il valore di 'CheckpointDelay' su 0 si desidera che i salvataggi dei checkpoint avvengano solo una volta ogni epoca.

Argomenti di output

comprimi tutto

Rete addestrata, restituita come un oggetto network.

Record di addestramento (epoch e perf), restituito come una struttura i cui campi dipendono dalla funzione di addestramento della rete (net.NET.trainFcn). Può comprendere campi quali:

  • Funzioni e parametri di addestramento, divisione dei dati e performance

  • Indici di divisione dei dati per i set di addestramento, convalida e test

  • Maschere di divisione dei dati per i set di addestramento, convalida e test

  • Numero di epoche (num_epochs) e epoca migliore (best_epoch)

  • Un elenco dei nomi degli stati di addestramento (states)

  • Campi per ciascun nome di stato che registrano il suo valore durante l'addestramento

  • Le migliori prestazioni della rete valutate a ciascuna epoca: migliore performance sul set di addestramento (best_perf), migliore performance sul set di convalida (best_vperf) e migliore performance sul set di test (best_tperf)

Algoritmi

train chiama la funzione indicata da net.trainFcn, utilizzando i valori dei parametri di addestramento indicati da net.trainParam.

Normalmente, un'epoca di addestramento è definita come una singola presentazione di tutti i vettori di input alla rete. La rete è quindi aggiornata in base ai risultati di tutte quelle presentazioni.

L’addestramento continua fino al raggiungimento di un numero massimo di epoche, al raggiungimento dell'obiettivo di performance o all’occorrenza di qualsiasi altra condizione di arresto della funzione net.trainFcn.

Alcune funzioni di addestramento si discostano da questa norma presentando un solo vettore (o sequenza) di input a ciascuna epoca. Un vettore (o sequenza) di input viene scelto in modo casuale per ogni epoca tra vettori (o sequenze) di input concorrenti. competlayer restituisce reti che utilizzano trainru, una funzione di addestramento che esegue tale scelta.

Cronologia versioni

Introduzione prima di R2006a

Vedi anche

| | |