Classificazione di sequenze utilizzando il Deep Learning

Apri live script

Questo esempio mostra come classificare i dati sequenziali utilizzando una rete con memoria a breve e lungo termine (LSTM).

Per addestrare una rete neurale profonda alla classificazione di dati sequenziali, è possibile utilizzare una rete neurale LSTM. Una rete neurale LSTM consente di immettere dati sequenziali in una rete ed eseguire previsioni basate sulle singole fasi temporali dei dati sequenziali.

Questo diagramma mostra il flusso di dati sequenziali attraverso una rete neurale di classificazione di sequenza.

Questo esempio utilizza il set di dati delle forme d'onda. Questo esempio addestra una rete neurale LSTM a riconoscere il tipo di forma d'onda data una serie di dati temporali. I dati di addestramento contengono dati di serie temporali per quattro tipi di forme d'onda. Ciascuna sequenza ha tre canali e varia in lunghezza.

Caricamento dei dati sequenziali

Caricare i dati di esempio da WaveformData. I dati sequenziali sono un array di celle di sequenze numObservationsx1, dove numObservations è il numero delle sequenze. Ciascuna sequenza è un array numerico numTimeSteps per -numChannels, dove numTimeSteps è il numero di fasi temporali della sequenza e numChannels è il numero di canali della sequenza. I dati dell'etichetta sono un vettore categorico numObservationsx1.

load WaveformData

Visualizzare alcune delle sequenze in un grafico.

numChannels = size(data{1},2);

idx = [3 4 5 12];
figure
tiledlayout(2,2)
for i = 1:4
    nexttile
    stackedplot(data{idx(i)},DisplayLabels="Channel "+string(1:numChannels))
    
    xlabel("Time Step")
    title("Class: " + string(labels(idx(i))))
end

Visualizzare i nomi della classe.

classNames = categories(labels)

classNames = 4×1 cell
    {'Sawtooth'}
    {'Sine'    }
    {'Square'  }
    {'Triangle'}

Accantonare i dati per i test. Suddividere i dati in un set di addestramento contenente il 90% dei dati e un set di test contenente il restante 10% dei dati. Per suddividere i dati, utilizzare la funzione trainingPartitions, allegata a questo esempio come file di supporto. Per accedere a questo file, aprire l'esempio come script live.

numObservations = numel(data);
[idxTrain,idxTest] = trainingPartitions(numObservations,[0.9 0.1]);
XTrain = data(idxTrain);
TTrain = labels(idxTrain);

XTest = data(idxTest);
TTest = labels(idxTest);

Preparazione dei dati per il riempimento

Per impostazione predefinita, durante l’addestramento, il software divide i dati di addestramento in mini-batch e riempie le sequenze in modo che abbiano la stessa lunghezza. Un riempimento eccessivo può avere un impatto negativo sulle prestazioni della rete.

Onde evitare che il processo di addestramento aggiunga un riempimento eccessivo, è possibile ordinare i dati di addestramento in base alla lunghezza della sequenza e scegliere una dimensione del mini-batch in modo che le sequenze in un mini-batch abbiano una lunghezza simile. La figura seguente mostra l'effetto del riempimento delle sequenze prima e dopo l'ordinamento dei dati.

Ottenere le lunghezze delle sequenze per ciascuna osservazione.

numObservations = numel(XTrain);
for i=1:numObservations
    sequence = XTrain{i};
    sequenceLengths(i) = size(sequence,1);
end

Ordinare i dati in base alla lunghezza della sequenza.

[sequenceLengths,idx] = sort(sequenceLengths);
XTrain = XTrain(idx);
TTrain = TTrain(idx);

Visualizzare le lunghezze delle sequenze ordinate in un grafico a barre.

figure
bar(sequenceLengths)
xlabel("Sequence")
ylabel("Length")
title("Sorted Data")

Definizione dell'architettura della rete neurale LSTM

Definire l'architettura della rete neurale LSTM.

Specificare che la dimensione dell'input sia il numero di canali dei dati di input.
Specificare un livello LSTM bidirezionale con 120 unità nascoste e generare l'ultimo elemento della sequenza.
Infine, per includere un livello completamente connesso con una dimensione di output che corrisponda al numero di classi, seguito da un livello softmax.

Se si ha accesso a frequenze complete al momento della previsione, è possibile utilizzare un livello LSTM bidirezionale nella rete. Un livello LSTM bidirezionale apprende dalla sequenza completa ad ogni fase temporale. Se non si ha accesso all'intera sequenza al momento della previsione, ad esempio se si stanno prevedendo valori o una fase temporale alla volta, utilizzare invece un livello LSTM.

numHiddenUnits = 120;
numClasses = 4;

layers = [
    sequenceInputLayer(numChannels)
    bilstmLayer(numHiddenUnits,OutputMode="last")
    fullyConnectedLayer(numClasses)
    softmaxLayer]

layers = 
  4×1 Layer array with layers:

     1   ''   Sequence Input    Sequence input with 3 dimensions
     2   ''   BiLSTM            BiLSTM with 120 hidden units
     3   ''   Fully Connected   4 fully connected layer
     4   ''   Softmax           softmax

Specificazione delle opzioni di addestramento

Specificare le opzioni di addestramento. La scelta tra le opzioni richiede un'analisi empirica. Per scoprire le diverse configurazioni delle opzioni di addestramento eseguendo esperimenti, è possibile utilizzare l'applicazione Experiment Manager.

Addestrare utilizzando il solver Adam.
Addestrare per 200 epoche.
Specificare una velocità di apprendimento di 0,002.
Tagliare i gradienti con una soglia di 1.
Per mantenere le sequenze ordinate per lunghezza, disabilitare il rimescolamento.
Visualizzare i progressi dell'addestramento in un grafico e monitorare la precisione.
Disattivare l’output verboso.

options = trainingOptions("adam", ...
    MaxEpochs=200, ...
    InitialLearnRate=0.002,...
    GradientThreshold=1, ...
    Shuffle="never", ...
    Plots="training-progress", ...
    Metrics="accuracy", ...
    Verbose=false);

Addestramento della rete neurale LSTM

Addestrare la rete neurale utilizzando la funzione trainnet. Per la classificazione, utilizzare la perdita di entropia incrociata. Per impostazione predefinita, la funzione trainnet utilizza una GPU, se disponibile. L'utilizzo di una GPU richiede una licenza Parallel Computing Toolbox™ e un dispositivo GPU supportato. Per informazioni sui dispositivi supportati, vedere GPU Computing Requirements (Parallel Computing Toolbox). In caso contrario, la funzione utilizza la CPU. Per specificare l'ambiente di esecuzione, utilizzare l'opzione di addestramento ExecutionEnvironment.

net = trainnet(XTrain,TTrain,layers,"crossentropy",options);

Test della rete neurale LSTM

Classificare i dati di test e calcolare la precisione della classificazione delle previsioni.

La rete neurale LSTM net è stata addestrata utilizzando mini-batch di sequenze con lunghezza simile. Assicurarsi che i dati di test siano organizzati nello stesso modo. Ordinare i dati di test in base alla lunghezza della sequenza.

numObservationsTest = numel(XTest);
for i=1:numObservationsTest
    sequence = XTest{i};
    sequenceLengthsTest(i) = size(sequence,1);
end

[sequenceLengthsTest,idx] = sort(sequenceLengthsTest);
XTest = XTest(idx);
TTest = TTest(idx);

Classificare i dati di test e calcolare la precisione della classificazione delle previsioni.

Fare previsioni utilizzando la funzione minibatchpredict e convertire i punteggi in etichette utilizzando la funzione scores2label. Per impostazione predefinita, la funzione minibatchpredict utilizza una GPU, se disponibile.

scores = minibatchpredict(net,XTest);
YTest = scores2label(scores,classNames);

Calcolare la precisione della classificazione. La precisione è la percentuale di etichette previste correttamente.

acc = mean(YTest == TTest)

acc = 0.8700

Visualizzare i risultati della classificazione in un grafico di confusione.

figure
confusionchart(TTest,YTest)

Vedi anche