Main Content

La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

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 de LSTM. Una red de LSTM permite introducir datos secuenciales en una red y hacer predicciones basadas en las unidades de tiempo individuales de los datos secuenciales.

Este ejemplo utiliza el conjunto de datos de forma de onda Waveform. En este ejemplo se entrena una red 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 numChannels por -numTimeSteps, donde numChannels es el número de canales de la secuencia y numTimeSteps es el número de unidades de tiempo 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},1);

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

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,2);
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 de LSTM

Defina la arquitectura de la red 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 y de una de clasificación.

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
    classificationLayer]
layers = 
  5×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
     5   ''   Classification Output   crossentropyex

Especifique las opciones de entrenamiento. Entrene usando el solver Adam con una tasa de aprendizaje del 0,002 y un umbral de gradiente de 1. Establezca el número máximo de épocas en 150 y desactive la función de mezclar. De forma predeterminada, el software se entrena en una GPU, si se dispone de ella. Utilizar una GPU requiere Parallel Computing Toolbox y un dispositivo GPU compatible. Para obtener información sobre los dispositivos compatibles, consulte GPU Computing Requirements (Parallel Computing Toolbox).

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

Entrenar la red de LSTM

Entrene la red de LSTM con las opciones de entrenamiento especificadas usando trainNetwork.

net = trainNetwork(XTrain,TTrain,layers,options);

Probar la red de LSTM

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

XTest(1:3)
ans=3×1 cell array
    {3×127 double}
    {3×180 double}
    {3×193 double}

La red 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,2);
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.

YTest = classify(net,XTest);
acc = mean(YTest == TTest)
acc = 0.8400

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

figure
confusionchart(TTest,YTest)

Consulte también

| | | |

Temas relacionados