Algoritmo Scaled Conjugate Gradient Backpropagation

4.2 CONTROLADOR RNA

4.2.4 Algoritmo Scaled Conjugate Gradient Backpropagation

Os 17.393 dados de entrada/saída do Controlador PD (utilizado aqui também como professor, excluindo-se a parte Integral do treinamento) foram aqui separados em 70% para treinamento, 15% para validação e 15% para teste, utilizando-se a ferramenta Neural Net Fitting do Matlab, disponível no APÊNDICE B, para o algoritmo de treinamento Scaled Conjugate Gradient.

Seu melhor ajuste de pesos foi encontrado na época de número 143, porém para um MSE de 8,8936e-05, conforme Figura 47.

Figura 46 - Comparativo de controle de atitude entre o Controlador Neural treinado pelo algoritmo Bayesian Regularization e o Controlador PID.

O teste de regressão não se saiu tão bem quanto os demais algoritmos aqui apresentados, apresentando um fit de 0,99888, mais distantes dos padrões ensinados pelo Controlador PD conforme Figura 48.

Figura 47 - Curva de performance de aprendizado da Rede treinada pelo algoritmo Scaled Conjugate Gradient.

As tabelas a seguir, representam os pesos e bias encontrados no treinamento da Rede Neural a ser embarcada no microcontrolador para controle de atitude do quadricóptero, sendo a Tabela 7 e Tabela 8 os pesos e bias encontrados pelo algoritmo de treinamento Scaled Conjugate Gradient.

BIAS CAMADA OCULTA PESOS ENTRADA1 _(ERRO) _{(DERIVADA DO ERRO}PESOS ENTRADA2 NEURON.1 -4,4316319234233905 2,878977486564132 -3,3630245827334688 NEURON.2 -3,4629956680049507 3,1898775923773885 -3,0055794459259482 NEURON.3 2,683171792180862 -3,8737670367921644 -1,4499110252116709 NEURON.4 -1,5143372363846292 1,9837892743608758 -3,9284843366246851 NEURON.5 0,48724925629125215 -2,2698628226464495 3,6245017076778239 NEURON.6 -0,4863718103237733 2,2081422943517488 2,8004884504514207 NEURON.7 -1,3191179931431505 -1,7926266121664807 4,0641495803912324 NEURON.8 1,6969401033097467 2,8917832213579655 3,522902435231023 NEURON.9 3,7394050929127425 3,3145350245664211 -2,7015126774315248 NEURON.10 4,5064206561917217 0,51841938712079694 4,2975857298526225

Tabela 7 - Bias e pesos da Rede Neural da Camada de Entrada x Camada Oculta encontrados no treinamento da Rede Neural pelo agoritmo Scaled Conjugate Gradient.

Fonte: Própria.

Figura 48 - Teste de Regressão obtido durante o treinamento da Rede Neural pelo algoritmo Scaled Conjugate Gradient.

BIAS CAMADA DE _SAÍDA PESOS NA SAÍDA NEURON.1 -0,12109497992792231 0,22678120294328374 NEURON.2 -0,14598169542490058 NEURON.3 -0,10217371272392035 NEURON.4 -0,088111904889080064 NEURON.5 0,10347245855201478 NEURON.6 0,1534572940547409 NEURON.7 0,14767572849232685 NEURON.8 0,13600345770980526 NEURON.9 -0,17063988310982384 NEURON.10 0,41386655239436454

Tabela 8 - Bias e pesos da Camada Oculta x Camada de Saída encontrados no treinamento da Rede Neural pelo algoritmo Scaled Conjugate Gradient.

Fonte: Própria.

E, semelhante as condições impostas aos demais controladores deste trabalho, foi gerada uma referência alternada entre -15º à 15º com um intervalo de tempo de 20 segundos para cada ângulo de referência, de modo a confrontar a saída real do ângulo medido pelo sensor MPU6050 embarcado no quadricóptero com a referência exigida, conforme Figura 49.

Figura 49 - Teste de Comportamento do Controlador Neural treinado pelo algoritmo Scaled Conjugate Gradient para uma referência alternada em teste real no quadricóptero.

A Rede Neural treinada pelo algoritmo Scaled Conjugate Gradient para a mesma massa de dados de entrada/saída que os outros algoritmos, não conseguiu mapear bem o que lhe fora ensinado por seu professor PD, e em determinado momento, precisamente na referência de ângulo 10º, o controlador baseado em Redes Neurais se perdeu no que lhe fora imposto de entrada erro e derivada do erro, fazendo com que o quadricóptero parasse o controle, tombando o quadricóptero que foi segurado pela base de testes construída, mantendo-se em 35º aproximadamente o tempo todo, por isso, o dado foi somente coletado até aproximadamente 50 segundos.

Comparando o resultado demonstrado na Figura 49 até o momento de sua perda de controle com o resultado do PID demonstrado na Figura 29, chegamos a Figura 50, a qual podemos ver que no início o controlador neural teve um bom comportamento, porém, não conseguiu generalizar tão bem o que fora lhe ensinado assim como os outros algoritmos.

Figura 50 - Comparativo de controle de atitude entre o Controlador Neural treinado pelo algoritmo Scaled Conjugate Gradient e o Controlador PID.

4.3 COMPARATIVO ENTRE CONTROLADORES NEURAIS

A Figura 51 mostra um gráfico com todos os resultados dos Controladores Neurais implementados diante de uma mesma referência.

Vale ressaltar que isso não quer dizer que um algoritmo de treinamento é melhor que outro, pois a cada treinamento os resultados são diferentes, às vezes determinado algoritmo chega em um menor erro, e às vezes outro algoritmo de treinamento se sai melhor com um menor erro. Vai depender de fatores como número de neurônios utilizados, quantidade de dados para treinamento, teste e validação, e até mesmo sobre a problemática definida.

Neste caso, o algoritmo Bayesian regularization acabou se mostrando um pouco melhor que os outros com um fit de 100%, logo após o algoritmo Levenberg Marquardt com um fit de 99,998%, o algoritmo Backpropagation puro com um fit de 99,997%, e por fim o Scaled Conjugate Gradient com um fit de 99,888%, que não foi o suficiente para o controle do sistema deste trabalho.

Figura 51 – Comparativo entre Controladores Neurais Fonte: Software Matlab.

4.4 COMPARATIVO ENTRE CONTROLADOR PID E CONTROLADORES NEURAIS Conforme mostra a Figura 52, os controladores híbridos (PDNN+I) desenvolvidos utilizando RNAs a base de algoritmo de treinamento Backpropagation, Levenberg Marquardt e Bayesian Regularization para o papel do Controlador PD somando-se o Integrador do Controlador Clássico PID se saíram muito bem em relação ao seu professor (PD), com exceção da rede neural treinada pelo algoritmo Scaled Conjugate Gradient.

Porém, a Rede Neural da forma implementada neste trabalho, não existe sem um professor (neste caso o Controlador Clássico PID), para o processo de aprendizagem.

Figura 52 - Comparativo entre Controlador PID e Controladores RNA híbridos. Fonte: Software Matlab.

5 CONCLUSÃO

Neste trabalho foram realizados estudos e implementações de um controlador PID e quatro controladores baseados em RNAs na aplicação do controle de atitude de um quadricóptero real, analisando seus resultados individuais e comparando-os.

Nos testes realizados, de acordo com os resultados apresentados, os Controladores Neurais, com exceção do controlador neural desenvolvido pelo algoritmo Scaled Conjugate Gradient, obtiveram um desempenho muito semelhante ao Controlador PD.

Cabe aqui salientar que tal desempenho se dá pelo fato dos Controladores Neurais terem aprendido com um professor (aprendizado supervisionado), assemelhando-se bem ao mesmo, exceto pela parte da Integral, que a rede neural baseada no PID não conseguiu aprender devido ao fato de ter um entendimento tabelado com início e fim para entradas e saídas e o comportamento da parte integral não ter uma saída correspondente a uma entrada, ou seja, ela é somatória e pode apresentar uma diferente contribuição ao PID para o mesmo erro e derivada do erro em tempos diferentes, e por isso foi necessário continuar-se com a soma da parte integral aos Controladores Neurais desenvolvidos, chamando-se neste trabalho o controlador desenvolvido como PDNN+I (Proportional and Derivative Neural Network + Integral).

Para valores nunca vistos no processo de treinamento das Redes Neurais dos padrões de entrada e saída apresentados, as Redes Neurais comportaram-se bem, mostrando terem aprendido o padrão da equação PD apresentada, com exceção do algoritmo Scaled Conjugate Gradient, como citado, significando que se o professor da Rede Neural tiver um ótimo desempenho, a Rede Neural poderá também obter.

Ainda, existem algumas técnicas como “Aprendizagem por Reforço” e “Algoritmos Genéticos” os quais o autor deste trabalho recomenda como futuros trabalhos. Essas técnicas prometem um aprendizado além dos aqui apresentados, os quais a Rede Neural atualiza seu conhecimento além dos previamente ensinados por um professor durante cada execução do sistema, dando um ajuste mais preciso pela Rede, e dessa forma, a Rede Neural pode vir a superar-se a si mesma a cada iteração e consequentemente superar seu professor.

REFERÊNCIAS

ALVES, Ana S. C. Estudo e Aplicação de Técnicas de Controle Embarcadas para Estabilização de Voo de Quadricopteros. 2012. 121 f. Tese (Doutorado em Engenharia Elétrica) – Faculdade de Engenharia da Universidade Federal de Juiz de Fora, Juiz de Fora, 2012.

BARROS, Victor Pedroso Ambiel. Avaliação do desempenho de algoritmos de retropropagação com redes neurais artificiais para a resolução de problemas não-lineares. 2018. 136 f. Dissertação (Mestrado em Ciência da Computação) - Universidade Tecnológica Federal do Paraná. Ponta Grossa, 2018.

BULLINARIA, John. Step by Step Guide to implementing a Neural Network in C. School of Computer Science. The University of Birmingham. Reino Unido. 2009. Disponível em: < http://www.cs.bham.ac.uk/~jxb/INC/nn.html> Acesso em: 05 mar. 2018.

CALVO, R. Arquitetura híbrida inteligente para navegação autônoma de robôs. São Carlos:[s.n.], 2007. Disponível em: <http://www.teses.usp.br/teses/disponiveis/55/55134/tde- 15062007-161911/>.Acessoem: 27 out. 2015.

CARRARA, V. Redes Neurais Aplicadas ao Controle de Atitude de Satélites com Geometria Variável. 1997. Tese (Doutorado em Mecânica Espacial e Controle) - Instituto Nacional de Pesquisas Espaciais, São José dos Campos - SP, 1997.

DJI. Quadricóptero Mavic Pro. 2018. Disponível em: <http://www.dji.com>.

FORESEE, F. D.; HAGAN, M. T. Gauss-Newton Approximation to Bayesian Regularization. International Joint Conference on Neural Networks, p. 1930-1935, 1997. GONCALVES, Rodrigo Mikosz et al . Modelagem preditiva de linha de costa utilizando redes neurais artificiais. Bol. Ciênc. Geod. Curitiba , v. 16, n. 3, p. 420-444, Sept. 2010.

Disponível em:

<http://www.scielo.br/scielo.php?script=sci_arttext&pid=S198221702010000300004&lng=en &nrm=iso>. Acesso em: 29 Out. 2018.

HAGAN, M. T.; MENHAJ M. B. Training feedforward networks with the Marquardt algorithm. IEE Transactions on Neural Networks, v. 5, n. 6, p. 989-993, 1994.

HAYKIN, Simon. Redes Neurais: Princípios e prática. 2. ed. Porto Alegre: Bookman, 2001. KIŞI, Ö.; UNCUOĞLU, E. Comparison of three back-propagation training algorithms for two case studies. Indian Journal of Engineering & Materials Sciences, v. 12, p. 434-442, 2005. LEISHMAN, J. G. A History of Helicopter Flight. University of Maryland. College Park.

2000. Disponível em: <

https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=4&cad=rja&uact=8& ved=2ahUKEwjB8_y739_eAhUHGZAKHav0AOQQFjADegQIBhAC&url=http%3A%2F%2 Fitlims-

zsis.meil.pw.edu.pl%2Fpomoce%2FWTLK%2FENG%2FSup%2FA_History_of_Helicopter_ Flight.pdf&usg=AOvVaw3A3IsyegpzW_kTQ4Q_jsdb> Acesso em: 12 set. 2015.

LEISHMAN, J. G. The bréguet-richet quadrotor helicopter of. Vertiflite, n. 47, p. 4, 2002. LERA, G.; PINZOLAS, M. Neighborhood based Levenberg-Marquardt algorithm for neural network training. IEE Transactions on Neural Networks, v. 13, n. 5, p. 1200-1203, 2002.

MACKAY, D, J. C. Bayesian interpolation. Neural Computation, v. 4, p. 415-447, 1992. MELO, A. S. de. Implementação de um Quadrotor como Plataforma de Desenvolvimento para Algoritmos de Controle. 2010. 113 f. Dissertação (Mestrado em Engenharia Elétrica) – Programa de Pós-Graduação em Engenharia Elétrica, Centro Tecnológico da Universidade Federal do Espírito Santo, 2010. Disponível em: <http://portais4.ufes.br/posgrad/teses/tese_2872_DissertacaoMestradoAlexandreSecchindeMe lo.pdf>. Acesso em: 21 ago. 2015.

MCCORMICK, B. Aerodynamics, aeronautics, and flight mechanics. [S.l.]: Wiley, 1979. ISBN 9780471030324.

MCCULLOCH, W. S.; PITTS, W. A logical calculus of the ideas immanent in nervous activity. Bulletin of Mathematical Biophysics, v. 5, p. 115–133, 1943.

MIRANDA, B. C. O. Controle Baseado em Lógica Fuzzy para Veículos Aéreos Autônomos Não Tripulados do tipo Octorotor. In: SIMPÓSIO BRASILEIRO DE AUTOMAÇÃO INTELIGENTE, 2013, Fortaleza. Anais eletrônicos... Fortaleza: SBAI, 2013. Disponível em: <http://www.sbai2013.ufc.br/Programa_SBAI_DINCON_2013_FINAL.pdf>. Acesso em: 27 ago. 2015.

MØLLER, M. F. A scaled conjugate gradient algorithm for fast supervised learning. Neural networks, v. 6, n. 4, p. 525-533, 1993.

NISE, Norman S. Engenharia de sistemas de controle; tradução e revisão técnica Jackson Paul Matsuura. - 6. ed. - Rio de Janeiro: LTC, 2014.

OGATA, K.; MAYA, P. Á.; LEONARDI, F. Engenharia de controle moderno. [S.l.]: Prentice Hall, 2003.

ROSENBLATT, F. The perceptron: a perceiving and recognizing automaton.[S.l.], 1957. SCHNITMAN, L. Controladores Preditivos Baseados em Redes Neurais Artificiais. 1998. Dissertação (Mestrado em Engenharia Elétrica) – Programa de Pós-Graduação em Engenharia Elétrica, Universidade Federal da Bahia, 1998. Disponível em: < http://www.ppgee.eng.ufba.br/teses/3fa84f4664183cab6c0c9022d582c762.pdf>. Acesso em: 10 nov. 2015.

SILVA, André T. da. Controle de posição com restrição à orientação de um Veículo Aéreo Não-Tripulado tipo Quadrirrotor. 2014. 56 f. Dissertação (Mestrado em Engenharia Elétrica e de Computação) – Programa de Pós-Graduação em Engenharia Elétrica e de

Computação, Universidade Federal do Rio Grande do Norte, 2014. Disponível em: <http://repositorio.ufrn.br:8080/jspui/bitstream/123456789/15493/1/AndreTS_DISSERT.pdf> . Acesso em: 26 ago. 2015.

SILVA, L. N. de C. Análise e síntese de estratégias de aprendizado para redes neurais artificiais. Campinas, SP: [s.n.], 1998. Disponível em: <http://www.bibliotecadigital.unicamp-.br/document/?code=vtls000136455>. Acesso em: 28 out. 2015.

VIEIRA, J. C. S. Plataforma móvel aérea quadrotor. Dissertação (Mestrado) — Universidadedo Minho - Ciclo de Estudos Integrados Conducentes ao Grau de Mestre em EngenhariaEletrónica Industrial e Computadores, 2011. Disponível em: <http://intranet.dei.uminho.pt/gdmi/galeria/temas/pdf/48031.pdf>. Acesso em: 06 set. 2015.

APÊNDICE A – DADOS PROVINDOS DO CONTROLADOR PD NO CONTROLE DE ATITUDE DO QUADRICÓPTERO UTILIZADO PARA TREINAMENTO DA REDE NEURAL

Os dados utilizados para treinamento da Rede Neural com entradas sendo “erro” e “derivada do erro”, e saída a ação do “Controlador PD” foram dispostos na Tabela 9, estes dados ainda precisaram ser normalizados para utilização no algoritmo de treinamento, de acordo com sua função de ativação, tendo sua saída entre 0 e 1 ou -1 e 1.

LINHA ERRO DERIVADA DO ERRO CONTROLADOR PD NORMALIZADO ERRO

DERIVADA DO ERRO NORMALIZADO CONTROLADOR PD NORMALIZADO 1 4110675 4110675 170181968 0.70278 0.977467 0.975569 2 2567125 -1543550 -58148024 0.438888 -0.36704 -0.33333 3 1707884 -859240 -31978582 0.291988 -0.20432 -0.18332 4 1225915 -481969 -17562488 0.209588 -0.11461 -0.10068 5 953546 -272368 -9559789 0.163023 -0.06477 -0.0548 6 826378 -127168 -3929807 0.141281 -0.03024 -0.02253 7 492746 -333631 -12655407 0.084242 -0.07933 -0.07255 8 417033 -75713 -2444690 0.071298 -0.018 -0.01401 9 308623 -108409 -3904307 0.052764 -0.02578 -0.02238 10 209876 -98747 -3656090 0.035881 -0.02348 -0.02096 ... ... ... ... ... ... ... 17393 985702 -50612 -644524 0.16852 -0.01203 -0.00369 Tabela 9 - Formato de dados provindos do Controlador PD e normalizados para treinamento das Redes Neurais.

APÊNDICE B – FERRAMENTA NEURAL NET FITTING DO MATLAB UTILIZADO PARA TREINAMENTO E GERAÇÃO DAS REDES NEURAIS

Neste apêndice são inseridas algumas imagens da ferramenta Neural Net Fitting do Matlab, utilizado para treinamento e geração das Redes Neurais deste trabalho.

Na Figura 54, são selecionados os dados de Input (entrada) e Target (alvo) para a Rede Neural, disponíveis no APÊNDICE A.

Figura 53 – Tela inicial da ferramenta Neural Fitting do Matlab Fonte: Própria.

Na Figura 55 são configurados as quantidades que será destinado à treinamento, validação e teste para os dados de Input e Target selecionados na Figura 54.

Figura 54 - Tela de inserção de dados da ferramenta Neural Fitting do Matlab Fonte: Própria.

Figura 55 - Tela de quantidade de dados para treinamento, validação e teste da ferramenta Neural Fitting do Matlab

A Figura 56 mostra a tela onde é configurado a quantidade de neurônios para a Camada Oculta da Rede Neural.

Na Figura 57 é exibida a tela onde se configura o algoritmo que será utilizado para treinamento da Rede Neural e o botão “Train” para iniciar o treinamento.

Figura 56 - Tela para configuração da quantidade de neurônios na Camada Oculta da ferramenta Neural Fitting do Matlab

Ao clicar no botão “Train” da Figura 57, é exibida automaticamente a tela conforme Figura 58, onde é possível extrair dados como performance e regressão disponíveis neste trabalho.

Figura 57 - Tela para configuração do altoritmo de treinamento da ferramenta Neural Fitting do Matlab Fonte: Própria.

Figura 58 - Tela de execução em tempo real da Rede Neural da ferramenta Neural Fitting do Matlab Fonte: Própria.

Após a finalização do treinamento da Rede Neural, ao avançar algumas telas após a exibida na Figura 57, é possível encontrar o painel demonstrado na Figura 59, onde o código da Rede treinada pode ser disponibilizado para o Matlab.

O código gerado pela ferramenta Neural Net Fitting do Matlab com algoritmo de treinamento Levenberg Marquardt, encontra-se logo abaixo.

function [y1] = myNeuralNetworkFunction(x1)

%MYNEURALNETWORKFUNCTION neural network simulation function. %

% Generated by Neural Network Toolbox function genFunction, 15-Dec-2018 18:02:17.

% [y1] = myNeuralNetworkFunction(x1) takes these arguments: % x = 2xQ matrix, input #1

% and returns:

% y = 1xQ matrix, output #1

% where Q is the number of samples.

%#ok<*RPMT0>

% ===== NEURAL NETWORK CONSTANTS =====

Figura 59 - Tela para geração da função da Rede Neural treinada na ferramenta Neural Fitting do Matlab Fonte: Própria.

% Input 1 x1_step1_xoffset = [-1;-1]; x1_step1_gain = [1.09564293013561;1.0113948696796]; x1_step1_ymin = -1; % Layer 1 b1 = [-4.7946154674436405;- 3.2994029843245292;1.3645883930926495;1.0404221702070933;0.0579914416369202 16;0.065408180050365444;-0.13484028622751318;- 2.1072761455357081;3.9567125928627198;4.371680071532869]; IW1_1 = [0.67068555561189536 3.9037363396340781;3.4982468207293125 - 2.4481373191058999;-0.38502780450307689 -2.2423365092887457;- 1.7273315597872907 1.2080048395665661;3.4400590516593077 1.8747505903688213;0.081439126580724122 0.47434991372913021;- 0.24379449844577222 0.17240522288606328;-0.41210565313027758 - 2.4248552715508382;3.8707995509926043 0.85051143631426418;3.7452321946749692 -1.4704820814047384]; % Layer 2 b2 = 0.26816453825549613; LW2_1 = [0.33854936648632522 -0.0022704780709331906 -0.036130089569306093 0.0036487545401550693 -5.6380099343315387e-06 1.8292996063326412 0.44494141448811092 -0.036842379657288864 0.00022704900050175825 - 0.0016784424869623258]; % Output 1 y1_step1_ymin = -1; y1_step1_gain = 1.01236648176873; y1_step1_xoffset = -1; % ===== SIMULATION ======== % Dimensions Q = size(x1,2); % samples % Input 1 xp1 = mapminmax_apply(x1,x1_step1_gain,x1_step1_xoffset,x1_step1_ymin); % Layer 1 a1 = tansig_apply(repmat(b1,1,Q) + IW1_1*xp1); % Layer 2 a2 = repmat(b2,1,Q) + LW2_1*a1; % Output 1 y1 = mapminmax_reverse(a2,y1_step1_gain,y1_step1_xoffset,y1_step1_ymin); end % ===== MODULE FUNCTIONS ========

% Map Minimum and Maximum Input Processing Function function y = mapminmax_apply(x,settings_gain,settings_xoffset,settings_ymin) y = bsxfun(@minus,x,settings_xoffset); y = bsxfun(@times,y,settings_gain); y = bsxfun(@plus,y,settings_ymin); end

function a = tansig_apply(n) a = 2 ./ (1 + exp(-2*n)) - 1; end

% Map Minimum and Maximum Output Reverse-Processing Function function x = mapminmax_reverse(y,settings_gain,settings_xoffset,settings_ymin) x = bsxfun(@minus,y,settings_ymin); x = bsxfun(@rdivide,x,settings_gain); x = bsxfun(@plus,x,settings_xoffset); end

O código gerado pela ferramenta Neural Net Fitting do Matlab com algoritmo de treinamento Bayesian Regularization, encontra-se logo abaixo.

function [y1] = myNeuralNetworkFunction(x1)

%MYNEURALNETWORKFUNCTION neural network simulation function. %

% Generated by Neural Network Toolbox function genFunction, 15-Dec-2018 19:17:20.

% [y1] = myNeuralNetworkFunction(x1) takes these arguments: % x = 2xQ matrix, input #1

% and returns:

% y = 1xQ matrix, output #1

% where Q is the number of samples.

%#ok<*RPMT0>

% ===== NEURAL NETWORK CONSTANTS ===== % Input 1 x1_step1_xoffset = [-1;-1]; x1_step1_gain = [1.09564293013561;1.0113948696796]; x1_step1_ymin = -1; % Layer 1 b1 = [0.0062344893121035871;-0.017678168366624378;1.2799141894759265;- 0.037195356884099133;-0.0045986521363191746;-0.068996899333848352;- 0.035536775089772328;0.01504143285208763;-1.2897096873838008;- 0.0027776767049251033]; IW1_1 = [0.0084896578954653402 0.20427442014193004;0.010792903555082535 0.21097245672951118;0.016469873445170077 0.36029616033326373;0.0090553420020863772 0.19488086595003254;0.0097835342252170134 0.20907000306765847;- 0.0055150337524643373 -0.20206239930434389;-0.15484029712278888 - 0.039375138758944786;-0.0099589353855996654 - 0.20696842273724395;0.016149178437732455 0.35991906787600303;0.01017611237307715 0.21183381723947761]; % Layer 2 b2 = 0.012821332730584934;

LW2_1 = [0.49628798802995988 0.59977232429257299 1.0815479300634312 0.47211942540225244 0.57901303288537798 -0.43514686878642628 0.00041414194953324444 -0.51169439898956925 1.0881963817449658 0.58815223098389802]; % Output 1 y1_step1_ymin = -1; y1_step1_gain = 1.01236648176873; y1_step1_xoffset = -1; % ===== SIMULATION ======== % Dimensions Q = size(x1,2); % samples % Input 1 xp1 = mapminmax_apply(x1,x1_step1_gain,x1_step1_xoffset,x1_step1_ymin); % Layer 1 a1 = tansig_apply(repmat(b1,1,Q) + IW1_1*xp1); % Layer 2 a2 = repmat(b2,1,Q) + LW2_1*a1; % Output 1 y1 = mapminmax_reverse(a2,y1_step1_gain,y1_step1_xoffset,y1_step1_ymin); end % ===== MODULE FUNCTIONS ========

% Sigmoid Symmetric Transfer Function function a = tansig_apply(n)

a = 2 ./ (1 + exp(-2*n)) - 1; end

O código gerado pela ferramenta Neural Net Fitting do Matlab com algoritmo de treinamento Scaled Conjugate Gradient, encontra-se logo abaixo.

function [y1] = myNeuralNetworkFunction(x1)

% Generated by Neural Network Toolbox function genFunction, 15-Dec-2018 19:26:14.

% [y1] = myNeuralNetworkFunction(x1) takes these arguments: % x = 2xQ matrix, input #1

% and returns:

% y = 1xQ matrix, output #1

% where Q is the number of samples.

%#ok<*RPMT0>

% ===== NEURAL NETWORK CONSTANTS ===== % Input 1 x1_step1_xoffset = [-1;-1]; x1_step1_gain = [1.09564293013561;1.0113948696796]; x1_step1_ymin = -1; % Layer 1 b1 = [-4.4316319234233905;-3.4629956680049507;2.683171792180862;- 1.5143372363846292;0.48724925629125215;-0.4863718103237733;- 1.3191179931431505;1.6969401033097467;3.7394050929127425;4.5064206561917217 ]; IW1_1 = [2.878977486564132 -3.3630245827334688;3.1898775923773885 - 3.0055794459259482;-3.8737670367921644 - 1.4499110252116709;1.9837892743608758 -3.9284843366246851;- 2.2698628226464495 3.6245017076778239;2.2081422943517488 2.8004884504514207;-1.7926266121664807 4.0641495803912324;2.8917832213579655 3.522902435231023;3.3145350245664211 -2.7015126774315248;0.51841938712079694 4.2975857298526225]; % Layer 2 b2 = -0.12109497992792231; LW2_1 = [0.22678120294328374 -0.14598169542490058 -0.10217371272392035 - 0.088111904889080064 0.10347245855201478 0.1534572940547409 0.14767572849232685 0.13600345770980526 -0.17063988310982384 0.41386655239436454]; % Output 1 y1_step1_ymin = -1; y1_step1_gain = 1.01236648176873; y1_step1_xoffset = -1; % ===== SIMULATION ======== % Dimensions Q = size(x1,2); % samples % Input 1 xp1 = mapminmax_apply(x1,x1_step1_gain,x1_step1_xoffset,x1_step1_ymin); % Layer 1 a1 = tansig_apply(repmat(b1,1,Q) + IW1_1*xp1); % Layer 2 a2 = repmat(b2,1,Q) + LW2_1*a1; % Output 1

y1 = mapminmax_reverse(a2,y1_step1_gain,y1_step1_xoffset,y1_step1_ymin); end

% ===== MODULE FUNCTIONS ========

% Sigmoid Symmetric Transfer Function function a = tansig_apply(n)

a = 2 ./ (1 + exp(-2*n)) - 1; end

Lembrando que é necessária a conversão para a linguagem de acordo onde se utilizará, no caso deste trabalho para a linguagem C, utilizada no microcontrolador Tiva TM4C123G.

APÊNDICE C – ALGORITMO BACKPROPAGATION ADAPTADO DE JOHN BULLINARIA

A seguir, apresenta-se o algoritmo adaptado de John Bullinaria (2009) utilizado para a implementação do algoritmo de treinamento Backpropagation no controle de atitude do quadricóptero, utilizando o Matlab.

NUMPAT = 17393; NUMIN = 3; NUMHID = 11; NUMOUT = 2; NumPattern = NUMPAT; NumInput = NUMIN; NumHidden = NUMHID; NumOutput = NUMOUT; eta = 1.5; alpha = 0.9; smallwt = 0.5; y = zeros(1, 10000);

for j = 2: NumHidden % initialize WeightIH and DeltaWeightIH for i = 1 : NumInput

DeltaWeightIH(i, j) = 0.0 ;

WeightIH(i, j) = 2.0 * ( rand() - 0.5 ) * smallwt ; end

end

for k = 2 : NumOutput % initialize WeightHO and DeltaWeightHO */ for j = 1 : NumHidden

DeltaWeightHO(j , k) = 0.0 ;

WeightHO(j, k) = 2.0 * ( rand() - 0.5 ) * smallwt ; end

end

tic;

for epoch = 1 : 10000 % iterate weight updates */

for p = 2 : NumPattern % /* randomize order of training patterns */

ranpat(p) = p ; end

for p = 2 : NumPattern

np = floor(p + rand() * ( NumPattern + 1 - p )) ; op = ranpat(p);

ranpat(p) = ranpat(np); ranpat(np) = op ;

end

Error = 0.0 ;

for np = 2 : NumPattern % /* repeat for all the training patterns */

p = ranpat(np);

for j = 2 : NumHidden % /* compute hidden unit activations */

SumH(p, j) = WeightIH(1, j) ; for i = 2 : NumInput

SumH(p, j) = SumH(p, j) + Input(p, i) * WeightIH(i, j) ;

end

Hidden(p, j) = 1.0/(1.0 + exp(-SumH(p, j))) ; end

for k = 2 : NumOutput % /* compute output unit activations and errors */

SumO(p, k) = WeightHO(1, k) ; for j = 2 : NumHidden

SumO(p, k) = SumO(p, k) + Hidden(p, j) * WeightHO(j, k) ;

end

Output(p, k) = 1.0/(1.0 + exp(-SumO(p, k))) ; % /* Sigmoidal Outputs */

% Output[p][k] = SumO[p][k]; Linear Outputs */ Error = Error + 0.5 * (Target(p, k) - Output(p, k)) * (Target(p, k) - Output(p, k)) ; % /* SSE */

% Error -= ( Target[p][k] * log( Output[p][k] ) + ( 1.0 - Target[p][k] ) * log( 1.0 - Output[p][k] ) ) ; Cross-Entropy Error */ DeltaO(k) = (Target(p, k) - Output(p, k)) * Output(p, k) * (1.0 - Output(p, k)) ; % /* Sigmoidal Outputs, SSE */

% DeltaO[k] = Target[p][k] - Output[p][k]; Sigmoidal Outputs, Cross-Entropy Error */

% DeltaO[k] = Target[p][k] - Output[p][k]; Linear Outputs, SSE */

end

for j = 2 : NumHidden % /* 'back-propagate' errors to hidden layer */

SumDOW(j) = 0.0 ; for k = 2 : NumOutput

SumDOW(j) = SumDOW(j) + WeightHO(j, k) * DeltaO(k) ; end

DeltaH(j) = SumDOW(j) * Hidden(p, j) * (1.0 - Hidden(p, j)) ;

end

for j = 2 : NumHidden % /* update weights WeightIH */ DeltaWeightIH(1, j) = eta * DeltaH(j) + alpha *

DeltaWeightIH(1, j) ;

WeightIH(1, j) = WeightIH(1, j) + DeltaWeightIH(1, j) ; for i = 2 : NumInput

DeltaWeightIH(i, j) = eta * Input(p, i) * DeltaH(j) + alpha * DeltaWeightIH(i, j);

WeightIH(i, j) = WeightIH(i, j) + DeltaWeightIH(i, j) ; end

end

for k = 2 : NumOutput % /* update weights WeightHO */ DeltaWeightHO(1, k) = eta * DeltaO(k) + alpha * DeltaWeightHO(1, k) ;

WeightHO(1, k) = WeightHO(1, k) + DeltaWeightHO(1, k) ; for j = 2 : NumHidden

DeltaWeightHO(j, k) = eta * Hidden(p, j) * DeltaO(k) + alpha * DeltaWeightHO(j, k) ;

WeightHO(j, k) = WeightHO(j, k) + DeltaWeightHO(j, k) ; end

end end

y(epoch) = Error;

if( mod(epoch, 100) == 0 )

fprintf('\nEpoch %-5d : Error = %f', epoch, Error) ; end

if( Error < 0.0004 )

break ; % /* stop learning when 'near enough' */ end end toc; x = 1:10000; plot(x, y);

title('Aprendizagem Backpropagation da função PD por uma Rede Neural

MLP 2:10:1');

xlabel('Épocas'); ylabel('Erro'); grid on;

Abaixo, encontra-se o código implementado no microcontrolador com os pesos e bias encontrados.

double pdnn(const double x1[2]){

static const double bih[10] = {-2.10862248403382, -1.73846890245032, -1.44726756505499, -1.46040057671700, -1.60306958824825, -7.30761881139383, -1.35089703883652, -10.0115974733019, -1.69959530905121, -3.58107798597621}; static const double w1ih[10] = {-0.218708919142166, -0.0520636149535119, 0.339660993312912, 0.121235759640445, -0.0349174296818387, 0.328106680063253, 0.150359692425880, -0.352769675869063, 0.0961974178817107,

0.0327551801599087};

static const double w2ih[10] = {-3.08146583387343, -1.19905583326812, 0.405246379942607, 0.744664532157731, -1.02617517363645, 6.84658657524243, 2.83662693149937, -9.23004533690593, -1.15654529334274, 2.16072941367041}; static const double bho = 0.160926070975181;

static const double who[10] = {-1.69332653167146, -0.957113701242848, 0.283664330993748, 0.522528979177052, -0.820601118547166, 4.48318496949349, 1.57585375088535, -6.93936891998385, -1.41209035215042, 2.45364604441638};

double SomaIH[10], Hidden[10], SomaHO, Output; SomaIH[0] = bih[0] + x1[0]*w1ih[0] + x1[1]*w2ih[0]; SomaIH[1] = bih[1] + x1[0]*w1ih[1] + x1[1]*w2ih[1]; SomaIH[2] = bih[2] + x1[0]*w1ih[2] + x1[1]*w2ih[2]; SomaIH[3] = bih[3] + x1[0]*w1ih[3] + x1[1]*w2ih[3];

SomaIH[4] = bih[4] + x1[0]*w1ih[4] + x1[1]*w2ih[4]; SomaIH[5] = bih[5] + x1[0]*w1ih[5] + x1[1]*w2ih[5]; SomaIH[6] = bih[6] + x1[0]*w1ih[6] + x1[1]*w2ih[6]; SomaIH[7] = bih[7] + x1[0]*w1ih[7] + x1[1]*w2ih[7]; SomaIH[8] = bih[8] + x1[0]*w1ih[8] + x1[1]*w2ih[8]; SomaIH[9] = bih[9] + x1[0]*w1ih[9] + x1[1]*w2ih[9]; Hidden[0] = 1.0/(1.0 + exp(-SomaIH[0]));

Hidden[1] = 1.0/(1.0 + exp(-SomaIH[1])); Hidden[2] = 1.0/(1.0 + exp(-SomaIH[2])); Hidden[3] = 1.0/(1.0 + exp(-SomaIH[3])); Hidden[4] = 1.0/(1.0 + exp(-SomaIH[4])); Hidden[5] = 1.0/(1.0 + exp(-SomaIH[5])); Hidden[6] = 1.0/(1.0 + exp(-SomaIH[6])); Hidden[7] = 1.0/(1.0 + exp(-SomaIH[7])); Hidden[8] = 1.0/(1.0 + exp(-SomaIH[8])); Hidden[9] = 1.0/(1.0 + exp(-SomaIH[9]));

SomaHO = bho + Hidden[0]*who[0] + Hidden[1]*who[1] + Hidden[2]*who[2] + Hidden[3]*who[3] + Hidden[4]*who[4] + Hidden[5]*who[5] + Hidden[6]*who[6] + Hidden[7]*who[7] + Hidden[8]*who[8] + Hidden[9]*who[9];

Output = 1.0/(1.0 + exp(-SomaHO)); return Output;

}

A seguir, a chamada da função, com as devidas conversões para entrada e saída.

input[0] = (e[1]*1000000)/5849161; input[1] = (derivada*1000000)/4205436;

PDNN_I = (((pdnn(input)*344625744)-174443776)/1000000) + 0.25*referencia[amostra] + ui[1];

A saída PDNN_I irá para o controle dos rotores. pwmLeft = throttle + PID + offset;

APÊNDICE D – ALGORITMOS NEURAIS: LEVENBERG MARQUARDT,

BAYESIAN REGULARIZATION E SCALED CONJUGATE GRADIENT

EMBARCADOS NO MICROCONTROLADOR

Rede Neural treinada com algoritmo Levenberg Marquardt.

double pdnn(const double x1[2])

{

double xp1[2];

int k;

double b[10];

static const double a[10] = { -4.7946154674436405, -3.2994029843245292,

1.3645883930926495, 1.0404221702070933, 0.057991441636920216, 0.065408180050365444, -0.13484028622751318, -2.1072761455357081, 3.95671259286272, 4.371680071532869 }; double b_b[10]; double d0; int i0;

static const double b_a[20] = { 0.67068555561189536, 3.4982468207293125,

-0.38502780450307689, -1.7273315597872907, 3.4400590516593077, 0.081439126580724122, -0.24379449844577222, -0.41210565313027758, 3.8707995509926043, 3.7452321946749692, 3.9037363396340781, -2.4481373191059, -2.2423365092887457, 1.2080048395665661, 1.8747505903688213, 0.47434991372913021, 0.17240522288606328, -2.4248552715508382, 0.85051143631426418, -1.4704820814047384 };

static const double c_a[10] = { 0.33854936648632522, -0.0022704780709331906,

-0.036130089569306093, 0.0036487545401550693, -5.6380099343315387E-6, 1.8292996063326412, 0.44494141448811092, -0.036842379657288864, 0.00022704900050175825, -0.0016784424869623258 };

/* ===== NEURAL NETWORK CONSTANTS ===== */

/* Input 1 */ /* Layer 1 */ /* Layer 2 */ /* Output 1 */ /* ===== SIMULATION ======== */ /* Dimensions */ /* samples */ /* Input 1 */ /* ===== MODULE FUNCTIONS ======== */

/* Map Minimum and Maximum Input Processing Function */

for (k = 0; k < 2; k++) {

xp1[k] = (x1[k] - -1.0) * (1.09564293013561 + -0.084248060456010077 * (double)k) + -1.0;

}

/* Layer 1 */

memcpy(&b[0], &a[0], 10U * sizeof(double));

/* Sigmoid Symmetric Transfer Function */

for (k = 0; k < 10; k++) { d0 = 0.0;

d0 += b_a[k + 10 * i0] * xp1[i0]; } b_b[k] = b[k] + d0; } /* Layer 2 */ /* Output 1 */

/* Map Minimum and Maximum Output Reverse-Processing Function */

d0 = 0.0; for (k = 0; k < 10; k++) { d0 += c_a[k] * (2.0 / (1.0 + exp(-2.0 * b_b[k])) - 1.0); } return ((0.26816453825549613 + d0) - -1.0) / 1.01236648176873 + -1.0; }

Rede Neural treinada com algoritmo Bayesian Regularization.

double pdnn(const double x1[2])

{

double xp1[2];

int k;

double b[10];

static const double a[10] = { 0.0062344893121035871, -0.017678168366624378,

1.2799141894759265, -0.037195356884099133, -0.0045986521363191746, -0.068996899333848352, -0.035536775089772328, 0.01504143285208763, -1.2897096873838008, -0.0027776767049251033 }; double b_b[10]; double d0; int i0;

static const double b_a[20] = { 0.00848965789546534, 0.010792903555082535,

0.016469873445170077, 0.0090553420020863772, 0.0097835342252170134, -0.0055150337524643373, -0.15484029712278888, -0.0099589353855996654, 0.016149178437732455, 0.01017611237307715, 0.20427442014193004, 0.21097245672951118, 0.36029616033326373, 0.19488086595003254, 0.20907000306765847, -0.20206239930434389, -0.039375138758944786, -0.20696842273724395, 0.35991906787600303, 0.21183381723947761 };

static const double c_a[10] = { 0.49628798802995988, 0.599772324292573,

No documento Comparativo entre controlador PID e redes neurais artificiais no controle de atitude de um quadricóptero (páginas 66-97)