sim

Симулируйте нейронную сеть

Синтаксис

[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,...)

Получить справку

Введите help network/sim.

Описание

sim симулирует нейронные сети.

[Y,Xf,Af] = sim(net,X,Xi,Ai,T) берет

`net`	Сеть
`X`	Сетевые входные параметры
`Xi`	Начальный вход задерживает условия (значение по умолчанию = нули)
`Ai`	Начальные условия задержки слоя (значение по умолчанию = нули)
`T`	Сетевые цели (значение по умолчанию = нули)

и возвращается

`Y`	Сетевые выходные параметры
`Xf`	Итоговый вход задерживает условия
`Af`	Условия задержки последнего слоя

sim обычно называется неявно путем вызова нейронной сети как функции. Например, эти два выражения возвращают тот же результат:

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

Обратите внимание на то, что аргументы Xi, Ai, Xf, и Af являются дополнительными и должными являются только использоваться в сетях, которые ввели или задержки слоя.

Аргументы сигнала могут иметь два формата: массив ячеек или матрица.

Формат массива ячеек является самым легким описать. Это является самым удобным для сетей с несколькими вводами и выводами и позволяет последовательностям входных параметров быть представленными:

`X`	`Ni`- `TS` cellArray	Каждый элемент `X{i,ts}` `Ri`- `Q` матрица.
`Xi`	`Ni`- `ID` cellArray	Каждый элемент `Xi{i,k}` `Ri`- `Q` матрица.
`Ai`	`Nl`- `LD` cellArray	Каждый элемент `Ai{i,k}` `Si`- `Q` матрица.
`T`	`No`- `TS` cellArray	Каждый элемент `X{i,ts}` `Ui`- `Q` матрица.
`Y`	`No`- `TS` cellArray	Каждый элемент `Y{i,ts}` `Ui`- `Q` матрица.
`Xf`	`Ni`- `ID` cellArray	Каждый элемент `Xf{i,k}` `Ri`- `Q` матрица.
`Af`	`Nl`- `LD` cellArray	Каждый элемент `Af{i,k}` `Si`- `Q` матрица.

где

`Ni`	=	`net.numInputs`
`Nl`	=	`net.numLayers`
`No`	=	`net.numOutputs`
`ID`	=	`net.numInputDelays`
`LD`	=	`net.numLayerDelays`
`TS`	=	Количество временных шагов
`Q`	=	Пакетный размер
`Ri`	=	`net.inputs{i}.size`
`Si`	=	`net.layers{i}.size`
`Ui`	=	`net.outputs{i}.size`

Столбцы Xi, Ai, Xf, и Af упорядочены от самого старого условия задержки до нового:

`Xi{i,k}`	=	Введите `i` во время `ts = k - ID`
`Xf{i,k}`	=	Введите `i` во время `ts = TS + k - ID`
`Ai{i,k}`	=	Слой выход `i` во время `ts = k - LD`
`Af{i,k}`	=	Слой выход `i` во время `ts = TS + k - LD`

Матричный формат может использоваться, если только одним временным шагом должен быть симулированный (TS = 1). Это удобно для сетей только с одним вводом и выводом, но может также использоваться с сетями, которые имеют больше.

Каждый матричный аргумент найден путем хранения элементов соответствующего аргумента массива ячеек в одной матрице:

`X`	`(sum of Ri)`- `Q` матрица
`Xi`	`(sum of Ri)`- `(ID*Q)` матрица
`Ai`	`(sum of Si)`- `(LD*Q)` матрица
`T`	`(sum of Ui)`- `Q` матрица
`Y`	`(sum of Ui)`- `Q` матрица
`Xf`	`(sum of Ri)`- `(ID*Q)` матрица
`Af`	`(sum of Si)`- `(LD*Q)` матрица

[Y,Xf,Af] = sim(net,{Q TS},Xi,Ai) используется в сетях, которые не имеют входа, когда обозначение массива ячеек используется.

[Y,...] = sim(net,...,'useParallel',...), [Y,...] = sim(net,...,'useGPU',...), или [Y,...] = sim(net,...,'showResources',...) (или сеть, названная как функция), принимает, что дополнительные аргументы пары имя/значение управляют, как выполняются вычисления. Две из этих опций позволяют обучению произойти быстрее или на больших наборах данных с помощью параллельных рабочих или устройств графического процессора, если Parallel Computing Toolbox доступен. Это дополнительные пары имя/значение:

`'useParallel','no'`	Вычисления происходят на нормальном потоке MATLAB. Это - `'useParallel'` по умолчанию установка.
`'useParallel','yes'`	Вычисления происходят на параллельных рабочих, если параллельный пул открыт. В противном случае вычисления происходят на нормальном потоке MATLAB.
`'useGPU','no'`	Вычисления происходят на центральном процессоре. Это - значение по умолчанию 'useGPU' установка.
`'useGPU','yes'`	Вычисления происходят на текущем gpuDevice, если это - поддерживаемый графический процессор (См. Parallel Computing Toolbox для требований графического процессора.), Если текущий gpuDevice не поддержан, вычисления остаются на центральном процессоре. Если `'useParallel'` также `'yes'` и параллельный пул открыт, затем каждый рабочий с помощью уникального графического процессора использует тот графический процессор, другие рабочие выполняют вычисления на своих соответствующих ядрах процессора.
`'useGPU','only'`	Если никакой параллельный пул не открыт, то эта установка совпадает с `'yes'`. Если параллельный пул открыт, то только рабочие с помощью уникальных графических процессоров используются. Однако, если параллельный пул открыт, но не поддержал графические процессоры, доступны, то вычисления возвращаются к выполнению на всех центральных процессорах рабочего.
`'showResources','no'`	Не отображайте вычислительные ресурсы, используемые в командной строке. Это - настройка по умолчанию.
`'showResources','yes'`	Покажите в командной строке сводные данные вычислительных ресурсов, на самом деле используемых. Фактические ресурсы могут отличаться от требуемых ресурсов, если вычисление параллели или графического процессора требуют, но параллельный пул не открыт, или поддерживаемый графический процессор не доступен. Когда параллельные рабочие используются, режим расчета каждого рабочего описан, включая рабочих в пуле, которые не используются.

[Ycomposite,...] = sim(net,Xcomposite,...) берет Составные данные и возвращает Составные результаты. Если Составные данные используются, то 'useParallel' автоматически установлен в 'yes'.

[Ygpu,...] = sim(net,Xgpu,...) берет gpuArray данные и возвращает результаты gpuArray. Если gpuArray данные используются, то 'useGPU' автоматически установлен в 'yes'.

Примеры

В следующих примерах, sim функция вызвана неявно путем вызова объекта нейронной сети (net) как функция.

Симулируйте сети Feedforward

Этот пример загружает набор данных, который сопоставляет анатомические измерения x к содержаниям жира в организме t. Сеть feedforward с 10 нейронами создана и обучена на тех данных, затем симулировала.

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

Симулируйте сети временных рядов NARX

Этот пример обучает разомкнутый цикл нелинейно-авторегрессивная сеть с внешним входом, чтобы смоделировать поднимаемую магнитную систему, заданную управлением текущий x и ответ вертикального положения магнита t, затем симулирует сеть. Функциональный preparets готовит данные перед обучением и симуляцией. Это создает объединенные входные параметры сети разомкнутого цикла xo, который содержит обоих внешний вход x и предыдущие значения положения t. Это также готовится, задержка утверждает 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)

Эта та же система может также быть симулирована в форме с обратной связью.

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

Симулируйте параллельно на параллельном пуле

С Parallel Computing Toolbox можно симулировать и обучить нейронные сети быстрее и на больших наборах данных, чем может соответствовать на одном PC. Здесь обучение и симуляция происходят через параллельных работников MATLAB.

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

Симулируйте на графических процессорах

Используйте Составные значения, чтобы распределить данные вручную и возвратить результаты как Составное значение. Если данные загружаются, когда они распределяются, то, в то время как каждая часть набора данных должна поместиться в RAM, набор данных в целом ограничивается только общим RAM всех рабочих.

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');

Сети могут быть симулированы с помощью текущего устройства графического процессора, если оно поддерживается Parallel Computing Toolbox.

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

Поместить данные по графическому процессору вручную и получить результаты на графическом процессоре:

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

Чтобы запуститься параллельно, с рабочими, сопоставленными с помощью уникальных графических процессоров, использующих в своих интересах то оборудование, в то время как остальная часть рабочих используют центральные процессоры:

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

Только Используя рабочих с помощью уникальных графических процессоров может привести к более высоким скоростям, когда рабочие центрального процессора не могут поддержать на высоком уровне.

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

Алгоритмы

sim использование эти свойства симулировать сеть net.

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

Эти свойства определяют вес сети и смещают значения и количество задержек, сопоставленных с каждым весом:

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

Эти функциональные свойства указывают как sim применяет вес и значения смещения к входным параметрам, чтобы получить выход каждого слоя:

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

Смотрите также

adapt | init | revert | train

Документация

sim