1 RELATRIO DE

INTELIGNCIA COMPUTACIONAL
AULA DO DIA 29/08/2013

Professor: Leonardo Bonato Flix

Aluno: Caio Eduardo Silva

Matrcula: 2013220230004

So Joo del-Rei, 17 de Outubro de 2013.

Sumrio

1. Introduo .......................................................................................................... 3

2. Objetivo ............................................................................................................. 3

3. Perceptron ......................................................................................................... 3

4. Adaline ............................................................................................................... 4

5. Desenvolvimento e resultados ........................................................................... 5

5.1. Problema prtico 1 ...................................................................................... 5

5.2. Problema prtico 2 ...................................................................................... 6

6. Concluso........................................................................................................... 9

7. Referncias Bibliogrficas ................................................................................. 9

ANEXO I .................................................................................................................. 10

ANEXO II ................................................................................................................. 11

ANEXO III ............................................................................................................... 14

ANEXO IV ............................................................................................................... 15
 1. Introduo
O desenvolvimento de redes neurais artificiais foi motivado pela observao da grande
capacidade de processamento de informaes do crebro humano, que possui cerca de 100 bilhes
de neurnios, sua clula fundamental. Cada um desses neurnios processa e se comunica com
milhares de outros continuamente e em paralelo. A estrutura individual desses neurnios, a
topologia de suas conexes e o comportamento conjunto desses elementos de processamento
naturais formam a base para o estudo das RNAS. As RNAS tentam ento reproduzir as funes das
redes biolgicas, buscando implementar seu comportamento funcional e sua dinmica [2].
Nesse sentido, Rosenblatt (1958) props o modelo Perceptron, que a forma mais simples de
configurao de uma rede neural artificial, sendo uma de suas aplicaes a identificao de padres
geomtricos [1].
Widrow e Hoff em 1960 idealizaram o Adaline, e embora seja tambm um tipo de rede bem
simples, o Adaline promoveu alguns outros avanos que foram de essencial importncia para o
progresso da rea de RNAS [1].
Para uma familiarizao com as RNAS, as redes Perceptron e Adaline foram utilizadas no
desenvolvimento de dois problemas prticos que sero apresentados a seguir.

2. Objetivo
O objetivo deste relatrio apresentar o desenvolvimento de exerccios que foram propostos na
aula do dia 29 de agosto de 2013 da disciplina de Inteligncia Computacional, sendo este uma das
formas de avaliao desta disciplina do Programa de Ps-Graduao em Engenharia Eltrica (UFSJ
/ CEFET-MG).

3. Perceptron
A rede Percetron uma rede simples, que possui apenas uma camada neural e apenas um
neurnio nesta camada.

Figura 1 Ilustrao da rede Perceptron.

3
 Seu princpio de funcionamento tambm muito simples, e, por meio da Figura 1, pode-se
resumir o funcionamento desta rede da seguinte forma:
As entradas {xi}, informaes do processo a ser mapeado, so inicialmente ponderadas
pelos pesos sinpticos {wi} com o objetivo de quantificar a importncia de cada uma
frente aos objetivos funcionais atribudos ao neurnio, que mapear o comportamento
de entrada/sada do processo.
O valor da composio de todas as entradas ponderadas pelos seus respectivos pesos
sinpticos, adicionado ainda do limiar de ativao {}, passado como argumento para
a funo de ativao e esta ter como resultado a sada {} da rede Perceptron.
Com relao ao treinamento da rede Perceptron, o mesmo apresentado resumidamente em
[1], da seguinte maneira:
Se a sada produzida pelo Perceptron est coincidente com a sada desejada, os pesos
sinpticos e limiares da rede sero ento incrementados (ajustes excitatrio) proporcionalmente aos
valores de seus sinais de entrada; caso contrrio, ou seja, a sada produzida pela rede diferente do
valor desejado, os pesos sinpticos e limiar sero ento decrementados (inibitrio). Este processo
repetido, sequencialmente para todas as amostras de treinamento, ate que a sada produzida pelo
Perceptron seja similar sada desejada de cada amostra.

4. Adaline
A rede Adaline similar rede Perceptron, constitudo de apenas uma camada neural e
possuindo apenas um neurnio artificial.
Seu princpio de funcionamento tambm muito simples, e basicamente igual ao da rede
Perceptron.

Figura 2 Ilustrao da rede Adaline.

Na Figura 2 percebe-se um bloco associador junto estrutura do Adaline, cuja funo auxiliar
no processo de treinamento da rede [1].
4
 O processo de ajuste dos pesos e limiar do Adaline baseado no algoritmo de aprendizado
denominado de regra Delta ou regra de aprendizado de Widrow-Hoff, conhecido tambm como
algoritmo LMS (least mean square) ou mtodo do Gradiente Descentente [1].
Assumindo-se a disponibilidade de p amostras de treinamento, a ideia bsica envolvida com a
aplicao da regra Delta objetivando ajustar os pesos e limiar do neurnio est em minimizar a
diferena entre a sada desejada {} e a resposta do combinador linear {}, considerando-se para
tanto todas as p amostras [1].

5. Desenvolvimento e resultados
5.1. Problema prtico 1

Pela anlise de um processo de destilao fracionada de petrleo observou-se que determinado

leo poderia ser classificado em duas classes de pureza (P1 e P2) a partir da medio de trs
grandezas (x1, x2 e x3), que representam algumas de suas propriedades fsico-qumicas. A equipe de
engenheiros e cientistas pretende usar uma rede Perceptron para executar a classificao automtica
das duas classes.
Assim, baseado nas informaes coletadas do processo, formou-se o conjunto de treinamento
apresentado no Anexo I, tomando por conveno o valor -1 para leo pertencente classe P1 e o
valor 1 para leo pertencente classe P2.
Utilizando o algoritmo supervisionado de Hebb (regra de Hebb) para classificao de padres, 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 aleatrios entre
zero e um. Para cada treinamento o gerador de nmeros aleatrios foi reiniciado para que os
elementos do vetor de pesos iniciais no fossem os mesmos.
Os resultados destes cinco treinamentos foram registrados na Tabela 1 apresentada a seguir.
Tabela 1 Resultados dos treinamentos do Perceptron.
Vetor de pesos iniciais Vetor de pesos finais
Treinamento Nmero de pocas

1 (T1) 0,8147 0,9058 0,1270 0,9134 -3,0653 1,5526 2,4737 -0,7326 413
2 (T2) 0,6324 0,0975 0,2785 0,5469 -2,9276 1,4230 2,4175 -0,7018 362
3 (T3) 0,9575 0,9649 0,1576 0,9706 -3,0225 1,5410 2,4530 -0,7233 405
4 (T4) 0,9572 0,4854 0,8003 0,1419 -3,1028 1,5372 2,5191 -0,7122 448
5 (T5) 0,4218 0,9157 0,7922 0,9595 -3,0582 1,5270 2,4554 -0,7270 412

Aps o treinamento do Perceptron, o mesmo foi colocado em operao, sendo aplicado na

classificao automtica das amostras de leo da Tabela 2, indicando nesta tabela os resultados das
sadas (Classes) referentes aos cinco processos de treinamento realizados no item 1.

5
 Tabela 2 Amostras de leo para validar a rede Perceptron.
y y y y y
Amostra
(T1) (T2) (T3) (T4) (T5)
1 -0,3665 0,0620 5,9891 -1 -1 -1 -1 -1
2 -0,7842 1,1267 5,5912 1 1 1 1 1
3 0,3012 0,5611 5,8234 1 1 1 1 1
4 0,7757 1,0648 8,0677 1 1 1 1 1
5 0,1570 0,8028 6,3040 1 1 1 1 1
6 -0,7014 1,0316 3,6005 1 1 1 1 1
7 0,3748 0,1536 6,1537 -1 -1 -1 -1 -1
8 -0,6920 0,9404 4,4058 1 1 1 1 1
9 -1,3970 0,7141 4,9263 -1 -1 -1 -1 -1
10 -1,8842 -0,2805 1,2548 -1 -1 -1 -1 -1

Considerando a utilizao dos mesmos dados para treino e uma mesma taxa de aprendizado, a
quantidade de pocas necessrias para a convergncia do processo de treinamento do Perceptron
varia, pois os valores iniciais dos elementos do vetor de pesos so diferentes a cada treinamento.
Para a aplicao em questo, pode-se afirmar que suas classes so linearmente separveis, uma
vez que a rede conseguiu classificar as duas classes de forma relativamente tranquila, ou seja,
utilizando um nmero finito de pocas relativamente pequeno.
O treinamento e a operao da rede Perceptron utilizada neste projeto prtico foram
desenvolvidos por meio dos algoritmos implementados em MATLAB que se encontram no Anexo
II.

5.2. Problema prtico 2

Um sistema de gerenciamento automtico de duas vlvulas, situado a 500 metros de um

processo industrial, envia um sinal codificado constitudo de quatro grandezas {x1, x2, x3, x4}, as
quais so necessrias para seus acionamentos. Conforme mostra a Figura 3, uma mesma via de
comunicao utilizada para acionar ambas as vlvulas, sendo que o comutador localizado prximo
a estas deve decidir se o sinal para a vlvula A ou B.

Figura 3 Estrutura esquemtica do sistema de acionamento de vlvulas.

6
 Entretanto, durante a comunicao, os sinais sofrem interferncias que alteram o contedo das
informaes originalmente transmitidas. Para contornar este problema, a equipe de engenheiros e
cientistas pretende treinar um Adaline para classificar os sinais ruidosos, cujo objetivo ento
garantir ao sistema comutador se os dados devem ser encaminhados para o comando de ajuste da
vlvula A ou B.
Assim, fundamentado nas medies de alguns sinais j com rudos compilou-se o conjunto de
treinamento apresentado no Anexo III, tomando-se por conveno o valor -1 para os sinais que
devem ser encaminhados para o ajuste da vlvula A e o valor +1 se os mesmos devem ser
encaminhados para a vlvula B.
Utilizando o algoritmo de aprendizado regra Delta visando classificao de padres pelo
Adaline, foram executados 5 treinamentos para o Adaline, iniciando-se o vetor de pesos {w} em
cada treinamento com valores aleatrios entre zero e um. Para cada treinamento o gerador de
nmeros aleatrios foi reiniciado para que os elementos do vetor de pesos iniciais no fossem os
mesmos. Foi utilizada uma taxa de aprendizado {} igual a 0,0025 e uma preciso {} igual a 10-6.
Os resultados destes cinco treinamentos foram registrados na Tabela 3 apresentada a seguir.
Tabela 3 Resultados dos treinamentos do Adaline.
Vetor de pesos iniciais Vetor de pesos finais Nmero
Treinamento de

pocas
1 (T1) 0,9593 0,5472 0,1386 0,1493 0,2575 -1,8131 1,3129 1,6423 -0,4277 -1,1778 922
2 (T2) 0,8407 0,2543 0,8143 0,2435 0,9293 -1,8131 1,3129 1,6423 -0,4277 -1,1778 917
3 (T3) 0,3500 0,1966 0,2511 0,6160 0,4733 -1,8130 1,3129 1,6423 -0,4276 -1,1778 912
4 (T4) 0,3517 0,8308 0,5853 0,5497 0,9172 -1,8131 1,3129 1,6423 -0,4276 -1,1778 905
5 (T5) 0,2858 0,7572 0,7537 0,3804 0,5678 -1,8130 1,3129 1,6423 -0,4276 -1,1778 884

A seguir, foram traados para os dois primeiros treinamentos realizados no Adaline os

respectivos grficos dos valores de erro quadrtico mdio em funo de cada poca de treinamento.
Erro quadrtico mdio

1.4

1.2

1
Erro

0.8

0.6

0.4

0 100 200 300 400 500 600 700 800 900

Nmero de pocass

Figura 4 Erro quadrtico mdio para o 1 treinamento do Adaline.

7
 Erro quadrtico mdio

3.5

2.5

Erro
2

1.5

0.5

0 100 200 300 400 500 600 700 800 900

Nmero de pocass

Figura 5 Erro quadrtico mdio para o 2 treinamento do Adaline.

Diferentemente do Perceptron, o Adaline mesmo para problemas cujas classes envolvidas
so linearmente no separveis passvel de convergncia em funo do patamar de preciso
atribudo para medir a diferena dos erros quadrticos mdios entre duas pocas sucessivas, desta
forma, no possvel dizer se as classes envolvidas com o problema so linearmente separveis.
Para os cinco treinamentos realizados, foram aplicados ao Adaline os sinais registrados na
Tabela 4, visando-se classificar (indicar o comutador) se os referidos sinais devem ser
encaminhados para a vlvula A ou B.

Tabela 4 Amostras de sinais para a classificao pelo Adaline.

y y y y y
Amostra
(T1) (T2) (T3) (T4) (T5)
1 0,9694 0,6909 0,4334 3,4965 -1 -1 -1 -1 -1
2 0,5427 1,3832 0,6390 4,0352 -1 -1 -1 -1 -1
3 0,6081 -0,9196 0,5925 0,1016 1 1 1 1 1
4 -0,1618 0,4694 0,2030 3,0117 -1 -1 -1 -1 -1
5 0,1870 -0,2578 0,6124 1,7749 -1 -1 -1 -1 -1
6 0,4891 -0,5276 0,4378 0,6439 1 1 1 1 1
7 0,3777 2,0149 0,7423 3,3932 1 1 1 1 1
8 1,1498 -0,4067 0,2469 1,5866 1 1 1 1 1
9 0,9325 1,0950 1,0359 3,3591 1 1 1 1 1
10 0,5060 1,3317 0,9222 3,7174 -1 -1 -1 -1 -1
11 0,0497 -2,0656 0,6124 -0,6585 -1 -1 -1 -1 -1
12 0,4004 3,5369 0,9766 5,3532 1 1 1 1 1
13 -0,1874 1,3343 0,5374 3,2189 -1 -1 -1 -1 -1
14 0,5060 1,3317 0,9222 3,7174 -1 -1 -1 -1 -1
15 1,6375 -0,7911 0,7537 0,5515 1 1 1 1 1

O Adaline tem seu processo de ajuste dos pesos e limiar baseado no algoritmo de aprendizado
denominado de regra Delta, conhecido tambm como mtodo do Gradiente Descendente, cuja ideia
8
bsica a de ajustar os pesos e limiar pela minimizao da diferena entre a sada desejada {} e a
reposta do combinador linear {}. Sendo o objetivo obter um vetor de pesos timo tal que o erro
quadrtico sobre todo o conjunto de amostras seja o mnimo possvel e, por este motivo,
independente dos valores iniciais atribudos ao vetor de pesos, o vetor de pesos final obtido ao aps
a convergncia da rede ser sempre o mesmo.
O treinamento e a operao do Adaline utilizado neste projeto prtico foram desenvolvidos por
meio dos algoritmos implementados em MATLAB que se encontram no Anexo IV.

6. Concluso
A partir dos resultados obtidos tanto para a rede Perceptron quanto para a rede Adaline e
levando em considerao a facilidade de implementao destas, aliado ao pequeno custo
computacional das mesmas, conclui-se que estas so muito teis para o desenvolvimento de
aplicaes simples, como as apresentadas neste relatrio, e muito teis para um primeiro contato e
aprendizado do funcionamento das redes neurais artificias.

7. Referncias Bibliogrficas

[1] SILVA, IN da; SPATTI, Danilo Hernane; FLAUZINO, Rogrio Andrade. Redes neurais
artificiais para engenharia e cincias aplicadas. So Paulo: Artliber, 2010.
[2] BRAGA, A. de P.; CARVALHO, ACPLF; LUDERMIR, Teresa Bernarda. Redes neurais
artificiais: teoria e aplicaes. Livros Tcnicos e Cientficos, 2007.

9
 ANEXO I

Dados do projeto prtico 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 7,7985 1
0,6418 1,0234 7,0427 1
0,2569 0,673 8,3265 -1
1,1155 0,6043 7,4446 1
0,0914 0,3399 7,0677 -1
0,0121 0,5256 4,6316 1
-0,0429 0,466 5,4323 1
0,434 0,687 8,2287 -1
0,2735 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 7,4858 1
0,2144 0,7515 7,1699 1
0,2013 1,0014 6,5489 1
0,6483 0,2183 5,8991 1
-0,1147 0,2242 7,2435 -1
-0,797 0,8795 3,8762 1
-1,0625 0,6366 2,4707 1
0,5307 0,1285 5,6883 1
-1,22 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 5,4631 1

10
 ANEXO II
Algoritmo para a fase de treinamento da rede Perceptron.

clear all;
close all;
clc;
%Projeto Prtico Pg. 70 - Inteligncia Computacional
%Aluno: Caio Eduardo Silva
%Matrcula: 2013220230004
%Prof.: Leonardo Bonato Flix
%Redes Neurais Artificiais
%Algoritmo Perceptron - Fase de treinamento

load('dados_treino.txt');
xin = [ -ones(1,length(dados_treino)); %Bias (b)
dados_treino(:,1)'; %Varivel x1
dados_treino(:,2)'; %Varivel x2
dados_treino(:,3)']; %Varivel x3

n = 0.01; %Taxa de aprendizado

num_max = 500; %Nmero mximo de iteraes
d = dados_treino(:,4)'; %Sada desejada

[l,c] = size(xin); %Tamanho dos dados

eee = 0;
for t = 1:5
figure(t);
w = rand(l,1); %Vetor inicial de pesos

w_inicial = w; %Vetor inicial de pesos (para salvar)

erro = 1; %Erro existe (Chute inicial)

i = 0; %Epca 0
while (i<=num_max && erro~=0)
erro = 0; %Erro no existe
for k = 1:length(xin)
u = w'*xin(:,k); %Potencial de ativao
y = sign(u); %Sinal de sada
if(y~=d(k))
w = w + n*(d(k) - y)*xin(:,k); %Clculo dos novos pesos
erro = 1; %Erro existe
eee(i+1) = (d(k) - y);
end
end
plot(eee);
hold on;
grid 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','Matriz_w_inicial','Matriz_w','Matriz_epoca', '-

ascii');

11
 Algoritmo para a fase de operao da rede Perceptron.

clear all;
close all;
clc;

%Projeto Prtico Pg. 70 - Inteligncia Computacional

%Aluno: Caio Eduardo Silva
%Matrcula: 2013220230004
%Prof.: Leonardo Bonato Flix

%Redes Neurais Artificiais

%Algoritmo Perceptron - Fase de operao

load('dados_operacao.txt');
load('resultado_treino.txt');
xin = [ -ones(1,length(dados_operacao)); %Bias (b)
dados_operacao(:,1)'; %Varivel x1
dados_operacao(:,2)'; %Varivel x2
dados_operacao(:,3)']; %Varivel x3

w_inicial = resultado_treino(1:4,:);
w = resultado_treino(5:8,:);
epoca = resultado_treino(9,:);

disp('Resultados:')
disp(' ');
disp(' ');
for o = 1:5
u = w(:,o)'*xin; %Potencial de ativao
y(o,:) = sign(u); %Sinal de sada
[classe_a,classe_b,na,nb] = separaclasse(u,w(:,o),xin);
disp(['DADOS DE OPERAO PARA O ',num2str(o),' TREINAMENTO:']);
disp(' ');
disp(['Os dados classificados na classe A so:']);
classe_a
disp(['Os dados classificados na classe B so:']);
classe_b
disp(['O nmero de elementos classificados na classe A igual a:
',num2str(na)]);
disp(['O nmero de elementos classificados na classe B igual a:
',num2str(nb)]);
disp(' ');
disp(' ');
end

Funo para separao de classes.

function [classe_a,classe_b,na,nb]=separaclasse(u,w,xin)

%Separao de Classes

u = w'*xin; %Potencial de ativao

y = sign(u);

xn = xin(2:end,:);

12
a = 1;
b = 1;
for i = 1:length(y)
if(y(i)==-1)
classe_a(:,a) = xn(:,i);
a = a + 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 prtico 2:
0,4329 -1,3719 0,7022 -0,8535 1
0,3024 0,2286 0,863 2,7909 -1
0,1349 -0,6445 1,053 0,5687 -1
0,3374 -1,7163 0,367 -0,6283 -1
1,1434 -0,0485 0,6637 1,2606 1
1,3749 -0,5071 0,4464 1,3009 1
0,7221 -0,7587 0,7681 -0,5592 1
0,4403 -0,8072 0,5154 -0,3129 1
-0,5231 0,3548 0,2538 1,5776 -1
0,3255 -2 0,7112 -1,1209 1
0,5824 1,3915 -0,2291 4,1735 -1
0,134 0,6081 0,445 3,223 -1
0,148 -0,2988 0,4778 0,8649 1
0,7359 0,1869 -0,0872 2,3584 1
0,7115 -1,1469 0,3394 0,9573 -1
0,8251 -1,284 0,8452 1,2382 -1
0,1569 0,3712 0,8825 1,7633 1
0,0033 0,6835 0,5389 2,8249 -1
0,4243 0,8313 0,2634 3,5855 -1
1,049 0,1326 0,9138 1,9792 1
1,4276 0,5331 -0,0145 3,7286 1
0,5971 1,4865 0,2904 4,6069 -1
0,8475 2,1479 0,3179 5,8235 -1
1,3967 -0,4171 0,6443 1,3927 1
0,0044 1,5378 0,6099 4,7755 -1
0,2201 -0,5668 0,0515 0,7829 1
0,63 -1,248 0,8591 0,8093 -1
-0,2479 0,896 0,0547 1,7381 1
-0,3088 -0,0929 0,8659 1,5483 -1
-0,518 1,4974 0,5453 2,3993 1
0,6833 0,8266 0,0829 2,8864 1
0,4353 -1,4066 0,4207 -0,4879 1
-0,1069 -3,2329 0,1856 -2,4572 -1
0,4662 0,6261 0,7304 3,437 -1
0,8298 -1,4089 0,3119 1,3235 -1

14
 ANEXO IV
Algoritmo para a fase de treinamento do Adaline.

clear all;
close all;
clc;
%Projeto Prtico Pg. 87 - Inteligncia Computacional
%Aluno: Caio Eduardo Silva
%Matrcula: 2013220230004
%Prof.: Leonardo Bonato Flix

%Redes Neurais Artificiais

%Algoritmo Perceptron - Fase de treinamento

load('dados_treino.txt');
xin = [ -ones(1,length(dados_treino)); %Bias (b)
dados_treino(:,1)'; %Varivel x1
dados_treino(:,2)'; %Varivel x2
dados_treino(:,3)'; %Varivel x3
dados_treino(:,4)']; %Varivel x4

n = 0.0025; %Taxa de aprendizado

num_max = 1000; %Nmero mximo de iteraes
d = dados_treino(:,5)'; %Sada desejada
tol = 10^-6;

[l,c] = size(xin); %Tamanho dos dados

for t = 1:5
w = rand(l,1); %Vetor inicial de pesos
w_inicial = w; %Vetor inicial de pesos (para salvar)
eqm_ant = 0;
eqm_atual = eqm(xin,w,d);

erro = abs(eqm_atual - eqm_ant); %Erro

i = 0; %poca 0

while (i<=num_max && erro>tol)

for k = 1:length(xin)
u = w'*xin(:,k); %Potencial de ativao
w = w + n*(d(k) - u)*xin(:,k); %Clculo 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('Nmero de pocass');
ylabel('Erro');
title('Erro quadrtico mdio');
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','Matriz_w_inicial','Matriz_w','Matriz_epoca', '-

ascii');

Algoritmo para a fase de operao do Adaline.

clear all;
close all;
clc;
%Projeto Prtico Pg. 87 - Inteligncia Computacional
%Aluno: Caio Eduardo Silva
%Matrcula: 2013220230004
%Prof.: Leonardo Bonato Flix

%Redes Neurais Artificiais

%Algoritmo Adaline - Fase de operao

load('dados_operacao.txt');
load('resultado_treino.txt');
xin = [ -ones(1,length(dados_operacao)); %Bias (b)
dados_operacao(:,1)'; %Varivel x1
dados_operacao(:,2)'; %Varivel x2
dados_operacao(:,3)'; %Varivel x3
dados_operacao(:,4)']; %Varivel x4

w_inicial = resultado_treino(1:5,:);
w = resultado_treino(6:10,:);
epoca = resultado_treino(11,:);

disp('Resultados:')
disp(' ');
disp(' ');
for o = 1:5
u = w(:,o)'*xin; %Potencial de ativao
y(o,:) = sign(u); %Sinal de sada
[classe_a,classe_b,na,nb] = separaclasse(u,w(:,o),xin);
disp(['DADOS DE OPERAO PARA O ',num2str(o),' TREINAMENTO:']);
disp(' ');
disp(['Os dados classificados na classe A so:']);
classe_a
disp(['Os dados classificados na classe B so:']);
classe_b
disp(['O nmero de elementos classificados na classe A igual a:
',num2str(na)]);
disp(['O nmero de elementos classificados na classe B igual a:
',num2str(nb)]);
disp(' ');
disp(' ');
end

Funo para o clculo do erro quadrtico mdio.

function z = eqm(xin,w,d)
%Funo para o clculo do erro quadrtico mdio
s = 0;
16
 p = length(xin);
for k = 1:p
u = w'*xin(:,k);
s = s + (d(k) - u)^2;
end
z = (1/p)*s;
end

Funo para separao de classes.

function [classe_a,classe_b,na,nb]=separaclasse(u,w,xin)

%Separao de Classes

u = w'*xin; %Potencial de ativao

y = sign(u);

xn = xin(2:end,:);

a = 1;
b = 1;
for i = 1:length(y)
if(y(i)==-1)
classe_a(:,a) = xn(:,i);
a = a + 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