trainNetwork
Entrenar redes neuronales de deep learning
Sintaxis
Descripción
Para tareas de clasificación y regresión, puede entrenar varios tipos de redes neuronales utilizando la función trainNetwork.
Por ejemplo, puede entrenar:
una red neuronal convolucional (ConvNet, CNN) para datos de imágenes
una red neuronal recurrente (RNN) como una memoria de corto-largo plazo (LSTM) o una red neuronal de una unidad recurrente cerrada (GRU) para datos de secuencia y series de tiempo
una red neuronal de perceptrón multicapa (MLP) para datos de características numéricas
Puede entrenar tanto en una CPU como en una GPU. Para la clasificación y la regresión de imágenes, puede entrenar una sola red neuronal en paralelo utilizando varias GPU o un grupo paralelo local o remoto. Para entrenar una red en una GPU o en paralelo, es necesario utilizar Parallel Computing Toolbox™. Para utilizar una GPU para deep learning, debe también disponer de un dispositivo GPU compatible. Para obtener información sobre los dispositivos compatibles, consulte GPU Computing Requirements (Parallel Computing Toolbox). Para especificar opciones de entrenamiento, incluidas opciones para el entorno de ejecución, utilice la función trainingOptions.
Cuando entrena una red neuronal, puede especificar los predictores y las respuestas como una sola entrada o en dos entradas independientes.
Ejemplos
Entrenar la red para clasificar imágenes
Cargue los datos como un objeto ImageDatastore.
digitDatasetPath = fullfile(matlabroot,'toolbox','nnet', ... 'nndemos','nndatasets','DigitDataset'); imds = imageDatastore(digitDatasetPath, ... 'IncludeSubfolders',true, ... 'LabelSource','foldernames');
El almacén de datos contiene 10.000 imágenes sintéticas con dígitos del 0 al 9. Las imágenes se generan aplicando transformaciones al azar a imágenes de dígitos creadas con diferentes fuentes. Cada imagen de dígito tiene 28 por 28 píxeles. El almacén de datos contiene la misma cantidad de imágenes por categoría.
Muestre algunas de las imágenes del almacén de datos.
figure numImages = 10000; perm = randperm(numImages,20); for i = 1:20 subplot(4,5,i); imshow(imds.Files{perm(i)}); drawnow; end
Divida el almacén de datos de forma que cada categoría del conjunto de entrenamiento contenga 750 imágenes y el conjunto de prueba contenga el resto de las imágenes de cada etiqueta.
numTrainingFiles = 750;
[imdsTrain,imdsTest] = splitEachLabel(imds,numTrainingFiles,'randomize');splitEachLabel divide los archivos de imagen de digitData en dos nuevos almacenes de datos, imdsTrain y imdsTest.
Defina la arquitectura de la red neuronal convolucional.
layers = [ ... imageInputLayer([28 28 1]) convolution2dLayer(5,20) reluLayer maxPooling2dLayer(2,'Stride',2) fullyConnectedLayer(10) softmaxLayer classificationLayer];
Establezca la configuración predeterminada de las opciones del gradiente descendente estocástico con momento. Establezca el número máximo de épocas en 20 y comience el entrenamiento con una tasa de aprendizaje inicial de 0,0001.
options = trainingOptions('sgdm', ... 'MaxEpochs',20,... 'InitialLearnRate',1e-4, ... 'Verbose',false, ... 'Plots','training-progress');
Entrene la red.
net = trainNetwork(imdsTrain,layers,options);
Ejecute la red entrenada en el conjunto de pruebas, que no se ha utilizado para entrenar la red, y prediga las etiquetas de imagen (dígitos).
YPred = classify(net,imdsTest); YTest = imdsTest.Labels;
Calcule la precisión. La precisión es la relación entre el número de etiquetas verdaderas de los datos de prueba que coinciden con las clasificaciones de classify y el número de imágenes de los datos de prueba.
accuracy = sum(YPred == YTest)/numel(YTest)
accuracy = 0.9400
Entrenar una red con imágenes aumentadas
Entrene una red neuronal convolucional con datos de imágenes aumentadas. El aumento de datos ayuda a evitar que la red se sobreajuste y memorice los detalles exactos de las imágenes de entrenamiento.
Cargue los datos de muestra, que están formados por imágenes sintéticas de dígitos manuscritos.
[XTrain,YTrain] = digitTrain4DArrayData;
digitTrain4DArrayData carga el conjunto de entrenamiento de dígitos como datos de un arreglo 4D. XTrain es un arreglo de 28 por 28 por 1 por 5000, donde:
28 es la altura y la anchura de las imágenes.
1 es el número de canales.
5000 es el número de imágenes sintéticas de dígitos manuscritos.
YTrain es un vector categórico que contiene las etiquetas para cada observación.
Reserve 1000 de las imágenes para la validación de la red.
idx = randperm(size(XTrain,4),1000); XValidation = XTrain(:,:,:,idx); XTrain(:,:,:,idx) = []; YValidation = YTrain(idx); YTrain(idx) = [];
Cree un objeto imageDataAugmenter que especifique las opciones de preprocesamiento para el aumento de imágenes, como el cambio de tamaño, la rotación, la traslación y la reflexión. Traslade aleatoriamente las imágenes hasta tres píxeles horizontal y verticalmente, y rote las imágenes con un ángulo de hasta 20 grados.
imageAugmenter = imageDataAugmenter( ... 'RandRotation',[-20,20], ... 'RandXTranslation',[-3 3], ... 'RandYTranslation',[-3 3])
imageAugmenter =
imageDataAugmenter with properties:
FillValue: 0
RandXReflection: 0
RandYReflection: 0
RandRotation: [-20 20]
RandScale: [1 1]
RandXScale: [1 1]
RandYScale: [1 1]
RandXShear: [0 0]
RandYShear: [0 0]
RandXTranslation: [-3 3]
RandYTranslation: [-3 3]
Cree un objeto augmentedImageDatastore para utilizarlo durante el entrenamiento de la red y especifique el tamaño de salida de la imagen. Durante el entrenamiento, el almacén de datos lleva a cabo el aumento de imágenes y cambia su tamaño. El almacén de datos aumenta las imágenes sin guardar ninguna en la memoria. trainNetwork actualiza los parámetros de la red y descarta las imágenes aumentadas.
imageSize = [28 28 1];
augimds = augmentedImageDatastore(imageSize,XTrain,YTrain,'DataAugmentation',imageAugmenter);Especifique la arquitectura de la red neuronal convolucional.
layers = [
imageInputLayer(imageSize)
convolution2dLayer(3,8,'Padding','same')
batchNormalizationLayer
reluLayer
maxPooling2dLayer(2,'Stride',2)
convolution2dLayer(3,16,'Padding','same')
batchNormalizationLayer
reluLayer
maxPooling2dLayer(2,'Stride',2)
convolution2dLayer(3,32,'Padding','same')
batchNormalizationLayer
reluLayer
fullyConnectedLayer(10)
softmaxLayer
classificationLayer];Especifique las opciones de entrenamiento para el gradiente descendente estocástico con momento.
opts = trainingOptions('sgdm', ... 'MaxEpochs',15, ... 'Shuffle','every-epoch', ... 'Plots','training-progress', ... 'Verbose',false, ... 'ValidationData',{XValidation,YValidation});
Entrene la red. Puesto que las imágenes de validación no son aumentadas, la precisión de validación es superior a la precisión de entrenamiento.
net = trainNetwork(augimds,layers,opts);
Entrenar la red para la regresión de imágenes
Cargue los datos de muestra, que están formados por imágenes sintéticas de dígitos manuscritos. La tercera salida contiene los ángulos correspondientes en grados en los que se ha rotado cada imagen.
Cargue las imágenes de entrenamiento como arreglos 4D mediante digitTrain4DArrayData. La salida XTrain es un arreglo de 28 por 28 por 1 por 5000, donde:
28 es la altura y la anchura de las imágenes.
1 es el número de canales.
5000 es el número de imágenes sintéticas de dígitos manuscritos.
YTrain contiene los ángulos de rotación en grados.
[XTrain,~,YTrain] = digitTrain4DArrayData;
Muestre 20 imágenes aleatorias de entrenamiento mediante imshow.
figure numTrainImages = numel(YTrain); idx = randperm(numTrainImages,20); for i = 1:numel(idx) subplot(4,5,i) imshow(XTrain(:,:,:,idx(i))) drawnow; end
Especifique la arquitectura de la red neuronal convolucional. Para problemas de regresión, incluya una capa de regresión al final de la red.
layers = [ ...
imageInputLayer([28 28 1])
convolution2dLayer(12,25)
reluLayer
fullyConnectedLayer(1)
regressionLayer];Especifique las opciones de entrenamiento de la red. Establezca la tasa de aprendizaje inicial en 0.001.
options = trainingOptions('sgdm', ... 'InitialLearnRate',0.001, ... 'Verbose',false, ... 'Plots','training-progress');
Entrene la red.
net = trainNetwork(XTrain,YTrain,layers,options);
Pruebe el rendimiento de la red evaluando la precisión de predicción de los datos de prueba. Utilice predict para predecir los ángulos de rotación de las imágenes de validación.
[XTest,~,YTest] = digitTest4DArrayData; YPred = predict(net,XTest);
Evalúe el rendimiento del modelo calculando el error cuadrático medio raíz (RMSE) del ángulo de rotación predicho y del real.
rmse = sqrt(mean((YTest - YPred).^2))
rmse = single
6.0516
Entrenar la red para clasificar secuencias
Entrene una red de LSTM de deep learning para la clasificación secuencia a etiqueta.
Cargue el conjunto de datos de las vocales japonesas tal y como se describe en [1] y [2]. XTrain es un arreglo de celdas que contiene 270 secuencias de diferentes longitudes con 12 características que se corresponden con coeficientes cepstrales LPC. Y es un vector categórico de las etiquetas 1,2,...,9. Las entradas de XTrain son matrices con 12 filas (una fila por característica) y un número variable de columnas (una columna por unidad de tiempo).
[XTrain,YTrain] = japaneseVowelsTrainData;
Visualice la primera serie de tiempo en una gráfica. Cada línea se corresponde con una característica.
figure
plot(XTrain{1}')
title("Training Observation 1")
numFeatures = size(XTrain{1},1);
legend("Feature " + string(1:numFeatures),'Location','northeastoutside')
Defina la arquitectura de la red de LSTM. Especifique el tamaño de la entrada como 12 (el número de características de los datos de entrada). Especifique una capa de LSTM con 100 unidades ocultas y que genere el último elemento de la secuencia. Por último, especifique nueve clases incluyendo una capa totalmente conectada de tamaño 9, seguida de una capa softmax y una capa de clasificación.
inputSize = 12; numHiddenUnits = 100; numClasses = 9; layers = [ ... sequenceInputLayer(inputSize) lstmLayer(numHiddenUnits,'OutputMode','last') fullyConnectedLayer(numClasses) softmaxLayer classificationLayer]
layers =
5x1 Layer array with layers:
1 '' Sequence Input Sequence input with 12 dimensions
2 '' LSTM LSTM with 100 hidden units
3 '' Fully Connected 9 fully connected layer
4 '' Softmax softmax
5 '' Classification Output crossentropyex
Especifique las opciones de entrenamiento. Especifique el solver como 'adam' y 'GradientThreshold' como 1. Establezca el tamaño del minilote en 27 y el número máximo de épocas en 70.
Dado que los minilotes son pequeños y tienen secuencias cortas, la CPU es más adecuada para el entrenamiento. Establezca 'ExecutionEnvironment' en 'cpu'. Para realizar un entrenamiento en una GPU, si está disponible, establezca 'ExecutionEnvironment' en 'auto' (el valor por defecto).
maxEpochs = 70; miniBatchSize = 27; options = trainingOptions('adam', ... 'ExecutionEnvironment','cpu', ... 'MaxEpochs',maxEpochs, ... 'MiniBatchSize',miniBatchSize, ... 'GradientThreshold',1, ... 'Verbose',false, ... 'Plots','training-progress');
Entrene la red de LSTM con las opciones de entrenamiento especificadas.
net = trainNetwork(XTrain,YTrain,layers,options);
Cargue el conjunto de prueba y clasifique las secuencias por hablantes.
[XTest,YTest] = japaneseVowelsTestData;
Clasifique los datos de prueba. Especifique el mismo tamaño de minilote utilizado para el entrenamiento.
YPred = classify(net,XTest,'MiniBatchSize',miniBatchSize);Calcule la precisión de clasificación de las predicciones.
acc = sum(YPred == YTest)./numel(YTest)
acc = 0.9568
Entrenar una red con características numéricas
Si tiene un conjunto de datos de características numéricas (por ejemplo, una colección de datos numéricos sin dimensiones espaciales ni temporales), puede entrenar una red de deep learning utilizando una capa de entrada de características.
Lea los datos de la caja de engranajes del archivo CSV "transmissionCasingData.csv".
filename = "transmissionCasingData.csv"; tbl = readtable(filename,'TextType','String');
Convierta las etiquetas para la predicción en categóricas utilizando la función convertvars.
labelName = "GearToothCondition"; tbl = convertvars(tbl,labelName,'categorical');
Para entrenar una red utilizando características categóricas, primero debe convertir las características categóricas en numéricas. Primero, convierta los predictores categóricos en numéricos con la función convertvars especificando un arreglo de cadena que contenga los nombres de todas las variables de entrada categórica. En este conjunto de datos, hay dos características categóricas con los nombres "SensorCondition" y "ShaftCondition".
categoricalInputNames = ["SensorCondition" "ShaftCondition"]; tbl = convertvars(tbl,categoricalInputNames,'categorical');
Forme un lazo con las variables de entrada categórica. Para cada variable:
Convierta los valores categóricos en vectores codificados one-hot usando la función
onehotencode.Añada los vectores one-hot a la tabla utilizando la función
addvars. Especifique que los vectores se inserten después de la columna que contiene los datos categóricos correspondientes.Elimine la columna correspondiente que contiene los datos categóricos.
for i = 1:numel(categoricalInputNames) name = categoricalInputNames(i); oh = onehotencode(tbl(:,name)); tbl = addvars(tbl,oh,'After',name); tbl(:,name) = []; end
Divida los vectores en columnas independientes utilizando la función splitvars.
tbl = splitvars(tbl);
Visualice las primeras filas de la tabla. Observe que los predictores categóricos se han dividido en varias columnas con los valores categóricos como los nombres de las variables.
head(tbl)
SigMean SigMedian SigRMS SigVar SigPeak SigPeak2Peak SigSkewness SigKurtosis SigCrestFactor SigMAD SigRangeCumSum SigCorrDimension SigApproxEntropy SigLyapExponent PeakFreq HighFreqPower EnvPower PeakSpecKurtosis No Sensor Drift Sensor Drift No Shaft Wear Shaft Wear GearToothCondition
________ _________ ______ _______ _______ ____________ ___________ ___________ ______________ _______ ______________ ________________ ________________ _______________ ________ _____________ ________ ________________ _______________ ____________ _____________ __________ __________________
-0.94876 -0.9722 1.3726 0.98387 0.81571 3.6314 -0.041525 2.2666 2.0514 0.8081 28562 1.1429 0.031581 79.931 0 6.75e-06 3.23e-07 162.13 0 1 1 0 No Tooth Fault
-0.97537 -0.98958 1.3937 0.99105 0.81571 3.6314 -0.023777 2.2598 2.0203 0.81017 29418 1.1362 0.037835 70.325 0 5.08e-08 9.16e-08 226.12 0 1 1 0 No Tooth Fault
1.0502 1.0267 1.4449 0.98491 2.8157 3.6314 -0.04162 2.2658 1.9487 0.80853 31710 1.1479 0.031565 125.19 0 6.74e-06 2.85e-07 162.13 0 1 0 1 No Tooth Fault
1.0227 1.0045 1.4288 0.99553 2.8157 3.6314 -0.016356 2.2483 1.9707 0.81324 30984 1.1472 0.032088 112.5 0 4.99e-06 2.4e-07 162.13 0 1 0 1 No Tooth Fault
1.0123 1.0024 1.4202 0.99233 2.8157 3.6314 -0.014701 2.2542 1.9826 0.81156 30661 1.1469 0.03287 108.86 0 3.62e-06 2.28e-07 230.39 0 1 0 1 No Tooth Fault
1.0275 1.0102 1.4338 1.0001 2.8157 3.6314 -0.02659 2.2439 1.9638 0.81589 31102 1.0985 0.033427 64.576 0 2.55e-06 1.65e-07 230.39 0 1 0 1 No Tooth Fault
1.0464 1.0275 1.4477 1.0011 2.8157 3.6314 -0.042849 2.2455 1.9449 0.81595 31665 1.1417 0.034159 98.838 0 1.73e-06 1.55e-07 230.39 0 1 0 1 No Tooth Fault
1.0459 1.0257 1.4402 0.98047 2.8157 3.6314 -0.035405 2.2757 1.955 0.80583 31554 1.1345 0.0353 44.223 0 1.11e-06 1.39e-07 230.39 0 1 0 1 No Tooth Fault
Visualice los nombres de las clases del conjunto de datos.
classNames = categories(tbl{:,labelName})classNames = 2x1 cell
{'No Tooth Fault'}
{'Tooth Fault' }
A continuación, divida el conjunto de datos en particiones de entrenamiento y de prueba. Reserve el 15% de los datos para las pruebas.
Determine el número de observaciones para cada partición.
numObservations = size(tbl,1); numObservationsTrain = floor(0.85*numObservations); numObservationsTest = numObservations - numObservationsTrain;
Cree un arreglo de índices aleatorios que se corresponda con las observaciones y divídalo utilizando los tamaños de partición.
idx = randperm(numObservations); idxTrain = idx(1:numObservationsTrain); idxTest = idx(numObservationsTrain+1:end);
Divida la tabla de datos en particiones de entrenamiento y de prueba utilizando los índices.
tblTrain = tbl(idxTrain,:); tblTest = tbl(idxTest,:);
Defina una red con una capa de entrada de características y especifique el número de características. Configure también la capa de entrada para normalizar los datos utilizando la normalización de puntuación Z.
numFeatures = size(tbl,2) - 1;
numClasses = numel(classNames);
layers = [
featureInputLayer(numFeatures,'Normalization', 'zscore')
fullyConnectedLayer(50)
batchNormalizationLayer
reluLayer
fullyConnectedLayer(numClasses)
softmaxLayer
classificationLayer];Especifique las opciones de entrenamiento.
miniBatchSize = 16; options = trainingOptions('adam', ... 'MiniBatchSize',miniBatchSize, ... 'Shuffle','every-epoch', ... 'Plots','training-progress', ... 'Verbose',false);
Entrene la red con la arquitectura definida por layers, los datos de entrenamiento y las opciones de entrenamiento.
net = trainNetwork(tblTrain,layers,options);
Prediga las etiquetas de los datos de prueba con la red entrenada y calcule la precisión. La precisión es la proporción de etiquetas que la red predice correctamente.
YPred = classify(net,tblTest,'MiniBatchSize',miniBatchSize);
YTest = tblTest{:,labelName};
accuracy = sum(YPred == YTest)/numel(YTest)accuracy = 0.9688
Argumentos de entrada
Argumentos de salida
Más acerca de
Referencias
[1] Kudo, M., J. Toyama, and M. Shimbo. "Multidimensional Curve Classification Using Passing-Through Regions." Pattern Recognition Letters. Vol. 20, No. 11–13, pp. 1103–1111.
[2] Kudo, M., J. Toyama, and M. Shimbo. Japanese Vowels Data Set. https://archive.ics.uci.edu/ml/datasets/Japanese+Vowels
Capacidades ampliadas
Historial de versiones
Introducido en R2016aConsulte también
trainingOptions | SeriesNetwork | DAGNetwork | LayerGraph | classify | predict | analyzeNetwork | assembleNetwork | Deep Network Designer
Temas
- Crear una red neuronal de deep learning sencilla para clasificación
- Transferencia del aprendizaje mediante una red preentrenada
- Entrenar una red neuronal convolucional para regresión
- Clasificación de secuencias mediante deep learning
- Train Network on Image and Feature Data
- Deep learning en MATLAB
- Define Custom Deep Learning Layers
- Lista de capas de deep learning
You can also select a web site from the following list:
Americas
- América Latina (Español)
- Canada (English)
- United States (English)
Europe
- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)
- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)