Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

Clasifique series de tiempo usando análisis de wavelet y aprendizaje profundo

Este ejemplo muestra cómo clasificar las señales de electrocardiograma humano (ECG) mediante la transformación de wavelet continua (CWT) y una red neuronal convolucional profunda (CNN).

Entrenar una CNN profunda desde cero es computacionalmente costoso y requiere una gran cantidad de datos de entrenamiento. En varias aplicaciones, no se dispone de una cantidad suficiente de datos de entrenamiento, y no es factible sintetizar nuevos ejemplos de formación realistas. En estos casos, es deseable aprovechar las redes neuronales existentes que se han entrenado en grandes conjuntos de datos para tareas conceptualmente similares. Este aprovechamiento de las redes neuronales existentes se denomina aprendizaje de transferencia. En este ejemplo, adaptamos dos CNNs profundos, GoogLeNet y AlexNet, preentrenados para el reconocimiento de imágenes para clasificar las formas de onda de ECG basadas en una representación de frecuencia de tiempo.

GoogLeNet y AlexNet son CNNs profundos diseñados originalmente para clasificar imágenes en 1000 categorías. Reutilizamos la arquitectura de red de la CNN para clasificar las señales de ECG basadas en imágenes del CWT de los datos de la serie temporal. Para ejecutar este ejemplo, debe tener la caja de herramientas Wavelet™, la caja de herramientas de procesamiento de imágenes™™, el paquete de soporte técnico de Deep Learning Toolbox,™ modelo de herramientas de aprendizaje profundo y el paquete de soporte de Deep Learning Toolbox™ modelo.for GoogLeNet Networkfor AlexNet Network Para buscar e instalar los paquetes de soporte, utilice el explorador de complementos de MATLAB™. La opción dentro de este ejemplo se establece para que los procesos de entrenamiento se ejecuten en una CPU. Si su máquina tiene una GPU y una caja de herramientas de computación paralela™, puede acelerar los procesos de entrenamiento estableciendo la opción para ejecutarse en la GPU. Los datos utilizados en este ejemplo están disponibles públicamente.PhysioNet

Descripción de los datos

En este ejemplo, se utilizan datos de ECG obtenidos de tres grupos de personas: personas con arritmia cardíaca (ARR), personas con insuficiencia cardíaca congestiva (CHF) y personas con ritmos sinusales normales (NSR). En total se utilizan 162 grabaciones de ECG de tres bases de datos de PhysioNet: [3] [7], [3] y [1] [3].MIT-BIH base de datos de arritmiasMIT-BIH base de datos de ritmo sinusal normalLa base de datos de insuficiencia cardíaca congestiva BIDMC Más concretamente, 96 grabaciones de personas con arritmia, 30 grabaciones de personas con insuficiencia cardíaca congestiva, y 36 grabaciones de personas con ritmos sinusales normales. El objetivo es entrenar un clasificador para distinguir entre ARR, CHF y NSR.

Descargar datos

El primer paso es descargar los datos de la.Repositorio de GitHub Para descargar los datos del sitio web, haga clic y seleccione.Clone or downloadDownload ZIP Guarde el archivo en una carpeta en la que tenga permiso de escritura.physionet_ECG_data-master.zip Las instrucciones de este ejemplo suponen que ha descargado el archivo en su directorio temporal, en MATLAB.tempdir Modifique las instrucciones subsiguientes para descomprimir y cargar los datos si decide descargar los datos de la carpeta diferente.tempdir Si está familiarizado con git, puede descargar la última versión de las herramientas () y obtener los datos de un símbolo del sistema usando.Gitgit clone https://github.com/mathworks/physionet_ECG_data/

Después de descargar los datos de GitHub, descomprima el archivo en su directorio temporal.

unzip(fullfile(tempdir,'physionet_ECG_data-master.zip'),tempdir) 

La descompresión crea la carpeta en el directorio temporal.physionet-ECG_data-master Esta carpeta contiene el archivo de texto README.md y ECGData. zip. El archivo ECGData. zip contiene

  • ECGData. MAT

  • Modified_physionet_data. txt

  • License.txt.

ECGData. MAT contiene los datos utilizados en este ejemplo. El archivo. txt, Modified_physionet_data. txt, es requerido por la política de copia de PhysioNet y proporciona las atribuciones de origen para los datos, así como una descripción de los pasos de preprocesamiento aplicados a cada grabación ECG.

Descomprimir en physionet-ECG_data-Master.ECGData.zip Cargue el archivo de datos en el área de trabajo de MATLAB.

unzip(fullfile(tempdir,'physionet_ECG_data-master','ECGData.zip'),...     fullfile(tempdir,'physionet_ECG_data-master')) load(fullfile(tempdir,'physionet_ECG_data-master','ECGData.mat')) 

es una matriz de estructura con dos campos: y.ECGDataDataLabels El campo es una matriz 162-por-65536 donde cada fila es una grabación ECG muestreada a 128 Hertz. es una matriz de celdas de diagnóstico de 162-by-1, una para cada fila de.DataLabelsData Las tres categorías de diagnóstico son: ' ARR ', ' CHF ' y ' NSR '.

Para almacenar los datos preprocesados de cada categoría, primero cree un directorio de datos ECG dentro.dataDirtempdir A continuación, cree tres subdirectorios en nombre después de cada categoría de ECG.'data' La función auxiliar hace esto. acepta, el nombre de un directorio de datos ECG y el nombre de un directorio principal como argumentos de entrada.helperCreateECGDirectorieshelperCreateECGDirectoriesECGData Puede reemplazar con otro directorio donde tenga permiso de escritura.tempdir Puede encontrar el código fuente de esta función auxiliar en la sección funciones auxiliares al final de este ejemplo.

parentDir = tempdir; dataDir = 'data'; helperCreateECGDirectories(ECGData,parentDir,dataDir) 

Trazar un representante de cada categoría de ECG. La función auxiliar hace esto. acepta como entrada.helperPlotRepshelperPlotRepsECGData Puede encontrar el código fuente de esta función auxiliar en la sección funciones auxiliares al final de este ejemplo.

helperPlotReps(ECGData) 

Cree representaciones de frecuencia de tiempo

Después de hacer las carpetas, cree representaciones de frecuencia de tiempo de las señales de ECG. Estas representaciones se denominan scalogramas. Un scalograma es el valor absoluto de los coeficientes CWT de una señal.

Para crear los scalogramas, calcule previamente un banco de filtros CWT. La precomputación del Banco de filtros CWT es el método preferido al obtener el CWT de muchas señales utilizando los mismos parámetros.

Antes de generar los scalogramas, examine uno de ellos. Cree un banco de filtros CWT utilizando para una señal con 1000 muestras.cwtfilterbank Utilice el Banco de filtros para tomar el CWT de las primeras 1000 muestras de la señal y obtener el scalograma de los coeficientes.

Fs = 128; fb = cwtfilterbank('SignalLength',1000,...     'SamplingFrequency',Fs,...     'VoicesPerOctave',12); sig = ECGData.Data(1,1:1000); [cfs,frq] = wt(fb,sig); t = (0:999)/Fs;figure;pcolor(t,frq,abs(cfs)) set(gca,'yscale','log');shading interp;axis tight; title('Scalogram');xlabel('Time (s)');ylabel('Frequency (Hz)') 

Utilice la función auxiliar, para crear los scalogramas como imágenes RGB y escribirlos en el subdirectorio apropiado.helperCreateRGBfromTFdataDir El código fuente de esta función auxiliar se encuentra en la sección funciones auxiliares al final de este ejemplo. Para ser compatible con la arquitectura GoogLeNet, cada imagen RGB es una matriz de tamaño 224-by-224-by-3.

helperCreateRGBfromTF(ECGData,parentDir,dataDir) 

Divida en datos de formación y validación

Cargue las imágenes del scalograma como un almacén de datos de imagen. La función etiqueta automáticamente las imágenes en función de los nombres de las carpetas y almacena los datos como un objeto ImageDatastore.imageDatastore Un almacén de datos de imágenes le permite almacenar información de imagen de gran tamaño, incluidos datos que no caben en la memoria, y leer de forma eficaz lotes de imágenes durante el entrenamiento de una CNN.

allImages = imageDatastore(fullfile(parentDir,dataDir),...     'IncludeSubfolders',true,...     'LabelSource','foldernames'); 

Divida aleatoriamente las imágenes en dos grupos, uno para el entrenamiento y el otro para la validación. Utilice el 80% de las imágenes para el entrenamiento y el resto para la validación. Para fines de reproducibilidad, establecemos la semilla aleatoria en el valor predeterminado.

rng default [imgsTrain,imgsValidation] = splitEachLabel(allImages,0.8,'randomized'); disp(['Number of training images: ',num2str(numel(imgsTrain.Files))]); disp(['Number of validation images: ',num2str(numel(imgsValidation.Files))]); 
Number of training images: 130 Number of validation images: 32 

GoogLeNet

Load

Cargue la red neuronal preentrenada de GoogLeNet. Si no está instalado el paquete de soporte técnico de Deep Learning Toolbox™ modelo, el software proporciona un vínculo al paquete de soporte técnico necesario en el explorador de complementos.for GoogLeNet Network Para instalar el paquete de soporte, haga clic en el vínculo y, a continuación, haga clic en.Install

net = googlenet; 

Extraiga el gráfico de capas de la red y trace el gráfico de capas.

lgraph = layerGraph(net); numberOfLayers = numel(lgraph.Layers); figure('Units','normalized','Position',[0.1 0.1 0.8 0.8]); plot(lgraph) title(['GoogLeNet Layer Graph: ',num2str(numberOfLayers),' Layers']); 

Inspeccione el primer elemento de la propiedad layers de la red. Tenga en cuenta que GoogLeNet requiere imágenes RGB de tamaño 224-by-224-by-3.

net.Layers(1) 
 ans =     ImageInputLayer with properties:                  Name: 'data'            InputSize: [224 224 3]     Hyperparameters     DataAugmentation: 'none'        Normalization: 'zerocenter'         AverageImage: [224×224×3 single]  

Modify GoogLeNet Network Parameters

Cada capa de la arquitectura de red se puede considerar un filtro. Las capas anteriores identifican las características más comunes de las imágenes, como los blobs, los bordes y los colores. Las capas posteriores se centran en características más específicas con el fin de diferenciar las categorías.

Para volver a entrenar GoogLeNet a nuestro problema de clasificación ECG, reemplace las últimas cuatro capas de la red. La primera de las cuatro capas, es una capa de caída.'pool5-drop_7x7_s1' Una capa de abandono establece aleatoriamente los elementos de entrada a cero con una probabilidad dada. La capa de caída se utiliza para ayudar a evitar el sobreajuste. La probabilidad predeterminada es 0,5. Consulte para obtener más información.dropoutLayer Las tres capas restantes, ' loss3-Classifier ', ' prob ' y ' Output ', contienen información sobre cómo combinar las entidades que la red extrae en probabilidades de clase y etiquetas. De forma predeterminada, las tres últimas capas están configuradas para 1000 categorías.

Agregue cuatro capas nuevas al gráfico de capa: una capa de caída con una probabilidad de caída del 60%, una capa completamente conectada, una capa softmax y una capa de salida de clasificación. Establezca la capa final completamente conectada para que tenga el mismo tamaño que el número de clases en el nuevo conjunto de datos (3, en este ejemplo). Para aprender más rápido en las capas nuevas que en las capas transferidas, aumente los factores de velocidad de aprendizaje de la capa completamente conectada. Almacene las dimensiones de la imagen GoogLeNet en.inputSize

lgraph = removeLayers(lgraph,{'pool5-drop_7x7_s1','loss3-classifier','prob','output'});  numClasses = numel(categories(imgsTrain.Labels)); newLayers = [     dropoutLayer(0.6,'Name','newDropout')     fullyConnectedLayer(numClasses,'Name','fc','WeightLearnRateFactor',5,'BiasLearnRateFactor',5)     softmaxLayer('Name','softmax')     classificationLayer('Name','classoutput')]; lgraph = addLayers(lgraph,newLayers);  lgraph = connectLayers(lgraph,'pool5-7x7_s1','newDropout'); inputSize = net.Layers(1).InputSize; 

Set Training Options and Train GoogLeNet

El entrenamiento de una red neuronal es un proceso iterativo que implica minimizar una función de pérdida. Para minimizar la función de pérdida, se utiliza un algoritmo de descenso de degradado. En cada iteración, se evalúa el degradado de la función de pérdida y se actualizan los pesos del algoritmo de descenso.

El entrenamiento se puede ajustar estableciendo varias opciones. especifica el tamaño del paso inicial en la dirección del degradado negativo de la función de pérdida. especifica el tamaño de un subconjunto del conjunto de entrenamiento que se usará en cada iteración.InitialLearnRateMiniBatchSize Una época es un pase completo del algoritmo de entrenamiento en todo el conjunto de entrenamiento. especifica el número máximo de épocas que se utilizarán para el entrenamiento.MaxEpochs Elegir el número correcto de épocas no es una tarea trivial. La disminución del número de épocas tiene el efecto de subajustar el modelo, y el aumento del número de épocas resulta en sobreajuste.

Utilice la función para especificar las opciones de formación.trainingOptions Se establece en 10, a 10 y a 0,0001.MiniBatchSizeMaxEpochsInitialLearnRate Visualice el progreso del entrenamiento estableciendo a.Plotstraining-progress Utilice el descenso de gradiente estocástico con Momentum Optimizer. De forma predeterminada, la formación se realiza en una GPU si hay una disponible (requiere Parallel Computing Toolbox™ y una GPU habilitada para CUDA® con capacidad de cómputo 3,0 o superior). Para fines de reproducibilidad, entrenar la red utilizando sólo una CPU, estableciendo el a, y establecer la semilla aleatoria en el valor predeterminado.ExecutionEnvironmentcpu Los tiempos de ejecución serán más rápidos si se puede utilizar una GPU.

options = trainingOptions('sgdm',...     'MiniBatchSize',15,...     'MaxEpochs',20,...     'InitialLearnRate',1e-4,...     'ValidationData',imgsValidation,...     'ValidationFrequency',10,...     'Verbose',1,...     'ExecutionEnvironment','cpu',...     'Plots','training-progress'); 

El proceso de entrenamiento suele tardar 1-5 minutos en una CPU de escritorio. La ventana de comandos muestra información de entrenamiento durante la ejecución. Los resultados incluirán el número de época, el número de iteración, el tiempo transcurrido, la precisión del mini lote, la precisión de validación y el valor de la función de pérdida para los datos de validación.

rng default trainedGN = trainNetwork(imgsTrain,lgraph,options); 
Initializing input data normalization. |======================================================================================================================| |  Epoch  |  Iteration  |  Time Elapsed  |  Mini-batch  |  Validation  |  Mini-batch  |  Validation  |  Base Learning  | |         |             |   (hh:mm:ss)   |   Accuracy   |   Accuracy   |     Loss     |     Loss     |      Rate       | |======================================================================================================================| |       1 |           1 |       00:00:05 |        6.67% |       18.75% |       4.9207 |       2.4153 |      1.0000e-04 | |       2 |          10 |       00:00:25 |       66.67% |       62.50% |       0.9578 |       1.3203 |      1.0000e-04 | |       3 |          20 |       00:00:46 |       46.67% |       75.00% |       1.2938 |       0.5938 |      1.0000e-04 | |       4 |          30 |       00:01:06 |       53.33% |       78.13% |       0.7139 |       0.4628 |      1.0000e-04 | |       5 |          40 |       00:01:27 |       73.33% |       84.38% |       0.4740 |       0.3422 |      1.0000e-04 | |       7 |          50 |       00:01:47 |       93.33% |       84.38% |       0.2818 |       0.2945 |      1.0000e-04 | |       8 |          60 |       00:02:08 |       80.00% |       87.50% |       0.3610 |       0.2482 |      1.0000e-04 | |       9 |          70 |       00:02:28 |       86.67% |       84.38% |       0.3397 |       0.2574 |      1.0000e-04 | |      10 |          80 |       00:02:49 |      100.00% |       96.88% |       0.0718 |       0.1922 |      1.0000e-04 | |      12 |          90 |       00:03:10 |       86.67% |      100.00% |       0.2872 |       0.1726 |      1.0000e-04 | |      13 |         100 |       00:03:30 |       86.67% |       96.88% |       0.4367 |       0.1650 |      1.0000e-04 | |      14 |         110 |       00:03:51 |       86.67% |      100.00% |       0.3139 |       0.1589 |      1.0000e-04 | |      15 |         120 |       00:04:12 |       93.33% |       96.88% |       0.1491 |       0.1524 |      1.0000e-04 | |      17 |         130 |       00:04:32 |      100.00% |      100.00% |       0.0553 |       0.1368 |      1.0000e-04 | |      18 |         140 |       00:04:53 |       93.33% |       96.88% |       0.0997 |       0.1414 |      1.0000e-04 | |      19 |         150 |       00:05:13 |       93.33% |       93.75% |       0.1621 |       0.1339 |      1.0000e-04 | |      20 |         160 |       00:05:34 |       93.33% |       96.88% |       0.0881 |       0.1176 |      1.0000e-04 | |======================================================================================================================| 

Inspeccione las tres últimas capas de la red entrenada. Tenga en cuenta que la capa de salida de clasificación menciona las tres etiquetas.

trainedGN.Layers(end-2:end) cNames = trainedGN.Layers(end).ClassNames 
 ans =     3x1 Layer array with layers:       1   'fc'            Fully Connected         3 fully connected layer      2   'softmax'       Softmax                 softmax      3   'classoutput'   Classification Output   crossentropyex with 'ARR' and 2 other classes  cNames =    3×1 cell array      {'ARR'}     {'CHF'}     {'NSR'}  

Evaluate GoogLeNet Accuracy

Evalúe la red utilizando los datos de validación.

[YPred,probs] = classify(trainedGN,imgsValidation); accuracy = mean(YPred==imgsValidation.Labels); display(['GoogLeNet Accuracy: ',num2str(accuracy)]) 
GoogLeNet Accuracy: 0.96875 

La precisión es idéntica a la precisión de validación notificada en la figura de visualización del entrenamiento. Los scalogramas se dividieron en colecciones de entrenamiento y validación. Ambas colecciones se utilizaron para entrenar GoogLeNet. La forma ideal de evaluar el resultado de la formación es hacer que la red clasifique los datos que no ha visto. Dado que hay una cantidad insuficiente de datos para dividir en entrenamiento, validación y pruebas, tratamos la precisión de validación calculada como la precisión de la red.

Explore GoogLeNet Activations

Cada capa de una CNN produce una respuesta, o activación, a una imagen de entrada. Sin embargo, hay sólo unas pocas capas dentro de una CNN que son adecuadas para la extracción de características de imagen. Las capas al principio de la red capturan las entidades de imagen básicas, como las aristas y los BLOBs. Para ver esto, visualice los pesos de filtro de red desde la primera capa convolucional. Hay 64 conjuntos individuales de pesos en la primera capa.

wghts = trainedGN.Layers(2).Weights; wghts = rescale(wghts); wghts = imresize(wghts,5); figure montage(wghts) title('First Convolutional Layer Weights') 

Puede examinar las activaciones y descubrir qué características aprende GoogLeNet comparando las áreas de activación con la imagen original. Para obtener más información, consulte y.Visualize Activations of a Convolutional Neural Network (Deep Learning Toolbox)Visualize Features of a Convolutional Neural Network (Deep Learning Toolbox)

Examine qué áreas de las capas convolucionales se activan en una imagen de la clase.ARR Compare con las áreas correspondientes en la imagen original. Cada capa de una red neuronal convolucional consta de muchos arrays 2-D llamados.channels Pase la imagen a través de la red y examine las activaciones de salida de la primera capa convolucional,.'conv1-7x7_s2'

convLayer = 'conv1-7x7_s2';  imgClass = 'ARR'; imgName = 'ARR_10.jpg'; imarr = imread(fullfile(parentDir,dataDir,imgClass,imgName));  trainingFeaturesARR = activations(trainedGN,imarr,convLayer); sz = size(trainingFeaturesARR); trainingFeaturesARR = reshape(trainingFeaturesARR,[sz(1) sz(2) 1 sz(3)]); figure montage(rescale(trainingFeaturesARR),'Size',[8 8]) title([imgClass,' Activations']) 

Encuentre el canal más fuerte para esta imagen. Compare el canal más fuerte con la imagen original.

imgSize = size(imarr); imgSize = imgSize(1:2); [~,maxValueIndex] = max(max(max(trainingFeaturesARR))); arrMax = trainingFeaturesARR(:,:,:,maxValueIndex); arrMax = rescale(arrMax); arrMax = imresize(arrMax,imgSize); figure; imshowpair(imarr,arrMax,'montage') title(['Strongest ',imgClass,' Channel: ',num2str(maxValueIndex)]) 

AlexNet

AlexNet es una CNN profunda cuya arquitectura admite imágenes de tamaño 227-by-227-by-3. Aunque las dimensiones de la imagen son diferentes para GoogLeNet, no tiene que generar nuevas imágenes RGB en las dimensiones de AlexNet. Puede utilizar las imágenes RGB originales.

Load

Cargue la red neuronal de AlexNet preentrenada. Si no está instalado el paquete de soporte técnico de Deep Learning Toolbox™ modelo, el software proporciona un vínculo al paquete de soporte técnico necesario en el explorador de complementos.for AlexNet Network Para instalar el paquete de soporte, haga clic en el vínculo y, a continuación, haga clic en.Install

alex = alexnet; 

Revise la arquitectura de red. Tenga en cuenta que la primera capa especifica el tamaño de entrada de la imagen como 227-by-227-by-3, y que AlexNet tiene menos capas que GoogLeNet.

layers = alex.Layers 
 layers =     25x1 Layer array with layers:       1   'data'     Image Input                   227x227x3 images with 'zerocenter' normalization      2   'conv1'    Convolution                   96 11x11x3 convolutions with stride [4  4] and padding [0  0  0  0]      3   'relu1'    ReLU                          ReLU      4   'norm1'    Cross Channel Normalization   cross channel normalization with 5 channels per element      5   'pool1'    Max Pooling                   3x3 max pooling with stride [2  2] and padding [0  0  0  0]      6   'conv2'    Grouped Convolution           2 groups of 128 5x5x48 convolutions with stride [1  1] and padding [2  2  2  2]      7   'relu2'    ReLU                          ReLU      8   'norm2'    Cross Channel Normalization   cross channel normalization with 5 channels per element      9   'pool2'    Max Pooling                   3x3 max pooling with stride [2  2] and padding [0  0  0  0]     10   'conv3'    Convolution                   384 3x3x256 convolutions with stride [1  1] and padding [1  1  1  1]     11   'relu3'    ReLU                          ReLU     12   'conv4'    Grouped Convolution           2 groups of 192 3x3x192 convolutions with stride [1  1] and padding [1  1  1  1]     13   'relu4'    ReLU                          ReLU     14   'conv5'    Grouped Convolution           2 groups of 128 3x3x192 convolutions with stride [1  1] and padding [1  1  1  1]     15   'relu5'    ReLU                          ReLU     16   'pool5'    Max Pooling                   3x3 max pooling with stride [2  2] and padding [0  0  0  0]     17   'fc6'      Fully Connected               4096 fully connected layer     18   'relu6'    ReLU                          ReLU     19   'drop6'    Dropout                       50% dropout     20   'fc7'      Fully Connected               4096 fully connected layer     21   'relu7'    ReLU                          ReLU     22   'drop7'    Dropout                       50% dropout     23   'fc8'      Fully Connected               1000 fully connected layer     24   'prob'     Softmax                       softmax     25   'output'   Classification Output         crossentropyex with 'tench' and 999 other classes 

Modify AlexNet Network Parameters

Para volver a entrenar a AlexNet para clasificar nuevas imágenes, realice cambios similares a los hechos para GoogLeNet.

De forma predeterminada, las tres últimas capas de AlexNet están configuradas para 1000 categorías. Estas capas deben ajustarse a nuestro problema de clasificación de ECG. La capa 23, la capa completamente conectada, debe establecerse para tener el mismo tamaño que el número de categorías en nuestros datos de ECG. La capa 24 no necesita cambiar con nuestro problema de clasificación ECG. aplica una función softmax a la entrada.Softmax Consulte para obtener más información.softmaxLayer La capa 25, la capa de salida de clasificación, contiene el nombre de la función de pérdida utilizada para entrenar la red y las etiquetas de clase. Puesto que hay tres categorías del ECG, fije la capa 23 para ser una capa totalmente conectada del tamaño igual a 3, y fije la capa 25 para ser la capa de salida de la clasificación.

layers(23) = fullyConnectedLayer(3); layers(25) = classificationLayer; 

Prepare RGB Data for AlexNet

Las imágenes RGB tienen dimensiones apropiadas para la arquitectura GoogLeNet. Obtener de la primera capa de AlexNet las dimensiones de imagen utilizadas por AlexNet. Utilice esas cotas para crear almacenes de datos de imagen aumentada que redimensionarán automáticamente las imágenes RGB existentes para la arquitectura de AlexNet. Para obtener más información, consulte.augmentedImageDatastore

inputSize = alex.Layers(1).InputSize; augimgsTrain = augmentedImageDatastore(inputSize(1:2),imgsTrain); augimgsValidation = augmentedImageDatastore(inputSize(1:2),imgsValidation); 

Set Training Options and Train AlexNet

Establezca las opciones de entrenamiento para que coincidan con las utilizadas para GoogLeNet. Entonces entrena a AlexNet. El proceso de entrenamiento suele tardar 1-5 minutos en una CPU de escritorio.

rng default mbSize = 10; mxEpochs = 10; ilr = 1e-4; plt = 'training-progress';  opts = trainingOptions('sgdm',...     'InitialLearnRate',ilr, ...     'MaxEpochs',mxEpochs ,...     'MiniBatchSize',mbSize, ...     'ValidationData',augimgsValidation,...     'ExecutionEnvironment','cpu',...     'Plots',plt);  trainedAN = trainNetwork(augimgsTrain,layers,opts); 
Initializing input data normalization. |======================================================================================================================| |  Epoch  |  Iteration  |  Time Elapsed  |  Mini-batch  |  Validation  |  Mini-batch  |  Validation  |  Base Learning  | |         |             |   (hh:mm:ss)   |   Accuracy   |   Accuracy   |     Loss     |     Loss     |      Rate       | |======================================================================================================================| |       1 |           1 |       00:00:02 |       20.00% |       18.75% |       2.6121 |       1.9324 |      1.0000e-04 | |       4 |          50 |       00:00:34 |      100.00% |       87.50% |       0.0961 |       0.3066 |      1.0000e-04 | |       8 |         100 |       00:01:07 |      100.00% |       96.88% |       0.1020 |       0.1581 |      1.0000e-04 | |      10 |         130 |       00:01:27 |      100.00% |       93.75% |       0.0414 |       0.1236 |      1.0000e-04 | |======================================================================================================================| 

La precisión de validación es del 93,75%. Inspeccione las tres últimas capas de la red de AlexNet entrenada. Observe que la capa de salida de clasificación menciona las tres etiquetas.

trainedAN.Layers(end-2:end) 
 ans =     3x1 Layer array with layers:       1   'fc'            Fully Connected         3 fully connected layer      2   'prob'          Softmax                 softmax      3   'classoutput'   Classification Output   crossentropyex with 'ARR' and 2 other classes 

Conclusión

Este ejemplo muestra cómo utilizar el aprendizaje de transferencia y el análisis continuo de wavelet para clasificar tres clases de señales de ECG aprovechando los CNNs preentrenados GoogLeNet y AlexNet. Las representaciones de frecuencia horaria basadas en wavelet de las señales de ECG se utilizan para crear escalogramas. Se generan imágenes RGB de los scalogramas. Las imágenes se utilizan para afinar ambos CNNs profundos. También se exploraron activaciones de diferentes capas de red.

Este ejemplo ilustra un posible flujo de trabajo que puede utilizar para clasificar señales mediante modelos de CNN preentrenados. Otros flujos de trabajo son posibles. GoogLeNet y AlexNet son modelos preentrenados en un subconjunto de la base de datos de ImageNet [10], que se utiliza en el desafío de reconocimiento visual a gran escala de ImageNet (ILSVRC) [8]. La colección ImageNet contiene imágenes de objetos del mundo real como peces, pájaros, electrodomésticos y hongos. Los scalogramas caen fuera de la clase de objetos del mundo real. Con el fin de encajar en la arquitectura GoogLeNet y AlexNet, los scalogramas también experimentaron la reducción de datos. En lugar de afinar los CNNs preentrenados para distinguir diferentes clases de scalogramas, entrenar una CNN desde cero en las dimensiones originales del scalograma es una opción.

Referencias

  1. Baim, d. s., w. s. Colucci, E. S. Monrad, h. s. Smith, r. f. Wright, A. Lanoue, d. f. Gauthier, b. j. Ransil, W. Grossman, y E. Braunwald, entre otros. "La supervivencia de los pacientes con insuficiencia cardíaca congestiva severa tratada con milrinona oral." .Journal of the American College of Cardiology Vol. 7, número 3, 1986, págs. 661 – 670.

  2. Engin, M. "ECG ritmo clasificación utilizando red neuro-difusa." .Pattern Recognition Letters Vol. 25, número 15, 2004, págs. 1715 – 1722.

  3. Goldberger A. L., L. A. N. Amaral, L. Glass, j. m. Hausdorff, P. ch. Ivanov, r. g. Mark, j. e. Mietus, g. b. Moody, C.-K. Peng, y h. e. Stanley. "PhysioBank, PhysioToolkit y PhysioNet: Componentes de un nuevo recurso de investigación para señales fisiológicas complejas. " Circulación. Vol. 101, número 23: e215 – E220. [Circulación de páginas electrónicas; ]; 2000 (13 de junio). Doi:http://circ.ahajournals.org/content/101/23/e215.full 10.1161/01. CIR. 101.23. e215.

  4. Leonarduzzi, r. f., G. Schlotthauer, y m. e. Torres. "Análisis multifractal basado en el líder de wavelet de la variabilidad de la frecuencia cardíaca durante la isquemia miocárdica." En,, 110 – 113.Engineering in Medicine and Biology Society (EMBC)Annual International Conference of the IEEE Buenos Aires, Argentina: IEEE, 2010.

  5. Li, T., y M. Zhou. "Clasificación ECG usando la entropía de paquetes wavelet y bosques aleatorios." .Entropy Vol. 18, número 8, 2016, p. 285.

  6. Maharaj, e. m., y A. M. Alonso. "Análisis discriminante de series temporales multivariadas: Aplicación al diagnóstico basado en señales ECG. ".Computational Statistics and Data Analysis Vol. 70, 2014, págs. 67 – 87.

  7. Moody, g. b., y r. g. Mark. "El impacto de la base de datos de arritmias MIT-BIH." .IEEE Engineering in Medicine and Biology Magazine Vol. 20. Número 3, mayo-junio 2001, págs. 45 – 50. (PMID: 11446209)

  8. Russakovsky, O., J. Deng y H. su et al. "Desafío de reconocimiento visual a gran escala de ImageNet." .International Journal of Computer Vision Vol. 115, número 3, 2015, págs. 211 – 252.

  9. Zhao, Q., y L. Zhang. "Extracción y clasificación de características de ECG mediante la transformación de wavelet y máquinas de vectores de soporte." En, 1089 – 1092.IEEE International Conference on Neural Networks and Brain Pekín, China: IEEE, 2005.

  10. .ImageNethttp://www.image-net.org

Funciones de soporte

crea un directorio de datos dentro de un directorio principal y, a continuación, crea tres subdirectorios dentro del directorio de datos.helperCreateECGDataDirectories Los subdirectorios se nombran después de cada clase de señal de ECG encontrada en.ECGData

 function helperCreateECGDirectories(ECGData,parentFolder,dataFolder) % This function is only intended to support the ECGAndDeepLearningExample. % It may change or be removed in a future release.  rootFolder = parentFolder; localFolder = dataFolder; mkdir(fullfile(rootFolder,localFolder))  folderLabels = unique(ECGData.Labels); for i = 1:numel(folderLabels)     mkdir(fullfile(rootFolder,localFolder,char(folderLabels(i)))); end end  

traza las primeras mil muestras de un representante de cada clase de señal de ECG que se encuentra en.helperPlotRepsECGData

 function helperPlotReps(ECGData) % This function is only intended to support the ECGAndDeepLearningExample. % It may change or be removed in a future release.  folderLabels = unique(ECGData.Labels);  for k=1:3     ecgType = folderLabels{k};     ind = find(ismember(ECGData.Labels,ecgType));     subplot(3,1,k)     plot(ECGData.Data(ind(1),1:1000));     grid on     title(ecgType) end end  

utiliza para obtener la transformada de wavelet continua de las señales de ECG y genera los scalogramas a partir de los coeficientes de wavelet.helperCreateRGBfromTFcwtfilterbank La función auxiliar cambia el tamaño de los scalogramas y los escribe en el disco como imágenes JPEG.

 function helperCreateRGBfromTF(ECGData,parentFolder,childFolder) % This function is only intended to support the ECGAndDeepLearningExample. % It may change or be removed in a future release.  imageRoot = fullfile(parentFolder,childFolder);  data = ECGData.Data; labels = ECGData.Labels;  [~,signalLength] = size(data);  fb = cwtfilterbank('SignalLength',signalLength,'VoicesPerOctave',12); r = size(data,1);  for ii = 1:r     cfs = abs(fb.wt(data(ii,:)));     im = ind2rgb(im2uint8(rescale(cfs)),jet(128));          imgLoc = fullfile(imageRoot,char(labels(ii)));     imFileName = strcat(char(labels(ii)),'_',num2str(ii),'.jpg');     imwrite(imresize(im,[224 224]),fullfile(imgLoc,imFileName)); end end