ISAIAS FERREIRA

JOEL ALISON RIBEIRO CARVALHO

UTILIZAÇÃO DA BASE DE DADOS DE CANCER DE MAMA DO MATLAB

COMO PARÂMETROS PARA DESENVOLVIMENTO DE UMA REDE NEURAL
ATRAVÉS DO ALGORITMO BACKPROPAGATION

BELÉM-PA
2018
 ISAIAS FERREIRA
JOEL ALISON RIBEIRO CARVALHO

UTILIZAÇÃO DA BASE DE DADOS DE CANCER DE MAMA DO MATLAB

COMO PARÂMETROS PARA DESENVOLVIMENTO DE UMA REDE NEURAL
ATRAVÉS DO ALGORITMO BACKPROPAGATION

Relatório prático apresentado à matéria Redes

Neurais Artificiais, pertinente ao Curso de
Graduação em Engenharia Elétrica da
Universidade Federal do Pará, como requisito
parcial de aprovação na disciplina.

Professor Dr.ª Adriana Castro

Belém- PA
2018
 RESUMO

Neste trabalho está descrito o desenvolvimento de uma Rede Neural de classificação, mediante
o algoritmo backpropagation utilizando o software MatLabⓇ (2016), com sua base de dados
cancer de mama (cancer_dataset), disponível em seu pacote instalado. O código desenvolvido
visa variar o número de neurônios na camada escondida e o número máximo de épocas do
processo de treinamento. A metodologia para o critério de parada foi a validação cruzada
(cross-validation) e finalmente foram avaliadas 4 topologias a fim de verificar a que teve
melhor desempenho. Essa avaliação foi feita através da matriz de confusão e a taxa de acertos
média, variando os pesos iniciais 20 vezes para cada topologia. O desenvolvimento do
algoritmo proporcionou resultados satisfatórios, uma vez que a taxa de acertos foi superior a
95%, e a melhor topologia apresentou uma taxa de acertos média de 97% aproximadamente.

Palavras-chave: Redes Neurais, Treinamento, backpropagation.

 INTRODUÇÃO

Redes neurais artificiais são algoritmos computacionais inspirados no funcionamento

biológico do sistema nervoso dos seres vivos. Possuem a capacidade de armazenar e manter
conhecimento (baseado em informações) e podem ser definidas por um conjunto de pequenas
unidades de processamento que são denominados neurônios artificiais (adaptado de: SILVA,
SPATTI, FLAUZINO, 2010).
Existem dois processos principais de aprendizagem para redes neurais(RNAs): o
supervisionado e o não supervisionado. No processo supervisionado, a rede neural aprende
com o “auxílio de um professor” que pode reforçar ou coibir determinadas respostas da rede
até que a mesma tenha “aprendido” a matéria em questão. Para o processo não supervisionado,
que é o caso do algoritmo utilizado neste trabalho, a rede neural não necessita de auxílio.

1 ASPECTOS FUNDAMENTAIS DE UMA RNA

A Figura 1 mostra o modelo de um neurônio artificial
Figura 8: Neurônio Artificial

Fonte: (PACHECO, 2018)

Observa-se que o modelo matemático de um neurônio é de acordo com a Equação 1:
𝑛

𝑦 = ∑ 𝑤𝑖 𝑥𝑖 − 𝜃 (1).
𝑖=1

➢ Limiar de ativação ⇒ 𝛉: É uma variável que especifica qual será o patamar

apropriado para que o resultado produzido pelo combinador linear possa gerar
um valor de disparado em direção a saída de um neurônio, este parâmetro está
associado a bias (-1 que está acima do somatório na Figura 1), uma vez que é o
peso associado a ela.
➢ Potencial de ativação ⇒ 𝐮: É a diferença entre o combinador linear e o limiar
de ativação
➢ Função de ativação ⇒ 𝐟(𝐚): Responsável por limitar a saída de um neurônio
dentro de um intervalo de valores razoáveis a serem assumidos, de acordo com
sua funcionalidade: algumas funções de ativação estão ilustradas abaixo:
 As letras W1 , W2 , … , Wp da figura 8 são os pesos sinápticos que ponderam os valores
de entrada antes de passar pela função de ativação, gerados aleatoriamente antes do
treinamento. Este está relacionado ao ajuste desses pesos (processo recursivo) de forma a obter
melhor poder de resposta, em outras palavras, os pesos ideais de uma rede neural resultam em
uma boa generalização do problema, uma vez que apresenta uma saída mais próxima da
resposta real (saida desejada). É importante salientar que tal resposta sempre apresentará um
erro (que também é um parâmetro importante da RNA). SILVA, SPATTI E FLAUZINO
(2010) descrevem que esse erro não pode ser muito grande pois a rede não apresentará um bom
desempenho (underfitting), entretanto tal erro não pode ser muito pequeno, pois a rede
“decorará” uma vez que o erro está “viciado” nos dados de treinamento (Overfitting).
A Figura 2 abaixo mostra as principais funções de ativação existentes nas RNAs.
Figura 2: Algumas funções ativação de neurônios

Fonte: (SILVA, SPATTI, FLAUZINO, 2010)

1.1 ARQUITETURA E TOPOLOGIAS DE REDES NEURAIS

As arquiteturas de RNAs são diversas e estão relacionadas ao tipo de aplicação e a
forma estrutural com que a rede é configurada enquanto que as topologias estão associadas ao
número de neurônios em determinada camada da RNA. As Figuras 3: a) - c) mostram algumas
arquiteturas de redes neurais de aprendizado supervisionado, enquanto que a Figura 4 está
relacionada a um treinamento não supervisionado típico de mapas auto-organizáveis (SILVA,
SPATTI, FLAUZINO, 2010).
 Figura 3: Arquitetura de redes neurais supervisionadas

a) b)

c)

Fonte: SILVA, SPATTI, FLAUZINO, 2010).

Figura 4: Arquitetura de mapas auto-organizáveis

Fonte: (TEX)

2 O ALGORITMO BACKPROPAGATION
O algoritmo utilizado é o backpropagation em que os pesos são atualizados
primeiramente na camada de saída e depois nas camadas escondidas, utilizando o que a
literatura denomina de regra Delta generalizada.
As fórmulas de atualização dos pesos da camada de saída (equação 1), das camadas
intermediárias (equação 2) e da camada imediatamente após a entrada (equação 4) são
mostradas abaixo:
(𝐧) (𝐧) (n) (n−1)
𝐖𝐣𝐢 = 𝐖𝐣𝐢 + η ⋅ δj ⋅ Yi (2)
(𝐧−𝟏) (𝐧−𝟏) (n−1) (n−2) (3)
𝐖𝐣𝐢 = 𝐖𝐣𝐢 + η ⋅ δj ⋅ Yi
(𝟏) (𝟏) (1) (𝒊)
𝐖𝐣𝐢 = 𝐖𝐣𝐢 + η ⋅ δj ⋅ 𝐱𝐤 (4)
 Em que xK está associado a entrada i da amostra k, enquanto que o termo δ refere-se ao
gradiente local da camada n e é calculado da seguinte forma:
(n) (n) (n)
δj = (dj − Yj ) ⋅ g ′ (Ij ) (5)
n3
(n−1) (n) (n) (n−1)
δj = (∑ δk ⋅ Wji ) ⋅ g ′ (Ij ) (6)
k=1

A fórmula 5 refere-se ao gradiente local da camada de saída, sendo 𝑑𝑗 a saída desejada,

enquanto que a equação 6 calcula o gradiente local das camadas ocultas. Os termos “Y “são as
saídas dos respectivos neurônios associados a camada n e da mesma forma “I” é utilizado para
indicar a entrada do neurônio associada a camada n.

3 METODOLOGIA
3.1 VALIDAÇÃO CRUZADA (CROSS-VALIDATION)
Uma das formas mais eficientes para parar o treinamento de uma rede neural é o critério
de validação cruzada, em que a base de dados de treinamento se divide em duas: uma para
validação e uma para o o treinamento. A base de dados de treinamento é a que vai ser utilizada
para ajustar os pesos sinápticos. A base de dados de validação apenas para comparar seu erro
quadrático médio em analogia com o erro de treinamento. O treinamento irá parar no instante
em que o erro quadrático médio de validação começar a crescer, como mostra a Figura 5.
Figura 5: Validação cruzada

Fonte: (VISUAL STUDIO)

3.2 GERADOR DE NÚMEROS ALEATÓRIOS (RANDOM NUMBER GENERATOR)
O MatLabⓇ possui uma função que controla todas as funções que geram números
aleatórios chamada rng(s). Em que s indica o índice correspondente ao rng. O fluxograma da
Figura 6 mostra como essa função atua:
 Figura 6: Esquema de funcionamento da função rng

Fonte: (Autor)
Observa-se que a função rng proporciona melhor controle sobre a geração de números
aleatórios. Dessa forma pode-se garantir que todas as topologias tenham as mesmas variações
de pesos iniciais afim de se retirar um desempenho médio em razão dessas variações.

4 DESENVOLVIMENTO DO ALGORITMO
4.1 ARQUITETURA
A Figura 7 mostra a arquitetura proposta: 9 entradas cada amostra, N indica o número
de neurônios da camada escondida e 2 neurônios na camada de saída que apresentará uma saída
desejada (Target) binária de acordo com a classificação da amostra: [1 0] para a primeira classe
e [0 1] para a segunda classe.
Figura 7: Arquitetura da RNA

Fonte: (Autor)
 W1 simboliza os pesos da camada escondida, W2 representa os pesos da camada de
saída, I1 a entrada dos neurônios da camada escondida, Y1 a saída dos neurônios da camada
escondida, I2 a entrada dos neurônios da camada de saída e Y2 a saída da Rede Neural.
Com a bias presente na rede é necessário fazer alguns ajustes para seguir o treinamento.
Sendo x o vetor de entradas da rede, N o número de neurônios da camada escondida, F a função
de ativação da camada escondida e G a função de ativação da camada de saída tem-se:
1×10
x = [x1 , x2 , … , x9 ] →acrescentando a bias → x = [−1, x (1) , x (2) , … , x (9) ]
Logo os pesos da camada escondida deverão ser da seguinte forma:
(1.1) (1.2) (1.N) (10×N)
W1 W1 … W1
(2.1) (2.2) (2.N)
W1 W1 … W1
W1 = W1
(3.1)
W1
(3.2)
… W1
(3.N)

⋮
(10.1) (10.2) (10.N)
[W1 W1 … W1 ]
(1×N)
(10×N) (1×N) (1) (2) (N)
I1 = x (1×10) × W1 ⇒ I1 ⇒ 𝑌1 = [F(I1 ), F(I1 ), … , F(I1 )]

Acrescentando a bias:
(1×N+1)
(1) (2) (N)
𝑌1 = [−1, F(I1 ), F(I1 ), … , F(I1 )]

Logo os pesos da camada de saída deverão ser da seguinte forma:

(1.1) (1.2) (N+1×2)
W2 W2
(2.1) (2.2)
W2 W2
(3.1) (3.2)
W2 = W2 W2
⋮
(N.1) (N.2)
W2 W2
(N+1.1) (N+1.2)
[W2 W2 ]
(1×N+1) (N+1×2) (1×2)
I2 = Y1 × W2 ⇒ I2
(1×2)
Y2 = G(I2 ) ⇒ Y2
4.2 BASE DE DADOS
A base de dados cancer_dataset disponível no pacote de instalação do MatLabⓇ
apresenta 696 amostras (com 9 atributos cada), sendo 456 da classe 1 (com cancer) e 240 (sem
cancer). A base de dados foi dividida de acordo com a Tabela 1:
 Tabela 1: Divisão da base de dados
Treinamento Teste Validação Total
Classe 1 – Com Câncer 380 57 19 456
Classe 2 – Sem Câncer 200 30 10 240
Total 580 87 29 696
Fonte: (Autor)

4.3 FUNÇÕES DE ATIVAÇÃO UTILIZADAS

Para a camada oculta a função de ativação utilizada foi a sigmóide ou logística:
1 ′ (x)
βe−βx
f(x) = , f , com β = 0,85
1 + e−βx (1 + e−βx )2
Na camada de saída foi usada a função de ativação linear:
g(x) = αx, g ′ (x) = α, com α = 0,1

4.2 TOPOLOGIAS AVALIADAS

As topologias foram avaliadas através da matriz de confusão e da taxa de acertos como
mostra a Figura 8 e Equação 8:
Figura 8: Matriz de confusão

Fonte: (Autor)

Cada coluna corresponde a classe real, ou seja, o padrão que a rede deveria identificar
corretamente; e a linha indica qual classe a rede classificou. A diagonal principal refere-se aos
acertos da rede, e por conseguinte, o que estiver fora da diagonal principal a rede classicou
incorretamente. Dessa forma a taxa de acertos de cada rede neural é calculada em cima da
matriz de confusão pela Equação 8:
∑𝑛𝑘=1 𝑚𝑖𝑗 ∀ 𝑖 = 𝑗
𝑇𝑎𝑥𝑎 = × 100 (8)
∑𝑛𝑘=1 𝑚𝑖𝑗
Sendo n o número de amostras utilizadas para teste, e com a Equação 8 pode-se calcular
a taxa de desempenho média de cada topologia variando o gerador de sementes aleatórias do
MATLAB (rng) 20 vezes, de acordo com a Equação 9:
∑𝑘𝑖=1 𝑇𝑎𝑥𝑎(𝑖)
𝑇𝑎𝑥𝑎𝑚𝑒𝑑𝑖𝑎 = (9)
k
 Sendo k o número de vezes que os pesos iniciais foram variados. As topologias
utilizadas estão descritas na Tabela 2:
Tabela 2: Topologias avaliadas

Topologia 1 2 3 4

Número de
neurônios da camada 5 10 15 20
escondida
Fonte: (Autor)
Com 4 topologias e 20 variações no gerador de sementes aleatórias foram treinadas no
total 80 redes neurais.

5 RESULTADOS
Inicialmente foi testado o código backpropagation com apenas 5 neurônios na camada
escondida e o erro quadrático médio de treinamento e validação, em que é ressaltado o
momento em que o treinamento é parado:
Figura 9: Treinamento da rede

Fonte: (Autor)

É possível notar que no momento em que o erro de validação começa a subir o

treinamento é parado.
O teste é mostrado na Figura 10, pela matriz de confusão:
 Figura 9: Teste pela matriz de confusão

Fonte: (Autor)
Utilizando-se a Equação 8, determina-se a taxa de acertos:
56 + 30
𝑡𝑎𝑥𝑎 = × 100 ⇒ 𝑡𝑎𝑥𝑎 = 98,85%
56 + 30 + 1

A Figura 11 mostra a avaliação das 4 topologias pela taxa de acertos:

Figura 10: Taxa de acertos média de cada topologia

Fonte: (Autor)

Percebe-se que a melhor topologia foi a de 5 neurônios na camada oculta pois obteve a
maior taxa de acertos média.
5 PARÂMETROS DA MELHOR TOPOLOGIA

Como a melhor topologia foi a de 5 neurônios (Figura 11) na camada escondida,

abstraiu-se os parâmetros que foram ajustados ao final do treinamento.
Figura 11: Topologia de 5 neurônios na camada oculta

Fonte: (Autor)

5.1 PARÂMETROS ANTES DO TREINAMENTO:

Pesos da camada escondida

0,32439 0,32102 0,44489 0,36401 0,10493 0,22721 0,87914 0,93129 0,43893
0,68103 0,79629 0,21359 0,91323 0,30809 0,37408 0,04697 0,87615 0,42226
0,63175 0,95208 0,22696 0,1878 0,38279 0,13041 0,57235 0,10699 0,55814
0,47124 0,12869 0,4088 0,16756 0,1609 0,81298 0,71156 0,61636 0,2211
0,12854 0,31169 0,98726 0,69543 0,72186 0,31911 0,69999 0,10043 0,68656

Bias da camada escondida

0,30167
0,64192
0,94521
0,41079
0,99268

Pesos da camada de saída

0,64345 0,4692 0,58919 0,78161 0,05183
0,86194 0,79665 0,41184 0,19528 0,24415
 Bias da camada de saída
0,57527
0,59917

5.1 PARÂMETROS APÓS O TREINAMENTO

Pesos da camada escondida

0,844 0,47798 0,62249 0,53372 0,45206 0,33172 1,15931 1,06233 0,59042
2,1157 1,59797 1,32642 1,25842 0,20739 3,00111 1,28408 1,46058 1,57626
1,4957 0,80492 0,46229 -0,1713 -0,0699 1,7099 1,39458 0,24696 1,35606
1,2194 0,26081 0,57859 0,30667 0,57594 0,86582 1,07283 0,73417 0,40444
3,3723 2,26137 3,1668 2,02249 0,9057 4,259 2,24848 2,00107 2,2425

Bias da camada escondida

1,6593
4,5455
3,2241
2,1929
7,1538

Pesos da camada de saída

2,64282 -3,069 -1,9048 3,47314 -6,8969
1,16261 3,64252 2,36403 0,12545 5,55083

Bias da camada de saída

5,2783
2,1631
 CONCLUSÃO

O algoritmo apresentou um resultado ótimo, uma vez que, abstraiu as características de

cada classe da base de dados cancer_dataset com uma alta taxa de acertos, além de conseguir
parar o treinamento pelo critério de validação cruzada. Mesmo entre as topologias avaliadas a
taxa de acertos média foi acima de 96% e isto demonstra que o algoritmo trouxe resultados
satisfatórios.
 REFERÊNCIAS

I. N. SILVA, D. H. SPATTI, and R. A. FLAUZINO, Redes Neurais Artificiais para

Engenharia e Ciências Aplicadas. ArtLiber, 1a Ed, 2010.

PACHECO. Redes Neurais Artificiais. Disponível em

<http://pachecoandre.com.br/tag/redes-neurais/>. Acesso em 19 de novembro de 2018.

TEX. Disponível em: <https://tex.stackexchange.com/questions/144366/draw-a-kohonen-

som-feature-map>. Acesso em 13 de novembro de 2018.

VISUAL STUDIO. Neural Network Train-Validate-Test Stopping. Disponível em:

<https://visualstudiomagazine.com/articles/2015/05/01/train-validate-test-stopping.aspx>.
Acesso em 19 de novembro de 2018.
 ANEXO

(1) Extração da base de dados:

Nome: Base_de_Dados_Cancer

[entrada desejado] = cancer_dataset;

%% retira 2 amostras da classe 1 e 1 amostra da classe 2 afim de tornar a
base de dados divisível por 6 para uma possível validação cruzada múltipla
[~,x] = max(desejado);%Organizando as classes

fold=6;

% Indices para cada classe

ind = find(x==1);
h = datasample(ind,2,'Replace',false);
entrada(:,h) = [];
desejado(:,h)=[];
[~,x] = max(desejado);

ind = find(x==2);
g = [datasample(ind,1,'Replace',false)];
entrada(:,g) = [];
desejado(:,g)=[];
[~,x] = max(desejado);

(2) Definição dos índices dos subconjuntos de treinamento:

Nome: separacao_indices_treinamento

Base_de_Dados_Cancer % Carrega a base de dados do tópico 1

%% Definição dos índices dos subconjuntos de treinamento

n = length(entrada(1,:));
% Indices para cada classe
for i=unique(x)% Variando as classes
ind = find(x==i); % índices onde estão localizadas as amostras da
classe i
quant_class(i) = length(ind); %Indica a quantidade de cada classe
quant = length(ind)/6; %quantidade de números sorteados de cada classe
para treinamento
b = datasample(1:length(ind),quant,'Replace',false);% Sortear os
índices de teste classe i
c{i}=ind(b); %armazena os índices correspondentes ao sorteio acima
ind(b)=[];%Exclui os índices sorteados para sortear os restantes sem
repetições
end

indice_tev = [c{1} c{2}]; % índices de teste e validação juntos

(3) Definição dos índices dos subconjuntos de treinamento

Nome: Dados_teste_treinamento_validacao
Separacao_indices_treinamento % Carrega o código do tópico 2
% subconjunto de treinamento
entrada_train = entrada;
entrada_train(:,indice_tev) = [];
desejado_train = desejado;
desejado_train(:,indice_tev) = [];
h = desejado(:,indice_tev);
[~,x] = max(h);
for i=unique(x)% Variando as classes
ind = find(x==i); %variando as folds
quant_class(i) = length(ind); %Indica a quantidade de cada classe
quant = ceil((length(ind))/4); %quantidade de números sorteados de cada
classe para validação
b = datasample(1:length(ind),quant,'Replace',false);% Sortear os
índices de teste classe i
c{i}=ind(b); %armazena os índices correspondentes ao sorteio acima
ind(b)=[];%Exclui os índices sorteados para sortear os restantes sem
repetições
end

% subconjunto de teste
entrada_test = entrada(:,indice_tev);
entrada_test(:,[c{1} c{2}]) = [];
desejado_test = desejado(:,indice_tev);
desejado_test(:,[c{1} c{2}]) = [];

% subconjunto de validação
input = entrada(:,indice_tev);
target = desejado(:,indice_tev);
entrada_valid = input(:,[c{1} c{2}]);
desejado_valid = target(:,[c{1} c{2}]);

entrada_train = entrada_train';
desejado_train = desejado_train';
entrada_valid = entrada_valid';
desejado_valid = desejado_valid';
entrada_test = entrada_test';
desejado_test = desejado_test';
entrada = entrada';

(4) Função principal

function net = treinar(t,NEpocas)

Dados_teste_treinamento_validacao % Carrega o código

%% Processo para iniciar a rede

% Definição das funções de ativação e suas derivadas
f = @(x) 1/(1+exp(-0.85*x)); %Função sigmóide
fder = @(x) 0.85*exp(-0.85*x)/((1+exp(-0.85*x))^2); %Derivada da função
sigmóide
g = @(x) 0.1*x; %Função linear
gder = @(x) 0.1; %Derivada da função linear

Pesos_Camada_Oculta = rand(size(entrada,2)+1,t);
x = Pesos_Camada_Oculta;
Pesos_Camada_Saida = rand(t+1,size(desejado,1));
y = Pesos_Camada_Saida;

%% Início do Treinamento da rede

eta=0.1;
% Processo de treinamento para cada época
tic
cont=1;
for n = 1 : NEpocas
% Treinamento
 for m = 1 : length(entrada_train)
% função que calcula os parâmetros necessários para calcular erro e
% atualizar os pesos do tópico 5
rede =
calcula_saida(entrada_train(m,:),Pesos_Camada_Oculta,Pesos_Camada_Saida,f,g
);
% Erro Por Amostra
Erro(m) = sum((desejado_train(m,:)-rede.Y2).^2)/2;
% Atualização dos pesos da camada de saída
d2 = (desejado_train(m,:)-rede.Y2).*arrayfun(gder, rede.I2); %
gradiente local da camada de saída
Pesos_Camada_Saida = Pesos_Camada_Saida + (eta*d2'*rede.Y1)';
%Atualização dos pesos da camada oculta
d1 = d2*Pesos_Camada_Saida(2:t+1,:)'.*arrayfun(fder,rede.I1); %
gradiente local da camada oculta
Pesos_Camada_Oculta = Pesos_Camada_Oculta + (eta*d1'*[-1
entrada_train(m,:)])';
end
% Erro quadrático médio de treinamento
Erro_medio_train(n) = sum(Erro)/length(Erro);
clear Erro
% validação
for o = 1 : length(entrada_valid)
rede =
calcula_saida(entrada_valid(o,:),Pesos_Camada_Oculta,Pesos_Camada_Saida,f,g
);
Erro(o) = sum((desejado_valid(o,:)-rede.Y2).^2)/2;
end
% erro quadrático médio de validação
Erro_medio_valid(n) = sum(Erro)/length(Erro);
clear Erro
if n >= 3
% pause
[~, ind] = min(Erro_medio_valid(n-2:n));
if ind == 3
minimo(cont).peso_Oculto = Pesos_Camada_Oculta;
minimo(cont).peso_Saida = Pesos_Camada_Saida;
minimo(cont).epoca = n;
minimo(cont).errorT = Erro_medio_train(n);
minimo(cont).errorV = Erro_medio_valid(n);
cont = cont + 1;
end
if (n - minimo(end).epoca) > 25
break;
end
end
end
if n~=NEpocas
n=n-1;
end
%% Pârâmetros da rede treinada
a = size(Pesos_Camada_Oculta,1);
net.time = toc; % Tempo de execução
net.Epoch = n; % Época em que ocorreu a parada do treinamento
net.BestEpoch = minimo(end).epoca; % Época onde ocorreu a validação cruzada
e o melhor aprendizado da rede
net.WeigthInit{1} = x(2:a,:)';
net.WeigthInit{2} = y(2:t+1,:)';
net.BiasInit{1} = x(1,:)';
net.BiasInit{2} = y(1,:)';
net.Weigth{1} = minimo(end).peso_Oculto(2:a,:)'; % Pesos da camada
escondida de validação cruzada
net.Weigth{2} = minimo(end).peso_Saida(2:t+1,:)'; % pesos da camada de
saída de validação cruzada
net.Bias{1} = minimo(end).peso_Oculto(1,:)';
net.Bias{2} = minimo(end).peso_Saida(1,:)';
net.Func.Hidden = f; % Função de ativação da camada escondida
net.Func.HiddenDiff = fder; % Função derivada da camada escondida
net.Func.Out = g; % Função de ativação da camada de saída
net.Func.OutDiff = gder; % Função derivada da camada de saída
net.MSETrain = minimo(end).errorT;
net.MSEValid = minimo(end).errorV;
net.taxa = eta;
net.Input = entrada'; % Entrada da Rede Neural
net.Target = desejado;
net.fig = figure; % Gráfico
%% plotagem do erro de validação e treinamento observando o momento que o
erro de validação começa a crescer
d = net.BestEpoch;
set(net.fig,'NextPlot','replace')
clf;
hold on
plot(Erro_medio_train,'b','LineWidth',1.5)
plot(Erro_medio_valid,'r','LineWidth',1.5)
legend('Erro de Treino','Erro de Validação')
title('Erro Quadrático Médio')
grid(gca,'minor')
grid on
axis([0 n 0 0.3])
plot (d,Erro_medio_valid(d),'ro','MarkerSize',30,'LineWidth',2)
xlabel('Épocas')
%% Teste da rede
for p = 1 : length(entrada_test)
rede =
calcula_saida(entrada_test(p,:),[net.Bias{1}';net.Weigth{1}'],[net.Bias{2}'
;net.Weigth{2}'],f,g);
saida(p,:) = arrayfun(g,rede.I2);
end
net.output = saida';
saida = saida';
target = desejado_test';
[~,saida] = max(saida);
[~,target] = max(target);
net.MatrizDeConfusao = confusionmat(saida,target);
net.HitRate =
sum(diag(net.MatrizDeConfusao))/sum(sum(net.MatrizDeConfusao))*100;

(5) Função varre a rede retornando os parâmetros para atualização de pesos

function s = calcula_saida(input,w1,w2,f,g)

s.I1 = [-1 input]*w1;

s.Y1 = arrayfun(f,s.I1);
% Colocando a Bias na segunda camada
s.Y1 = [-1 s.Y1];

% segunda camada
s.I2 = s.Y1*w2;
s.Y2 = arrayfun(g,s.I2);
(6) Código para verificar melhor topologia

top = [5 10 15 20]; % topologias a analisar

for s=1:20
rng(s)
for t=1:length(top)
rede = treinar(top(t),100); % Utilização da função treinar do
tópico 4
matriz_de_confusao{s,t} = rede.MatrizDeConfusao; % matriz de
confusao da semente s e topologia t
taxa(s,t) =
sum(diag(matriz_de_confusao{s,t}))/sum(sum(matriz_de_confusao{s,t})); %
taxa de acertos referentes a topologia t e semente s
tempo = rede.time
end
end
save Verifica_A_Melhor_Topologia.mat
celula = {'5' '10' '15' '20'};
Taxa_media = (sum(taxa)/20)*100;
plot(Taxa_media,'bo--')
d = find(Taxa_media==max(Taxa_media));
xlabel('Número de neurônios na camada escondida')
title('Taxa de Acertos Média')
set(gca,'XTickLabel',celula)
hold on
plot (d,Taxa_media(d),'ro','MarkerSize',30,'LineWidth',2)
grid(gca,'minor')
grid on