\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`-by-`TS` массив ячеек	Каждым элементом `X{i,ts}` является `Ri`-by-`Q` матрица.
`Xi`	`Ni`-by-`ID` массив ячеек	Каждым элементом `Xi{i,k}` является `Ri`-by-`Q` матрица.
`Ai`	`Nl`-by-`LD` массив ячеек	Каждым элементом `Ai{i,k}` является `Si`-by-`Q` матрица.
`T`	`No`-by-`TS` массив ячеек	Каждым элементом `X{i,ts}` является `Ui`-by-`Q` матрица.
`Y`	`No`-by-`TS` массив ячеек	Каждым элементом `Y{i,ts}` является `Ui`-by-`Q` матрица.
`Xf`	`Ni`-by-`ID` массив ячеек	Каждым элементом `Xf{i,k}` является `Ri`-by-`Q` матрица.
`Af`	`Nl`-by-`LD` массив ячеек	Каждым элементом `Af{i,k}` является `Si`-by-`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)`-by-`Q` матрица
`Xi`	`(sum of Ri)`-by-`(ID*Q)` матрица
`Ai`	`(sum of Si)`-by-`(LD*Q)` матрица
`T`	`(sum of Ui)`-by-`Q` матрица
`Y`	`(sum of Ui)`-by-`Q` матрица
`Xf`	`(sum of Ri)`-by-`(ID*Q)` матрица
`Af`	`(sum of Si)`-by-`(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

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