Clasificación de secuencias mediante deep learning

Este ejemplo muestra cómo clasificar datos secuenciales mediante una red de memoria de corto-largo plazo (LSTM).

Para entrenar una red neuronal profunda con la que clasificar datos secuenciales, se puede utilizar una red neuronal de LSTM. Una red neuronal de LSTM permite introducir datos secuenciales en una red y hacer predicciones basadas en las unidades de tiempo individuales de los datos secuenciales.

Este diagrama ilustra los datos secuenciales que circulan por una red neuronal de clasificación de secuencias.

Este ejemplo utiliza el conjunto de datos de forma de onda Waveform. En este ejemplo se entrena una red neuronal de LSTM para reconocer el tipo de forma de onda dados los datos de series de tiempo. Los datos de entrenamiento contienen datos de series de tiempo para cuatro tipos de formas de onda. Cada secuencia cuenta con tres canales y diferentes longitudes.

Cargar datos secuenciales

Cargue los datos de ejemplo de WaveformData. Los datos secuenciales son un arreglo de celdas de numObservations por 1 de secuencias, donde numObservations es el número de secuencias. Cada secuencia es un arreglo numérico de numTimeSteps por -numChannels, donde numTimeSteps es el número de unidades de tiempo y numChannels es el número de canales de la secuencia. Los datos de etiqueta son un vector categórico de numObservations por 1.

load WaveformData

Visualice algunas de las secuencias en una gráfica.

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

Visualice los nombres de las clases.

classNames = categories(labels)

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

Reserve datos para pruebas. Divida los datos en un conjunto de entrenamiento que contenga el 90% de los datos y en un conjunto de prueba que contenga el 10% restante. Para dividir los datos, use la función trainingPartitions, incluida en este ejemplo como un archivo de soporte. Para acceder al archivo, abra el ejemplo como un script en vivo.

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

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

Preparar datos para el relleno

Durante el entrenamiento, de forma predeterminada, el software divide los datos de entrenamiento en minilotes y rellena las secuencias de manera que tengan la misma longitud. Si se rellenan demasiado, se puede producir un efecto negativo en el rendimiento de la red.

Para evitar que el proceso de entrenamiento añada demasiado relleno, puede ordenar los datos de entrenamiento por longitud de secuencia y elegir un tamaño de minilote para que las secuencias de un minilote tengan una longitud similar. La siguiente figura muestra el efecto de rellenar secuencias antes y después de ordenar los datos.

Obtenga las longitudes de las secuencias para cada observación.

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

Ordene los datos por longitud de secuencia.

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

Visualice las longitudes de las secuencias ordenadas en una gráfica de barras.

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

Definir la arquitectura de red neuronal de LSTM

Defina la arquitectura de la red neuronal de LSTM.

Especifique el tamaño de entrada como el número de canales de los datos de entrada.
Especifique una capa de LSTM bidireccional con 120 unidades ocultas y obtenga como salida el último elemento de la secuencia.
Por último, incluya una capa totalmente conectada con un tamaño de salida que coincida con el número de clases, seguida de una capa softmax.

Si tiene acceso a secuencias completas en el momento de la predicción, podrá usar una capa de LSTM bidireccional en su red. Una capa de LSTM bidireccional aprende de la secuencia completa en cada unidad de tiempo. Si no tiene acceso a la secuencia completa en el momento de la predicción, por ejemplo, si está pronosticando valores o prediciendo una unidad de tiempo cada vez, utilice una capa de LSTM en su lugar.

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

Especificar las opciones de entrenamiento

Especifique las opciones de entrenamiento. Para escoger entre las opciones se requiere un análisis empírico. Para explorar diferentes configuraciones de opciones de entrenamiento mediante la ejecución de experimentos, puede utilizar la app Experiment Manager.

Entrene usando el solver Adam.
Entrene durante 200 épocas.
Especifique una tasa de aprendizaje de 0,002.
Corte los gradientes con un umbral de 1.
Para mantener las secuencias ordenadas por longitud, desactive la ordenación aleatoria.
Muestre el progreso del entrenamiento en una gráfica y monitorice la precisión.
Deshabilite la salida detallada.

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

Entrenar una red neuronal de LSTM

Entrene la red neuronal con la función trainnet. Para la clasificación, utilice la pérdida de entropía cruzada. De forma predeterminada, la función trainnet usa una GPU en caso de que esté disponible. Para utilizar una GPU se requiere una licencia de Parallel Computing Toolbox™ y un dispositivo GPU compatible. Para obtener información sobre los dispositivos compatibles, consulte GPU Computing Requirements (Parallel Computing Toolbox). De lo contrario, la función usa la CPU. Para especificar el entorno de ejecución, utilice la opción de entrenamiento ExecutionEnvironment.

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

Probar una red neuronal de LSTM

Clasifique los datos de prueba y calcule la precisión de clasificación de las predicciones.

La red neuronal de LSTM net se ha entrenado utilizando minilotes de secuencias de longitud similar. Asegúrese de que los datos de prueba se organizan de la misma forma. Ordene los datos de prueba por longitud de secuencia.

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

Clasifique los datos de prueba y calcule la precisión de clasificación de las predicciones.

Realice predicciones con la función minibatchpredict y convierta las puntuaciones en etiquetas con la función scores2label. De forma predeterminada, la función minibatchpredict usa una GPU en caso de que esté disponible.

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

Calcule la precisión de clasificación. La precisión es el porcentaje de imágenes que la red clasifica correctamente.

acc = mean(YTest == TTest)

acc = 0.8700

Muestre los resultados de la clasificación en una gráfica de confusión.

figure
confusionchart(TTest,YTest)

Consulte también