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.

Layer

Capa de red para deep learning

Descripción

Capas que definen la arquitectura de las redes neuronales de deep learning.

Creación

Para ver una lista de las capas de deep learning de MATLAB^®, consulte Lista de capas de deep learning. Para especificar la arquitectura de una red neuronal con todas las capas conectadas de forma secuencial, cree directamente un arreglo de capas. Para especificar la arquitectura de una red en la que las capas puedan tener varias entradas o salidas, use un objeto LayerGraph.

De manera alternativa, puede importar capas de Caffe, Keras y ONNX usando importCaffeLayers, importKerasLayers y importONNXLayers, respectivamente.

Para aprender a crear sus propias capas personalizadas, consulte Define Custom Deep Learning Layers.

Funciones del objeto

trainNetwork

Entrenar redes neuronales de deep learning

Ejemplos

Construir una arquitectura de red

Defina una arquitectura de red neuronal convolucional para la clasificación con una capa convolucional, una capa ReLU y una capa totalmente conectada.

layers = [ ...
    imageInputLayer([28 28 3])
    convolution2dLayer([5 5],10)
    reluLayer
    fullyConnectedLayer(10)
    softmaxLayer
    classificationLayer]

layers = 
  6x1 Layer array with layers:

     1   ''   Image Input             28x28x3 images with 'zerocenter' normalization
     2   ''   2-D Convolution         10 5x5 convolutions with stride [1  1] and padding [0  0  0  0]
     3   ''   ReLU                    ReLU
     4   ''   Fully Connected         10 fully connected layer
     5   ''   Softmax                 softmax
     6   ''   Classification Output   crossentropyex

layers es un objeto Layer.

De manera alternativa, puede crear las capas individualmente y, después, concatenarlas.

input = imageInputLayer([28 28 3]);
conv = convolution2dLayer([5 5],10);
relu = reluLayer;
fc = fullyConnectedLayer(10);
sm = softmaxLayer;
co = classificationLayer;

layers = [ ...
    input
    conv
    relu
    fc
    sm
    co]

layers = 
  6x1 Layer array with layers:

     1   ''   Image Input             28x28x3 images with 'zerocenter' normalization
     2   ''   2-D Convolution         10 5x5 convolutions with stride [1  1] and padding [0  0  0  0]
     3   ''   ReLU                    ReLU
     4   ''   Fully Connected         10 fully connected layer
     5   ''   Softmax                 softmax
     6   ''   Classification Output   crossentropyex

Acceder a las capas y las propiedades de un arreglo de capas

Defina una arquitectura de red neuronal convolucional para la clasificación con una capa convolucional, una capa ReLU y una capa totalmente conectada.

layers = [ ...
    imageInputLayer([28 28 3])
    convolution2dLayer([5 5],10)
    reluLayer
    fullyConnectedLayer(10)
    softmaxLayer
    classificationLayer];

Muestre la capa de entrada de imagen seleccionando la primera capa.

layers(1)

ans = 
  ImageInputLayer with properties:

                      Name: ''
                 InputSize: [28 28 3]
        SplitComplexInputs: 0

   Hyperparameters
          DataAugmentation: 'none'
             Normalization: 'zerocenter'
    NormalizationDimension: 'auto'
                      Mean: []

Vea el tamaño de entrada de la capa de entrada de imagen.

layers(1).InputSize

ans = 1×3

    28    28     3

Muestre el tramo de la capa convolucional.

layers(2).Stride

ans = 1×2

     1     1

Acceda al factor de tasa de aprendizaje de sesgos de la capa totalmente conectada.

layers(4).BiasLearnRateFactor

ans = 1

Crear una red DAG simple

Cree una red gráfica acíclica dirigida (DAG) simple de deep learning. Entrene a la red para clasificar imágenes de dígitos. La red simple de este ejemplo está compuesta por lo siguiente:

• Una rama principal con capas conectadas de forma secuencial.

• Una conexión de atajo que contiene una sola capa convolucional de 1 por 1. Las conexiones de atajo permiten que los gradientes de parámetros fluyan con mayor facilidad desde la capa de salida a las primeras capas de la red.

Cree la rama principal de la red como un arreglo de capas. La capa de suma añade varias entradas elemento por elemento. Especifique el número de entradas que debe sumar la capa de suma. Para añadir conexiones con facilidad más tarde, especifique los nombres de la primera capa ReLU y de la capa de suma.

layers = [
    imageInputLayer([28 28 1])
    
    convolution2dLayer(5,16,'Padding','same')
    batchNormalizationLayer
    reluLayer('Name','relu_1')
    
    convolution2dLayer(3,32,'Padding','same','Stride',2)
    batchNormalizationLayer
    reluLayer
    convolution2dLayer(3,32,'Padding','same')
    batchNormalizationLayer
    reluLayer
    
    additionLayer(2,'Name','add')
    
    averagePooling2dLayer(2,'Stride',2)
    fullyConnectedLayer(10)
    softmaxLayer
    classificationLayer];

Cree una gráfica de capas a partir del arreglo de capas. layerGraph conecta todas las capas de layers secuencialmente. Represente la gráfica de capas.

lgraph = layerGraph(layers);
figure
plot(lgraph)

Cree la capa convolucional de 1 por 1 y añádala a la gráfica de capas. Especifique el número de filtros convolucionales y el tramo, para que el tamaño de activación coincida con el tamaño de activación de la tercera capa ReLU. Este ajuste permite que la capa de suma añada las salidas de la tercera capa ReLU y de la capa convolucional de 1 por 1. Para comprobar que la capa se encuentra en la gráfica, represente la gráfica de capas.

skipConv = convolution2dLayer(1,32,'Stride',2,'Name','skipConv');
lgraph = addLayers(lgraph,skipConv);
figure
plot(lgraph)

Cree la conexión de atajo desde la capa 'relu_1' a la capa 'add'. Dado que especificó 2 como el número de entradas de la capa de suma durante su creación, la capa tiene dos entradas llamadas 'in1' y 'in2'. La tercera capa ReLU ya está conectada a la entrada 'in1'. Conecte la capa 'relu_1' a la capa 'skipConv', y la capa 'skipConv' a la entrada 'in2' de la capa 'add'. Ahora, la capa de suma sumará las salidas de la tercera capa ReLU y de la capa 'skipConv'. Para comprobar que las capas se han conectado correctamente, represente la gráfica de capas.

lgraph = connectLayers(lgraph,'relu_1','skipConv');
lgraph = connectLayers(lgraph,'skipConv','add/in2');
figure
plot(lgraph);

Cargue los datos de entrenamiento y validación, que están formados por imágenes de dígitos de escala de grises de 28 por 28.

[XTrain,YTrain] = digitTrain4DArrayData;
[XValidation,YValidation] = digitTest4DArrayData;

Especifique las opciones de entrenamiento y entrene la red. trainNetwork valida la red usando los datos de validación cada ValidationFrequency iteraciones.

options = trainingOptions('sgdm', ...
    'MaxEpochs',8, ...
    'Shuffle','every-epoch', ...
    'ValidationData',{XValidation,YValidation}, ...
    'ValidationFrequency',30, ...
    'Verbose',false, ...
    'Plots','training-progress');
net = trainNetwork(XTrain,YTrain,lgraph,options);

Muestre las propiedades de la red entrenada. La red es un objeto DAGNetwork.

net

net = 
  DAGNetwork with properties:

         Layers: [16x1 nnet.cnn.layer.Layer]
    Connections: [16x2 table]
     InputNames: {'imageinput'}
    OutputNames: {'classoutput'}

Clasifique las imágenes de validación y calcule la precisión. La red es muy precisa.

YPredicted = classify(net,XValidation);
accuracy = mean(YPredicted == YValidation)

accuracy = 0.9934

Historial de versiones

Introducido en R2016a

Consulte también

importCaffeLayers | trainNetwork | LayerGraph | importKerasLayers | assembleNetwork

Temas

• Crear una red neuronal de deep learning sencilla para clasificación
• Entrenar una red neuronal convolucional para regresión
• Deep learning en MATLAB
• Specify Layers of Convolutional Neural Network
• Lista de capas de deep learning
• Define Custom Deep Learning Layers

×

Abrir ejemplo

Tiene una versión modificada de este ejemplo. ¿Desea abrir este ejemplo con sus modificaciones?

No, sobrescribir la versión modificada Sí