forward

Calcular salidas de redes de deep learning para entrenamiento

Sintaxis

[Y1,...,YN] = forward(net,X1,...,XM)

[Y1,...,YN,state] = forward(X1,...,XM)

[Y1,...,YN,state,pruningActivations] = forward(X1,...,XM)

___ = forward(___,Name=Value)

Descripción

Algunas capas de deep learning se comportan de forma diferente durante el entrenamiento y la inferencia (predicción). Por ejemplo, durante el entrenamiento, las capas de abandono establecen elementos en cero de forma aleatoria para ayudar a evitar el sobreajuste, pero, durante la inferencia, las capas de abandono no cambian la entrada.

Para calcular salidas de red para entrenamiento, utilice la función forward. Para calcular salidas de red para inferencia, utilice la función predict.

[Y1,...,YN] = forward(net,X1,...,XM) devuelve las salidas de red Y1, ..., YN para el entrenamiento dados los datos de entrada X1, ..., XM y la red neuronal net.

[Y1,...,YN,state] = forward(X1,...,XM) también devuelve el estado de red actualizado.

[Y1,...,YN,state,pruningActivations] = forward(X1,...,XM) también devuelve un arreglo de celdas de activaciones de las capas de poda. Esta sintaxis solo se puede aplicar si net es un objeto TaylorPrunableNetwork.

Para podar una red neuronal profunda, se requiere el paquete de soporte Deep Learning Toolbox™ Model Compression Library. Este paquete es un complemento gratuito que puede descargarse a través de Add-On Explorer. Como alternativa, consulte Deep Learning Toolbox Model Compression Library.

___ = forward(___,Name=Value) especifica opciones adicionales con uno o más argumentos nombre-valor.

Ejemplos

Entrenar una red con un bucle de entrenamiento personalizado

En este ejemplo se muestra cómo entrenar una red que clasifica dígitos manuscritos con una programación de tasa de aprendizaje personalizada.

Puede entrenar la mayoría de tipos de redes neuronales utilizando las funciones trainnet y trainingOptions. Si la función trainingOptions no proporciona las opciones que necesita (por ejemplo, un solver personalizado), puede definir su propio bucle de entrenamiento personalizado mediante los objetos dlarray y dlnetwork para la diferenciación automática. Para ver un ejemplo de cómo volver a entrenar una red de deep learning preentrenada mediante la función trainnet, consulte Volver a entrenar redes neuronales para clasificar nuevas imágenes.

El entrenamiento de una red neuronal profunda es una tarea de optimización. Considerando una red neuronal como una función $$f(X;\theta )$$, donde $$X$$ es la entrada de la red y $$\theta$$ es el conjunto de parámetros que se pueden aprender, puede optimizar $$\theta$$ para que minimice parte del valor de pérdida en función de los datos de entrenamiento. Por ejemplo, optimice los parámetros que se pueden aprender $$\theta$$ de modo que, para unas entradas determinadas $$X$$ con los objetivos correspondientes $$T$$, minimicen el error entre las predicciones $$Y=f(X;\theta )$$ y $$T$$.

La función de pérdida usada depende del tipo de tarea. Por ejemplo:

• En tareas de clasificación, puede minimizar el error de entropía cruzada entre las predicciones y los objetivos.

• En tareas de regresión, puede minimizar el error cuadrático medio entre las predicciones y los objetivos.

Puede optimizar el objetivo mediante el gradiente descendente: minimice la pérdida $$L$$ actualizando iterativamente los parámetros que se pueden aprender $$\theta$$ dando pasos hacia el mínimo utilizando los gradientes de pérdida con respecto a los parámetros que se pueden aprender. Los algoritmos de gradiente descendente suelen actualizar los parámetros que se pueden aprender utilizando una variante de un paso de actualización de la forma $${\theta }_{t+1}={\theta }_t-\rho \nabla L$$, donde $$t$$ es el número de iteración, $$\rho$$ es la tasa de aprendizaje y $$\nabla L$$ denota los gradientes (las derivadas de la pérdida con respecto a los parámetros que se pueden aprender).

En este ejemplo se entrena una red para clasificar dígitos manuscritos con el algoritmo de gradiente descendente estocástico (sin momento).

Cargar los datos de entrenamiento

Cargue los datos de dígitos como un almacén de datos de imágenes mediante la función imageDatastore y especifique la carpeta que contiene los datos de imagen.

unzip("DigitsData.zip")

imds = imageDatastore("DigitsData", ...
    IncludeSubfolders=true, ...
    LabelSource="foldernames");

Divida los datos en conjuntos de prueba y de entrenamiento. Reserve el 10% de los datos para las pruebas con la función splitEachLabel.

[imdsTrain,imdsTest] = splitEachLabel(imds,0.9,"randomize");

La red usada en este ejemplo requiere imágenes de entrada de un tamaño de 28 por 28 por 1. Para cambiar automáticamente el tamaño de las imágenes de entrenamiento, utilice un almacén de datos de imágenes aumentado. Especifique operaciones de aumento adicionales para realizar en las imágenes de entrenamiento: traslade aleatoriamente las imágenes hasta 5 píxeles a lo largo de los ejes vertical y horizontal. El aumento de datos ayuda a evitar que la red se sobreajuste y memorice los detalles exactos de las imágenes de entrenamiento.

inputSize = [28 28 1];
pixelRange = [-5 5];

imageAugmenter = imageDataAugmenter( ...
    RandXTranslation=pixelRange, ...
    RandYTranslation=pixelRange);

augimdsTrain = augmentedImageDatastore(inputSize(1:2),imdsTrain,DataAugmentation=imageAugmenter);

Para cambiar el tamaño de las imágenes de prueba de forma automática sin realizar más aumentos de datos, utilice un almacén de datos de imágenes aumentadas sin especificar ninguna operación adicional de preprocesamiento.

augimdsTest = augmentedImageDatastore(inputSize(1:2),imdsTest);

Determine el número de clases de los datos de entrenamiento.

classes = categories(imdsTrain.Labels);
numClasses = numel(classes);

Definir la red

Defina la red para la clasificación de imágenes.

• Para la entrada de imagen, especifique una capa de entrada de imagen con un tamaño de entrada que coincida con los datos de entrenamiento.

• No normalice la entrada de la imagen; establezca la opción Normalization de la capa de entrada en "none".

• Especifique tres bloques convolución-batchnorm-ReLU.

• Rellene la entrada a las capas de convolución de modo que la salida tenga el mismo tamaño estableciendo la opción Padding como "same".

• Para la primera capa de convolución, especifique 20 filtros de tamaño 5. Para las capas de convolución restantes, especifique 20 filtros de tamaño 3.

• Para la clasificación, especifique una capa totalmente conectada con un tamaño que coincida con el número de clases.

• Para asignar la salida a probabilidades, incluya una capa softmax.

Al entrenar una red mediante un bucle de entrenamiento personalizado, no incluya una capa de salida.

layers = [
    imageInputLayer(inputSize,Normalization="none")
    convolution2dLayer(5,20,Padding="same")
    batchNormalizationLayer
    reluLayer
    convolution2dLayer(3,20,Padding="same")
    batchNormalizationLayer
    reluLayer
    convolution2dLayer(3,20,Padding="same")
    batchNormalizationLayer
    reluLayer
    fullyConnectedLayer(numClasses)
    softmaxLayer];

Cree un objeto dlnetwork a partir del arreglo de capas.

net = dlnetwork(layers)

net = 
  dlnetwork with properties:

         Layers: [12×1 nnet.cnn.layer.Layer]
    Connections: [11×2 table]
     Learnables: [14×3 table]
          State: [6×3 table]
     InputNames: {'imageinput'}
    OutputNames: {'softmax'}
    Initialized: 1

  View summary with summary.

Definir la función de pérdida del modelo

El entrenamiento de una red neuronal profunda es una tarea de optimización. Considerando una red neuronal como una función $$f(X;\theta )$$, donde $$X$$ es la entrada de la red y $$\theta$$ es el conjunto de parámetros que se pueden aprender, puede optimizar $$\theta$$ para que minimice parte del valor de pérdida en función de los datos de entrenamiento. Por ejemplo, optimice los parámetros que se pueden aprender $$\theta$$ de modo que, para unas entradas determinadas $$X$$ con los objetivos correspondientes $$T$$, minimicen el error entre las predicciones $$Y=f(X;\theta )$$ y $$T$$.

Defina la función modelLoss. La función modelLoss toma un objeto net de dlnetwork, un minilote de datos de entrada X con objetivos correspondientes T y devuelve la pérdida, los gradientes de la pérdida con respecto a los parámetros que se pueden aprender en net y el estado de la red. Para calcular los gradientes automáticamente, utilice la función dlgradient.

function [loss,gradients,state] = modelLoss(net,X,T)

% Forward data through network.
[Y,state] = forward(net,X);

% Calculate cross-entropy loss.
loss = crossentropy(Y,T);

% Calculate gradients of loss with respect to learnable parameters.
gradients = dlgradient(loss,net.Learnables);

end

Definir funciones de SGD

Cree la función sgdStep, que toma los parámetros y los gradientes de la pérdida con respecto a los parámetros y devuelve los parámetros actualizados utilizando el algoritmo de gradiente descendente estocástico, expresado como $${\theta }_{t+1}={\theta }_t-\rho \nabla L$$, donde $$t$$ es el número de iteración, $$\rho$$ es la tasa de aprendizaje y $$\nabla L$$ denota los gradientes (las derivadas de la pérdida con respecto a los parámetros que se pueden aprender).

function parameters = sgdStep(parameters,gradients,learnRate)

parameters = parameters - learnRate .* gradients;

end

No es necesario definir una función de actualización personalizada para los bucles de entrenamiento personalizados. Como alternativa, puede utilizar funciones de actualización integradas como sgdmupdate, adamupdate y rmspropupdate.

Especificar las opciones de entrenamiento

Entrene con un tamaño de minilote de 128 y una tasa de aprendizaje de 0,01 durante quince épocas.

numEpochs = 15;
miniBatchSize = 128;
learnRate = 0.01;

Entrenar un modelo

Cree un objeto minibatchqueue que procese y gestione minilotes de imágenes durante el entrenamiento. Para cada minilote:

• Utilice la función de preprocesamiento de minilotes personalizada preprocessMiniBatch (definida al final de este ejemplo) para convertir los objetivos en vectores codificados one-hot.

• Dé formato a los datos de imagen con las etiquetas de dimensión "SSCB" (espacial, espacial, canal, lote). De forma predeterminada, el objeto minibatchqueue convierte los datos en objetos dlarray con el tipo subyacente single. No dé formato a los objetivos.

• Descarte los minilotes parciales.

• Entrene en una GPU, si se dispone de ella. De forma predeterminada, el objeto minibatchqueue convierte cada salida en gpuArray si hay una GPU disponible. 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).

mbq = minibatchqueue(augimdsTrain,...
    MiniBatchSize=miniBatchSize,...
    MiniBatchFcn=@preprocessMiniBatch,...
    MiniBatchFormat=["SSCB" ""], ...
    PartialMiniBatch="discard");

Calcule el número total de iteraciones para monitorizar el progreso del entrenamiento.

numObservationsTrain = numel(imdsTrain.Files);
numIterationsPerEpoch = floor(numObservationsTrain / miniBatchSize);
numIterations = numEpochs * numIterationsPerEpoch;

Inicialice el objeto TrainingProgressMonitor. Dado que el cronómetro empieza cuando crea el objeto de monitorización, asegúrese de crear el objeto cerca del bucle de entrenamiento.

monitor = trainingProgressMonitor( ...
    Metrics="Loss", ...
    Info="Epoch", ...
    XLabel="Iteration");

Entrene la red con un bucle de entrenamiento personalizado. Para cada época, cambie el orden de los datos y pase en bucle por minilotes de datos. Para cada minilote:

• Evalúe la pérdida, los gradientes y el estado del modelo utilizando las funciones dlfeval y modelLoss y actualice el estado de la red.

• Actualice los parámetros de red usando la función dlupdate con la función de actualización personalizada.

• Actualice la pérdida y los valores de época en la monitorización del progreso del entrenamiento.

• Detenga el proceso si la propiedad Stop de la monitorización se ha establecido como verdadero. El valor de la propiedad Stop del objeto TrainingProgressMonitor cambia a verdadero cuando hace clic en el botón Stop.

epoch = 0;
iteration = 0;

% Loop over epochs.
while epoch < numEpochs && ~monitor.Stop
    
    epoch = epoch + 1;

    % Shuffle data.
    shuffle(mbq);
    
    % Loop over mini-batches.
    while hasdata(mbq) && ~monitor.Stop

        iteration = iteration + 1;
        
        % Read mini-batch of data.
        [X,T] = next(mbq);
        
        % Evaluate the model gradients, state, and loss using dlfeval and the
        % modelLoss function and update the network state.
        [loss,gradients,state] = dlfeval(@modelLoss,net,X,T);
        net.State = state;
        
        % Update the network parameters using SGD.
        updateFcn = @(parameters,gradients) sgdStep(parameters,gradients,learnRate);
        net = dlupdate(updateFcn,net,gradients);
        
        % Update the training progress monitor.
        recordMetrics(monitor,iteration,Loss=loss);
        updateInfo(monitor,Epoch=epoch);
        monitor.Progress = 100 * iteration/numIterations;
    end
end

Probar un modelo

Pruebe la red neuronal con la función testnet. Evalúe la precisión de la clasificación de una sola etiqueta. La precisión es el porcentaje de predicciones correctas. De forma predeterminada, la función testnet usa una GPU en caso de que esté disponible. Para seleccionar el entorno de ejecución manualmente, utilice el argumento ExecutionEnvironment de la función testnet.

accuracy = testnet(net,augimdsTest,"accuracy")

accuracy = 
96.3000

Visualice las predicciones en una gráfica de confusión. Realice predicciones con la función minibatchpredict y convierta las puntuaciones de clasificación en etiquetas con la función scores2label. De forma predeterminada, la función minibatchpredict usa una GPU en caso de que esté disponible. Para seleccionar el entorno de ejecución manualmente, utilice el argumento ExecutionEnvironment de la función minibatchpredict.

scores = minibatchpredict(net,augimdsTest);
YTest = scores2label(scores,classes);

Visualice las predicciones en una gráfica de confusión.

TTest = imdsTest.Labels;
figure
confusionchart(TTest,YTest)

Los valores grandes de la diagonal indican predicciones precisas para la clase correspondiente. Los valores grandes fuera de la diagonal indican una fuerte confusión entre las clases correspondientes.​

Funciones de apoyo

Función de preprocesamiento de minilotes

La función preprocessMiniBatch preprocesa un minilote de predictores y etiquetas dando los siguientes pasos:

1. Preprocesa las imágenes usando la función preprocessMiniBatchPredictors.

2. Extrae los datos de la etiqueta del arreglo de celdas entrante y los concatena en un arreglo categórico a lo largo de la segunda dimensión.

3. Hace una codificación one-hot de las etiquetas categóricas en arreglos numéricos. La codificación en la primera dimensión produce un arreglo codificado que coincide con la forma de la salida de la red.

function [X,T] = preprocessMiniBatch(dataX,dataT)

% Preprocess predictors.
X = preprocessMiniBatchPredictors(dataX);

% Extract label data from cell and concatenate.
T = cat(2,dataT{:});

% One-hot encode labels.
T = onehotencode(T,1);

end

Función de preprocesamiento de predictores de minilotes

La función preprocessMiniBatchPredictors preprocesa un minilote de predictores extrayendo los datos de imagen del arreglo de celdas de entrada y concatenándolos en un arreglo numérico. Para la entrada en escala de grises, la concatenación sobre la cuarta dimensión añade una tercera dimensión a cada imagen, para usarla como dimensión de canal única.

function X = preprocessMiniBatchPredictors(dataX)

% Concatenate.
X = cat(4,dataX{:});

end

Argumentos de entrada

net — Red neuronal

objeto dlnetwork | objeto TaylorPrunableNetwork

Red neuronal, especificada como uno de estos valores:

• Objeto dlnetwork: red neuronal para bucles de entrenamiento personalizados.

• Objeto TaylorPrunableNetwork: red neuronal para bucles de poda personalizados.

Para podar una red neuronal profunda, se requiere el paquete de soporte Deep Learning Toolbox Model Compression Library. Este paquete es un complemento gratuito que puede descargarse a través de Add-On Explorer. Como alternativa, consulte Deep Learning Toolbox Model Compression Library.

X1,...,XM — Datos de entrada

objetos dlarray con formato | objetos dlarray sin formato | arreglos numéricos

Datos de entrada, cada uno especificado como uno de estos valores:

• Objeto dlarray con formato

• Objeto dlarray sin formato (desde R2025a)

• Arreglo numérico (desde R2025a)

La entrada Xi corresponde a la entrada de la red net.InputNames(i).

Para entrenar una red neuronal usando un bucle de entrenamiento personalizado que usa la diferenciación automática, los datos de entrada deben ser objetos dlarray con o sin formato.

Sugerencia

Las redes neuronales esperan datos de entrada con una disposición específica. Por ejemplo, las redes de clasificación de secuencias de vectores suelen esperar que las representaciones de secuencias de vectores sean arreglos de t por c, donde t y c son el número de unidades de tiempo y los canales de las secuencias, respectivamente. Las redes neuronales suelen tener una capa de entrada que especifica la disposición esperada de los datos.

La mayoría de los almacenes de datos y funciones generan como salida datos con la disposición que espera la red. Si los datos tienen una disposición diferente de lo que espera la red, indique que los datos tienen una disposición diferente usando la opción InputDataFormats o especificando los datos de entrada como un objeto dlarray con formato. Normalmente es más sencillo ajustar la opción de entrenamiento InputDataFormats que preprocesar los datos de entrada.

Para obtener más información, consulte Deep Learning Data Formats.

Para crear una red neuronal que recibe datos sin formato, use un objeto inputLayer y no especifique un formato. Para introducir datos sin formato en una red directamente, no debe especificar el argumento InputDataFormats. (desde R2025a)

Antes de R2025a: Para redes neuronales que no tengan capas de entrada, debe especificar un formato utilizando el argumento InputDataFormats o usar objetos dlarray con formato como entrada.

Argumentos de par nombre-valor

Especifique pares de argumentos opcionales como Name1=Value1,...,NameN=ValueN, donde Name es el nombre del argumento y Value es el valor correspondiente. Los argumentos de nombre-valor deben aparecer después de otros argumentos. Sin embargo, el orden de los pares no importa.

Ejemplo: forward(net,X,Outputs=["relu1" "relu2"]) especifica que se extraigan salidas de las capas con los nombres "relu1" y "relu2".

Outputs — Salidas de redes neuronales

arreglo de cadena | arreglo de celdas de vectores de caracteres

Salidas de redes neuronales, especificadas como arreglo de cadenas o arreglo de celdas de vectores de caracteres de nombres de capa o rutas de las salidas de las capas. Especifique la salida utilizando una de las siguientes formas:

• "layerName", donde layerName es el nombre de una capa con una única salida.

• "layerName/outputName", donde layerName es el nombre de una capa y outputName es el nombre de la salida de la capa. Use esta opción para las capas con varias salidas.

Para utilizar las salidas de las capas dentro de un objeto networkLayer, expanda, en primer lugar, la red anidada con la función expandLayers.

Si no especifica las capas de las que extraer las salidas, de forma predeterminada, el software utiliza las salidas especificadas por net.Outputs.

Acceleration — Optimización de rendimiento

"auto" (predeterminado) | "none"

Optimización del rendimiento, especificada como uno de estos valores:

• "auto": aplica automáticamente un número de optimizaciones adecuado para la red de entrada y los recursos de hardware.

• "none": deshabilita todas las optimizaciones.

El uso de la opción de aceleración "auto" puede ofrecer beneficios de rendimiento, pero a costa de un mayor tiempo de ejecución inicial. Las siguientes llamadas con parámetros compatibles son más rápidas. Utilice la optimización de rendimiento cuando planee llamar a la función varias veces con datos de entrada diferentes con el mismo tamaño y forma.

InputDataFormats — Descripción de dimensiones de datos de entrada

"auto" (predeterminado) | arreglo de cadena | arreglo de celdas de vectores de caracteres | vector de caracteres

Desde R2025a

Descripción de las dimensiones de los datos de entrada, especificada como un arreglo de cadenas, un vector de caracteres o un arreglo de celdas de vectores de caracteres.

Si InputDataFormats es "auto", el software usa los formatos esperados por la entrada de red. De lo contrario, el software usa los formatos especificados para la entrada de red correspondiente.

Un formato de datos es una cadena de caracteres, en la que cada carácter describe el tipo de la dimensión de datos correspondiente.

Los caracteres son los siguientes:

• "S": espacial

• "C": canal

• "B": lote

• "T": tiempo

• "U": sin especificar

Por ejemplo, considere una matriz que representa un lote de secuencias donde la primera, segunda y tercera dimensión corresponden a canales, observaciones y unidades de tiempo, respectivamente. Puede describir los datos como si tuvieran el formato "CBT" (canal, lote, tiempo).

Puede especificar varias dimensiones etiquetadas "S" o "U". Puede utilizar las etiquetas "C", "B" y "T" como máximo una vez cada una. El software ignora las dimensiones únicas "U" restantes tras la segunda dimensión.

Para redes neuronales con varias entradas net, especifique un arreglo de formatos de datos de entrada, donde InputDataFormats(i) corresponde a la entrada net.InputNames(i).

Para obtener más información, consulte Deep Learning Data Formats.

Para crear una red neuronal que recibe datos sin formato, use un objeto inputLayer y no especifique un formato. Para introducir datos sin formato en una red directamente, no debe especificar el argumento InputDataFormats. (desde R2025a)

Antes de R2025a: Para redes neuronales que no tengan capas de entrada, debe especificar un formato utilizando el argumento InputDataFormats o usar objetos dlarray con formato como entrada.

Tipos de datos: char | string | cell

OutputDataFormats — Descripción de dimensiones de datos de salida

"auto" (predeterminado) | arreglo de cadena | arreglo de celdas de vectores de caracteres | vector de caracteres

Desde R2025a

Descripción de las dimensiones de los datos de salida, especificada como uno de estos valores:

• "auto": si los datos de salida contienen el mismo número de dimensiones que los de entrada, la función forward usa el formato especificado por InputDataFormats. Si los datos de salida contienen un número de dimensiones distinto que los de entrada, la función forward permuta automáticamente las dimensiones de los datos de salida para que sean coherentes con las capas de entrada de la red o el valor InputDataFormats.

• Cadena, vector de caracteres o arreglo de celdas de vectores de caracteres: la función forward usa los formatos de datos especificados.

Un formato de datos es una cadena de caracteres, en la que cada carácter describe el tipo de la dimensión de datos correspondiente.

Los caracteres son los siguientes:

• "S": espacial

• "C": canal

• "B": lote

• "T": tiempo

• "U": sin especificar

Por ejemplo, considere una matriz que representa un lote de secuencias donde la primera, segunda y tercera dimensión corresponden a canales, observaciones y unidades de tiempo, respectivamente. Puede describir los datos como si tuvieran el formato "CBT" (canal, lote, tiempo).

Puede especificar varias dimensiones etiquetadas "S" o "U". Puede utilizar las etiquetas "C", "B" y "T" como máximo una vez cada una. El software ignora las dimensiones únicas "U" restantes tras la segunda dimensión.

Para obtener más información, consulte Deep Learning Data Formats.

Tipos de datos: char | string | cell

Argumentos de salida

Y1,...,YN — Datos de salida

Arreglo numérico | objeto dlarray

Datos de salida de red con varias salidas, devueltos como uno de estos valores:

• Objeto dlarray con formato

• Objeto dlarray sin formato (desde R2025a)

• Arreglo numérico (desde R2025a)

El tipo de datos coincide con el tipo de datos de los datos de entrada.

El orden de las salidas Y1, …, YN coincide con el de las salidas especificadas por el argumento Outputs.

Para una red neuronal de clasificación, los elementos de la salida corresponden a las puntuaciones para cada clase. El orden de las puntuaciones coincide con el de las categorías de los datos de entrenamiento. Por ejemplo, si entrena la red neuronal con las etiquetas categóricas TTrain, el orden de las puntuaciones coincide con el de las categorías dadas por categories(TTrain).

state — Estado de la red actualizado

tabla

Estado de la red actualizado, devuelto como tabla.

El estado de la red es una tabla con tres columnas:

• Layer: nombre de la capa, especificado como un escalar de cadena.

• Parameter: nombre del parámetro de estado, especificado como un escalar de cadena.

• Value: valor del parámetro de estado, especificado como un objeto dlarray.

Los estados de capa retienen información calculada durante la operación de capa que se retendrá para su uso en posteriores propagaciones de la capa. Por ejemplo, las capas LSTM contienen estados de celda y estados ocultos, y las capas de normalización de lotes calculan estadísticas de ejecución.

Para capas recurrentes, como las capas LSTM, con la propiedad HasStateInputs establecida en 1 (true), la tabla de estados no contiene entradas para los estados de la capa.

Actualice el estado de un objeto dlnetwork usando la propiedad State.

pruningActivations — Activaciones de las capas de poda

arreglo de celdas que contiene objetos dlarray

Arreglo de celdas de activaciones de las capas de poda, si la red de entrada es un objeto TaylorPrunableNetwork.

Capacidades ampliadas

Arreglos GPU

Acelere código mediante la ejecución en una unidad de procesamiento gráfico (GPU) mediante Parallel Computing Toolbox™.

La función forward es compatible con entradas de arreglos de GPU con estas notas y limitaciones de uso:

• Esta función se ejecuta en la GPU si cumple al menos una de estas condiciones:

  • Cualquiera de los valores de los parámetros que se pueden aprender de la red dentro de net.Learnables.Value son objetos dlarray con datos subyacentes de tipo gpuArray.

  • El argumento de entrada X es un objeto dlarray con datos subyacentes de tipo gpuArray.

Para obtener más información, consulte Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Historial de versiones

Introducido en R2019b

R2025a: Especificar arreglos numéricos y objetos dlarray sin formato

Si lo prefiere, especifique los formatos de los datos de entrada y salida usando las opciones InputDataFormats y OutputDataFormats, respectivamente. Si especifica datos sin formato como entrada para la red neuronal y no especifica el argumento InputDataFormats, la función pasa los datos sin formato a la red directamente.

Para crear una red neuronal que recibe datos sin formato, use un objeto inputLayer y no especifique un formato.

R2021a: forward devuelve valores de estado como objetos dlarray

Para objetos dlnetwork, el argumento de salida state devuelto por la función forward es una tabla que contiene los nombres y valores de los parámetros de estado de cada capa de la red.

A partir de la versión R2021a, los valores de estado son objetos dlarray. Este cambio permite mejorar la asistencia cuando se usan objetos AcceleratedFunction. Para acelerar las funciones de deep learning que tienen valores de entrada que cambian con frecuencia, por ejemplo, una entrada que contiene el estado de la red, los valores que cambian con frecuencia deben especificarse como objetos dlarray.

En versiones anteriores, los valores de estado son arreglos numéricos.

En la mayoría de los casos, no necesitará actualizar su código. Si tiene código que requiere que los valores de estado sean arreglos numéricos, para reproducir el comportamiento anterior, extraiga manualmente los datos de los valores de estado mediante la función extractdata con la función dlupdate.

state = dlupdate(@extractdata,net.State);

Consulte también

dlarray | dlgradient | dlfeval | predict | dlnetwork | TaylorPrunableNetwork

Temas

• Entrenar redes generativas antagónicas (GAN)
• Información sobre la diferenciación automática
• Define Custom Training Loops, Loss Functions, and Networks