Universidade Federal do Piauí - UFPI

Disciplina: Redes Neurais

Docente: Fábio Rocha

Discente: Isleane Paiva Machado

1. KNN (k-Nearest Neighbors)

É um algoritmo de aprendizado de máquina supervisionado muito utilizado para classificação.

Em problemas de classificação, o KNN busca classificar uma nova instância (amostra) com base na classe das
K amostras mais próximas (vizinhos) encontradas no conjunto de treinamento. O valor de K é um parâmetro do
algoritmo e deve ser definido pelo usuário. O KNN calcula a distância entre a nova instância e todas as outras
instâncias do conjunto de treinamento (por exemplo, utilizando a distância euclidiana). Em seguida, seleciona
os K vizinhos mais próximos (aqueles com as menores distâncias) e determina a classe mais frequente entre
eles. Essa classe é atribuída à nova instância como a sua classe de predição.

Neste código, foi utilizzado o algoritmo KNN (k-Nearest Neighbors) com diferentes valores de K (K=3 e K=5)
para realizar a classificação das flores íris. O conjunto de dados é carregado a partir do conjunto de dados
padrão do MATLAB, que contém informações sobre as medidas de sepalas e pétalas de três espécies de flores
íris (setosa, versicolor e virginica).

No código abaixo foi realizado a normalização dos dados de entrada, colocando todos os atibutos na mesma

escala entre [0, 1] e armazenados em dados normalizados. A proporçãode treinamento e teste foi definida em

70% e 30% respectivamente.

A acurácia foi utilizada como métrica nesse código, a fim de avaliar o desempenho do aloritmo de
classificaçção KNN.

O algoritmo rodou 20 vezes conforme solicitado para ao fim apresentar o máximo, média, minimo e desvio

padrão das iterações.

Os dados foram embaralhados a fim de melhorar a capacidade de generalização do modelos em dados

desconhecidos.

% 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;

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

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

% Definindo a proporção de treinamento e teste

trainRatio = 0.7;

1
testRatio = 0.3;

% Inicializando vetores para armazenar os resultados de K=3 e K=5

accuracies_k3 = zeros(20, 1);
accuracies_k5 = zeros(20, 1);

for k = 1:20
% Calculando o número de instâncias para treinamento e teste
numInstances = size(X, 1);
numTrain = round(numInstances * trainRatio);
numTest = round(numInstances * testRatio);

% Embaralhando os dados
idx = randperm(numInstances);
X_norm = X_norm(idx, :);
Y = Y(idx);

% Convertendo os rótulos de classe para o formato numérico

[~, ~, Y_idx] = unique(Y);
Ytrain = Y_idx(1:numTrain);
Ytest = Y_idx(numTrain+1:numTrain+numTest);

% Dividindo os dados em treinamento e teste

Xtrain = X_norm(1:numTrain, :);
Xtest = X_norm(numTrain+1:numTrain+numTest, :);

% Classificação usando o algoritmo KNN com K=3

kNN_model_k3 = fitcknn(Xtrain, Ytrain, 'NumNeighbors', 3);
Ypred_k3 = predict(kNN_model_k3, Xtest);
accuracy_k3 = sum(Ypred_k3 == Ytest) / numTest;
accuracies_k3(k) = accuracy_k3;

% Classificação usando o algoritmo KNN com K=5

kNN_model_k5 = fitcknn(Xtrain, Ytrain, 'NumNeighbors', 5);
Ypred_k5 = predict(kNN_model_k5, Xtest);
accuracy_k5 = sum(Ypred_k5 == Ytest) / numTest;
accuracies_k5(k) = accuracy_k5;
end

% Apresentando os resultados para K=3

disp('Resultados para K=3:');

Resultados para K=3:

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

Mínimo: 0.88889

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

Máximo: 0.97778

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

Média: 0.94889

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

Desvio Padrão: 0.027073

% Apresentando os resultados para K=5

disp('Resultados para K=5:');

Resultados para K=5:

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

Mínimo: 0.91111

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

Máximo: 0.97778

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

Média: 0.95556

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

Desvio Padrão: 0.023912

2. APRESENTAÇÃO DA MATRIZ DE CONFUSÃO

A matriz de confusão é uma tabela que permite visualizar o desempenho do modelo de classificação ao
comparar suas predições com os rótulos verdadeiros dos dados de teste.

% Gerando a matriz de confusão para K=3

confusionMat_k3 = confusionmat(Ytest, Ypred_k3);
disp('Matriz de Confusão para K=3:');

Matriz de Confusão para K=3:

disp(confusionMat_k3);

21 0 0
0 10 1
0 1 12

% Gerando a matriz de confusão para K=5

confusionMat_k5 = confusionmat(Ytest, Ypred_k5);
disp('Matriz de Confusão para K=5:');

Matriz de Confusão para K=5:

disp(confusionMat_k5);

3
 21 0 0
0 10 1
0 1 12

3. GRÁFICO DE DISPERSÃO DAS ESPÉCIES

% Gerando o gráfico de dispersão
figure;
gscatter(X_norm(:, 1), X_norm(:, 2), Y);
xlabel('Sepal Length');
ylabel('Sepal Width');
title('Classificação de Flores Íris');