sim

Simular una red neuronal

Sintaxis

[Y,Xf,Af] = sim(net,X,Xi,Ai,T)
[Y,Xf,Af] = sim(net,{Q TS},Xi,Ai)
[Y,...] = sim(net,...,'useParallel',...)
[Y,...] = sim(net,...,'useGPU',...)
[Y,...] = sim(net,...,'showResources',...)
[Ycomposite,...] = sim(net,Xcomposite,...)
[Ygpu,...] = sim(net,Xgpu,...)


Para obtener ayuda

Escriba help network/sim.

Descripción

sim simula redes neuronales.

[Y,Xf,Af] = sim(net,X,Xi,Ai,T) toma:

net	Network
X	Entradas de la red
Xi	Condiciones de retardo de entrada iniciales (valor predeterminado = ceros)
Ai	Condiciones de retardo de capa iniciales (valor predeterminado = ceros)
T	Objetivos de la red (valor predeterminado = ceros)

y devuelve

Y	Salidas de la red
Xf	Condiciones de retardo de entrada finales
Af	Condiciones de retardo de capa finales

Normalmente, se llama a sim implícitamente lllamando a la red neuronal como una función. Por ejemplo, estas dos expresiones devuelven el mismo resultado:

y = sim(net,x,xi,ai)
y = net(x,xi,ai)

Tenga en cuenta que los argumentos Xi, Ai, Xf y Af son opcionales y solo hay que usarlos para redes que tienen retardos de entrada o de capa.

Los argumentos de señal pueden tener dos formatos: arreglo de celdas o matriz.

El formato de arreglo de celdas es el más fácil de describir. Es más conveniente para redes con múltiples entradas y salidas, lo que permite presentar secuencias de entradas como las siguientes:

X	Arreglo de celdas de Ni por TS	Cada elemento X{i,ts} es una matriz de Ri por Q.
Xi	Arreglo de celdas de Ni por ID	Cada elemento Xi{i,k} es una matriz de Ri por Q.
Ai	Arreglo de celdas de Nl por LD	Cada elemento Ai{i,k} es una matriz de Si por Q.
T	Arreglo de celdas de No por TS	Cada elemento X{i,ts} es una matriz de Ui por Q.
Y	Arreglo de celdas de No por TS	Cada elemento Y{i,ts} es una matriz de Ui por Q.
Xf	Arreglo de celdas de Ni por ID	Cada elemento Xf{i,k} es una matriz de Ri por Q.
Af	Arreglo de celdas de Nl por LD	Cada elemento Af{i,k} es una matriz de Si por Q.

donde

Ni	=	net.numInputs
Nl	=	net.numLayers
No	=	net.numOutputs
ID	=	net.numInputDelays
LD	=	net.numLayerDelays
TS	=	Número de unidades de tiempo
Q	=	Tamaño del lote
Ri	=	net.inputs{i}.size
Si	=	net.layers{i}.size
Ui	=	net.outputs{i}.size

Las columnas de Xi, Ai, Xf y Af se ordenan desde el estado de retardo más antiguo hasta el más reciente:

Xi{i,k}	=	Entrada i en tiempo ts = k - ID
Xf{i,k}	=	Entrada i en tiempo ts = TS + k - ID
Ai{i,k}	=	Salida de capa i en tiempo ts = k - LD
Af{i,k}	=	Salida de capa i en tiempo ts = TS + k - LD

El formato de matriz se puede usar si solo hay que simular una unidad de tiempo ((TS = 1)). Resulta conveniente para redes con una única entrada y una única salida, pero también se puede usar con redes que tengan más.

Cada argumento de matriz se encuentra almacenando los elementos del argumento de arreglo de celdas correspondiente en una sola matriz:

X	Matriz de (sum of Ri) por Q
Xi	Matriz de (sum of Ri) por (ID*Q)
Ai	Matriz de (sum of Si) por (LD*Q)
T	Matriz de (sum of Ui) por Q
Y	Matriz de (sum of Ui) por Q
Xf	Matriz de (sum of Ri) por (ID*Q)
Af	Matriz de (sum of Si) por (LD*Q)

[Y,Xf,Af] = sim(net,{Q TS},Xi,Ai) se utiliza para redes que no cuentan con una entrada cuando se utiliza la notación de arreglo de celdas.

[Y,...] = sim(net,...,'useParallel',...), [Y,...] = sim(net,...,'useGPU',...) o [Y,...] = sim(net,...,'showResources',...) (o la red llamada como función) acepta argumentos opcionales de par nombre-valor para controlar cómo se realizan los cálculos. Dos de estas opciones permiten que el entrenamiento se realice más rápido o en conjuntos de datos más grandes empleando workers paralelos o dispositivos GPU si Parallel Computing Toolbox está disponible. Estos son los pares nombre-valor opcionales:

'useParallel','no'	Los cálculos tienen lugar en el hilo normal de MATLAB. Este es el ajuste de 'useParallel' por defecto.
'useParallel','yes'	Los cálculos tienen lugar en workers paralelos si hay un grupo paralelo abierto. En caso contrario, los cálculos tienen lugar en el hilo normal de MATLAB.
'useGPU','no'	Los cálculos tienen lugar en la CPU. Esta es la opción predeterminada de 'useGPU'.
'useGPU','yes'	Los cálculos tienen lugar en el gpuDevice actual, si se trata de una GPU compatible (consulte los requisitos de Parallel Computing Toolbox for GPU). Si no se admite el gpuDevice actual, los cálculos permanecen en la CPU. Si 'useParallel' es también 'yes' y si hay un grupo paralelo abierto, cada worker con una GPU única utiliza esa GPU; otros workers ejecutan cálculos en sus núcleos de CPU correspondientes.
'useGPU','only'	Si no hay ningún grupo paralelo abierto, este ajuste es el mismo que 'yes'. Si hay un grupo paralelo abierto, solo se usan workers con GPU únicas. Sin embargo, si hay un grupo paralelo abierto, pero no hay GPU compatibles disponibles, los cálculos vuelven a realizarse en todas las CPU de los workers.
'showResources','no'	No muestra los recursos de cálculo utilizados en la línea de comandos. Este es el ajuste por defecto.
'showResources','yes'	En la línea de comandos muestra un resumen de todos los recursos de cálculo utilizados realmente. Los recursos reales pueden diferir de los solicitados si se solicita cálculo paralelo o de GPU, pero no hay un grupo paralelo abierto, o si no hay una GPU admitida disponible. Cuando se utilizan workers paralelos, se describe el modo de cálculo de cada worker, incluidos los workers del grupo que no se utilizan.

[Ycomposite,...] = sim(net,Xcomposite,...) toma datos compuestos y devuelve resultados compuestos. Si se usan datos compuestos, 'useParallel' se establece automáticamente en 'yes'.

[Ygpu,...] = sim(net,Xgpu,...) toma datos gpuArray y devuelve resultados gpuArray. Si se usan datos gpuArray, 'useGPU' se establece automáticamente en 'yes'.

Ejemplos

En los ejemplos siguientes, se llama a la función sim implícitamente llamando al objeto de red neuronal (net) como una función.

Simular redes prealimentadas

En este ejemplo se carga un conjunto de datos que asigna medidas anatómicas x a porcentajes de grasa corporal t. Se crea y se entrena una red prealimentada con 10 neuronas con esos datos, y luego se simula.

[x,t] =  bodyfat_dataset;  
net = feedforwardnet(10);
net = train(net,x,t);

y = net(x);

Simular redes de series de tiempo NARX

Este ejemplo entrena una red autorregresiva no lineal de lazo abierto con entrada externa para modelar un sistema de levitación magnética definido por una corriente de control x y la respuesta de posición vertical t del imán; después, simula la red. La función preparets prepara los datos antes del entrenamiento y la simulación. Crea las entradas combinadas xo de la red de lazo abierto, que contienen tanto la entrada externa x como los valores de posición t anteriores. También prepara los estados de retardo xi.

[x,t] = maglev_dataset;
net = narxnet(10);
[xo,xi,~,to] = preparets(net,x,{},t);
net = train(net,xo,to,xi);
y = net(xo,xi)

Este mismo sistema se puede simular también en forma de lazo cerrado.

netc = closeloop(net);
view(netc)
[xc,xi,ai,tc] = preparets(netc,x,{},t);
yc = netc(xc,xi,ai);

Simular una red en paralelo en un grupo paralelo

Con Parallel Computing Toolbox, podrá simular y entrenar redes más rápido y con conjuntos de datos más grandes de los que caben en un PC. Actualmente, el entrenamiento y la simulación se producen en workers de MATLAB paralelos.

parpool
[X,T] = vinyl_dataset;
net = feedforwardnet(10);
net = train(net,X,T,'useParallel','yes','showResources','yes');
Y = net(X,'useParallel','yes');

Simulación en unidades GPU

Utilice valores compuestos para distribuir manualmente los datos y obtener los resultados como un valor compuesto. Si se cargan los datos a la vez que se distribuyen, entonces, aunque cada elemento del conjunto de datos debe caber en la RAM, el conjunto de datos completo solo está limitado por la RAM total de todos los workers.

Xc = Composite;
for i=1:numel(Xc)
    Xc{i} = X+rand(size(X))*0.1;  % Use real data instead of random
end
Yc = net(Xc,'showResources','yes');

Las redes se pueden simular utilizando el dispositivo GPU actual, si Parallel Computing Toolbox lo admite.

gpuDevice % Check if there is a supported GPU
Y = net(X,'useGPU','yes','showResources','yes');

Para introducir datos manualmente en una GPU y obtener los resultados de la GPU:

Xgpu = gpuArray(X);
Ygpu = net(Xgpu,'showResources','yes');
Y = gather(Ygpu);

Para ejecutar en paralelo, con workers asociados a unidades GPU únicas aprovechando ese hardware, mientras que el resto de los workers usan unidades CPU:

Y = net(X,'useParallel','yes','useGPU','yes','showResources','yes');

Utilizar solo workers con GPU únicas puede dar lugar a una velocidad mayor, ya que puede que los workers de la CPU no sigan el ritmo.

Y = net(X,'useParallel','yes','useGPU','only','showResources','yes');

Algoritmos

sim emplea estas propiedades para simular una red net.

net.numInputs, net.numLayers
net.outputConnect, net.biasConnect
net.inputConnect, net.layerConnect

Estas propiedades determinan los valores de peso y sesgo de la red, así como el número de retardos asociados a cada peso:

net.IW{i,j}
net.LW{i,j}
net.b{i}
net.inputWeights{i,j}.delays
net.layerWeights{i,j}.delays

Estas propiedades de función indican cómo sim aplica los valores de peso y sesgo a las entradas para obtener la salida de cada capa:

net.inputWeights{i,j}.weightFcn
net.layerWeights{i,j}.weightFcn
net.layers{i}.netInputFcn
net.layers{i}.transferFcn

Historial de versiones

Introducido antes de R2006a

Consulte también

init | adapt | train | revert