1° RELATÓRIO DE INTELIGÊNCIA COMPUTACIONAL AULA DO DIA 29/08/2013
Professor: Leonardo Bonato Félix Aluno: Caio Eduardo Silva Matrícula: 2013220230004
São João del-Rei, 17 de Outubro de 2013.
Sumário 1.
Introdução ............................................ .................................................................. ............................................ ........................................ .................. 3
2.
Objetivo ........................................... ................................................................. ............................................ ............................................ ...................... 3
3.
Perceptron Perceptron ........................................... ................................................................. ............................................ ........................................ .................. 3
4.
Adaline ............................................. ................................................................... ............................................ ............................................ ...................... 4
5.
Desenvolvimento e resultados ......................................................... ........................................................................... .................. 5 5.1.
Problema prático 1 .......................................... ................................................................ ............................................ ...................... 5
5.2.
Problema prático 2 .......................................... ................................................................ ............................................ ...................... 6
6.
Conclusão........................................................... .................................................................................. .............................................. ......................... .. 9
7.
Referências Bibliográficas ............................................. .................................................................... .................................... ............. 9
ANEXO I ........................................... ................................................................. ............................................ ............................................. ........................... .... 10 ANEXO II ................................................. ....................................................................... ............................................ .......................................... .................... 11 ANEXO III ........................................... .................................................................. ............................................. ............................................. ....................... 14 ANEXO IV ........................................... .................................................................. ............................................. ............................................. ....................... 15
1. Introdução O desenvolvimento de redes neurais artificiais foi motivado pela observação da grande capacidade de processamento de informações do cérebro humano, que possui cerca de 100 bilhões de neurônios, sua célula fundamental. Cada um desses neurônios processa e se comunica com milhares de outros continuamente e em paralelo. A estrutura individual desses neurônios, a topologia de suas conexões e o comportamento conjunto desses elementos de processamento naturais formam a base para o estudo das RNAS. As RNAS tentam então reproduzir as funções das redes biológicas, buscando implementar seu comportamento funcional e sua dinâmica [2]. Nesse sentido, Rosenblatt (1958) propôs o modelo Perceptron, Perceptron, que que é a forma mais simples de configuração de uma rede neural artificial, sendo uma de suas aplicações a identificação de padrões geométricos [1]. Widrow e Hoff em 1960 idealizaram o Adaline, Adaline, e embora seja também um tipo de rede bem simples, o Adaline Adaline promoveu alguns outros avanços que foram de essencial importância para o progresso da área de RNAS [1]. Para uma familiarização com as RNAS, as redes Perceptron e Adaline Adaline foram utilizadas no desenvolvimento de dois problemas práticos que serão apresentados a seguir. 2. Objetivo O objetivo deste relatório é apresentar o desenvolvimento de exercícios que foram propostos na aula do dia 29 de agosto de 2013 da disciplina de Inteligência Computacional, sendo este uma das formas de avaliação desta disciplina do Programa de Pós-Graduação em Engenharia Elétrica (UFSJ / CEFET-MG).
3. Perceptron A rede Percetron Percetron é uma rede simples, que possui apenas uma camada neural e apenas um neurônio nesta camada.
Figura 1 – Ilustração Ilustração da rede Perceptron .
3
Seu princípio de funcionamento também é muito simples, e, por meio da Figura 1, pode-se resumir o funcionamento desta rede da seguinte forma:
As entradas {xi}, informações do processo a ser mapeado, são inicialmente ponderadas pelos pesos sinápticos {wi} com o objetivo de quantificar a importância de cada uma frente aos objetivos funcionais atribuídos ao neurônio, que é mapear o comportamento de entrada/saída do processo.
O valor da composição de todas as entradas ponderadas pelos seus respectivos pesos sinápticos, adicionado ainda do limiar de ativação { }, é passado como argumento para a função de ativação e esta terá como resultado a saída { } da rede Perceptron rede Perceptron..
Com relação ao treinamento da rede Perceptron, Perceptron, o mesmo é apresentado resumidamente em [1], da seguinte maneira: Se a saída produzida pelo Perceptron Perceptron está coincidente com a saída desejada, os pesos sinápticos e limiares da rede serão então incrementados (ajustes excitatório) proporcionalmente aos valores de seus sinais de entrada; caso contrário, ou seja, a saída produzida pela rede é diferente do valor desejado, os pesos sinápticos e limiar serão então decrementados (inibitório). Este processo é repetido, sequencialmente para todas as amostras de treinamento, ate que a saída produzida pelo Perceptron Perceptron seja similar à saída desejada de cada amostra.
A daline 4. Ad A rede Adaline Adaline é similar à rede Perceptron, Perceptron, é constituído de apenas uma camada neural e possuindo apenas um neurônio neurônio artificial. Seu princípio de funcionamento também é muito simples, e é basicamente igual ao da rede Perceptron Perceptron .
Figura 2 – Ilustração Ilustração da rede Adaline Adaline.
Na Figura 2 percebe-se p ercebe-se um bloco associador junto à estrutura do Adaline, Adaline, cuja função é auxiliar no processo de treinamento da rede [1]. 4
O processo de ajuste dos pesos e limiar do Adaline Adaline é baseado no algoritmo de aprendizado denominado de regra Delta ou regra de aprendizado de Widrow-Hoff, conhecido também como algoritmo LMS (least (least mean square) square ) ou método do Gradiente Descentente [1]. Assumindo-se a disponibilidade de p amostras de treinamento, a ideia básica envolvida com a aplicação da regra Delta objetivando ajustar os pesos e limiar do neurônio está em minimizar a diferença entre a saída desejada { } e a resposta do combinador linear { }, considerando-se para tanto todas as p amostras [1]. 5. Desenvolvimento e resultados 5.1. Problema prático 1 Pela análise de um processo de destilação fracionada de petróleo observou-se que determinado óleo poderia ser classificado em duas classes de pureza (P 1 e P2) a partir da medição de três grandezas (x1, x2 e x 3), que representam algumas de suas propriedades físico-químicas. A equipe de engenheiros e cientistas pretende usar uma rede Perceptron rede Perceptron para para executar a classificação automática das duas classes. Assim, baseado nas informações coletadas do processo, formou-se o conjunto de treinamento apresentado no Anexo I, tomando por convenção o valor -1 para óleo pertencente à classe P 1 e o valor 1 para óleo pertencente à classe P 2. Utilizando o algoritmo supervisionado de Hebb (regra de Hebb) para classificação de padrões, e assumindo-se a taxa de aprendizagem como 0,01, foram executados 5 treinamentos para a rede Perceptron, iniciando-se o vetor de pesos {w} em cada treinamento com valores aleatórios entre zero e um. Para cada treinamento o gerador de números aleatórios foi reiniciado para que os elementos do vetor de pesos iniciais não fossem os mesmos. Os resultados destes cinco treinamentos foram registrados na Tabela 1 apresentada a seguir. Tabela 1 – Resultados Resultados dos treinamentos do Perceptron .
Treinamento 1° (T1) 2° (T2) 3° (T3) 4° (T4) 5° (T5)
Vetor de pesos iniciais 0,8147 0,9058 0,1270 0,9134 0,6324 0,0975 0,2785 0,5469 0,9575 0,9649 0,1576 0,9706 0,9572 0,4854 0,8003 0,1419 0,4218 0,9157 0,7922 0,9595
Vetor de pesos finais Número de épocas -3,0653 1,5526 2,4737 -0,7326 413 -2,9276 1,4230 2,4175 -0,7018 362 -3,0225 1,5410 2,4530 -0,7233 405 -3,1028 1,5372 2,5191 -0,7122 448 -3,0582 1,5270 2,4554 -0,7270 412
Após o treinamento do Perceptron Perceptron , o mesmo foi colocado em operação, sendo aplicado na classificação automática das amostras de óleo da Tabela 2, indicando nesta tabela os resultados das saídas (Classes) referentes aos cinco processos de treinamento realizados no item 1.
5
Tabela 2 – Amostras Amostras de óleo para validar a rede Perceptron.
Amostra 1 2 3 4 5 6 7 8 9 10
-0,3665 0,0620 -0,7842 1,1267 0,3012 0,5611 0,7757 1,0648 0,1570 0,8028 -0,7014 1,0316 0,3748 0,1536 -0,6920 0,9404 -1,3970 0,7141 -1,8842 -0,2805
5,9891 5,5912 5,8234 8,0677 6,3040 3,6005 6,1537 4,4058 4,9263 1,2548
y y y y y (T1) (T2) (T3) (T4) (T5) -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1
Considerando a utilização dos mesmos dados para treino e uma mesma taxa de aprendizado, a quantidade de épocas necessárias para a convergência do processo de treinamento do Perceptron varia, pois os valores iniciais dos elementos do vetor de pesos são diferentes a cada treinamento. Para a aplicação em questão, pode-se afirmar que suas classes são linearmente separáveis, uma vez que a rede conseguiu classificar as duas classes de forma relativamente tranquila, ou seja, utilizando um número finito de épocas relativamente pequeno. O treinamento e a operação da rede Perceptron Perceptron utilizada neste projeto prático foram desenvolvidos por meio dos algoritmos implementados em MATLAB que se encontram no Anexo II. 5.2. Problema prático 2 Um sistema de gerenciamento automático de duas válvulas, situado a 500 metros de um processo industrial, envia um sinal codificado constituído de quatro grandezas {x1, x2, x3, x4}, as quais são necessárias para seus acionamentos. Conforme mostra a Figura 3, uma mesma via de comunicação é utilizada para acionar ambas as válvulas, sendo que o comutador localizado local izado próximo a estas deve decidir se o sinal é para a válvula A ou B.
Figura 3 – Estrutura Estrutura esquemática do sistema de acionamento de válvulas.
6
Entretanto, durante a comunicação, os sinais sofrem interferências que alteram o conteúdo das informações originalmente transmitidas. Para contornar este problema, a equipe de engenheiros e cientistas pretende treinar um Adaline Adaline para classificar os sinais ruidosos, cujo objetivo é então garantir ao sistema comutador se os dados devem ser encaminhados para o comando de ajuste da válvula A ou B. Assim, fundamentado nas medições de alguns sinais já com ruídos compilou-se o conjunto de treinamento apresentado no Anexo III, tomando-se por convenção o valor -1 para os sinais que devem ser encaminhados para o ajuste da válvula A e o valor +1 se os mesmos devem ser encaminhados para a válvula B. Utilizando o algoritmo de aprendizado regra Delta visando classificação de padrões pelo Adaline, Adaline, foram executados 5 treinamentos para o Adaline, Adaline, iniciando-se o vetor de pesos {w} em cada treinamento com valores aleatórios entre zero e um. Para cada treinamento o gerador de números aleatórios foi reiniciado para que os elementos do vetor de pesos iniciais não fossem os mesmos. Foi utilizada uma taxa de aprendizado {} igual a 0,0025 e uma precisão {} igual a 10 -6. Os resultados destes cinco treinamentos foram registrados na Tabela 3 apresentada a seguir. Tabela 3 – Resultados Resultados dos treinamentos do Adaline Adaline.
Vetor de pesos iniciais Treinamento 1° (T1) 2° (T2) 3° (T3) 4° (T4) 5° (T5)
Vetor de pesos finais
0,9593 0,5472 0,1386 0,1493 0,2575 -1,8131 1,3129 1,6423 -0,4277 0,8407 0,2543 0,8143 0,2435 0,9293 -1,8131 1,3129 1,6423 -0,4277 0,3500 0,1966 0,2511 0,6160 0,4733 -1,8130 1,3129 1,6423 -0,4276 0,3517 0,8308 0,5853 0,5497 0,9172 -1,8131 1,3129 1,6423 -0,4276 0,2858 0,7572 0,7537 0,3804 0,5678 -1,8130 1,3129 1,6423 -0,4276
-1,1778 -1,1778 -1,1778 -1,1778 -1,1778
Número de épocas 922 917 912 905 884
A seguir, foram traçados para os dois primeiros treinamentos realizados no Adaline os respectivos gráficos dos valores de erro quadrático médio em função de cada época de treinamento. Erro quadrático médio 1.4
1.2
1 o r r E
0.8
0.6
0.4 0
100
200
300
400 500 600 Número de épocass
700
800
900
Figura 4 – Erro Erro quadrático médio para o 1° treinamento do Adaline Adaline.
7
Erro quadrático médio 4 3.5 3 2.5 o r r E
2 1.5 1 0.5 0
100
200
300
400 500 600 Número de épocass
700
800
900
Figura 5 – Erro Erro quadrático médio para o 2° treinamento do Adaline Adaline.
Diferentemente do Perceptron, Perceptron, o Adaline Adaline mesmo para problemas cujas classes envolvidas são linearmente não separáveis é passível de convergência em função do patamar de precisão atribuído para medir a diferença dos erros quadráticos médios entre duas épocas sucessivas, desta forma, não é possível dizer se as classes envolvidas com o problema são linearmente separáveis. Para os cinco treinamentos realizados, foram aplicados ao Adaline Adaline os sinais registrados na Tabela 4, visando-se classificar (indicar o comutador) se os referidos sinais devem ser encaminhados para a válvula A ou B.
Tabela 4 – Amostras Amostras de sinais para a classif icação pelo Adaline Adaline.
Amostra
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0,9694 0,5427 0,6081 -0,1618 0,1870 0,4891 0,3777 1,1498 0,9325 0,5060 0,0497 0,4004 -0,1874 0,5060 1,6375
0,6909 1,3832 -0,9196 0,4694 -0,2578 -0,5276 2,0149 -0,4067 1,0950 1,3317 -2,0656 3,5369 1,3343 1,3317 -0,7911
0,4334 3,4965 0,6390 4,0352 0,5925 0,1016 0,2030 3,0117 0,6124 1,7749 0,4378 0,6439 0,7423 3,3932 0,2469 1,5866 1,0359 3,3591 0,9222 3,7174 0,6124 -0,6585 0,9766 5,3532 0,5374 3,2189 0,9222 3,7174 0,7537 0,5515
y y y y y (T1) (T2) (T3) (T4) (T5) -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1
O Adaline tem Adaline tem seu processo de ajuste dos pesos e limiar baseado no algoritmo de aprendizado denominado de regra Delta, conhecido também como método do Gradiente Descendente, cuja ideia 8
básica é a de ajustar os pesos e limiar pela minimização da diferença entre a saída sa ída desejada {} e a reposta do combinador linear { }. Sendo o objetivo obter um vetor de pesos ótimo tal que o erro quadrático sobre todo o conjunto de amostras seja o mínimo possível e, por este motivo, independente dos valores iniciais atribuídos ao vetor de pesos, o vetor de pesos final obtido ao após a convergência da rede será sempre o mesmo. O treinamento e a operação do Adaline do Adaline utilizado utilizado neste projeto prático foram desenvolvidos por meio dos algoritmos implementados em MATLAB que se encontram no Anexo IV.
6. Conclusão A partir dos resultados obtidos tanto para a rede Perceptron Perceptron quanto para a rede Adaline e levando em consideração a facilidade de implementação destas, aliado ao pequeno custo computacional das mesmas, conclui-se que estas são muito úteis para o desenvolvimento de aplicações simples, como as apresentadas neste relatório, e muito úteis para um primeiro contato e aprendizado do funcionamento das redes neurais artificias.
7. Referências Bibliográficas
[1] [1] SILVA, IN da; SPATTI, Danilo Hernane; FLAUZINO, Rogério Andrade. Redes neurais artificiais para engenharia e ciências aplicadas. São Paulo: Artliber, Artliber, 2010. [2] BRAGA, A. de P.; CARVALHO, ACPLF; LUDERMIR, Teresa Bernarda. Redes neurais artificiais: teoria e aplicações. aplicações. Livros Técnicos e Científicos, 2007.
9
ANEXO I
Dados do projeto prático 1: -0,6508 0,1097 4,0009 -1 -1,4492 0,8896 4,4005 -1 2,085 0,6876 12,071 -1 0,2626 1,1476 1,1476 7,7985 1 0,6418 1,0234 1,0234 7,0427 1 0,2569 0,673 8,3265 -1 1,1155 0,6043 0,6043 7,4446 1 0,0914 0,3399 7,0677 -1 0,0121 0,5256 0,5256 4,6316 1 -0,0429 0,466 5,4323 5,4323 1 0,434 0,687 8,2287 -1 0,2735 1,0287 1,0287 7,1934 1 0,4839 0,4851 7,485 -1 0,4089 -0,1267 5,5019 -1 1,4391 0,1614 8,5843 -1 -0,9115 -0,1973 2,1962 -1 0,3654 1,0475 1,0475 7,4858 1 0,2144 0,7515 0,7515 7,1699 1 0,2013 1,0014 1,0014 6,5489 1 0,6483 0,2183 0,2183 5,8991 1 -0,1147 0,2242 7,2435 -1 -0,797 0,8795 0,8795 3,8762 1 -1,0625 0,6366 0,6366 2,4707 1 0,5307 0,1285 0,1285 5,6883 1 -1,22 0,7777 0,7777 1,7252 1 0,3957 0,1076 5,6623 -1 -0,1013 0,5989 7,1812 -1 2,4482 0,9455 11,2095 1 2,0149 0,6192 10,9263 -1 0,2012 0,2611 0,2611 5,4631 1
10
ANEXO II Algoritmo para a fase de treinamento da rede Perceptron. clear all all; ; close all all; ; clc; %Projeto Prático Pág. 70 - Inteligência Computacional %Aluno: Caio Eduardo Silva %Matrícula: 2013220230004 %Prof.: Leonardo Bonato Félix %Redes Neurais Artificiais %Algoritmo Perceptron - Fase de treinamento load('dados_treino.txt' load( 'dados_treino.txt' ); xin = [ -ones(1,length(dados_treino)); dados_treino(:,1)'; dados_treino(:,2)'; dados_treino(:,3)'];
%Bias (b) %Variável x1 %Variável x2 %Variável x3
n = 0.01; num_max = 500; d = dados_treino(:,4)';
%Taxa de aprendizado %Número máximo de iterações %Saída desejada
[l,c] = size(xin); eee = 0; for t for t = 1:5 figure(t); w = rand(l,1);
%Tamanho dos dados
w_inicial = w;
%Vetor inicial de pesos %Vetor inicial de pesos (para salvar)
erro = 1; %Erro existe (Chute inicial) i = 0; %Epóca 0 while (i<=num_max while (i<=num_max && erro~=0) erro = 0; %Erro não existe for k for k = 1:length(xin) u = w'*xin(:,k); w'*xin(:,k); %Potencial de ativação y = sign(u); %Sinal de saída if(y~=d(k)) if (y~=d(k)) w = w + n*(d(k) - y)*xin(:,k); %Cálculo dos novos pesos erro = 1; %Erro existe eee(i+1) = (d(k) - y); end end plot(eee); hold on on; ; grid on on; ; i=i+1; %Conta mais uma época
end Matriz_w_inicial(:,t) = w_inicial; Matriz_w(:,t) = w; Matriz_epoca(:,t) = i; end save ('resultado_treino.txt' ( 'resultado_treino.txt' ,'Matriz_w_inicial' ,'Matriz_w' ,'Matriz_epoca' , ascii'); ascii' );
'-
11
Algoritmo para a fase de operação da rede Perceptron. clear all all; ; close all all; ; clc; %Projeto Prático Pág. 70 - Inteligência Computacional %Aluno: Caio Eduardo Silva %Matrícula: 2013220230004 %Prof.: Leonardo Bonato Félix %Redes Neurais Artificiais %Algoritmo Perceptron - Fase de operação load('dados_operacao.txt' load( 'dados_operacao.txt' ); load('resultado_treino.txt' load( 'resultado_treino.txt' ); xin = [ -ones(1,length(dados_operacao)); dados_operacao(:,1)'; dados_operacao(:,2)'; dados_operacao(:,3)'];
%Bias (b) %Variável x1 %Variável x2 %Variável x3
w_inicial = resultado_treino(1:4,:); w = resultado_treino(5:8,:); epoca = resultado_treino(9,:); disp('Resultados:' disp( 'Resultados:') ) disp(' disp( ' '); '); disp(' disp( ' '); '); for o for o = 1:5 u = w(:,o)'*xin; %Potencial de ativação y(o,:) = sign(u); %Sinal de saída [classe_a,classe_b,na,nb] = separaclasse(u,w(:,o),xin); disp(['DADOS disp([ 'DADOS DE OPERAÇÃO PARA O ' ,num2str(o), '° TREINAMENTO:' ]); disp(' disp( ' '); '); disp(['Os disp([ 'Os dados classificados na classe A são:' ]); classe_a disp(['Os disp([ 'Os dados classificados na classe B são:' ]); classe_b disp(['O disp([ 'O número de elementos classificados na classe A é igual a: ',num2str(na)]); disp(['O disp([ 'O número de elementos classificados na classe B é igual a: ',num2str(nb)]); disp(' disp( ' '); '); disp(' disp( ' '); '); end
Função para separação de classes. function function [classe_a,classe_b,na,nb]=separaclasse(u,w,xin) %Separação de Classes u = w'*xin;
%Potencial de ativação
y = sign(u); xn = xin(2:end,:);
12
a = 1; b = 1; for i for i = 1:length(y) if(y(i)==-1) if (y(i)==-1) classe_a(:,a) = xn(:,i); a = a + 1; elseif(y(i)==1) elseif (y(i)==1) classe_b(:,b) = xn(:,i); b = b + 1; end end na = length(classe_a); nb= length(classe_b); end
13
ANEXO III Dados do projeto prático 2: 0,4329 0,3024 0,1349 0,3374 1,1434 1,3749 0,7221 0,4403 -0,5231 0,3255 0,5824 0,134 0,148 0,7359 0,7115 0,8251 0,1569 0,0033 0,4243 1,049 1,4276 0,5971 0,8475 1,3967 0,0044 0,2201 0,63 -0,2479 -0,3088 -0,518 0,6833 0,4353 -0,1069 0,4662 0,8298
-1,3719 0,2286 -0,6445 -1,7163 -0,0485 -0,5071 -0,7587 -0,8072 0,3548 -2 1,3915 0,6081 -0,2988 0,1869 -1,1469 -1,284 0,3712 0,6835 0,8313 0,1326 0,5331 1,4865 2,1479 -0,4171 1,5378 -0,5668 -1,248 0,896 -0,0929 1,4974 0,8266 -1,4066 -3,2329 0,6261 -1,4089
0,7022 0,863 1,053 0,367 0,6637 0,4464 0,7681 0,5154 0,2538 0,7112 -0,2291 0,445 0,4778 -0,0872 0,3394 0,3394 0,8452 0,8825 0,5389 0,2634 0,9138 0,9138 -0,0145 0,2904 0,3179 0,6443 0,6099 0,0515 0,8591 0,0547 0,8659 0,5453 0,0829 0,4207 0,1856 0,7304 0,3119 0,3119
-0,8535 2,7909 0,5687 -0,6283 1,2606 1,3009 -0,5592 -0,3129 1,5776 -1,1209 4,1735 4,1735 3,223 0,8649 2,3584 0,9573 1,2382 1,7633 2,8249 3,5855 1,9792 1,9792 3,7286 4,6069 5,8235 1,3927 4,7755 0,7829 0,8093 1,7381 1,5483 2,3993 2,8864 -0,4879 -2,4572 3,437 1,3235
1 -1 -1 -1 1 1 1 1 -1 1 -1 -1 1 1 -1 -1 1 -1 -1 1 1 -1 -1 1 -1 1 -1 1 -1 1 1 1 -1 -1 -1
14
ANEXO IV
A daline. Algoritmo para a fase de treinamento do Ad clear all all; ; close all all; ; clc; %Projeto Prático Pág. 87 - Inteligência Computacional %Aluno: Caio Eduardo Silva %Matrícula: 2013220230004 %Prof.: Leonardo Bonato Félix %Redes Neurais Artificiais %Algoritmo Perceptron - Fase de treinamento load('dados_treino.txt' load( 'dados_treino.txt' ); xin = [ -ones(1,length(dados_treino)); dados_treino(:,1)'; dados_treino(:,2)'; dados_treino(:,3)'; dados_treino(:,4)'];
%Bias (b) %Variável %Variável %Variável %Variável
x1 x2 x3 x4
n = 0.0025; num_max = 1000; d = dados_treino(:,5)'; tol = 10^-6;
%Taxa de aprendizado %Número máximo de iterações %Saída desejada
[l,c] = size(xin);
%Tamanho dos dados
for t for t = 1:5 w = rand(l,1); w_inicial = w; eqm_ant = 0; eqm_atual = eqm(xin,w,d); eqm(xin,w,d);
%Vetor inicial de pesos %Vetor inicial de pesos (para salvar)
erro = abs(eqm_atual abs(eqm_atua l - eqm_ant); i = 0; %Época 0
%Erro
while (i<=num_max && erro>tol) while (i<=num_max for k for k = 1:length(xin) u = w'*xin(:,k); w'*xin(:,k); %Potencial de ativação w = w + n*(d(k) - u)*xin(:,k); %Cálculo dos novos pesos end aux = eqm_atual; eqm_atual = eqm(xin,w,d); erro = abs(eqm_atual - aux);
e(i+1) = eqm_atual; i=i+1;
%Conta mais uma época
end figure; plot(e); xlabel('Número xlabel( 'Número de épocass' ); ylabel('Erro' ylabel( 'Erro'); ); title('Erro title( 'Erro quadrático médio' ); grid; axis([0 i 0.95*min(e) 1.05*max(e)]); Matriz_w_inicial(:,t) = w_inicial; Matriz_w(:,t) = w;
15
Matriz_epoca(:,t) = i; end save ('resultado_treino.txt' ( 'resultado_treino.txt' ,'Matriz_w_inicial' ,'Matriz_w' ,'Matriz_epoca' , ascii'); ascii' );
'-
Algoritmo para a fase de operação do Ad A daline. clear all all; ; close all all; ; clc; %Projeto Prático Pág. 87 - Inteligência Computacional %Aluno: Caio Eduardo Silva %Matrícula: 2013220230004 %Prof.: Leonardo Bonato Félix %Redes Neurais Artificiais %Algoritmo Adaline - Fase de operação load('dados_operacao.txt' load( 'dados_operacao.txt' ); load('resultado_treino.txt' load( 'resultado_treino.txt' ); xin = [ -ones(1,length(dados_operacao)); dados_operacao(:,1)'; dados_operacao(:,2)'; dados_operacao(:,3)'; dados_operacao(:,4)'];
%Bias (b) %Variável %Variável %Variável %Variável
x1 x2 x3 x4
w_inicial = resultado_treino(1:5,:); w = resultado_treino(6:10,:); epoca = resultado_treino(11,:);
disp('Resultados:' disp( 'Resultados:') ) disp(' disp( ' '); '); disp(' disp( ' '); '); for o for o = 1:5 u = w(:,o)'*xin; %Potencial de ativação y(o,:) = sign(u); %Sinal de saída [classe_a,classe_b,na,nb] = separaclasse(u,w(:,o),xin); disp(['DADOS disp([ 'DADOS DE OPERAÇÃO PARA O ' ,num2str(o), '° TREINAMENTO:' ]); disp(' disp( ' '); '); disp(['Os disp([ 'Os dados classificados na classe A são:' ]); classe_a disp(['Os disp([ 'Os dados classificados na classe B são:' ]); classe_b disp(['O disp([ 'O número de elementos classificados na classe A é igual a: ',num2str(na)]); disp(['O disp([ 'O número de elementos classificados na classe B é igual a: ',num2str(nb)]); disp(' disp( ' '); '); disp(' disp( ' '); '); end
Função para o cálculo do erro quadrático médio. function z = eqm(xin,w,d) function z %Função para o cálculo do erro quadrático médio s = 0;
16
p = length(xin); for k for k = 1:p u = w'*xin(:,k); w'*xin(:,k); s = s + (d(k) - u)^2; end z = (1/p)*s; end
Função para separação de classes. function function [classe_a,classe_b,na,nb]=separaclasse(u,w,xin) %Separação de Classes u = w'*xin;
%Potencial de ativação
y = sign(u); xn = xin(2:end,:); a = 1; b = 1; for i for i = 1:length(y) if(y(i)==-1) if (y(i)==-1) classe_a(:,a) = xn(:,i); a = a + 1; elseif(y(i)==1) elseif (y(i)==1) classe_b(:,b) = xn(:,i); b = b + 1; end end na = length(classe_a); nb= length(classe_b); end
17
