Universidade Federal do Piauí - UFPI

Disciplina: Redes Neurais

Docente: Fábio Rocha

Discente: Isleane Paiva Machado

1. MLP (MULTILAYER PERCEPTRON)

É um tipo de rede neural artificial que consiste em múltiplas camadas de neurônios, organizadas em uma
estrutura em forma de camadas interconectadas. É uma das arquiteturas de rede neural mais comumente
usadas e é conhecida por sua capacidade de aprender e modelar relações complexas entre os dados.

1.1 Utilizar MLP para classificação de padrão da flor Iris

Utilizando o algoritmo de retropropagação consistiu em uma série de iterações para ajustar os pesos sinápticos
e biases. Os dados utilizados foram do conjunto de flores iris.

A rede foi configurada com uma camada oculta contendo 3 neurônios, a camada de saída também possui 3
neurônios, representando as 3 classes de espécies iris.

Os biases da camada oculta foram definidos como:

[0.1 0.3 0.2]

Os bias da camada de saída foi definido como:

[0.3 0.3 0.3]

Durante o treinamento, os pesos sinápticos e biases foram ajustados a cada iteração com base nos erros de
saída e retropropagados através da rede.

Após o treinamento, a acurácia da rede foi avaliada e os resultados dos percentuais de acertos foram
calculados. Além disso, foi gerado um gráfico de dispersão das espécies iris, mostrando a distribuição dos
dados no espaço de entrada. Também foi gerada uma matriz de confusão, que apresenta a quantidade de
classificações corretas e incorretas para cada classe de espécie iris.

% Carregando o conjunto de dados das flores iris

load fisheriris;

% Separando os dados de entrada e rótulos

X = meas; % atributos de medidas
Y = species; % espécies

% Codificando as classes
Y_encoded = zeros(size(Y, 1), 3);
Y_encoded(strcmp(Y, 'setosa'), 1) = 1;
Y_encoded(strcmp(Y, 'versicolor'), 2) = 1;
Y_encoded(strcmp(Y, 'virginica'), 3) = 1;

% Normalização Min-Max dos dados de entrada

1
X_norm = (X - min(X)) ./ (max(X) - min(X));

% Definindo os parâmetros da MLP

numInputs = size(X_norm, 2);
numHidden = 3;
numOutputs = 3;
learningRate = 0.1;
numEpochs = 1000;

% Inicializando vetores para armazenar os resultados dos percentuais de acertos

accuracies = zeros(20, 1);
weights_hidden = zeros(numInputs, numHidden);
weights_output = zeros(numHidden, numOutputs);

for k = 1:20
% Embaralhando os dados antes de dividir em treinamento e teste
idx = randperm(size(X_norm, 1));
X_shuffled = X_norm(idx, :);
Y_shuffled = Y_encoded(idx, :);

% Separando os dados de treinamento e teste

numTest = round(0.3 * size(X_norm, 1));
X_train = X_shuffled(1:end-numTest, :);
X_test = X_shuffled(end-numTest+1:end, :);
Y_train = Y_shuffled(1:end-numTest, :);
Y_test = Y_shuffled(end-numTest+1:end, :);

% Inicializando os pesos e biases aleatoriamente para cada iteração

W1 = rand(numInputs, numHidden);
b1 = [0.1 0.3 0.2];
W2 = rand(numHidden, numOutputs);
b2 = [0.3 0.3 0.3];

% Função de ativação sigmoid

sigmoid = @(x) 1 ./ (1 + exp(-x));

% Treinamento da MLP usando o algoritmo de retropropagação

for epoch = 1:numEpochs
% Forward pass
hiddenInput = X_train * W1 + b1;
hiddenOutput = sigmoid(hiddenInput);
outputInput = hiddenOutput * W2 + b2;
output = sigmoid(outputInput);

% Backward pass
outputError = output - Y_train;
outputDelta = outputError .* output .* (1 - output);
hiddenError = outputDelta * W2';
hiddenDelta = hiddenError .* hiddenOutput .* (1 - hiddenOutput);

2
 % Atualização dos pesos e biases
W2 = W2 - learningRate * hiddenOutput' * outputDelta;
b2 = b2 - learningRate * sum(outputDelta);
W1 = W1 - learningRate * X_train' * hiddenDelta;
b1 = b1 - learningRate * sum(hiddenDelta);
end

% Classificação dos dados de teste

hiddenInput = X_test * W1 + b1;
hiddenOutput = sigmoid(hiddenInput);
outputInput = hiddenOutput * W2 + b2;
output = sigmoid(outputInput);

% Decodificando as classes preditas

[~, predictedClass] = max(output, [], 2);
predictedSpecies = {'setosa', 'versicolor', 'virginica'};
predictedSpecies = predictedSpecies(predictedClass);

% Decodificando as classes verdadeiras

[~, trueClass] = max(Y_test, [], 2);
trueSpecies = {'setosa', 'versicolor', 'virginica'};
trueSpecies = trueSpecies(trueClass);

% Calculando a acurácia
accuracy = sum(strcmp(predictedSpecies, trueSpecies)) / numel(trueClass);
accuracies(k) = accuracy;

% Atualizando os pesos sinápticos

weights_hidden = W1;
weights_output = W2;

% Exibir a matriz de confusão para a última iteração

if k == 20
confusionMat = confusionmat(trueClass, predictedClass);
disp('Matriz de Confusão (Última Iteração):');
disp(confusionMat);
end
end

Matriz de Confusão (Última Iteração):

16 0 0
0 15 1
0 3 10

% Apresentando os resultados dos percentuais de acertos

disp('Resultados dos percentuais de acertos:');

Resultados dos percentuais de acertos:

disp(['Mínimo: ', num2str(min(accuracies))]);

3
 Mínimo: 0.91111

disp(['Máximo: ', num2str(max(accuracies))]);

Máximo: 1

disp(['Média: ', num2str(mean(accuracies))]);

Média: 0.96222

disp(['Desvio Padrão: ', num2str(std(accuracies))]);

Desvio Padrão: 0.022913

% Apresentando os pesos sinápticos

disp('Pesos da camada oculta:');

Pesos da camada oculta:

disp(weights_hidden);

-0.4871 -1.7928 -2.0942

3.3315 3.8443 -3.7490
-2.1328 -5.4205 6.9269
0.0447 -6.1591 11.7903

disp('Pesos da camada de saída:');

Pesos da camada de saída:

disp(weights_output);

0.9552 -2.9131 -0.2437

7.2149 -8.3206 -5.6850
-7.6280 -11.0037 11.7863

E por fim foi gerado um gráfico de dispersão das espécies

% Plotando o gráfico de dispersão

figure;
gscatter(meas(:,1), meas(:,2), species);
xlabel('Sepal Length');
ylabel('Sepal Width');
title('Gráfico de Dispersão das Espécies Iris');
legend('setosa', 'versicolor', 'virginica');

4
5