Alunos: Francisco Jadilson, Tiago Alves e Sandro Bruno

Lista 3 – Redes Neurais Artificiais

Questão 1: Especifique e determine uma máquina de vetor de suporte (SVM) para

separar os padrões 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 C1 dospontos da classe C2, conforme ilustrado na figura abaixo.

Figura 1 – Classes linearmente separáveis do problema.O melhor hiperplano pode ser encontrado usando uma máquina de vetor de

suporte (SVM).

A SVM foi implementada usando a função svmtrain do matlab. Essa função foiutilizada para treinar um classificador SVM usando os seguintes argumentos comoentrada:

- 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 quecaracterizam as classes.

- T=[d] → vetor de saídas desejadas da rede;

onde di=1 se o ponto pertencer à classe C1; e di=-1 se o ponto pertencer à classe C2.

A função svmtrain retornou os seguintes argumentos de saída:

- 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 linharepresenta um vetor de suporte (um elemento do espaço 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 função kernel linear durante esse treinamento, uma vez que asuperfície de separação é um hiperplano e o método usado para encontrar tal hiperplanode separação é o SMO (Otimização Mínima Sequencial).

SMO é um algoritmo iterativo utilizado para resolver o problema deprogramação quadrática:

maxα

∑i=1

n

α i−12∑i=1

n

∑j=1

n

y i y jK (xi x j)αiα j

Sujeito a:

0≤αi≤C

∑i=1

n

y iαi=0

Onde: C é um hiperparametro SVM; K(xi,xj) é a função kernel; e αi são osmultiplicadores de Lagrange.

Na figura abaixo está representado o hiperplano ótimo gerado a partir dosargumentos de saída da função svmtrain.

Figura 2 – Hiperplano ótimo para a separação das duas classes.

Um perceptron de Rosemblat também foi treinado para encontrar uma superfíciede separação para as duas classes.

A função train foi utilizada para o treinamento do perceptron, no qual asseguintes configurações foram realizadas:

- v = tangente sigmóide → função de ativação;

- η = 0.5 → fator de aprendizagem;

- n= 10 → número de épocas de treinamento.

W = [0 0 0] → vetor de pesos iniciais;

b = 0 → peso do bias inicial.

Após o treinamento encontrou-se a seguinte superfície de separação, a qual foideterminada a partir dos pesos sinápticos.

Figura 3 – Hiperplano obtido com o perceptron de Rosemblat.

A diferença básica entre as duas superfícies de decisão é que a segunda é um dosmuitos hiperplanos que podem ser usados para separar as duas classes, enquanto asegunda, obtida por meio do SVM, é o hiperplano ótimo, ou seja, aquele com a maiordistância de separação entre as classes. A vantagem disso é um melhor desempenho degeneralização do SVM para dados que não foram usados no treinamento, ou seja, eleapresenta uma probabilidade maior de classificar adequadamente algum padrão deentrada.

Questão 4: Um problema interessante para testar a capacidade de uma rede neural

atuar como classificador de padrões é o problema das duas espirais intercaladas.

Gere exemplos de treinamento usando as seguintes equações: para a espiral 1

x=θ4cosθ e y=θ

4sen θ com θ≥0 ; para a espiral 2 x=(θ

4+0.8)cosθ e

y=(θ4+0.8)senθ com θ≥0. Fazendo θ assumir 51 igualmente espaçados

valores entre 0 e 20 radianos, treine uma SVM para classificar os padrões

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

validação e calculando a matriz de confusão para atuar como classificador. Para

comparar as regiões de decisão 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 daespiral 2, conforme ilustrado na figura abaixo. Cada ponto representa um elemento doconjunto de treinamento. Perceba que trata-se de um problema não linearmenteseparável.

Figura 10 – Espirais intercaladas em um problema de classificação binária.

Uma SVM foi treinada usando os exemplos ilustrados na figura anterior. Afunção svmtrain, do Matlab, foi aplicada para treinar a SVM e os seguintes argumentosforam 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 quecaracterizam as duas espirais.

- T=[d] → vetor de saídas desejadas;

onde di=1 se o ponto pertencer à espiral 1; e di=-1 se o ponto pertencer à espiral 2.

- A função kernel escolhida para o treinamento foi a 'rbf'. Esta função foi escolhida dadaas características de distribuição dos pontos e por ter apresentado a melhor curva deseparação com relação aos outros tipos de função kernel disponíveis (linear, quadrática,polinomial e 'mlp'). Atribuiu-se um valor de 0.25 ao parâmetro sigma associado a essafunção. Tal valor foi escolhido por tentativa e erro, até encontrar um valor que produziuuma curva de separação satisfatória.

- O método de treinamento utilizado para encontrar a curva de separação foi o dosmínimos quadrados (LS). Esse método foi escolhido pois apresentou resultadossimilares ao da programação quadrática e em menor tempo.

Na figura abaixo encontra-se representada a curva de separação obtida com afunção svmtrain.

Figura 11 – Curva de separação obtida usando a função de base radial (rbf).

Para avaliar o classificador, um conjunto de dados de validação foi gerado eapresentado ao mesmo. Os dados consistem de uma grade uniforme de pontos cobrindoum quadrado [-5,5] e a função svmclassify foi utilizada para classificar tais dados comoespiral 1 ou espiral 2, de acordo com a curva de separação obtida durante o treinamentoda SVM.

A função svmclassify usa os argumentos de saída da função svmtrain (vetor desuportes, vetor de pesos e bias) para classificar os dados de validação de acordo com aequação

c=∑i

aik (s i , x )+b

Onde si são os vetores de suporte, ai são os pesos, b é o bias e k é a

função kernel:

k (si , x)=exp(−γ‖si−x‖2)

Se c≥0, então x é classificado como um membro do grupo espiral 1, caso contrário, é

classificado como um membro do grupo espiral 2. Os resultados podem ser visualizadosna figura abaixo.

Figura 12 – Classificação dos dados usando um classificador SVM de base radial.

Questão 5: Considere o problema de predição de uma série temporal definida

como x (n)=v (n)+β v (n−1) v(n−2) , com média zero e variância dada por

σ x2=σ v

2+β

2σ v2 onde v(n) é um ruído branco gaussiano com variância unitária e

β=0.5 . Utilizando uma rede NARX estime x̂ (n) usando como entradas os seis

últimos valores da série. Esboce a curva da série e a curva de predição em função

de n. Esboce também o erro de predição. Calcule a variância da predição e

compare com a variância da série temporal. Compare com a solução obtida na lista

2.

Na figura abaixo encontra-se representada a série temporal a ser predita.

Figura 13 – Série temporal para o problema de predição.

Projetou-se uma rede neural NARX para estimar a série temporal usando comoentrada os seis últimos valores da série. Para isso, utilizamos a função narxnet doMatlab, por meio da qual também foi possível ajustar os atrasos de entrada (1:6,determinado pela questão) e da realimentação (1:2, escolhido livremente). A quantidadede neurônios foi ajustada para 100 para que a rede neural possa fornecer uma prediçãomais próxima da série temporal.

Na figura a seguir pode-se visualizar a rede neural criada.

Figura 14 – Rede neural NARX.

A seguir estão representadas as curvas da série temporal e da predição obtidacom a rede neural acima.

Figura 15 – Curvas da série temporal e da predição.

Na figura abaixo encontra-se representado o erro de predição.

Figura 16 – Erro de predição.

As variâncias encontradas para a série e predição foram respectivamente:

σ x2=1.12;σ xp

2=1.11

Para efeito de comparação, foi testada uma segunda rede neural dinâmica queleva em consideração somente as entradas passadas. A função timedelaynet foi usadapara isso. Por meio dessa função foram ajustados o valor dos atrasos na entrada (1:6) e aquantidade de neurônios (100).

Na figura a seguir pode-se visualizar a rede neural criada.

Figura 17 – Rede neural dinâmica com entradas atrasadas.

As curvas da série temporal e predição da rede neural acima podem servisualizadas a seguir.

Figura 18 – Curvas da série temporal e da predição.

A curva de regressão pode ser visualizada a seguir.

Figura 19 – Curva de regressão entre a saída estimada e a desejada.

Na figura abaixo encontra-se representado o erro de predição.

Figura 20 – Erro de predição.

A variância da série predita com essa rede neural foi: σ xp2=1.11.

Anexo

Questão 1 – código Matlab

%% Questão 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 sequencialP2=[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 paratreinamento por lotes usando o peceptronP3=[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 paratreinamento usando svm% T={1 1 1 1 -1 -1 -1 -1}; %saidas desejadas para treinamento sequencialT2=[1 1 1 1 -1 -1 -1 -1]; %saídas desejadas para treinamento por lotes usando o perceptronT3=[1;1;1;1;-1;-1;-1;-1]; %saídas desejadas para treinamento usando svmnet1=linearlayer; %criação de uma rede linear de um unico neuronionet1.layers{1}.transferFcn='tansig'; %função de ativação tangente sigmóidenet1=configure(net1,P2,T2); %ajuste autmomático das dimensões das matrizes de pesos e biasnet1.inputWeights{1}.learnParam.lr=0.5; %fator de aprendizagem para ajuste dos pesos igual a 0.5net1.biases{1}.learnParam.lr=0.5; %fator de aprendizagem para ajustedo peso do bias igual a 0.5net1.trainParam.epochs=10; %definição de uma quantidade de 100 epocas para treinamento do neuronionet1.IW{1}=[0 0 0]; %definição dos pesos iniciaisnet1.b{1}=0; %definição do peso de bias inicial[net1,tr1]=train(net1,P2,T2); %treinamento do neuronio por lotes usando 100 épocasW(1:3)=net1.IW{1}(1:3); %pesos das entradas após o treinamentob=net1.b{1}; %peso do bias após o treinamentoX1=P2(1,1:4);X2=P2(1,5:8); %coordenadas no eixo-xY1=P2(2,1:4);Y2=P2(2,5:8); %coordenadas no eixo-yZ1=P2(3,1:4);Z2=P2(3,5:8); %coordenadas no eixo-zfz=@(x,y) (-W(1)*x -W(2)*y -b)/W(3); %superfície de separaçãofigure(1) %Apresentação gráfica das classesstem3(X1,Y1,Z1,'LineStyle','none','Marker','*','MarkerEdgeColor','b')hold onstem3(X2,Y2,Z2,'LineStyle','none','Marker','*','MarkerEdgeColor','r')hold offfigure(2) %Apresentação das classes com a superfície de separaçãoezmesh(fz,40)colormap([0 1 1])hold onstem3(X1,Y1,Z1,'LineStyle','none','Marker','*','MarkerEdgeColor','b')stem3(X2,Y2,Z2,'LineStyle','none','Marker','*','MarkerEdgeColor','r')hold offfigure(3)plotperform(tr1) %evolução do erro médio a cada época de treinamentosvmstruct=svmtrain(P3,T3); %treinamento do SVMsvm_3d_plot(svmstruct,P3); %função usada para plotar o hiperplano de separação

function[]=svm_3d_plot(svmstruct,Xdata)sv=svmstruct.SupportVectors; %vetores de suportealphahat=svmstruct.Alpha; %alfasbias=svmstruct.Bias; %biaskfun=svmstruct.KernelFunction; %função kernelkfunargs=svmstruct.KernelFunctionArgs; %argumentos da função kernelsh=svmstruct.ScaleData.shift; %fator de escala para os dados de entrada - deslocamentoscalef=svmstruct.ScaleData.scaleFactor; %fator de escala para os dadosde entrada - ganho Xdata1=repmat(scalef,size(Xdata,1),1).*(Xdata+repmat(sh,size(Xdata,1),1)); %dados de entrada escalonadosk=10; %parametro para definir tamanho do gridcubeXmin=min(Xdata1(:,1)); %limites mínimo e máximo dos eixoscubeYmin=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 xstepy=(cubeYmax-cubeYmin)/(k-1); %passo de cada ponto em ystepz=(cubeZmax-cubeZmin)/(k-1); %passo de cada ponto em z[x,y,z]=meshgrid(cubeXmin:stepx:cubeXmax,cubeYmin:stepy:cubeYmax,cubeZmin:stepz:cubeZmax); %geração dos pontos formando um sólidomm=size(x); %parametro usado para recuperar as dimensões iniciais do sólidox=x(:); %alinha os pontos x num vetor colunay=y(:); %idem anteriorz=z(:); %idem anteriorf=(feval(kfun,sv,[x y z],kfunargs{:})'*alphahat(:))+bias; %utiliza os pontos gerados para gerar a função linear de separaçãot=size(Xdata1,1)/2; %paramentro usado para plotar as classes separadamenteXdata1=(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 originaly=(y./repmat(scalef(2),size(y,1),1))-repmat(sh(2),size(y,1),1); %pontos y no formato originalz=(z./repmat(scalef(3),size(z,1),1))-repmat(sh(3),size(z,1),1); %pontos z no formato originalfigure()plot3(Xdata1(1:t,1),Xdata1(1:t,2),Xdata1(1:t,3),'b*') %plot da primeira classehold onplot3(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 classehold onsv=svmstruct.SupportVectorIndices; %indices da matriz do vetor de suportesv=Xdata1(sv,:); %pontos que fazem parte do vetor de suporteplot3(sv(:,1),sv(:,2),sv(:,3),'go'); %marcação dos pontos que são vetores de suportelegend('classe1','classe2','vetores de suporte')x0=reshape(x,mm); %reajuste das dimensões para a geração da figura usando isosurfacey0=reshape(y,mm); %idem anteriorz0=reshape(z,mm); %idem anteriorv0=reshape(f,mm); %reajuste das dimensões da função

[faces,verts]=isosurface(x0,y0,z0,v0,0,x0); %geração da superfície de decisãopatch('Vertices',verts,'Faces',faces,'FaceColor','k','edgecolor','none','FaceAlpha',0.5); %configurações de imagemgrid onbox onview(3)hold offend

Questão 2 – código Matlab

x1=-10:0.1:10; %vetor x1 de entradasx2=x1; %vetor x2 de entradasx=[x1; x2]; %dados de entrada da redey=zeros(1,length(x)); %inicialização do vetor de saídasfor i=1:length(x) y(i)=(sin(pi*norm(x(:,i))))/(pi*norm(x(:,i))); %saídas desejadas -> f(x)endnet5=feedforwardnet; %criação de uma R.N. multiplas camadas (1 camada escondida com 10 neuronios)net5=configure(net5,x,y); %ajuste das dimensões das matrizes de pesosnet5=init(net5); %inicialização dos pesos da R.N.[net5,tr]=train(net5,x,y); %treinamento da R.N.plotperf(tr) %grafico dos erros de treinamento, validação e testeyhat=net5(x); %saídas estimadas pela R.N. treinadatryhat=yhat(tr.trainInd); %estimativas para os dados de treinamentovyhat=yhat(tr.valInd); %estimativas para os dados de validaçãotsyhat=yhat(tr.testInd); %estimativas para os dados de testetryo=y(tr.trainInd); %saídas usadas para o treinamentovyo=y(tr.valInd); %saídas usadas para validaçãotsyo=y(tr.testInd); %saídas usadas para testefigure(2)plotregression(tryo,tryhat,'treinamento',vyo,vyhat,'validação',tsyo,tsyhat,'teste') %curva de regressão entre dados e estimativasfigure(3) %comparação entre as curvasplot3(x1,x2,y,'-b') hold onplot3(x1,x2,yhat,'-.r')grid onnet6=feedforwardnet; %criação de uma R.N. múltiplas camadasnet6.layers{1}.dimensions=20; %20 neurõnios na camada escondidanet6=configure(net6,x,y); %ajuste das dimensões das matrizes de pesosnet6=init(net6); %inicialização dos pesos da R.N.[net6,tr]=train(net6,x,y); %treinamento da R.N.plotperf(tr) %grafico dos erros de treinamento, validação e testeyhat2=net5(x); %saídas estimadas pela R.N. treinadatryhat2=yhat2(tr.trainInd); %estimativas para os dados de treinamentovyhat2=yhat2(tr.valInd); %estimativas para os dados de validaçãotsyhat2=yhat2(tr.testInd); %estimativas para os dados de testetryo2=y(tr.trainInd); %saídas usadas para o treinamentovyo2=y(tr.valInd); %saídas usadas para validaçãotsyo2=y(tr.testInd); %saídas usadas para testefigure(5)plotregression(tryo2,tryhat2,'treinamento',vyo2,vyhat2,'validação',tsyo2,tsyhat2,'teste') %regressão entre dados e estimativas

figure(6) %comparação entre as curvasplot3(x1,x2,y,'-b') hold onplot3(x1,x2,yhat2,'-.r')grid on

Questão 4 – código Matlab

%% Questão 4n=20/51; %passo do angulo thetatheta=0:n:20-n; %vetor de angulost=length(theta); %comprimento do vetor de dadosx1=zeros(1,t); %inicialização do vetor x1y1=zeros(1,t); %inicialização do vetor y1 C1=zeros(t,2); %inicialização dos exemplos da espiral 1 x2=x1; %inicialização do vetor x2y2=y1; %inicialização do vetor y2C2=zeros(t,2); %inicialização dos exemplos da espiral 2T=[ones(t,1); -1*ones(t,1)]; %vetor de saídas desejadasfor 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 2endfigure(1)stem(x1,y1,'Linestyle','none','Color','b','Marker','*')hold onstem(x2,y2,'LineStyle','none','Color','r','Marker','diamond')hold offgrid onlegend('Espiral 1 (+1)','Espiral 2 (-1)')P=[C1; C2]; %vetor de treinamentofigure(2)%tstart=tic;svmstruct=svmtrain(P,T,'kernel_function','rbf','rbf_sigma',0.25,'method','LS','showplot','true');%telapse=toc(tstart);x=-5:0.1:5-0.1; %vetor x de dados de validaçãoy=-5:0.1:5-0.1; %vetor y de dados de validaçãoV=zeros(10000,2); %inicialização do vetor de validaçãom=1; for j=1:100 for k=1:100 V(m,:)=[x(j) y(k)]; %agrupamento dos dados do vetor de validação m=m+1; endendclasse=svmclassify(svmstruct,V); %classificação dos dados de acordocom a curva encontrada na fase de treinamentop=1;q=1;C1hat=zeros(10000,2); %inicialização das estimativas para a classe 1C2hat=C1hat; %inicialização das estimativas para a classe 2for i=1:10000 if(classe(i)==1) %teste do vetor de classificação svm C1hat(p,:)=V(i,:); %dado estimado como pertencente à classe 1

p=p+1; else C2hat(q,:)=V(i,:); %dado estimado como pertencente à classe 2 q=q+1; endendfigure(3)stem(C1hat(1:p-1,1),C1hat(1:p-1,2),'LineStyle','none','Color','b','Marker','.')hold onstem(C2hat(1:q-1,1),C2hat(1:q-1,2),'LineStyle','none','Color','r','Marker','.')legend('Classe 1','Classe 2')

Questão 5 – código Matlab

%% Questão 5n=1000; %quantidade de dadosbeta=0.5;t=1:n; %vetor de indicesv=wgn(1,n,0); %ruído brancoxi=zeros(1,n); %inicialização da entradafor i=3:n xi(i)=v(i)+beta*v(i-1)*v(i-2); %entrada da rede neuralendfigura(1)plot(t,xi)grid onu=con2seq(xi); %entradas na forma de array sequencialy=u; %saidas iguais a entradanarx_net2=narxnet([1:6],[1:2],100); %rede neural NARXnarx_net2.divideFcn=''; %sem divisão dos dados em treinamento, validação e teste[p,Pi,Ai,T]=preparets(narx_net2,u,{},y); %ajuste dos dados para o treinamentonarx_net2=train(narx_net2,p,T,Pi); %treinamento da redeyp=sim(narx_net2,p,Pi); %saída preditafigure(2)plot(t,xi,'b',t(1,7:n),cell2mat(yp),'r')legend('Série Temporal','Predição')grid one=cell2mat(yp)-cell2mat(T);figure(3)plot(e)grid onnetd=timedelaynet([1:6],100); %rede neural dinamica com entradas atrasadas (FIR)netd.divideFcn=''; %sem divisão dos dados[pd,Pid,Aid,Td]=preparets(netd,u,u); %ajuste dos dadosnetd=train(netd,pd,Td,Pid); %treinamento da redeyd=sim(netd,pd,Pid); %saídas estimadasfigure(4)plot(t,xi,'b',t(1,7:n),cell2mat(yd),'r')legend('Série Temporal','Predição')grid oned=cell2mat(yd)-cell2mat(Td); %erro de prediçãoplot(ed)grid on