Notebook "Нейронные сети" NOTEBOOK "НЕЙРОННЫЕ СЕТИ" Глава 2 С34. Единичная функция активации с жестким ограничением hardlim. Эта функция описывается соотношением a = hardlim(n) = 1(n) и равна 0, если n и равна 1, если n 0. Построим график этой функции в диапазоне значений входа от -5 до + 5:n = -5:0.1:5; plot(n,hardlim(n),'b+:'); ^ C34. Линейная функция активации purelin. Эта функция описывается соотношением a = purelin(n) = n. Построим график этой функции в диапазоне значений входа от -5 до + 5:n=-5:0.1:5; plot(n,purelin(n),'b+:'); ^ C34. Логистическая функция активации logsig. Эта функция описывается соотношением a = logsig(n) = 1/(1 + exp(-n)). Она принадлежит к классу сигмоидальных функций, и ее аргумент может принимать любое значение в диапазоне от - до +, а выход изменяется в диапазоне от 0 до 1. Благодаря свойству дифференцируемости, эта функция часто используется в сетях с обучением на основе метода обратного распространения ошибки. Построим график этой функции в диапазоне значений входа от -5 до + 5:n=-5:0.1:5; plot(n,logsig(n),'b+:'); ^ C42. Формирование архитектуры нейронной сети. Следующий оператор создает сеть с прямой передачей сигналаnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'traingd');gensim(net) Эта сеть использует один вектор входа с двумя элементами, имеющими допустимые границы значений [-1 2] и [0 5]; - имеет 2 слоя с 3 нейронами в первом слое и 1 нейроном во втором слое; - используемые функции активации: tansig - в первом слое, purelin – во втором слое; используемая функция обучения traingd. ^ C42. Инициализация нейронной сети. После того как сформирована архитектура сети, должны быть заданы начальные значения весов и смещений, или иными словами, сеть должна быть инициализирована. Такая процедура выполняется с помощью метода init для объектов класса network. Оператор вызова этого метода имеет видnet = init(net); Если мы хотим заново инициализировать веса и смещения в первом слое, используя функцию rands, то следует ввести следующую последовательность операторов:net.layers{1}.initFcn = 'initwb';net.inputWeights{1,1}.initFcn = 'rands';net.biases{1,1}.initFcn = 'rands';net.biases{2,1}.initFcn = 'rands';net = init(net);^ C43. Моделирование сети. Статическая нейронная сеть характеризуется тем, что в ее состав не входят линии задержки и обратные связи. Рассмотрим однослойную сеть с двухэлементным вектором входа и линейной функцией активации. Для задания такой сети предназначена М-функция newlin, которая требует указать минимальное и максимальное значения для каждого из элементов входа; в данном случае они равны –1 и 1, соответственно, а также количество слоев, в данном случае 1. Формирование однослойной линейной сети net с двухэлементным входным сигналом со значениями от -1 до 1:net = newlin([-1 1;-1 1],1); Определим весовую матрицу и смещение, равными ^ W = [1 2], b = 0, и зададим эти значения, используя описание структуры сетиnet.IW{1,1} = [1 2]; net.b{1} = 0; Предположим, что на сеть подается следующая последовательность из четырех векторов входа Поскольку сеть статическая, можно перегруппировать эту последовательность в следующий числовой массив P = [-1 0 0 1; 0 -1 1 -1]; Теперь можно моделировать сетьA = sim(net,P) A = -1 -2 2 -1 Результат следует интерпретировать следующим образом. На вход сети подается последовательность из 4 входных сигналов, и сеть генерирует вектор выхода из 4 элементов. ^ Динамическая нейронная сеть характеризуется тем, что в ее состав входят линии задержки и/или обратные связи. Когда сеть содержит линии задержки, вход сети следует рассматривать как последовательность векторов, подаваемых на сеть в определенные моменты времени. Создание однослойной линейной сети с линией задержки [0 1]:net = newlin([-1 1],1,[0 1]); Зададим следующую матрицу весов W=[1 2] и нулевое смещение:net.IW{1,1} = [1 2]; net.biasConnect = 0; Предположим, что входная последовательность имеет вид {-1, -1/2, 1/2, 1} и зададим ее в виде массива ячеекP = {-1 -1/2 1/2 1}; Теперь можно моделировать сеть, используя метод sim:A = sim(net,P) A = [-1] [-2.5000] [-0.5000] [2] Если те же самые входы подать на сеть одновременно, то получим совершенно иную реакцию. Для этого сформируем следующий вектор входаP = [-1 -1/2 1/2 1]; После моделирования получаемA = sim(net,P) A = -1.0000 -0.5000 0.5000 1.0000 Результат такой же как, если применить каждый вход к отдельной сети и вычислить ее выход. Поскольку начальные условия для элементов запаздывания не указаны, то по умолчанию они приняты нулевыми. В этом случае выход сети равен. Если требуется моделировать реакцию сети для нескольких последовательностей сигналов на входе, то следует сформировать массив ячеек, размер каждой из которых совпадает с числом таких последовательностей. Пусть, например, требуется приложить к сети две последовательности Вход P в этом случае должен быть массивом ячеек, каждая из которых содержит два элемента по числу последовательностейP = {[-1,1],[-1/2,1/2],[1/2,-1/2],[1,-1]}; Теперь можно моделировать сеть:A = sim(net,P); cat(1, A{:}) ans = -1.0000 1.0000 -2.5000 2.5000 -0.5000 0.5000 2.0000 -2.0000 Глава 3 ^ C52. Адаптация нейронных сетей. Статические сети. Воспользуемся следующей моделью однослойной линейной сети с двухэлементным вектором входа, значения которого находятся в интервале [–1 1] и нулевым параметром скорости настройкиclearnet = newlin([-1 1;-1 1],1, 0, 0); Требуется адаптировать параметры сети так, чтобы она формировала линейную зависимость вида^ Последовательный способ. Рассмотрим случай последовательного представления обучающей последовательности. В этом случае входы и целевой вектор формируются в виде массива формата cellP = {[-1; 1] [-1/3; 1/4] [1/2; 0] [1/6; 2/3]}; T = {-1 -5/12 1 1}; P1 = [P{:}], T1=[T{:}] P1 = -1.0000 -0.3333 0.5000 0.1667 1.0000 0.2500 0 0.6667 T1 = -1.0000 -0.4167 1.0000 1.0000 Сначала зададим сеть с нулевыми значениями начальных весов и смещенийnet.IW{1} = [0 0]; net.b{1} = 0; Выполним один цикл адаптации сети с нулевым параметром скорости настройки:[net1,a,e] = adapt(net,P,T); В этом случае веса не модифицируются, выходы сети остаются нулевыми, поскольку параметр скорости настройки равен нулю, адаптации сети не происходит. Погрешности совпадают со значениями целевой последовательностиnet1.IW{1, 1}, a, e ans = 0 0 a = [0] [0] [0] [0] e = [-1] [-0.4167] [1] [1] Зададим значения параметров скорости настройки и весов входа и смещения net.IW{1} = [0 0]; net.b{1} = 0; net.inputWeights{1,1}.learnParam.lr = 0.2;net.biases{1,1}.learnParam.lr = 0; Выполним один цикл настройки:[net1,a,e] = adapt(net,P,T); net1.IW{1, 1}, a, e ans = 0.3454 -0.0694 a = [0] [-0.1167] [0.1100] [-0.0918] e = [-1] [-0.3000] [0.8900] [1.0918] Теперь выполним последовательную адаптацию сети в течение 30 циклов:net = newlin([-1 1;-1 1],1, 0, 0); net.IW{1} = [0 0]; net.b{1} = 0; Зададим значения параметров скорости настройки для весов входа и смещения net.inputWeights{1,1}.learnParam.lr = 0.2;net.biases{1,1}.learnParam.lr = 0;P = {[-1; 1] [-1/3; 1/4] [1/2; 0] [1/6; 2/3]}; T = {-1 -5/12 1 1}; for i=1:30,[net,a{i},e{i}] = adapt(net,P,T);W(i,:)=net.IW{1,1};endmse(cell2mat(e{30})) ans = 0.0017 Веса после 30 циклов:W(30,:) ans = 1.9199 0.9250 cell2mat(a{30}) ans = -0.9944 -0.4086 0.9566 0.9301 cell2mat(e{30}) ans = -0.0056 -0.0081 0.0434 0.0699 Построим графики зависимости значений выходов сети и весовых коэффициентов в зависимости от числа итераций:subplot(3,1,1)plot(0:30,[[0 0 0 0];cell2mat(cell2mat(a'))],'k') xlabel(''), ylabel('Выходы a(i)'),gridsubplot(3,1,2)plot(0:30,[[0 0]; W],'k') xlabel(''), ylabel('Веса входов w(i)'),gridsubplot(3,1,3)for i=1:30, E(i) = mse(e{i}); endsemilogy(1:30, E,'+k') xlabel(' Циклы'), ylabel('Ошибка'),grid ^ Групповой способ. Рассмотрим случай группового представления обучающей последовательности. В этом случае входы и целевой вектор формируются в виде массива формата double:clearP = [-1 -1/3 1/2 1/6; 1 1/4 0 2/3];T = [-1 -5/12 1 1]; Основной цикл адаптации сети выглядит следующим образом:net3 = newlin([-1 1;-1 1],1, 0, 0.2); net3.IW{1} = [0 0]; net3.b{1} = 0; net3.inputWeights{1,1}.learnParam.lr = 0.2;EE = 10; i=1;while EE > 0.0017176[net3,a{i},e{i},pf] = adapt(net3,P,T);W(i,:) = net3.IW{1,1};EE = mse(e{i});ee(i)= EE;i = i+1;end Результатом адаптации являются следующие значения коэффициентов, значений выходов и среднеквадратической погрешности адаптацииW(63,:) ans = 1.9114 0.8477 cell2mat(a(63)) ans = -1.0030 -0.3624 1.0172 0.9426 EE = mse(e{63}) EE = 0.0016 mse(e{1}) ans = 0.7934 Процедура адаптации выходов и параметров нейронной сети иллюстрируется графиками: subplot(3,1,1)plot(0:63,[zeros(1,4); cell2mat(a')],'k') % Рис.3.2,axlabel(''), ylabel('Выходы a(i)'),gridsubplot(3,1,2)plot(0:63,[[0 0]; W],'k') % Рис.3.2,бxlabel(''), ylabel('Веса входов w(i)'),gridsubplot(3,1,3)semilogy(1:63, ee,'+k') % Рис.3.2,вxlabel('Циклы'), ylabel('Ошибка'),grid ^ С56. Динамические сети. Эти сети характеризуются наличием линий задержки, и для них последовательное представление входов является наиболее естественным. ^ Последовательный способ. Обратимся к линейной модели нейронной сети с одним входом и одним элементом запаздывания. Установим начальные условия на линии задержки, а также для весов и смещения равными нулю; а параметр скорости настройки равным 0.5.clearnet = newlin([-1 1],1,[0 1],0.5);Pi = {0}; net.IW{1} = [0 0]; net.biasConnect = 0; Чтобы применить последовательный способ адаптации, представим входы и цели как массивы ячеекP = {-1/2 1/3 1/5 1/4}; T = { -1 1/6 11/15 7/10}; Попытаемся адаптировать сеть формировать нужный выход на основе следующего соотношения y(t) = 2p(t) + p(t-1). Используем для этой цели М-функцию adapt и основной цикл адаптации сети с заданной погрешностью:EE = 10; i = 1;while EE > 0.0001[net,a{i},e{i},pf] = adapt(net,P,T); W(i,:)=net.IW{1,1};EE = mse(e{i});ee(i) = EE;i = i+1;end Сеть адаптировалась за 22 цикла. Результатом адаптации при заданной погрешности являются следующие значения коэффициентов, выходов нейронной сети и среднеквадратической погрешностиW(22,:) ans = 1.9830 0.9822 a{22} ans = [-0.9896] [0.1714] [0.7227] [0.6918] EE EE = 7.7874e-005 Построим графики зависимости выходов системы и весовых коэффициентов от числа циклов обучения:subplot(3,1,1)plot(0:22,[zeros(1,4); cell2mat(cell2mat(a'))],'k') % Рис.3.3,axlabel(''), ylabel('Выходы a(i)'),gridsubplot(3,1,2)plot(0:22,[[0 0]; W],'k') % Рис.3.3,бxlabel(''), ylabel('Веса входов w(i)'),gridsubplot(3,1,3)semilogy(1:22,ee,'+k') % Рис.3.3,вxlabel('Циклы'), ylabel('Ошибка'),grid ^ C58. Обучение нейронных сетей Статические сети. Воспользуемся моделью однослойной линейной сети с двухэлементным вектором входа, значения которого находятся в интервале [–1 1] и нулевым параметром скорости настройки, как это было для случая адаптации:clearnet = newlin([-1 1;-1 1],1, 0, 0); net.IW{1} = [0 0]; net.b{1} = 0; Требуется обучить параметры сети так, чтобы она формировала линейную зависимость вида.^ Последовательный способ. Представим обучающую последовательность в виде массивов ячеекP = {[-1; 1] [-1/3; 1/4] [1/2; 0] [1/6; 2/3]};T = {-1 -5/12 1 1}; Теперь все готово к обучению сети. Будем обучать ее с помощью функции train в течение 30 циклов. Для обучения и настройки параметров сети используем функции trainwb и learnwh, соответственно.net.inputWeights{1,1}.learnParam.lr = 0.2;net.biases{1}.learnParam.lr = 0; net.trainParam.epochs = 30; net1 = train(net,P,T); TRAINB, Epoch 0/30, MSE 0.793403/0. TRAINB, Epoch 25/30, MSE 0.00373997/0. TRAINB, Epoch 30/30, MSE 0.00138167/0. TRAINB, Maximum epoch reached. Параметры сети после обучения равны следующим значениямW = net1.IW{1} W = 1.9214 0.9260 y = sim(net1, P) y = [-0.9954] [-0.4090] [0.9607] [0.9376] EE = mse([y{:}]-[T{:}]) EE = 0.0014 ^ Групповой способ. Для этого представим обучающую последовательность в виде массивов формата double array:P = [-1 -1/3 1/2 1/6; 1 1/4 0 2/3];T = [-1 -5/12 1 1];net1 = train(net,P,T); TRAINB, Epoch 0/30, MSE 0.793403/0. TRAINB, Epoch 25/30, MSE 0.00373997/0. TRAINB, Epoch 30/30, MSE 0.00138167/0. TRAINB, Maximum epoch reached. Параметры сети после обучения равны следующим значениямW = net1.IW{1} W = 1.9214 0.9260 y = sim(net1, P) y = -0.9954 -0.4090 0.9607 0.9376 EE = mse(y-T) EE = 0.0014 ^ Динамические сети. Обучение динамических сетей выполняется аналогичным образом с использованием метода train. Последовательный способ. Обратимся к линейной модели нейронной сети с одним входом и одним элементом запаздывания. Установим начальные условия для элемента запаздывания, весов и смещения, равными нулю; параметр скорости настройки, равным 0.5.clearnet = newlin([-1 1],1,[0 1],0.5);Pi = {0}; net.IW{1} = [0 0]; net.biasConnect = 0; net.trainParam.epochs = 22; Чтобы применить последовательный способ обучения, представим входы и цели как массивы ячеекP = {-1/2 1/3 1/5 1/4}; T = { -1 1/6 11/15 7/10}; Используем для этой цели М-функцию trainnet1 = train(net, P, T, Pi); TRAINB, Epoch 0/22, MSE 0.513889/0. TRAINB, Epoch 22/22, MSE 3.65137e-005/0. TRAINB, Maximum epoch reached. Параметры сети после обучения равны следующим значениямW = net1.IW{1} W = 1.9883 0.9841 y = sim(net1, P) y = [-0.9941] [0.1707] [0.7257] [0.6939] EE = mse([y{:}]-[T{:}]) EE = 3.6514e-005 ^ Градиентные алгоритмы обучения. С67. Алгоритм GD. Алгоритм GD, или алгоритм градиентного спуска используется для такой корректировки весов и смещений, чтобы минимизировать функционал ошибки, то есть обеспечить движение по поверхности функционала в направлении, противоположном градиенту функционала по настраиваемым параметрам. Рассмотрим двухслойную нейронную сеть прямой передачи сигнала с сигмоидальным и линейным слоями для обучения ее на основе метода обратного распространения ошибки clearnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'traingd'); ^ Последовательная адаптация. Чтобы подготовить модель сети к процедуре последовательной адаптации на основе алгоритма GD, необходимо указать ряд параметров. В первую очередь, это имя функции настройки learnFcn, соответствующее алгоритму градиентного спуска, в данном случае – это М-функция learngd: net.biases{1,1}.learnFcn = 'learngd';net.biases{2,1}.learnFcn = 'learngd';net.layerWeights{2,1}.learnFcn = 'learngd';net.inputWeights{1,1}.learnFcn = 'learngd'; С функцией learngd связан лишь один параметр скорости настройки lr. Текущие приращения весов и смещений сети определяются умножением этого параметра на вектор градиента. Чем больше значение параметра, тем больше приращение на текущей итерации. Если параметр скорости настройки выбран слишком большим, алгоритм может стать неустойчивым; если параметр слишком мал, то алгоритм может потребовать длительного счета. При выборе функции learngd по умолчанию устанавливается следующее значение параметра скорости настройки net.layerWeights{2,1}.learnParam ans = lr: 0.0100 Увеличим значение этого параметра до 0.2net.layerWeights{2,1}.learnParam.lr = 0.2; Мы теперь почти готовы к обучению сети. Осталось задать обучающее множество. Это простое множество входов и целей определим следующим образомp = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1]; Поскольку используется последовательный способ обучения, необходимо преобразовать массивы входов и целей в массивы ячеекp = num2cell(p,1);t = num2cell(t,1); Последний параметр, который требуется установить при последовательном обучении, это число проходов net.adaptParam.passesnet.adaptParam.passes = 50; Теперь можно выполнить настройку параметров, используя процедуру адаптации[net,a,e] = adapt(net,p,t); Чтобы проверить качество обучения, после окончания обучения смоделируем сеть.a = sim(net,p) a = -1.0127 -0.9960 1.0189 0.9813 mse(e) ans = 2.4546e-004 ^ Групповое обучение. Для обучения сети на основе алгоритма GD необходимо использовать М-функцию traingd взамен функции настройки learngd. В этом случае нет необходимости задавать индивидуальные функции обучения для весов и смещений, а достаточно указать одну обучающую функцию для всей сети. Вновь создадим ту же двухслойную нейронную сеть прямой передачи сигнала с сигмоидальным и линейным слоями для обучения по методу обратного распространения ошибки net = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'traingd'); Функция traingd характеризуется следующими параметрами, заданными по умолчаниюnet.trainParam ans = epochs: 100 goal: 0 lr: 0.0100 max_fail: 5 min_grad: 1.0000e-010 show: 25 time: Inf Установим новые значения параметров обучения, зададим обучающую последовательность в виде массива double и выполним процедуру обучения net.trainParam.show = 50;net.trainParam.lr = 0.05;net.trainParam.epochs = 300;net.trainParam.goal = 1e-5;p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];net = train(net,p,t); % Рис.3.8 TRAINGD, Epoch 0/300, MSE 0.300839/1e-005, Gradient 0.884133/1e-010 TRAINGD, Epoch 50/300, MSE 0.00576418/1e-005, Gradient 0.0975344/1e-010 TRAINGD, Epoch 100/300, MSE 6.76541e-005/1e-005, Gradient 0.0109646/1e-010 TRAINGD, Epoch 121/300, MSE 9.98702e-006/1e-005, Gradient 0.00422134/1e-010 TRAINGD, Performance goal met. ^ С69. Алгоритм GDM Вновь рассмотрим двухслойную нейронную сеть прямой передачи сигнала с сигмоидальным и линейным слоями (рис. 3.7)clearnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'traingdm'); ^ Последовательная адаптация. Чтобы подготовить модель сети к процедуре последовательной адаптации на основе алгоритма GDM, необходимо указать ряд параметров. В первую очередь, это имя функции настройки learnFcn, соответствующее алгоритму градиентного спуска с возмущением, в данном случае – это М-функция learngdm: net.biases{1,1}.learnFcn = 'learngdm';net.biases{2,1}.learnFcn = 'learngdm';net.layerWeights{2,1}.learnFcn = 'learngdm';net.inputWeights{1,1}.learnFcn = 'learngdm'; С этой функцией связано два параметра - параметр скорости настройки lr и параметр возмущения mc. При выборе функции learngdm по умолчанию устанавливаются следующие значения этих параметров net.layerWeights{2,1}.learnParam ans = lr: 0.0100 mc: 0.9000 Увеличим значение параметра скорости обучения до 0.2net.layerWeights{2,1}.learnParam.lr = 0.2; Мы теперь почти готовы к обучению сети. Осталось задать обучающее множество и количество проходов, равное 50.p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];p = num2cell(p,1);t = num2cell(t,1);net.adaptParam.passes = 50;tic, [net,a,e] = adapt(net,p,t); tocelapsed_time = 4.78a, mse(e) elapsed_time = 3.4600 elapsed_time = 4.7800 a = [-0.9889] [-1.0007] [1.0182] [0.9917] ans = 1.3116e-004 Эти результаты сравнимы с результатами работы алгоритма GD, рассмотренного ранее. ^ Групповое обучение. Альтернативой последовательной адаптации является групповое обучение, которое основано на применении функции train. В этом режиме параметры сети модифицируются только после того, как реализовано все обучающее множество, и градиенты, рассчитанные для каждого элемента множества, суммируются, чтобы определить приращения настраиваемых параметров. Для обучения сети на основе алгоритма GDM необходимо использовать М-функцию traingdm взамен функции настройки learngdm. Различие этих двух функций состоит в следующем. Алгоритм функции traingdm суммирует градиенты, рассчитанные на каждом цикле обучения, а параметры модифицируются только после того, как все обучающие данные будут представлены. Если проведено N циклов обучения и для функционала ошибки оказалось выполненным условие , то параметр возмущения mc следует установить в нуль. Вновь обратимся к той же сетиclear net = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'traingdm'); Функция traingdm характеризуется следующими параметрами, заданными по умолчаниюnet.trainParam ans = epochs: 100 goal: 0 lr: 0.0100 max_fail: 5 mc: 0.9000 min_grad: 1.0000e-010 show: 25 time: Inf По сравнению с функцией traingd здесь добавляется только один параметр возмущения mc. Установим следующие значения параметров обученияnet.trainParam.epochs = 300;net.trainParam.goal = 1e-5;net.trainParam.lr = 0.05;net.trainParam.mc = 0.9;net.trainParam.show = 50;p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];net = train(net,p,t); TRAINGDM, Epoch 0/300, MSE 1.93032/1e-005, Gradient 3.53636/1e-010 TRAINGDM, Epoch 50/300, MSE 0.0176601/1e-005, Gradient 0.202784/1e-010 TRAINGDM, Epoch 100/300, MSE 0.000838074/1e-005, Gradient 0.0350156/1e-010 TRAINGDM, Epoch 146/300, MSE 9.1672e-006/1e-005, Gradient 0.00361773/1e-010 TRAINGDM, Performance goal met. На рис. приведен график изменения ошибки обучения в зависимости от числа выполненных циклов.a = sim(net,p) a = -0.9949 -1.0027 1.0011 1.0014 Поскольку начальные веса и смещения инициализируются случайным образом, графики ошибок могут отличаться от одной реализации к другой и от графиков на рис. 3.8-3.9 книги.^ С72. Алгоритм GDA Вновь обратимся к той же нейронной сети (рис. 3.7), но будем использовать функцию обучения traingdaclearnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'traingda'); Функция traingda характеризуется следующими параметрами по умолчанию:net.trainParam ans = epochs: 100 goal: 0 lr: 0.0100 lr_inc: 1.0500 lr_dec: 0.7000 max_fail: 5 max_perf_inc: 1.0400 min_grad: 1.0000e-006 show: 25 time: Inf Установим следующие значения этих параметров и выполним обучение:net.trainParam.epochs = 300;net.trainParam.goal = 1e-5;net.trainParam.lr = 0.05;net.trainParam.mc = 0.9;net.trainParam.show = 50;p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];net = train(net,p,t); % Рис.3.10 TRAINGDA, Epoch 0/300, MSE 8.20691e-006/1e-005, Gradient 0.0024486/1e-006 TRAINGDA, Performance goal met. Теперь выполним моделирование обученной нейронной сети:a = sim(net,p) a = -0.9989 -1.0007 0.9955 1.0032 ^ С73. Алгоритм Rprop Алгоритм Rprop использует функцию обучения trainrpclearnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'trainrp'); Функция trainrp характеризуется следующими параметрами, заданными по умолчанию:net.trainParam ans = epochs: 100 show: 25 goal: 0 time: Inf min_grad: 1.0000e-006 max_fail: 5 delt_inc: 1.2000 delt_dec: 0.5000 delta0: 0.0700 deltamax: 50 Установим следующие значения этих параметров:net.trainParam.show = 10;net.trainParam.epochs = 300;net.trainParam.goal = 1e-5;p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];net = train(net,p,t); % Рис.3.11 TRAINRP, Epoch 0/300, MSE 2.27506/1e-005, Gradient 3.27134/1e-006 TRAINRP, Epoch 10/300, MSE 0.0190078/1e-005, Gradient 0.28722/1e-006 TRAINRP, Epoch 20/300, MSE 6.80914e-005/1e-005, Gradient 0.0217624/1e-006 TRAINRP, Epoch 23/300, MSE 6.8422e-006/1e-005, Gradient 0.00289721/1e-006 TRAINRP, Performance goal met. a = sim(net,p) a = -0.9957 -1.0019 0.9995 1.0023 ^ Алгоритмы метода сопряженных градиентов. C76. Алгоритм CGF Алгоритм CGF использует функцию обучения traincgfclearnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'traincgf'); Функция traincgf по умолчанию характеризуется следующими параметрами:net.trainParam ans = epochs: 100 show: 25 goal: 0 time: Inf min_grad: 1.0000e-006 max_fail: 5 searchFcn: 'srchcha' scale_tol: 20 alpha: 0.0010 beta: 0.1000 delta: 0.0100 gama: 0.1000 low_lim: 0.1000 up_lim: 0.5000 maxstep: 100 minstep: 1.0000e-006 bmax: 26 Установим следующие значения параметров: net.trainParam.epochs = 300;net.trainParam.show = 5;net.trainParam.goal = 1e-5;p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];net = train(net,p,t); %Рис.3.12 TRAINCGF-srchcha, Epoch 0/300, MSE 0.711565/1e-005, Gradient 1.7024/1e-006 TRAINCGF-srchcha, Epoch 5/300, MSE 0.000975456/1e-005, Gradient 0.0253333/1e-006 TRAINCGF-srchcha, Epoch 10/300, MSE 3.06365e-005/1e-005, Gradient 0.00748491/1e-006 TRAINCGF-srchcha, Epoch 12/300, MSE 7.50883e-006/1e-005, Gradient 0.00189117/1e-006 TRAINCGF, Performance goal met. a = sim(net,p) a = -1.0021 -0.9963 1.0029 0.9981 ^ C78. Алгоритм CGP Алгоритм CGP использует функцию обучения traincgpclearnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'traincgp'); Изменим установку следующих параметров:net.trainParam.epochs = 300;net.trainParam.show = 5;net.trainParam.goal = 1e-5;p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];net = train(net,p,t); %Рис.3.13 TRAINCGP-srchcha, Epoch 0/300, MSE 3.6913/1e-005, Gradient 4.54729/1e-006 TRAINCGP-srchcha, Epoch 5/300, MSE 0.00160249/1e-005, Gradient 0.077521/1e-006 TRAINCGP-srchcha, Epoch 8/300, MSE 9.42009e-006/1e-005, Gradient 0.00863694/1e-006 TRAINCGP, Performance goal met. a = sim(net,p) a = -1.0042 -0.9976 0.9975 0.9972 ^ C79. Алгоритм CGB Рассмотрим работу этого алгоритма на примере следующей нейронной сети: clearnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'traincgb'); Изменим установку следующих параметров:net.trainParam.epochs = 300;net.trainParam.show = 5;net.trainParam.goal = 1e-5;p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];net = train(net,p,t); % Рис.3.14 TRAINCGB-srchcha, Epoch 0/300, MSE 1.65035/1e-005, Gradient 2.94633/1e-006 TRAINCGB-srchcha, Epoch 5/300, MSE 0.000813691/1e-005, Gradient 0.0222647/1e-006 TRAINCGB-srchcha, Epoch 10/300, MSE 0.000142255/1e-005, Gradient 0.00672937/1e-006 TRAINCGB-srchcha, Epoch 15/300, MSE 1.38893e-005/1e-005, Gradient 0.00260293/1e-006 TRAINCGB-srchcha, Epoch 16/300, MSE 7.09083e-006/1e-005, Gradient 0.0025014/1e-006 TRAINCGB, Performance goal met. a = sim(net,p) a = -0.9985 -0.9987 0.9961 1.0030 ^ C80. Алгоритм SCG Алгоритм SCG использует функцию обучения trainrpclearnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'trainscg'); Функция trainrp по умолчанию характеризуется следующими параметрами:net.trainParam ans = epochs: 100 show: 25 goal: 0 time: Inf min_grad: 1.0000e-006 max_fail: 5 sigma: 5.0000e-005 lambda: 5.0000e-007 Изменим установки некоторых параметров:net.trainParam.epochs = 300;net.trainParam.show = 10;net.trainParam.goal = 1e-5;p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];net = train(net,p,t); %Рис.3.15 TRAINSCG, Epoch 0/300, MSE 1.71149/1e-005, Gradient 2.6397/1e-006 TRAINSCG, Epoch 10/300, MSE 8.2375e-005/1e-005, Gradient 0.0100708/1e-006 TRAINSCG, Epoch 12/300, MSE 1.58889e-006/1e-005, Gradient 0.00321225/1e-006 TRAINSCG, Performance goal met. a = sim(net,p) a = -1.0007 -1.0009 1.0022 0.9994 ^ Квазиньютоновы алгоритмы C81. Алгоритм BFGS Алгоритм BFGS использует функцию обучения trainbfgclearnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'trainbfg'); Установим параметры обучающей процедуры по аналогии с предшествующими примерами:net.trainParam.epochs = 300;net.trainParam.show = 5;net.trainParam.goal = 1e-5;p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];net = train(net,p,t); %Рис.3.16 TRAINBFG-srchbac, Epoch 0/300, MSE 0.469151/1e-005, Gradient 1.4258/1e-006 TRAINBFG-srchbac, Epoch 5/300, MSE 0.00212634/1e-005, Gradient 0.0981181/1e-006 TRAINBFG-srchbac, Epoch 10/300, MSE 2.12166e-005/1e-005, Gradient 0.0119488/1e-006 TRAINBFG-srchbac, Epoch 12/300, MSE 2.687e-007/1e-005, Gradient 0.000475672/1e-006 TRAINBFG, Performance goal met. a = sim(net,p) a = -0.9994 -1.0007 0.9998 1.0003 ^ C82. Алгоритм OSS Алгоритм OSS использует функцию обучения trainossclearnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'trainoss'); Установим параметры обучающей процедуры по аналогии с предшествующими примерами:net.trainParam.epochs = 300;net.trainParam.show = 5;net.trainParam.goal = 1e-5;p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];net=train(net,p,t); %Рис.3.17 TRAINOSS-srchbac, Epoch 0/300, MSE 2.15911/1e-005, Gradient 3.17681/1e-006 TRAINOSS-srchbac, Epoch 5/300, MSE 0.315332/1e-005, Gradient 1.12347/1e-006 TRAINOSS-srchbac, Epoch 10/300, MSE 0.0294864/1e-005, Gradient 0.553976/1e-006 TRAINOSS-srchbac, Epoch 15/300, MSE 0.000315263/1e-005, Gradient 0.0220646/1e-006 TRAINOSS-srchbac, Epoch 20/300, MSE 1.26224e-006/1e-005, Gradient 0.000784773/1e-006 TRAINOSS, Performance goal met. a = sim(net,p) a = -0.9987 -1.0006 0.9986 1.0010 ^ C83. Алгоритм LM Алгоритм LM использует функцию обучения trainlm:clearnet = newff([-1 2; 0 5],[3,1],{'tansig','purelin'},'trainlm'); Функция trainlm по умолчанию характеризуется следующими параметрами:net.trainParam ans = epochs: 100 goal: 0 max_fail: 5 mem_reduc: 1 min_grad: 1.0000e-010 mu: 0.0010 mu_dec: 0.1000 mu_inc: 10 mu_max: 1.0000e+010 show: 25 time: Inf Установим параметры обучающей процедуры по аналогии с предшествующими примерами:net.trainParam.epochs = 300;net.trainParam.show = 5;net.trainParam.goal = 1e-5;p = [-1 -1 2 2;0 5 0 5];t = [-1 -1 1 1];net = train(net,p,t); %Рис.3.18 TRAINLM, Epoch 0/300, MSE 2.99886/1e-005, Gradient 7.55892/1e-010 TRAINLM, Epoch 4/300, MSE 4.88189e-009/1e-005, Gradient 0.000243573/1e-010 TRAINLM, Performance goal met. a = sim(net,p) a = -1.0000 -1.0000 1.0001 1.0000 ^ Расширение возможностей процедур обучения. C89. Переобучение. Рассмотрим нейронную сеть типа 1-30-1 с 1 входом, 30 скрытыми нейронами и 1 выходом, которую необходимо обучить аппроксимировать функцию синуса, если заданы ее приближенные значения, которые получены как сумма значений синуса и случайных величин, распределенных по нормальному закону clearnet = newff([-1 1],[30,1],{'tansig','purelin'},'trainbfg');net.trainParam.epochs = 500;net.trainParam.show = 50;net.trainParam.goal = 1e-5;p = [-1:0.05:1];t = sin(2*pi*p)+0.1*randn(size(p)); t1 = sin(2*pi*p); [net,tr] = train(net,p,t); %Рис.3.19 TRAINBFG-srchbac, Epoch 0/500, MSE 7.31152/1e-005, Gradient 14.7762/1e-006 TRAINBFG-srchbac, Epoch 50/500, MSE 0.000354095/1e-005, Gradient 0.00393802/1e-006 TRAINBFG-srchbac, Epoch 100/500, MSE 1.86929e-005/1e-005, Gradient 0.000200169/1e-006 TRAINBFG-srchbac, Epoch 105/500, MSE 9.84507e-006/1e-005, Gradient 0.000336686/1e-006 TRAINBFG, Performance goal met. Для того чтобы убедиться, что в данном случае мы сталкиваемся с явлением переобучения, построим графики аппроксимируемой функции, ее приближенных значений и результата аппроксимации:an = sim(net,p); figure(1); plot(p,t,'+',p,an,'-',p,t1,':') % Рис.3.20legend('вход','выход','sin(2pi*t)'); grid on ^ C91. Метод регуляризации. Рассмотрим нейронную сеть типа 1-5-1 с 1 входом, 5 скрытыми нейронами и 1 выходом. Эта сеть использует те же типы нейронов, как и предыдущая сеть, но количество скрытых нейронов в 6 раз меньше, предельное количество циклов обучения сокращено до 100, а параметр регуляризации равен 0.9998.clearnet = newff([-1 1],[5,1],{'tansig','purelin'},'trainbfg');net.trainParam.epochs = 100;net.trainParam.show = 50;net.trainParam.goal = 1e-5;net.performFcn = 'msereg';net.performParam.ratio = 0.9998;p = [-1:0.05:1];t = sin(2*pi*p)+0.1*randn(size(p)); t1 = sin(2*pi*p); [net,tr] = train(net,p,t); %Рис.3.21,а TRAINBFG-srchbac, Epoch 0/100, MSEREG 1.44168/1e-005, Gradient 4.02109/1e-006 TRAINBFG-srchbac, Epoch 50/100, MSEREG 0.00943887/1e-005, Gradient 0.00377816/1e-006 TRAINBFG-srchbac, Epoch 100/100, MSEREG 0.00747179/1e-005, Gradient 0.00630789/1e-006 TRAINBFG, Maximum epoch reached, performance goal was not met. an = sim(net,p); figure(1); plot(p,t,'+',p,an,'-',p,t1,':') % Рис.3.21,бlegend('вход','выход','sin(2pi*t)'); grid on ^ Автоматическая регуляризация. Вновь обратимся к нейронной сети типа 1-20-1, предназначенной для решения задачи аппроксимации функции синуса.clearnet = newff([-1 1],[20,1],{'tansig','purelin'},'trainbr'); Функция trainbr по умолчанию характеризуется следующими параметрами:net.trainParam ans = epochs: 100 show: 25 goal: 0 time: Inf min_grad: 1.0000e-010 max_fail: 5 mem_reduc: 1 mu: 0.0050 mu_dec: 0.1000 mu_inc: 10 mu_max: 1.0000e+010 Установим следующие значения этих параметров:net = newff([-1 1],[20,1],{'tansig','purelin'},'trainbr');net.trainParam.epochs = 50;net.trainParam.show = 10;randn('seed',192736547);p = [-1:.05:1];t = sin(2*pi*p)+0.1*randn(size(p));net = init(net);net = train(net,p,t); % Рис.3.22 TRAINBR, Epoch 0/50, SSE 69.5303/0, SSW 21463.6, Grad 1.19e+002/1.00e-010, #Par 6.10e+001/61 TRAINBR, Epoch 10/50, SSE 0.0765763/0, SSW 6859.43, Grad 8.53e-003/1.00e-010, #Par 3.40e+001/61 TRAINBR, Epoch 20/50, SSE 0.0602212/0, SSW 5018.79, Grad 3.18e-001/1.00e-010, #Par 3.43e+001/61 TRAINBR, Epoch 30/50, SSE 0.0577611/0, SSW 4530.75, Grad 1.59e-002/1.00e-010, #Par 3.38e+001/61 TRAINBR, Epoch 40/50, SSE 0.0761021/0, SSW 2622.33, Grad 7.98e-002/1.00e-010, #Par 3.17e+001/61 TRAINBR, Epoch 50/50, SSE 0.0800647/0, SSW 2355.29, Grad 3.70e-002/1.00e-010, #Par 3.13e+001/61 TRAINBR, Maximum epoch reached. Построим графики исследуемых функций:an = sim(net,p); t1 = sin(2*pi*p); figure(1); plot(p,t,'+',p,an,'-',p,t1,':') % Рис.3.22legend('вход','выход','sin(2pi*t)'); grid on ^ C94. Формирование представительной выборки Сформируем обучающее подмножество на интервале входных значений от -1 до 1 с шагом 0.05 в виде суммы функции синуса и погрешности, описываемой случайной величиной, распределенной по нормальному закону с дисперсией 0.01clearp = [-1:0.05:1];t = sin(2*pi*p)+ 0.1*randn(size(p)); Затем сформируем контрольное подмножество. Определим входы в диапазоне от –0.975 до 0.975 и чтобы сделать задачу более реалистичной, добавим некоторую помеху, распределенную по нормальному закону v.P = [-0.975:.05:0.975];v.T = sin(2*pi*v.P)+0.1*randn(size(v.P)); Тестовое подмножество в данном примере не используется. Вновь сформируем нейронную сети типа 1-20-1 и обучим ее. Обратите внимание, что контрольное подмножество в виде массива структуры передается функции обучения в качестве шестого входного параметра. В данном случае используется обучающая функция traingdx, хотя может быть применена и любая другая функция обученияnet = newff([-1 1],[20,1],{'tansig','purelin'},'traingdx');net.trainParam.epochs = 300;net.trainParam.show = 25;net = init(net);[net,tr] = train(net,p,t,[],[],v); % Рис.3.24grid onlegend('контрольное подмножество', 'обучающее подмножество') TRAINGDX, Epoch 0/300, MSE 12.9244/0, Gradient 20.8895/1e-006 TRAINGDX, Epoch 25/300, MSE 0.500121/0, Gradient 0.978807/1e-006 TRAINGDX, Epoch 50/300, MSE 0.191717/0, Gradient 0.32784/1e-006 TRAINGDX, Epoch 75/300, MSE 0.0734146/0, Gradient 0.116014/1e-006 TRAINGDX, Epoch 100/300, MSE 0.0218068/0, Gradient 0.0437681/1e-006 TRAINGDX, Epoch 125/300, MSE 0.00574346/0, Gradient 0.0485314/1e-006 TRAINGDX, Epoch 130/300, MSE 0.00574346/0, Gradient 0.0485314/1e-006 TRAINGDX, Validation stop. Построим графики исследуемых функцийan = sim(net,p); t1 = sin(2*pi*p); figure(2); plot(p,t,'+',p,an,'-',p,t1,':') % Рис.3.25legend('вход','выход','sin(2pi*t)'); grid on ^ C96. Предварительная обработка и восстановление данных. Регрессионный анализ. Следующая последовательность операторов поясняет, как можно выполнен регрессионный анализ для сети, построенной на основе процедуры с прерыванием обученияclearp = [-1:0.05:1];t = sin(2*pi*p)+ 0.1*randn(size(p));v.P = [-0.975:.05:0.975];v.T = sin(2*pi*v.P)+0.1*randn(size(v.P));net = newff([-1 1],[20,1],{'tansig','purelin'},'traingdx');net.trainParam.show = 25;net.trainParam.epochs = 300;net = init(net);[net,tr]=train(net,p,t,[],[],v);grid onlegend('контрольное подмножество', 'обучающее подмножество') TRAINGDX, Epoch 0/300, MSE 8.33909/0, Gradient 13.9129/1e-006 TRAINGDX, Epoch 25/300, MSE 1.48273/0, Gradient 2.00314/1e-006 TRAINGDX, Epoch 50/300, MSE 0.361276/0, Gradient 0.543845/1e-006 TRAINGDX, Epoch 75/300, MSE 0.0769917/0, Gradient 0.147463/1e-006 TRAINGDX, Epoch 100/300, MSE 0.0181576/0, Gradient 0.0458443/1e-006 TRAINGDX, Epoch 125/300, MSE 0.00440005/0, Gradient 0.0691844/1e-006 TRAINGDX, Epoch 138/300, MSE 0.00427574/0, Gradient 0.033685/1e-006 TRAINGDX, Validation stop. a = sim(net,p); % Моделирование сетиfigure(2); [m,b,r] = postreg(a,t), grid on m = 0.9894 b = -0.0092 r = 0.9956 ^ Пример процедуры обучения. Требуется разработать вычислительный инструмент, который может определять уровни липидных составляющих холестерина на основе измерений спектра крови. Имеется статистика измерения 21 показателя липидного спектра крови для 264 пациентов. Кроме того, известны уровни hdl, ldl и vldl липидных составляющих холестерина, основанных на сепарации сыворотки. Необходимо определить состоятельность нового способа анализа крови, основанного на измерении ее спектра. Данные измерений спектра должны быть загружены из МАТ-файла choles_all и подвергнуты факторному анализуclear, load choles_all[pn,meanp,stdp,tn,meant,stdt] = prestd(p,t); [ptrans,transMat] = prepca(pn, 0.001); В этом случае сохраняются только те компоненты, которые объясняют 99.9 % изменений в наборе данных. Проверим, сколько же компонентов из первоначальных 21 являются состоятельными[R,Q] = size(ptrans) R = 4 Q = 264 Оказывается, что всего 4. Теперь сформируем из исходной выборки обучающее, контрольное и тестовое множества. Для этого выделим половину выборки для обучающего множества ptr и по четверти для контрольного v и тестового tiitst = 2:4:Q;iival = 4:4:Q;iitr = [1:4:Q 3:4:Q];v.P = ptrans(:,iival); v.T = tn(:,iival);t.P = ptrans(:,iitst); t.V = tn(:,iitst);ptr = ptrans(:,iitr); ttr = tn(:,iitr); Теперь необходимо сформировать и обучить нейронную сеть. Будем использовать сеть с 2 слоями, с функциями активации: в скрытом слое - гиперболический тангенс, в выходном слое - линейная функция. Такая структура эффективна для решения задач аппроксимации и регрессии. В качестве начального приближения установим 5 нейронов в скрытом слое. Сеть должна иметь 3 выходных нейрона, поскольку определено 3 цели. Для обучения применим алгоритм LMnet = newff(minmax(ptr),[5 3],{'tansig' 'purelin'},'trainlm')[net,tr]=train(net,ptr,ttr,[],[],v,t); net = Neural Network object: architecture: numInputs: 1 numLayers: 2 biasConnect: [1; 1] inputConnect: [1; 0] layerConnect: [0 0; 1 0] outputConnect: [0 1] targetConnect: [0 1]numOutputs: 1 (read-only) numTargets: 1 (read-only) numInputDelays: 0 (read-only) numLayerDelays: 0 (read-only) subobject structures: inputs: {1x1 cell} of inputs layers: {2x1 cell} of layers outputs: {1x2 cell} containing 1 output targets: {1x2 cell} containing 1 target biases: {2x1 cell} containing 2 biases inputWeights: {2x1 cell} containing 1 input weight layerWeights: {2x2 cell} containing 1 layer weight functions: adaptFcn: 'trains' initFcn: 'initlay' performFcn: 'mse' trainFcn: 'trainlm' parameters: adaptParam: .passes initParam: (none) performParam: (none) trainParam: .epochs, .goal, .max_fail, .mem_reduc, .min_grad, .mu, .mu_dec, .mu_inc, .mu_max, .show, .time weight and bias values: IW: {2x1 cell} containing 1 input weight matrix LW: {2x2 cell} containing 1 layer weight matrix b: {2x1 cell} containing 2 bias vectors other: userdata: (user stuff) TRAINLM, Epoch 0/100, MSE 1.66603/0, Gradient 576.465/1e-010 TRAINLM, Epoch 12/100, MSE 0.314181/0, Gradient 88.4175/1e-010 TRAINLM, Validation stop. Обучение остановлено, потому что контрольная ошибка в 5 раз превысила ошибку обучения. Построим графики всех ошибок figure(2)plot(tr.epoch,tr.perf,'-',tr.epoch,tr.vperf,'--',tr.epoch,tr.tperf,':');legend('Обучение', 'Контроль', 'Проверка'); grid on %Рис.3.27 Погрешности проверки на тестовом и контрольном множествах ведут себя одинаково, и нет заметных тенденций к переобучению. Теперь следует выполнить анализ реакции сети. Используем весь набор данных (обучение, признание выборки представительной и тестовый) и оценим линейную регрессию между выходами сети и соответствующими целя