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 | Cada elemento |
Xi | Arreglo de celdas de | Cada elemento |
Ai | Arreglo de celdas de | Cada elemento |
T | Arreglo de celdas de | Cada elemento |
Y | Arreglo de celdas de | Cada elemento |
Xf | Arreglo de celdas de | Cada elemento |
Af | Arreglo de celdas de | Cada elemento |
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 |
Xf{i,k} | = | Entrada |
Ai{i,k} | = | Salida de capa |
Af{i,k} | = | Salida de capa |
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 |
Xi | Matriz de |
Ai | Matriz de |
T | Matriz de |
Y | Matriz de |
Xf | Matriz de |
Af | Matriz de |
[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','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 |
'useGPU','only' | Si no hay ningún grupo paralelo abierto, este ajuste es el mismo que |
'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