Alunos: Francisco Jadilson, Tiago Alves e Sandro Bruno

Lista 3 Redes Neurais Artificiais

Questo 1: Especifique e determine uma mquina de vetor de suporte (SVM) para
separar os padres das classes 1 e 2 com os seguintes conjuntos de treinamentos:
C1={(0,0,0), (1,0,0), (1,0,1), (1,1,0)} e C2={(0,0,1), (0,1,1), (0,1,0), (1,1,1)}. Compare a
(SVM) obtida com a rede de perceptrons de Rosemblat projetada com o mesmo
fim na lista 2.
Deseja-se encontrar o melhor hiperplano que separa os pontos da classe C 1 dos
pontos da classe C2, conforme ilustrado na figura abaixo.

Figura 1 Classes linearmente separveis do problema.

O melhor hiperplano pode ser encontrado usando uma mquina de vetor de

suporte (SVM).
A SVM foi implementada usando a funo svmtrain do matlab. Essa funo foi
utilizada para treinar um classificador SVM usando os seguintes argumentos como
entrada:
- P=[x(n) y(n) z(n)] vetor de entradas da rede;
onde x(n), y(n) e z(n) representam vetores coluna com as coordenadas dos pontos que
caracterizam as classes.
- T=[d] vetor de sadas desejadas da rede;
onde di=1 se o ponto pertencer classe C1; e di=-1 se o ponto pertencer classe C2.
A funo svmtrain retornou os seguintes argumentos de sada:

- S=[0 0 0; 1 0 1; 1 1 0; 0 0 1; 0 1 0; 1 1 1] vetores de suporte, nos quais cada linha

representa um vetor de suporte (um elemento do espao de dados);
- A=[-1; -1; -1; 1; 1; 1] vetor de pesos i para os vetores de suporte;
- b=-0.5 offset do hiperplano;
Utilizou-se uma funo kernel linear durante esse treinamento, uma vez que a
superfcie de separao um hiperplano e o mtodo usado para encontrar tal hiperplano
de separao o SMO (Otimizao Mnima Sequencial).
SMO um algoritmo iterativo utilizado para resolver o problema de
programao quadrtica:
n

max
i 12 y i y j K ( x i x j)i j

i=1
i=1 j =1
Sujeito a:
0iC
n

y i i=0
i=1

Onde: C um hiperparametro SVM; K(xi,xj) a funo kernel; e i so os

multiplicadores de Lagrange.
Na figura abaixo est representado o hiperplano timo gerado a partir dos
argumentos de sada da funo svmtrain.

Figura 2 Hiperplano timo para a separao das duas classes.

Um perceptron de Rosemblat tambm foi treinado para encontrar uma superfcie

de separao para as duas classes.

A funo train foi utilizada para o treinamento do perceptron, no qual as

seguintes configuraes foram realizadas:
- v = tangente sigmide funo de ativao;
- = 0.5 fator de aprendizagem;
- n= 10 nmero de pocas de treinamento.
W = [0 0 0] vetor de pesos iniciais;
b = 0 peso do bias inicial.
Aps o treinamento encontrou-se a seguinte superfcie de separao, a qual foi
determinada a partir dos pesos sinpticos.

Figura 3 Hiperplano obtido com o perceptron de Rosemblat.

A diferena bsica entre as duas superfcies de deciso que a segunda um dos

muitos hiperplanos que podem ser usados para separar as duas classes, enquanto a
segunda, obtida por meio do SVM, o hiperplano timo, ou seja, aquele com a maior
distncia de separao entre as classes. A vantagem disso um melhor desempenho de
generalizao do SVM para dados que no foram usados no treinamento, ou seja, ele
apresenta uma probabilidade maior de classificar adequadamente algum padro de
entrada.
Questo 4: Um problema interessante para testar a capacidade de uma rede neural
atuar como classificador de padres o problema das duas espirais intercaladas.
Gere exemplos de treinamento usando as seguintes equaes: para a espiral 1

x= cos e y= sen com

4
4

0 ; para a espiral 2 x=( + 0.8) cos e

4

y=( +0.8) sen com 0. Fazendo assumir 51 igualmente espaados

4
valores entre 0 e 20 radianos, treine uma SVM para classificar os padres
associados a cada uma das classes, isto , a espiral 1 sendo uma classe e a espiral 2
sendo a outra classe. Verifique o desempenho do classificador usando o conjunto de
validao e calculando a matriz de confuso para atuar como classificador. Para
comparar as regies de deciso formadas pela rede, gere uma grade uniforme
como 100x100 exemplos de teste em um quadrado [-5,5]. Esboce os pontos
classificados pela rede.
Deseja-se encontrar a curva que separa os pontos da espiral 1 dos pontos da
espiral 2, conforme ilustrado na figura abaixo. Cada ponto representa um elemento do
conjunto de treinamento. Perceba que trata-se de um problema no linearmente
separvel.

Figura 10 Espirais intercaladas em um problema de classificao binria.

Uma SVM foi treinada usando os exemplos ilustrados na figura anterior. A

funo svmtrain, do Matlab, foi aplicada para treinar a SVM e os seguintes argumentos
foram definidos para o treinamento:
- P=[x(n) y(n)] vetor de exemplos;

onde x(n) e y(n) representam vetores coluna com as coordenadas dos pontos que
caracterizam as duas espirais.
- T=[d] vetor de sadas desejadas;
onde di=1 se o ponto pertencer espiral 1; e di=-1 se o ponto pertencer espiral 2.
- A funo kernel escolhida para o treinamento foi a 'rbf'. Esta funo foi escolhida dada
as caractersticas de distribuio dos pontos e por ter apresentado a melhor curva de
separao com relao aos outros tipos de funo kernel disponveis (linear, quadrtica,
polinomial e 'mlp'). Atribuiu-se um valor de 0.25 ao parmetro sigma associado a essa
funo. Tal valor foi escolhido por tentativa e erro, at encontrar um valor que produziu
uma curva de separao satisfatria.
- O mtodo de treinamento utilizado para encontrar a curva de separao foi o dos
mnimos quadrados (LS). Esse mtodo foi escolhido pois apresentou resultados
similares ao da programao quadrtica e em menor tempo.
Na figura abaixo encontra-se representada a curva de separao obtida com a
funo svmtrain.

Figura 11 Curva de separao obtida usando a funo de base radial (rbf).

Para avaliar o classificador, um conjunto de dados de validao foi gerado e

apresentado ao mesmo. Os dados consistem de uma grade uniforme de pontos cobrindo
um quadrado [-5,5] e a funo svmclassify foi utilizada para classificar tais dados como
espiral 1 ou espiral 2, de acordo com a curva de separao obtida durante o treinamento
da SVM.
A funo svmclassify usa os argumentos de sada da funo svmtrain (vetor de
suportes, vetor de pesos e bias) para classificar os dados de validao de acordo com a
equao

c= ai k (s i , x )+ b
i

Onde

s i so os vetores de suporte, ai so os pesos, b o bias e k a

funo kernel:
k (si , x)=exp(six2 )
Se c0, ento x classificado como um membro do grupo espiral 1, caso contrrio,
classificado como um membro do grupo espiral 2. Os resultados podem ser visualizados
na figura abaixo.

Figura 12 Classificao dos dados usando um classificador SVM de base radial.

Questo 5: Considere o problema de predio de uma srie temporal definida

como

x (n)=v ( n)+ v (n1) v(n2), com mdia zero e varincia dada por

2x = 2v +2 2v onde v(n) um rudo branco gaussiano com varincia unitria e

=0.5 . Utilizando uma rede NARX estime

^x (n) usando como entradas os seis

ltimos valores da srie. Esboce a curva da srie e a curva de predio em funo

de n. Esboce tambm o erro de predio. Calcule a varincia da predio e
compare com a varincia da srie temporal. Compare com a soluo obtida na lista
2.

Na figura abaixo encontra-se representada a srie temporal a ser predita.

Figura 13 Srie temporal para o problema de predio.

Projetou-se uma rede neural NARX para estimar a srie temporal usando como
entrada os seis ltimos valores da srie. Para isso, utilizamos a funo narxnet do
Matlab, por meio da qual tambm foi possvel ajustar os atrasos de entrada (1:6,
determinado pela questo) e da realimentao (1:2, escolhido livremente). A quantidade
de neurnios foi ajustada para 100 para que a rede neural possa fornecer uma predio
mais prxima da srie temporal.
Na figura a seguir pode-se visualizar a rede neural criada.

Figura 14 Rede neural NARX.

A seguir esto representadas as curvas da srie temporal e da predio obtida

com a rede neural acima.

Figura 15 Curvas da srie temporal e da predio.

Na figura abaixo encontra-se representado o erro de predio.

Figura 16 Erro de predio.

As varincias encontradas para a srie e predio foram respectivamente:

2

x =1.12; xp=1.11

Para efeito de comparao, foi testada uma segunda rede neural dinmica que
leva em considerao somente as entradas passadas. A funo timedelaynet foi usada
para isso. Por meio dessa funo foram ajustados o valor dos atrasos na entrada (1:6) e a
quantidade de neurnios (100).
Na figura a seguir pode-se visualizar a rede neural criada.

Figura 17 Rede neural dinmica com entradas atrasadas.

As curvas da srie temporal e predio da rede neural acima podem ser

visualizadas a seguir.

Figura 18 Curvas da srie temporal e da predio.

A curva de regresso pode ser visualizada a seguir.

Figura 19 Curva de regresso entre a sada estimada e a desejada.

Na figura abaixo encontra-se representado o erro de predio.

Figura 20 Erro de predio.

A varincia da srie predita com essa rede neural foi: 2xp=1.11.

Anexo
Questo 1 cdigo Matlab
%% Questo 1
% P={[0;0;0] [1;0;0] [1;0;1] [1;1;0] [0;0;1] [0;1;1] [0;1;0] [1;1;1]};
exemplos para treinamento sequencial
P2=[0 1 1 1 0 0 0 1;0 0 0 1 0 1 1 1;0 0 1 0 1 1 0 1];
%exemplos para
treinamento por lotes usando o peceptron
P3=[0 0 0;1 0 0;1 0 1;1 1 0;0 0 1;0 1 1;0 1 0;1 1 1];
%exemplos para
treinamento usando svm
% T={1 1 1 1 -1 -1 -1 -1};
%saidas desejadas para treinamento
sequencial
T2=[1 1 1 1 -1 -1 -1 -1];
%sadas desejadas para treinamento por
lotes usando o perceptron
T3=[1;1;1;1;-1;-1;-1;-1];
%sadas desejadas para treinamento usando
svm
net1=linearlayer;
%criao de uma rede linear de um unico neuronio
net1.layers{1}.transferFcn='tansig';
%funo de ativao tangente
sigmide
net1=configure(net1,P2,T2);
%ajuste autmomtico das dimenses das
matrizes de pesos e bias
net1.inputWeights{1}.learnParam.lr=0.5; %fator de aprendizagem para
ajuste dos pesos igual a 0.5
net1.biases{1}.learnParam.lr=0.5;
%fator de aprendizagem para ajuste
do peso do bias igual a 0.5
net1.trainParam.epochs=10;
%definio de uma quantidade de 100
epocas para treinamento do neuronio
net1.IW{1}=[0 0 0];
%definio dos pesos iniciais
net1.b{1}=0;
%definio do peso de bias inicial
[net1,tr1]=train(net1,P2,T2);
%treinamento do neuronio por lotes
usando 100 pocas
W(1:3)=net1.IW{1}(1:3);
%pesos das entradas aps o treinamento
b=net1.b{1};
%peso do bias aps o treinamento
X1=P2(1,1:4);X2=P2(1,5:8); %coordenadas no eixo-x
Y1=P2(2,1:4);Y2=P2(2,5:8); %coordenadas no eixo-y
Z1=P2(3,1:4);Z2=P2(3,5:8); %coordenadas no eixo-z
fz=@(x,y) (-W(1)*x -W(2)*y -b)/W(3);
%superfcie de separao
figure(1)
%Apresentao grfica das classes
stem3(X1,Y1,Z1,'LineStyle','none','Marker','*','MarkerEdgeColor','b')
hold on
stem3(X2,Y2,Z2,'LineStyle','none','Marker','*','MarkerEdgeColor','r')
hold off
figure(2)
%Apresentao das classes com a superfcie de separao
ezmesh(fz,40)
colormap([0 1 1])
hold on
stem3(X1,Y1,Z1,'LineStyle','none','Marker','*','MarkerEdgeColor','b')
stem3(X2,Y2,Z2,'LineStyle','none','Marker','*','MarkerEdgeColor','r')
hold off
figure(3)
plotperform(tr1)
%evoluo do erro mdio a cada poca de
treinamento
svmstruct=svmtrain(P3,T3); %treinamento do SVM
svm_3d_plot(svmstruct,P3); %funo usada para plotar o hiperplano de
separao

function[]=svm_3d_plot(svmstruct,Xdata)
sv=svmstruct.SupportVectors;
%vetores de suporte
alphahat=svmstruct.Alpha;
%alfas
bias=svmstruct.Bias;
%bias
kfun=svmstruct.KernelFunction; %funo kernel
kfunargs=svmstruct.KernelFunctionArgs; %argumentos da funo kernel
sh=svmstruct.ScaleData.shift;
%fator de escala para os dados de
entrada - deslocamento
scalef=svmstruct.ScaleData.scaleFactor; %fator de escala para os dados
de entrada - ganho
Xdata1=repmat(scalef,size(Xdata,1),1).*(Xdata+repmat(sh,size(Xdata,1),
1)); %dados de entrada escalonados
k=10;
%parametro para definir tamanho do grid
cubeXmin=min(Xdata1(:,1)); %limites mnimo e mximo dos eixos
cubeYmin=min(Xdata1(:,2)); %-cubeZmin=min(Xdata1(:,3)); %-cubeXmax=max(Xdata1(:,1)); %-cubeYmax=max(Xdata1(:,2)); %-cubeZmax=max(Xdata1(:,3)); %-stepx=(cubeXmax-cubeXmin)/(k-1);
%passo de cada ponto em x
stepy=(cubeYmax-cubeYmin)/(k-1);
%passo de cada ponto em y
stepz=(cubeZmax-cubeZmin)/(k-1);
%passo de cada ponto em z
[x,y,z]=meshgrid(cubeXmin:stepx:cubeXmax,cubeYmin:stepy:cubeYmax,cubeZ
min:stepz:cubeZmax); %gerao dos pontos formando um slido
mm=size(x); %parametro usado para recuperar as dimenses iniciais do
slido
x=x(:); %alinha os pontos x num vetor coluna
y=y(:); %idem anterior
z=z(:); %idem anterior
f=(feval(kfun,sv,[x y z],kfunargs{:})'*alphahat(:))+bias;
%utiliza
os pontos gerados para gerar a funo linear de separao
t=size(Xdata1,1)/2; %paramentro usado para plotar as classes
separadamente
Xdata1=(Xdata1./repmat(scalef,size(Xdata,1),1))repmat(sh,size(Xdata,1),1); %dados de entrada no formato original(sem
escalonamento)
x=(x./repmat(scalef(1),size(x,1),1))-repmat(sh(1),size(x,1),1);
%pontos x no formato original
y=(y./repmat(scalef(2),size(y,1),1))-repmat(sh(2),size(y,1),1);
%pontos y no formato original
z=(z./repmat(scalef(3),size(z,1),1))-repmat(sh(3),size(z,1),1);
%pontos z no formato original
figure()
plot3(Xdata1(1:t,1),Xdata1(1:t,2),Xdata1(1:t,3),'b*')
%plot da
primeira classe
hold on
plot3(Xdata1(t+1:size(Xdata1,1),1),Xdata1(t+1:size(Xdata1,1),2),Xdata1
(t+1:size(Xdata1,1),3),'r*') %plot da segunda classe
hold on
sv=svmstruct.SupportVectorIndices; %indices da matriz do vetor de
suporte
sv=Xdata1(sv,:);
%pontos que fazem parte do vetor de suporte
plot3(sv(:,1),sv(:,2),sv(:,3),'go');
%marcao dos pontos que so
vetores de suporte
legend('classe1','classe2','vetores de suporte')
x0=reshape(x,mm);
%reajuste das dimenses para a gerao da figura
usando isosurface
y0=reshape(y,mm);
%idem anterior
z0=reshape(z,mm);
%idem anterior
v0=reshape(f,mm);
%reajuste das dimenses da funo

[faces,verts]=isosurface(x0,y0,z0,v0,0,x0); %gerao da superfcie de

deciso
patch('Vertices',verts,'Faces',faces,'FaceColor','k','edgecolor','none
','FaceAlpha',0.5);
%configuraes de imagem
grid on
box on
view(3)
hold off
end

Questo 2 cdigo Matlab

x1=-10:0.1:10; %vetor x1 de entradas
x2=x1; %vetor x2 de entradas
x=[x1; x2]; %dados de entrada da rede
y=zeros(1,length(x));
%inicializao do vetor de sadas
for i=1:length(x)
y(i)=(sin(pi*norm(x(:,i))))/(pi*norm(x(:,i))); %sadas desejadas
-> f(x)
end
net5=feedforwardnet;
%criao de uma R.N. multiplas camadas (1
camada escondida com 10 neuronios)
net5=configure(net5,x,y);
%ajuste das dimenses das matrizes de
pesos
net5=init(net5);
%inicializao dos pesos da R.N.
[net5,tr]=train(net5,x,y); %treinamento da R.N.
plotperf(tr)
%grafico dos erros de treinamento, validao e teste
yhat=net5(x);
%sadas estimadas pela R.N. treinada
tryhat=yhat(tr.trainInd);
%estimativas para os dados de treinamento
vyhat=yhat(tr.valInd); %estimativas para os dados de validao
tsyhat=yhat(tr.testInd);
%estimativas para os dados de teste
tryo=y(tr.trainInd);
%sadas usadas para o treinamento
vyo=y(tr.valInd);
%sadas usadas para validao
tsyo=y(tr.testInd); %sadas usadas para teste
figure(2)
plotregression(tryo,tryhat,'treinamento',vyo,vyhat,'validao',tsyo,ts
yhat,'teste') %curva de regresso entre dados e estimativas
figure(3)
%comparao entre as curvas
plot3(x1,x2,y,'-b')
hold on
plot3(x1,x2,yhat,'-.r')
grid on
net6=feedforwardnet;
%criao de uma R.N. mltiplas camadas
net6.layers{1}.dimensions=20;
%20 neurnios na camada escondida
net6=configure(net6,x,y);
%ajuste das dimenses das matrizes de
pesos
net6=init(net6);
%inicializao dos pesos da R.N.
[net6,tr]=train(net6,x,y); %treinamento da R.N.
plotperf(tr)
%grafico dos erros de treinamento, validao e teste
yhat2=net5(x);
%sadas estimadas pela R.N. treinada
tryhat2=yhat2(tr.trainInd);
%estimativas para os dados de
treinamento
vyhat2=yhat2(tr.valInd); %estimativas para os dados de validao
tsyhat2=yhat2(tr.testInd);
%estimativas para os dados de teste
tryo2=y(tr.trainInd);
%sadas usadas para o treinamento
vyo2=y(tr.valInd);
%sadas usadas para validao
tsyo2=y(tr.testInd); %sadas usadas para teste
figure(5)
plotregression(tryo2,tryhat2,'treinamento',vyo2,vyhat2,'validao',tsy
o2,tsyhat2,'teste') %regresso entre dados e estimativas

figure(6)
%comparao entre as curvas
plot3(x1,x2,y,'-b')
hold on
plot3(x1,x2,yhat2,'-.r')
grid on

Questo 4 cdigo Matlab

%% Questo 4
n=20/51;
%passo do angulo theta
theta=0:n:20-n; %vetor de angulos
t=length(theta);
%comprimento do vetor de dados
x1=zeros(1,t); %inicializao do vetor x1
y1=zeros(1,t); %inicializao do vetor y1
C1=zeros(t,2); %inicializao dos exemplos da espiral 1
x2=x1; %inicializao do vetor x2
y2=y1; %inicializao do vetor y2
C2=zeros(t,2); %inicializao dos exemplos da espiral 2
T=[ones(t,1); -1*ones(t,1)]; %vetor de sadas desejadas
for i=1:t
x1(i)=(theta(i)/4)*cos(theta(i));
%dados do vetor x
y1(i)=(theta(i)/4)*sin(theta(i));
%dados do vetor y
C1(i,:)=[x1(i) y1(i)]; %exemplos da classe 1
x2(i)=((theta(i)/4)+0.8)*cos(theta(i)); %dados do vetor x2
y2(i)=((theta(i)/4)+0.8)*sin(theta(i)); %dados do vetor y2
C2(i,:)=[x2(i) y2(i)]; %exemplos da classe 2
end
figure(1)
stem(x1,y1,'Linestyle','none','Color','b','Marker','*')
hold on
stem(x2,y2,'LineStyle','none','Color','r','Marker','diamond')
hold off
grid on
legend('Espiral 1 (+1)','Espiral 2 (-1)')
P=[C1; C2]; %vetor de treinamento
figure(2)
%tstart=tic;
svmstruct=svmtrain(P,T,'kernel_function','rbf','rbf_sigma',0.25,'metho
d','LS','showplot','true');
%telapse=toc(tstart);
x=-5:0.1:5-0.1; %vetor x de dados de validao
y=-5:0.1:5-0.1; %vetor y de dados de validao
V=zeros(10000,2);
%inicializao do vetor de validao
m=1;
for j=1:100
for k=1:100
V(m,:)=[x(j) y(k)]; %agrupamento dos dados do vetor de
validao
m=m+1;
end
end
classe=svmclassify(svmstruct,V);
%classificao dos dados de acordo
com a curva encontrada na fase de treinamento
p=1;
q=1;
C1hat=zeros(10000,2);
%inicializao das estimativas para a classe 1
C2hat=C1hat;
%inicializao das estimativas para a classe 2
for i=1:10000
if(classe(i)==1)
%teste do vetor de classificao svm
C1hat(p,:)=V(i,:); %dado estimado como pertencente classe 1

p=p+1;
else

C2hat(q,:)=V(i,:);
q=q+1;

%dado estimado como pertencente classe 2

end
end
figure(3)
stem(C1hat(1:p-1,1),C1hat(1:p1,2),'LineStyle','none','Color','b','Marker','.')
hold on
stem(C2hat(1:q-1,1),C2hat(1:q1,2),'LineStyle','none','Color','r','Marker','.')
legend('Classe 1','Classe 2')

Questo 5 cdigo Matlab

%% Questo 5
n=1000; %quantidade de dados
beta=0.5;
t=1:n; %vetor de indices
v=wgn(1,n,0);
%rudo branco
xi=zeros(1,n); %inicializao da entrada
for i=3:n
xi(i)=v(i)+beta*v(i-1)*v(i-2); %entrada da rede neural
end
figura(1)
plot(t,xi)
grid on
u=con2seq(xi); %entradas na forma de array sequencial
y=u;
%saidas iguais a entrada
narx_net2=narxnet([1:6],[1:2],100); %rede neural NARX
narx_net2.divideFcn=''; %sem diviso dos dados em treinamento,
validao e teste
[p,Pi,Ai,T]=preparets(narx_net2,u,{},y);
%ajuste dos dados para o
treinamento
narx_net2=train(narx_net2,p,T,Pi); %treinamento da rede
yp=sim(narx_net2,p,Pi); %sada predita
figure(2)
plot(t,xi,'b',t(1,7:n),cell2mat(yp),'r')
legend('Srie Temporal','Predio')
grid on
e=cell2mat(yp)-cell2mat(T);
figure(3)
plot(e)
grid on
netd=timedelaynet([1:6],100);
%rede neural dinamica com entradas
atrasadas (FIR)
netd.divideFcn=''; %sem diviso dos dados
[pd,Pid,Aid,Td]=preparets(netd,u,u);
%ajuste dos dados
netd=train(netd,pd,Td,Pid); %treinamento da rede
yd=sim(netd,pd,Pid);
%sadas estimadas
figure(4)
plot(t,xi,'b',t(1,7:n),cell2mat(yd),'r')
legend('Srie Temporal','Predio')
grid on
ed=cell2mat(yd)-cell2mat(Td);
%erro de predio
plot(ed)
grid on