train

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

Parallel Computing Toolbox™ consente a Deep Learning Toolbox™ di simulare e addestrare le reti più velocemente e su set di dati più ampi di quelli che possono essere inseriti in un PC. L'addestramento in parallelo è attualmente 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.

parpool
[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 configura è 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');

Un altro utilizzo della feature checkpoint è quando si interrompe una sessione di addestramento in parallelo (avviata con il parametro 'UseParallel'), anche se lo strumento per l'addestramento delle reti neurali non è disponibile durante l'addestramento in parallelo. In questo caso, impostare un 'CheckpointFile', utilizzare Ctrl+C per interrompere l’addestramento in qualsiasi momento, quindi caricare il file del checkpoint per ottenere la rete e il record di addestramento.