Radial Basis Function(RBFs)

Prévia do material em texto

REDES NEURAIS DE BASES RADIAIS (RBFS) AGOSTO 2021 1
Trabalho Intermediário
Redes Neurais Artificiais
Prof. Braga
2021.1
João Correia Costa
I. INTRODUÇÃO
AS Redes Neurais de Base Radial (RBFs) são ampla-mente utilizadas em aplicações envolvendo interpolação
de funções multivariadas e classificação de bases de dados
complexas e não-lineares. Um importante atributo desse tipo
de rede é a simplicidade da sua arquitetura, sendo constituı́da,
em geral, de uma camada de entrada, uma única camada
escondida e uma camada de saı́da, como indicado na Fig.
1. Essa caracterı́stica é precisamente o que justifica a rápida
convergência dos algoritmos que implementam RBFs, prin-
cipalmente se compararmos essa rede ao Perceptron Multi-
camadas (MLP), o qual necessita de múltiplas projeções dos
dados de entrada nas camadas escondidas, o que exige um
maior processamento.
A camada escondida de uma RBF é constituı́da por unidades
de processamento, neurônios artificiais. Cada unidade inclui
uma função radial própria, com um centro hiperdimensional
e um raio, caracterizando uma hiperesfera. Essa camada é
responsável por incorporar a não-linearidade à rede, tornando
a classificação possı́vel pela camada de saı́da, a qual realiza
operações lineares simples sobre as respostas dos neurônios
escondidos [1].
Em teoria, estudos demonstram que o desempenho de uma
rede RBF depende, em grande medida, da escolha do número
de neurônios escondidos, e de seus respectivos centros e
raios[2, 3]. Além disso, é importante verificar a compatibil-
idade entre os algoritmos de inicialização da rede e os dados
em questão, visto que a distribuição dos dados no hiperespaço
pode suprimir o desempenho do algoritmo, mesmo que este
tenha apresentado anteriormente bons resultados em uma
variedade de datasets.
Este artigo tem como proposta realizar uma comparação de
desempenho entre três métodos de inicialização de redes neu-
rais RBF, indicados na seção IV. Para tanto, consideraremos a
acurácia média obtida a partir do mapeamento de 4 datasets:
BreastCancer, Iris, Statlog e Wine, importados do repositório
da UCI Machine Learning.
O artigo foi organizado da seguinte forma: na seção II, consta a
revisão de literatura; na seção III, descreveremos, com maior
rigor, a rede neural implementada; na seção IV, explanare-
mos sobre os algoritmos de inicialização utilizados; na seção
V, apresentaremos gráficos relacionadas ao desempenho dos
modelos para as bases de dados supracitadas; na seção VI,
concluiremos;
II. REVISÃO DE LITERATURA
Uma escolha natural para inicialização da rede neural RBF,
seria associar cada ponto do dataset ao centro de uma função
radial de modo que o número de graus de liberdade fosse igual
ao número de amostras. Segundo Chris Bishop[3], para esse
caso, a função definida pela rede classificaria perfeitamente
cada ponto. Se a base de dados tem um comportamento
regular, mas está contamida por ruido, a rede irá aprender
todos os detalhes associados a cada ponto, ao invés de absorver
o padrão dominante. Esse fenômeno é usualmente chamado
de overfitting. A função gerada apresenta grande oscilação e
baixa capacidade de generalização.
A fim de minimizar o overfitting, Cevikalp, Larlus e Ju-
rie[1] propõe um algoritmo baseado em clusters homogêneos
(HC). Segundo o artigo desenvolvido por esses pesquisadores,
Supervised Clustering Algorithm for the Initializationof RBF
Neural Network Classifiers[1], ao evitar, simultaneamente, a
presença de clusters heterogêneos e a vizinhança entre clusters
homogêneos, o HC tende a apresentar ampla capacidade de
generalização para uma diversidade de datasets.
III. DETALHES TÉCNICOS PARA A IMPLEMENTAÇÃO DA
REDE NEURAL
A rede neural implementada neste artigo tem uma arquite-
tura de três camadas feedforward, como indicado na Fig. 1. O
vetor de entrada X é propagado para os neurônios da camada
escondida, cada um dos quais aplica uma função radial própria,
dada por:
hi = h(|x− µi|) (1)
Onde µi é o centro da função de base radial hi associada ao
i-ésimo neurônio escondido e |...| indica a distância euclidiana
entre vetores. As funções hi são todas gaussianas, como
indicado na equação (2), cujos centros e raios são determi-
nados durante o processo de aprendizado, por algoritimos de
inicialização, os quais serão descritos na seção III.
hi(x) = e
−(x−µi)2/2r2i (2)
Onde ri é o raio associado ao i-ésimo neurônio escondido.
Como as funções radiais têm centros e raios fixos, pode-se
fazer uma analogia com hiperesferas. Durante o treinamento,
2 REDES NEURAIS DE BASES RADIAIS (RBFS) AGOSTO 2021
Figure 1: Arquitetura de uma Rede Neural de Base Radial. As
setas evidenciam o caráter da rede feed-forward. Os sı́mbolos
sigma na camada de saı́da indicam operações lineares de
perceptrons
essas hiperesferas devem ser espalhadas no espaço de entrada,
evitando sobreposição entre classes distintas. Após determinar
os raios e centros das funções radiais, o vetor de entrada X é
projetado na camada intermediária, resultado na matriz H .
H =

h1(x1) h2(x1) . . . hi(x1)
h1(x2) h2(x1) . . . hi(x2)
...
... . . .
...
h1(xN ) h2(xN ) . . . hi(xN )

Onde N corresponde ao número total de amostras.
Considerando que a camada intermediária foi capaz de lin-
earizar a base de dados, obtemos a saı́da da rede a partir
da combinação linear das saı́das de cada neurônio escondido,
como indicado na equação (3).
Hw = Y (3)
O vetor de pesos w pode ser facilmente obtido,
multiplicando-se a equação (3) à esquerda pela pseudo-inversa
de H . Como indicado na equação (4):
w = H+Y (4)
Onde H+ é a pseudo-inversa de H .
Neste artigo, as bases de dados consideradas apresentam
duas ou três classes distintas. Para o caso de três classes, a
matriz-coluna Y é reescrita numa matrix (NX2), através do
mapeamento indicado:01
2
− >
0 01 0
1 1

O mapeamento reescreve cada label em um vetor de duas
dimensões. Dessa forma, a equação (3) é ajustada: modelando
dois perceptrons na camada de saı́da, necessários para classi-
ficar uma base com três classes, ou um único perceptron, caso
a base tenha apenas duas classes distintas e o mapeamento
não tenha sido aplicado.
Figure 2: Algoritmos de Inicialização: a) Não-Supervisionado,
b) Supervisionado
IV. ALGORITMOS DE INICIALIZAÇÃO
Os algoritmos de inicialização de RBFs têm como obje-
tivo determinar os centros e raios da camada intermediária.
Usualmente, métodos não-supervisionados são implementados
para seleção dos parâmetros, como o algoritmo K-means.
Duas limitações desses algoritmos são: primeiro, é necessário
determinar previamente o número de clusters da camada
intermediária, segundo, a rotulação dos dados é ignorada[1].
A primeira delas; implica em inicializar o código com vários
valores do parâmetro k (número de clusters), aumentando o
custo computacional ,até identificação da faixa de valores
que se ajusta à base de dados. A segunda, pode levar a
situações como a indicada na Fig.2(a): clusters heterogêneos,
com duas classes distintas associadas ao mesmo centro, provo-
cando queda de desempenho, e cluster homogêneos que são
separados desnecessariamente em dois ou mais grupos[1].
Ao considerar o rótulo das amostras, os algoritmos super-
visionados tendem a distribuir os clusters na configuração
indicada na Fig.2(b). Clusters heterogêneos são separados e
os homogêneos conservados.
Neste artigo, analisaremos dois algoritmos não-
supervisionados: o Random e o K-means, e um supervisionado:
o Homogeneus Clustering(HC)[1].
A. Algoritmo Random
O método Randomizado é o mais simples tratado neste
artigo. Após estabelecer o número de clusters (hiperparâmetro
k), são seleciondos aleatoriamente k pares de dados do espaço
de entrada. Para cada par de dados é calculado um centro, cor-
respondendo a média aritimética do par, e um raio, associado
a distânciaeuclidiana entre os dois pontos.
B. Algoritmo k-means
O kmeans é um algoritmo de clustering não-
superviosionado, ou seja, parciona o espaço de entrada
em K grupos sem considerar a rotulação dos dados. O
objetivo do método é encontrar a configuração de clusters
que minimize a distância euclidiana média entre as amostras
e os centros. A estabilização da posição dos centros é um
indicativo de que a configuração corrente é homogênea,
isto é as distâncias médias foram minimizadas. As estapas
implementadas pelo algoritmo são:
ROBERG et al.: HIGH-EFFICIENCY DIODE AND TRANSISTOR RECTIFIERS 3
1) Especificar o número de clusters (k).
2) Selecionar aleatoriamente (k) pontos da base de dados
para inicializar os centros
3) Calcular a distância euclidiana entre os dados e os
centros.
4) Associar os dados ao centro mais próximos, formando
clusters.
5) Determinar os novos centros a partir da média dos dados
de cada cluster.
6) Retornar a etapa 3 e repetir o processo até que o
deslocamento dos centros seja inferior a um determinado
critério de convergência.
C. Algoritmo Homogeneous Clustering (HC)
O HC é um algoritmo supervisionado, em que a quantidade
de clusters e sua localização são determinados automatica-
mente ao final do processo. O método se baseia na separação
de clusters rivais com sobreposição de classes. A ideia é
garantir a homogeneidade dos grupos, ponderada por um bias.
A seguir as etapas do agoritmo[1]:
1) Escolher o número inicial (k) de clusters como o número
de classes distintas na base de dados.
2) Para todos os clusters Hi pertencente a classe i, deter-
minar a distância di entre o centro µi e o ponto mais
distante, e atribuı́-la ao raio do cluster.
3) Associar o centro a media aritmética de cada classe.
4) Calcular a distância entre todos os centros da
configuração corrente e armazenar numa matriz trian-
gular para evitar repetições.
M =

0 d12 . . . d1k
0 0 . . . d2k
...
...
. . .
...
0 0 . . . 0

Matriz Mij representando a distância dij entre os cen-
tros i e j.
5) Checar a relação entre os raios dos clusters e as
distâncias entre os centros. Há três situações possı́veis:
a) dij ≥ di+dj ; Não há intersecção entre os clusters
Hi e Hj . Não há necessidade de separação. Como
indicado na Fig.3(a).
b) dij ≤ di + dj e |di − dj | < dij ; Há intersecção
entre as hiperesferas e existem três situações
possı́veis:
i) Não há amostras na intersecção
como indicado na Fig.3(b).
Formalmente: ||xi − µi|| < ||xi + µj ||
e ||xj − µj || < ||xj + µi||; onde xi é uma
amostra do cluster Hi. Nenhum cluster
novo é criado. Todas as amostras são
classificadas corretamente.
ii) Há amostras pertencentes a Hi
na intersecção, e elas estão mais
próximas do cluster rival Hj .
Formalmente: ||xi − µi|| > ||xi + µj ||
e ||xj − µj || < ||xj + µi||; Esse caso está
Figure 3: Possı́veis cenários de intersecção entre clusters
ilustrado na Fig.3(c). O cluster Hi deve
sofrer split em dois novos clusters, se o
número de amostras xi na intersecção for
superior ao bias estabelecido.
iii) Há amostras pertencentes aos dois clusters
Hi e Hj na intersecção, que estão mais
próximas dos centros de clusters rivais do
que dos centros ao quais elas pertencem.
Formalmente: ||xi − µi|| > ||xi + µj || e
||xj − µj || > ||xj + µi||;Este caso está
ilustrado na Fig.3(d). Portanto, se o número
de amostras na intersecção for superior ao
bias, ambos os clusters devem sofrer split.
c) dij ≤ di + dj e |di − dj | ≥ dij ; Neste caso uma
das hiperesferas engloba a outra, como indicado
na Fig.3(e). O cluster maior deve sofrer split.
6) Repetir as etapas anteriores até que nenhum split seja
aplicado.
O algoritimo HC foi obtido integralmente do artigo : A
Supervised Clustering Algorithm for the Initialization of RBF
Neural Network Classifiers. (Hakan Cevikalp, Diane Larlus,
Frederic Jurie)[1]
Embora o Homogeneus Clustering (HC) evite grupamentos
como os indicados na Fig.1(a), para bases de dados de
múltiplas dimensões, é possı́vel que a existência de muitas
regiões de intersecção entre classes distintas, leve a splits
excessivos, os quais eventualmente podem gerar queda de
desempenho e elevação do custo computacional.
A separação de clusters implementada para o caso indicado
na Fig.3(e), utiliza o método K-means, com hiperparâmetro
k=2. De forma que esse algoritmo parcione o cluster maior,
eliminando a situação de ”englobamento”.
V. RESULTADOS
Nesta seção, avaliaremos o desempenho da rede neural RBF
nas bases de dados Iris, BreastCancer, Wine e Statlog. Nas
subseções relativas a cada dataset, indicamos o número de
instâncias e de classes dsitintas. A rede neural será inicializada
a partir dos algoritmos: Random, K-means e Homogeneus
Cluster.
A métrica utilizada para avaliar o desempenho foi a acurácia
média. Para os métodos Random e k-means foram realizados
4 REDES NEURAIS DE BASES RADIAIS (RBFS) AGOSTO 2021
Figure 4: Gráfico de Desempenho com barra de desvio para
os algoritmos K-means e Random aplicados no BreastCancer;
Treinamento repetido 20 vezes
treinamentos repetidos da rede (20 vezes), variando o hiper-
parâmetro K (número de clusters), a fim de se obter uma
acurácia média e o desvio padrão. Para o método Homogeneus
Cluster, variou-se o hiperparâmetro bias, o qual interfere na
decisão do algoritmo a respeito da divisão do cluster, após
avaliar os dados da intersecção.
Como indicado na seção II, todas as unidades de pro-
cessamento da camada intemediária, têm como função de
ativação uma normal Gaussiana eq.(2), cujos parâmetros serão
ajustados pelos algoritmos supracitados.
O tratamento dos dados consistiu na normalização entre 0 e
1, como indicado na eq. (5). Não foi aplicado nenhum método
de seleção de caracterı́sticas essenciais. 70% das amostras
foram selecionadas para treinamento e os outros 30% foram
selecionados para teste.
xi = (xi − xmin)/(xmax − xmin) (5)
A. Dataset BreastCancer
Os atributos foram computados a partir de uma imagem
digitalizada de uma amostra de massa mamária[4]. A base de
dados é composta de 569 instâncias e 2 classes. Cada amostra
é um vetor de 30 dimensões. A classificação dos dados implica
em determinar a presença ou não de câncer nas imagens.
O gráfico indicado na Fig.4 apresenta o desempenho da
rede para os algoritmos k-means e Random. O hiperparâmetro
K foi variado entre 1 e 30. Observou-se um desempenho
acima de 90% para ambos os métodos. Comparativamente, o
Random obteve desempenho pouco superior. Possivelmente, o
desempenho do K-means poderia ser melhorado com um novo
mapeamento, que checasse clusters homogêneos próximos e
os unisse, além de identificar clusters heterogêneos visando a
separação.
B. Dataset Statlog
A base de dados Statlog é, assim como o BreastCancer,
binária. São 270 instâncias, cada uma com 20 atributos.
Plotamos o desempenho do modelo para o Statlog na Fig.5.
Nos dados de treinamento, observa-se, para ambos os métodos,
o aumento da acurácia média a medida que o número de
clusters aumenta. O k-means atinge os 85% de acurácia a
partir de 17 clusters, o random, a partir de 10 clusters. No
entanto, a comparação de desempenho com os dados de teste,
evidencia um overffiting, visto que o aumento de desempenho
nos dados de treinamento é acompanhado da diminuição da
acurácia nos dados de teste, a partir de 20 clusters.
Analisando o desempenho nos dados de treinamento, o K-
means apresenta um pico de desempenho entre 4 e 6 clusters,
logo em seguida é superado pelo random até os 20 neurônios,
quando o desempenho de ambos os modelos se aproxima e
decai.
Figure 5: Gráfico de Desempenho com barra de desvio para os
algoritmos K-means e Random aplicados no Statlog; Treina-
mento repetido 20 vezes
C. Dataset Iris
Essa base inclui três espécies iris: Iris setosa, Iris virginica
e Iris versicolor, com 50 amostras cada. Quatro atributos são
medidos para cadaamostra: o comprimento e a espessura da
sépala e da pétala. Como se trata de 3 classes distintas, é
necessário aplicar o mapeamento indicado na seção II. Dessa
forma, a rede neural terá dois perceptrons na camada de saı́da.
Plotamos o desempenho do modelo para inicialização a
partir do K-means e do Random na Fig.6. Observa-se um
desempenho inferior do algoritmo K-means, excetuando as
acurácias para k=3 e k=8.
Surpreendentemente, o algoritmo aleatório apresentou exce-
lente generalização, que é evidenciada pelas acurácias acima
de 90% nos dados de teste. O k-means, por outro lado,
apresentou bom desempenho para os dados de treinamento, e
queda das acurácias nos dados de teste a medida que o número
de clusters aumenta, indicando overfitting.
D. Dataset Wine
Essa base de dados é resultado da análise quı́mica de vinhos
produzidos na mesma região da Itália, porém provenientes de
diferentes platações. A análise determinou 13 constituintes
para cada um dos três tipos de vinhos. São no total 178
instâncias. Plotamos o desempenho do modelo da rede na
Fig.7. Nessa base de dados, o Random superou significati-
vamente o K-means. Os algoritmos se igualam para poucos
ROBERG et al.: HIGH-EFFICIENCY DIODE AND TRANSISTOR RECTIFIERS 5
Figure 6: Gráfico de Desempenho com barra de desvio para os
algoritmos K-means e Random aplicados no Iris; Treinamento
repetido 20 vezes
clusters, porém a partir de k=8, observa-se a melhoria das
acurácias de teste e de treinamento do Random, acompanhada
do decaimento do desempenho k-means.
Supõe-se que a sobreposição das classes, tenha gerado
muitos clusters heterogêneos que suprimiram o desempenho
do K-means.
Figure 7: Gráfico de Desempenho com barra de desvio para
os algoritmos K-means e Random aplicados no Wine; Treina-
mento repetido 20 vezes
E. Desempenho do Homogeneus Clustering (HC)
O desempenho do Homogeneus Clustering sobre as bases
de dados foi medido variando-se o bias e o hiperparâmetro
nclusters, o qual está associado a partição do cluster maior
no caso indicado na Fig.3(e). Construı́mos a tabela abaixo
explicitando o desempenho do modelo para os dados de teste.
Observou-se um baixo desempenho geral, exetuando-se as
cobinações dos hiperparâmetros (bias, ncluster) para o Statlog.
Supõe-se que o ajuste automático do número de centros im-
plementado pelo HC, tenha provocado um aumento demasiado
do fator k, levando a queda do desempenho.
(Bias/ncluster) (10, 4) (35, 2) (40, 20)
BreastCancer 0.66(3) 0.75(2) 0.60(2)
Statlog 0.50(8) 0.82(3) 0.83(2)
Iris 0.65(5) 0.65(7) 0.64(6)
Wine 0.51(9) 0.64(5) 0.65(4)
VI. CONCLUSÃO
O algoritmo aleatório Random, surpreendentemente, apre-
sentou as melhores acurácias em quase todas as bases de
dados. Alguns fatores podem ter afetado o desempenho do
K-means e do Homogeneus Clustering(HC). Por exemplo,
não foi implementado um método de extração de variáveis.
A motagem de uma matriz de correlação, poderia eliminar
atributos desnecessários, simplificando a base de dados e
evitando sopreposição, de forma que o K-means e o HC
pudessem escalar em desempenho. A introdução do K-means
como um dos métodos de split aplicados pelo algoritmo
HC, pode ter contribuido negativamente. O hiperparâmetro
ncluster, no caso indicado na Fig.3(e), parciona o cluster maior
em muitos grupos, criando, em demasia, clusters vizinhos de
mesma classe, o que se contrapõe a própria proposta do HC,
visualmente explicitada na Fig.2(b).
A determinação do raio no K-means, aparentemente não
repercutiu negativamente, porém, a implementação de novos
métodos para determinação dos raios poderia gerar melhores
resultados. Por exemplo, tomando-se o raio como a distância
euclidiana entre o ponto mais extremo e centro, tal como foi
aplicado na seleção de raios do HC.
Uma outra abordagem interessante, seria realizar um novo
mapeamento dos clusters após aplicado o K-means ou o HC,
identificando clusters homogêneos vizinhos e fundindo-os.
Isso poderia reduzir o parâmetro K e evitar overfitting.
REFERÊNCIAS BIBLIOGRÁFICAS
[1] A Supervised Clustering Algorithm for the Initialization
of RBF Neural Network Classifiers. (Hakan Cevikalp, Diane
Larlus, Frederic Jurie)
[2] Z. Uykan, C. Guzelis, M. E. Celebi, and H. N. Koivo,
“Analysis of input-output clustering for determining centers of
RBFN,” IEEE Trans. on Neural Networks, vol. 11, 2000
[3] Chris Bishop, Improving the Generalization Properties
of Radial Basis Function Neural Networks, Received 6 March
1991; accepted 18 April 1991.
6
APPENDIX
Algoritmo 1: RBF
i m p o r t numpy as np
i m p o r t pandas as pd
from s k l e a r n i m p o r t d a t a s e t s
from s k l e a r n . c l u s t e r i m p o r t KMeans
i m p o r t s e a b o r n as sbn
i m p o r t random
i m p o r t s e a b o r n as sbo
i m p o r t w a r n i n g s
i m p o r t s t a t i s t i c s
i m p o r t random
from s k l e a r n . c l u s t e r i m p o r t KMeans
from copy i m p o r t deepcopy
w a r n i n g s . f i l t e r w a r n i n g s ( ’ i g n o r e ’ )
i m p o r t m a t p l o t l i b . p y p l o t a s p l t
”””
1− dados de e n t r a d a n o r m a l i z a d o s e n t r e 0 e 1 ,
2− c e n t r o s a l o c a d o s no i n t e r i o r do h i p e r e s p a o d e f i n i d o p e l o s v e t o r e s de e n t r a d a .
3− r a i o s foram o b t i d o s a p a r t i r da d i s t n c i a m d i a e n t r e os p o n t o s a s s o c i a d o s a cada c e n t r o .
4− p a r c i o n a r o h i p e r e s p a o de e n t r a d a em c l u t e r s de ac o rd o com a p r o x i m i d a d e de cada c e n t r o .
”””
c l a s s Neuron :
d e f i n i t ( s e l f , c e n t e r , r a d i u s ) :
s e l f . c e n t e r = c e n t e r
s e l f . r a d i u s = r a d i u s
d e f a c t i v a t i o n ( s e l f , u ) :
i f s e l f . r a d i u s == 0 :
r e t u r n 0
r a d i u s = s e l f . r a d i u s
r e t u r n np . exp ( − 0 . 5 * ( 1 / ( r a d i u s **2) ) * ( u **2) )
d e f g e t o u t p u t ( s e l f , X) :
”””
r e t o r n a uma l i s t a c o n t e n d o um o u t p u t p a r a cada
x de e n t r a d a
”””
c e n t e r = np . a r r a y ( s e l f . c e n t e r )
s i z e = l e n (X)
o u t p u t = [ ]
f o r x i n X:
x = np . a r r a y ( x )
u = np . l i n a l g . norm ( x − c e n t e r )
o u t p u t . append ( s e l f . a c t i v a t i o n ( u ) )
r e t u r n np . a r r a y ( o u t p u t ) . r e s h a p e ( s i z e , 1 )
c l a s s RBF :
”””
k : n m e r o de n e u r n i o s na camada e s c o n d i d a ,
nd imens ion : d i m e n s o do v e t o r de e n t r a d a ,
X: v e t o r 2d dados de e n t r a d a n o r m a l i z a d o s e n t r e 0 e 1 ,
”””
d e f i n i t ( s e l f ) :
s e l f . k = None
s e l f . nd imens ion = None
s e l f . n e u r o n s = None
s e l f .w = None
s e l f . c e n t e r s = None
s e l f . h c b i a s = None
d e f g e t r a d i u s ( s e l f , X, l a b e l s ) :
”””
Os r a i o s a s s o c i a d o s a cada c e n t r o foram d e t e r m i n a d o s
p e l a d e s v i o p a d r o da d i s t n c i a e n t r e os p o n t o s de
cada c l u s t e r e seu r e s p e c t i v o c e n t r o .
”””
c e n t e r s = s e l f . c e n t e r s
c l u s t e r s s i z e s = [ l a b e l s . c o u n t ( l a b e l ) f o r l a b e l i n r a n g e ( s e l f . k ) ]
c l u s t e r s r a d i u s = [0 f o r i i n r a n g e ( s e l f . k ) ]
f o r x , l a b e l i n z i p (X, l a b e l s ) :
7
c l u s t e r s r a d i u s [ l a b e l ] += ( np . l i n a l g . norm ( np . a r r a y ( x ) − c e n t e r s [ l a b e l ] ) ) **2 / c l u s t e r s s i z e s [
↪→ l a b e l ]
r e t u r n np . s q r t ( c l u s t e r s r a d i u s )
d e f t r a i n ( s e l f , X, Y, a l g o r i t h m , b i a s h c =None , n c l u s t e r s =None , k=None ) :
# s e l f . c e n t e r s uma l i s t a de a r r a y s numpy
# cada c e n t r o uma a r r a y numpy
X arr = np . a r r a y (X)
sample s = l e n (X)
s e l f . nd imens ion = l e n (X[ 0 ] )
i f a l g o r i t h m == ’ random ’ :
i n d e x s = np . random . r a n d i n t ( low =0 , h igh = samples, s i z e =( k , 2 ) )
c e n t e r s = [ ( X arr [ i 1 ]+ X arr [ i 2 ] ) * ( 0 . 5 ) f o r ( i1 , i 2 ) i n i n d e x s ]
s e l f . c e n t e r s = c e n t e r s
s e l f . k = k
r a d i u s = [ np . l i n a l g . norm ( X arr [ i 1 ] − X arr [ i 2 ] ) f o r ( i1 , i 2 ) i n i n d e x s ]
i f a l g o r i t h m == ’ kmeans ’ :
km = KMeans ( n c l u s t e r s =k )
km . f i t (X)
c e n t e r s = [ l i s t ( c e n t e r ) f o r c e n t e r i n km . c l u s t e r c e n t e r s ]
s e l f . c e n t e r s = c e n t e r s
s e l f . k = k
l a b e l s = l i s t (km . l a b e l s )
r a d i u s = s e l f . g e t r a d i u s (X, l a b e l s )
i f a l g o r i t h m == ’ hc ’ :
hc = HC( X t r a i n , Y t r a i n )
hc . c l u s t e r i n g ( b i a s h c , n c l u s t e r s )
s e l f . b i a s h c = b i a s h c
c e n t e r s , r a d i u s = [ ] , [ ]
f o r c l u s t e r i n hc . c l u s t e r s :
c e n t e r s . append ( c l u s t e r . c e n t e r )
r a d i u s . append ( c l u s t e r . w id th )
n e u r o n s = [ Neuron ( c e n t e r , r ) f o r c e n t e r , r i n z i p ( c e n t e r s , r a d i u s ) ]
s i z e = l e n (X)
H = np . ones ( ( s i z e , 1 ) )
f o r neuron i n r e v e r s e d ( n e u r o n s ) :
o u t p u t = neuron . g e t o u t p u t (X)
H = np . c o n c a t e n a t e ( ( o u t p u t , H) , a x i s =1)
H = np . nan to num (H)
pseudo H = np . l i n a l g . p inv (H)
Y = np . a r r a y (Y)
#W, * = np . l i n a l g . l s t s q (H, Y t r a i n )
W = np . d o t ( pseudo H , Y t r a i n )
W = np . nan to num (W)
s e l f . n e u r o n s = n e u r o n s
s e l f .w = W
r e t u r n W
d e f c l a s s i f y ( s e l f , X, neurons , c l a s s e s ) :
s i z e = l e n (X)
H = np . ones ( ( s i z e , 1 ) )
f o r neuron i n r e v e r s e d ( n e u r o n s ) :
o u t p u t = neuron . g e t o u t p u t (X)
H = np . c o n c a t e n a t e ( ( o u t p u t , H) , a x i s =1)
i f c l a s s e s == 2 :
Y aprox = np . d o t (H, s e l f .w)
r e t u r n [1 i f y>= 0 . 5 e l s e 0 f o r y i n Y aprox ]
i f c l a s s e s == 3 :
8
Y aprox = np . d o t (H, s e l f .w)
Y a p r o x l i s t = [ l i s t ( y ) f o r y i n Y aprox ]
Y p r e d i c t = [ ]
f o r y i n Y a p r o x l i s t :
i f y [ 0 ] <=0.5 and y [ 1 ] <=0.5:
Y p r e d i c t . append ( [ 0 , 0 ] )
e l i f y [ 0 ] > 0 . 5 and y [ 1 ] > 0 . 5 :
Y p r e d i c t . append ( [ 1 , 1 ] )
e l s e :
Y p r e d i c t . append ( [ 1 , 0 ] )
r e t u r n Y p r e d i c t
d e f a c u r a c i a ( s e l f , Y p , Y) :
s i z e = l e n (Y)
a c e r t o s = 0
f o r y p , y i n z i p ( Y p , Y) :
i f y p == y :
a c e r t o s += 1
r e t u r n a c e r t o s / s i z e
Algoritmo 2: Homogeneus Clustering (HC)
c l a s s C l u s t e r :
”””
Modelo de c l u s t e r em um h i p e r e s p a o .
( wid th ) d i s t n c i a e n t r e o pon to mais d i s t a n t e e o c e n t r o do c l u s t e r
( c e n t e r ) m d i a e n t r e os p o n t o s p e r t e n c e n t e s ao c l u s t e r
”””
d e f i n i t ( s e l f , X, i n d e x s ) :
s e l f . c e n t e r = None
s e l f . w id th = None
s e l f . p o i n t s = None
s e l f . i n d e x s = i n d e x s
# E s p e c i f i c a n d o p r o p r i e d a d e s do c l u s t e r
s e l f . g e t p o i n t s (X, i n d e x s )
s e l f . g e t c e n t e r ( )
s e l f . g e t w i d t h ( )
d e f g e t p o i n t s ( s e l f , X, i n d e x s ) :
# Armazena os p o n t o s p e r t e n c e n t e s ao c l u s t e r
s e l f . p o i n t s = [X[ i ] f o r i i n i n d e x s ]
d e f g e t c e n t e r ( s e l f ) :
# C a l c u l a o h i p e r c e n t r o a s s o c i a d o ao c l u s t e r
s e l f . c e n t e r = np . mean ( np . a r r a y ( s e l f . p o i n t s ) , a x i s =0)
d e f g e t w i d t h ( s e l f ) :
# C a l c u l a o r a i o do c l u s t e r
d i s t a n c e s = np . a r r a y ( [ np . l i n a l g . norm ( np . a r r a y ( p o i n t ) − s e l f . c e n t e r ) f o r p o i n t i n s e l f . p o i n t s ] )
s e l f . w id th = np . max ( d i s t a n c e s )
c l a s s HC:
”””
Modelo de c l u s t e r i n g u t i l i z a n d o o a l g o r i t i m o deos c l u s t e r s
h o m o g n e o s i n d i c a d o s no a r t i g o −−− R e f e r n c i a −−−
Cada l i s t a ( s e l f . l a b e l s ) d e f i n e uma c o n f i g u r a o do s i s t e m a ( c l u s t e r s , c e n t e r s , w i d t h s )
”””
d e f i n i t ( s e l f , X, Y) :
# l a b e l i n i c i a l
s e l f . l a b e l s = Y
# Dados de e n t r a d a
s e l f .X = X
# C o n f i g u r a o i n i c i a l
s e l f . c l u s t e r s = [ ]
s e l f . d i s t a n c e s m e a n = None
# F lag do s i s t e m a
s e l f . f l a g = True
9
d e f g e t c l u s t e r s ( s e l f ) :
”””
D ef in e o e s t a d o do s i s t e m a com base
no a t r i b u t o no a t r i b u t o s e l f . l a b e l s
”””
s e l f . c l u s t e r s = [ ]
c l u s t e r s i n d e x s = [ ]
# l a b e l s p o s s v e i s
l a b e l s s e t = s e t ( s e l f . l a b e l s )
# I d e n t i f i c a n d o i n d e x s de cada c l u s t e r
f o r l a b e l i n l a b e l s s e t :
c l u s t e r i n d e x = [ i f o r i , l b l i n enumera t e ( s e l f . l a b e l s ) i f l b l == l a b e l ]
c l u s t e r s i n d e x s . append ( c l u s t e r i n d e x )
# I n i c i a l i z a n d o C l u s t e r s
f o r i n d e x s i n c l u s t e r s i n d e x s :
c l u s t e r = C l u s t e r ( s e l f . X, i n d e x s )
s e l f . c l u s t e r s . append ( c l u s t e r )
d e f g e t d i s t a n c e s m e a n ( s e l f ) :
”””
C a l c u l a n d o m a t r i z t r a i n g u l a r de d i s t n i c i a s e n t r e t o d o s os c e n t r o s
da c o n f i g u r a o ( s e l f . l a b e l s / s e l f . c l s u t e r s ) a t u a l do s i s t e m a
”””
d i s t a n c e s m e a n = [ ]
f o r i , c l u s t e r l i n enumera t e ( s e l f . c l u s t e r s ) :
d i s t a n c e s l = [ ]
f o r j , c l u s t e r c i n enumera t e ( s e l f . c l u s t e r s ) :
# M a t r i z t r i a n g u l a r
i f i >= j :
d i s t a n c e s l . append ( 0 )
c o n t i n u e
d i s t a n c e s l . append ( np . l i n a l g . norm ( np . a r r a y ( c l u s t e r l . c e n t e r ) − np . a r r a y ( c l u s t e r c . c e n t e r ) ) )
d i s t a n c e s m e a n . append ( d i s t a n c e s l )
s e l f . d i s t a n c e s m e a n = d i s t a n c e s m e a n
d e f r e l a b e l ( s e l f , b i a s , n c l u s t e r s =4) :
”””
M o d i f i c a l a b e l c o r r e n t e com base na r e l a o e n t r e d i s t a n c e s m e a n e
w i d t h s dos c l u s t e r s .
”””
s e l f . f l a g = F a l s e
n = l e n ( s e l f . c l u s t e r s )
f o r i i n r a n g e ( n ) :
f o r j i n r a n g e ( n ) :
i f i >= j :
c o n t i n u e
d i s t a n c e m e a n = np . a r r a y ( s e l f . d i s t a n c e s m e a n ) [ i , j ]
# Par de c l u s t e r s em a n l i s e
c l u s t e r l = s e l f . c l u s t e r s [ i ]
w l i ne = c l u s t e r l . w id th
c l u s t e r c = s e l f . c l u s t e r s [ j ]
w col = c l u s t e r c . w id th
# I n t e r s e c t i o n
i f ( d i s t a n c e m e a n < ( w l i ne + w col ) ) and ( abs ( w l i ne − w col ) < d i s t a n c e m e a n ) :
s e l f . i n t e r s e c ( c l u s t e r l , c l u s t e r c , b i a s )
# Um c l u s t e r e n g l o b a o o u t r o
i f ( d i s t a n c e m e a n < ( w l i ne + w col ) ) and ( abs ( w l i ne − w col ) >= d i s t a n c e m e a n ) :
i f w l i ne > w col and ( l e n ( c l u s t e r c . p o i n t s ) > b i a s ) :
s e l f . r e l a b e l o n e i n ( c l u s t e r l , n c l u s t e r s )
e l i f w col > w l i ne and ( l e n ( c l u s t e r l . p o i n t s ) > b i a s ) :
s e l f . r e l a b e l o n e i n ( c l u s t e r c , n c l u s t e r s )
d e f r e l a b e l o n e i n ( s e l f , c l u s t e r , n c l u s t e r s ) :
”””
10
A t u a l i z a n d o o e s t a d o do s i s t e m a ( s e l f . l a b e l s ) ao p a r c i o n a r o c l u s t e r de maior wid th
”””
km = KMeans ( n c l u s t e r s )
km . f i t ( c l u s t e r . p o i n t s )
l a b e l s = km . l a b e l s
max labe l = np . max ( s e l f . l ab e l s )
f o r i , i n d e x i n enumera t e ( c l u s t e r . i n d e x s ) :
i f l a b e l s [ i ] == 0 :
c o n t i n u e
e l s e :
s e l f . l a b e l s [ i n d e x ] = ( l a b e l s [ i ] + max labe l )
s e l f . f l a g = True
d e f i n t e r s e c ( s e l f , c l u s t e r l , c l u s t e r c , b i a s ) :
i n d e x s o u t l = s e l f . g e t o u t p o i n t s ( c l u s t e r l , c l u s t e r c )
i n d e x s o u t c = s e l f . g e t o u t p o i n t s ( c l u s t e r c , c l u s t e r l )
i f l e n ( i n d e x s o u t l ) > b i a s :
s e l f . u p d a t e l a b e l ( i n d e x s o u t l )
s e l f . f l a g = True
i f l e n ( i n d e x s o u t c ) > b i a s :
s e l f . u p d a t e l a b e l ( i n d e x s o u t c )
s e l f . f l a g = True
d e f g e t o u t p o i n t s ( s e l f , m a i n c l u s t e r , r i v a l c l u s t e r ) :
”””
I d e n t i f i c a n d o p o n t o s mais p r x i m o s do c l u s t e r r i v a l
”””
i n d e x s o u t = [ ]
f o r p o i n t , i i n z i p ( m a i n c l u s t e r . p o i n t s , m a i n c l u s t e r . i n d e x s ) :
i f np . l i n a l g . norm ( p o i n t − m a i n c l u s t e r . c e n t e r ) > np . l i n a l g . norm ( p o i n t − r i v a l c l u s t e r . c e n t e r ) :
# i n d e x s em X
i n d e x s o u t . append ( i )
r e t u r n i n d e x s o u t
d e f u p d a t e l a b e l ( s e l f , i n d e x s o u t ) :
max labe l = np . max ( s e l f . l a b e l s )
f o r i n d e x i n i n d e x s o u t :
s e l f . l a b e l s [ i n d e x ] = max labe l +1
d e f c l u s t e r i n g ( s e l f , b i a s , n c l u s t e r s ) :
s e l f . g e t c l u s t e r s ( )
s e l f . g e t d i s t a n c e s m e a n ( )
w h i l e s e l f . f l a g :
s e l f . r e l a b e l ( b i a s , n c l u s t e r s )
s e l f . g e t c l u s t e r s ( )
s e l f . g e t d i s t a n c e s m e a n ( )
Algoritmo 3: Funções Auxiliares
d e f n o r m a l i z e f e a t u r e s (X, min , max ) :
X normal ize = [ ]
f o r x i n X:
x n o r m a l i z e = ( x−min ) / ( max−min )
X normal ize . append ( x n o r m a l i z e )
r e t u r n X normal ize
d e f m a k e t r a i n t e s t d a t a (X, Y) :
Y = l i s t ( d f [ ’ t a r g e t ’ ] )
Y new = [ ]
f o r y i n Y:
i f y == 1 :
Y new . append ( [ 1 , 0 ] )
i f y == 0 :
Y new . append ( [ 0 , 0 ] )
i f y == 2 :
Y new . append ( [ 1 , 1 ] )
i n d e x s = [ i n d e x f o r i n d e x i n r a n g e ( l e n (X) ) ]
i n d e x s t r a i n = random . sample ( indexs , i n t ( 0 . 7 * l e n ( i n d e x s ) ) )
11
i n d e x s t e s t = [ i n d e x f o r i n d e x i n i n d e x s i f i n d e x n o t i n i n d e x s t r a i n ]
X t r a i n = [ l i s t (X[ i n d e x ] ) f o r i n d e x i n i n d e x s t r a i n ]
X t e s t = [ l i s t (X[ i n d e x ] ) f o r i n d e x i n i n d e x s t e s t ]
Y t r a i n = [ Y new [ i n d e x ] f o r i n d e x i n i n d e x s t r a i n ]
Y t e s t = [ Y new [ i n d e x ] f o r i n d e x i n i n d e x s t e s t ]
r e t u r n X t r a i n , Y t r a i n , X te s t , Y t e s t
d e f norm ( d f i n p u t ) :
r e t u r n ( d f − df . min ( ) ) / ( d f . max ( ) − d f . min ( ) )
Algoritmo 4: Estatı́stica
c l a s s S t a t s :
d e f i n i t ( s e l f ) :
s e l f . a c r s t e s t = [ ]
s e l f . a c r s t r a i n = [ ]
s e l f . s t d v s t e s t = [ ]
s e l f . s t d v s t r a i n = [ ]
s e l f . ks = None
d e f g e t a c u r a c i a s ( s e l f , X, Y, X tes t , Y te s t , t imes , k , c l a s s e s ) :
nd imens ion = l e n (X[ 0 ] )
a c r s t e s t r a n d o m , a c r s t r a i n r a n d o m , a c r s t e s t k m , a c r s t r a i n k m = [ ] , [ ] , [ ] , [ ]
f o r i i n r a n g e ( t i m e s ) :
r b f = RBF( k , nd imens ion = nd imens ion )
r b f . t r a i n (X, Y, True )
Y p t e s t = r b f . c l a s s i f y ( X te s t , r b f . neurons , c l a s s e s )
Y p t r a i n = r b f . c l a s s i f y (X, r b f . neurons , c l a s s e s )
a c r s t e s t r a n d o m . append ( r b f . a c u r a c i a ( Yp tes t , Y t e s t ) )
a c r s t r a i n r a n d o m . append ( r b f . a c u r a c i a ( Yp t r a in , Y) )
r b f . t r a i n (X, Y, F a l s e )
Y p t e s t = r b f . c l a s s i f y ( X te s t , r b f . neurons , c l a s s e s )
Y p t r a i n = r b f . c l a s s i f y (X, r b f . neurons , c l a s s e s )
a c r s t e s t k m . append ( r b f . a c u r a c i a ( Yp tes t , Y t e s t ) )
a c r s t r a i n k m . append ( r b f . a c u r a c i a ( Yp t r a in , Y) )
s e l f . a c r s t e s t . append ( [ s e l f . mean ( a c r s t e s t r a n d o m ) , s e l f . mean ( a c r s t e s t k m ) ] )
s e l f . a c r s t r a i n . append ( [ s e l f . mean ( a c r s t r a i n r a n d o m ) , s e l f . mean ( a c r s t r a i n k m ) ] )
s e l f . s t d v s t e s t . append ( [ s e l f . s t d v ( a c r s t e s t r a n d o m ) , s e l f . s t d v ( a c r s t e s t k m ) ] )
s e l f . s t d v s t r a i n . append ( [ s e l f . s t d v ( a c r s t r a i n r a n d o m ) , s e l f . s t d v ( a c r s t r a i n k m ) ] )
d e f t r a i n f o r k c l u s t e r s ( s e l f , X, Y, X tes t , Y te s t , t imes , ks = [ 1 , 5 , 10 , 15 , 20 , 25 , 30 , 50 , 1 0 0 ] ,
↪→ c l a s s e s =2) :
s e l f . ks = ks
f o r k i n ks :
s e l f . g e t a c u r a c i a s (X, Y, X tes t , Y te s t , t imes , k , c l a s s e s )
d e f s t d v ( s e l f , a c r s ) :
r e t u r n s t a t i s t i c s . s t d e v ( a c r s )
d e f mean ( s e l f , a c r s ) :
r e t u r n s t a t i s t i c s . mean ( a c r s )
d e f view ( s e l f , t i t l e ) :
s e l f . a c r s t e s t = np . a r r a y ( s e l f . a c r s t e s t )
s e l f . a c r s t r a i n = np . a r r a y ( s e l f . a c r s t r a i n )
s e l f . s t d v s t e s t = np . a r r a y ( s e l f . s t d v s t e s t )
s e l f . s t d v s t r a i n = np . a r r a y ( s e l f . s t d v s t r a i n )
sbn . a x e s s t y l e ( )
sbn . s e t s t y l e ( ” d a r k g r i d ” , {” axes . f a c e c o l o r ” : ” . 9 ” } )
f i g = p l t . f i g u r e ( )
p l t . e r r o r b a r ( s e l f . ks , s e l f . a c r s t r a i n [ : , 0 ] , y e r r = s e l f . s t d v s t r a i n [ : , 0 ] , l s = ”None” , c o l o r =
↪→ ( 0 , 0 , 0 . 6 , 0 . 2 ) )
p l t . p l o t ( s e l f . ks , s e l f . a c r s t r a i n [ : , 0 ] , marker = ” h ” , c o l o r = ( 0 , 0 , 0 . 6 ) , l a b e l =” Tra in −random ” )
12
p l t . e r r o r b a r ( s e l f . ks , s e l f . a c r s t e s t [ : , 0 ] , y e r r = s e l f . s t d v s t e s t [ : , 0 ] , l s = ”None” , c o l o r =
↪→ ( 0 . 6 , 0 , 0 , 0 . 2 ) )
p l t . p l o t ( s e l f . ks , s e l f . a c r s t e s t [ : , 0 ] , marker = ” h ” , c o l o r = ( 0 . 6 , 0 , 0 ) , l a b e l =” Tes t −random ” )
p l t . e r r o r b a r ( s e l f . ks , s e l f . a c r s t r a i n [ : , 1 ] , y e r r = s e l f . s t d v s t r a i n [ : , 1 ] , l s = ”None” , c o l o r =
↪→ ( 0 , 0 . 6 , 0 . 6 , 0 . 2 ) )
p l t . p l o t ( s e l f . ks , s e l f . a c r s t r a i n [ : , 1 ] , marker = ” h ” , c o l o r = ( 0 , 0 . 6 , 0 . 6 ) , l a b e l =” Tra in −Kmeans” )
p l t . e r r o r b a r ( s e l f . ks , s e l f . a c r s t e s t [ : , 1 ] , y e r r = s e l f . s t d v s t e s t [ : , 1 ] , l s = ”None” , c o l o r =
↪→ ( 0 . 6 , 0 . 6 , 0 , 0 . 2 ) )
p l t . p l o t ( s e l f . ks , s e l f . a c r s t e s t [ : , 1 ] , marker = ” h ” , c o l o r = ( 0 . 6 , 0 . 6 , 0 ) , l a b e l =” Tes t −Kmeans” )
p l t . t i t l e ( f ” A c u r c i a s m d i a s p a r a t r e i n a m e n t o com K c l u s t e r s r e p e t i d o 20 v e z e s ({ t i t l e } ) ” ,
↪→ f o n t s i z e =16)
p l t . x l a b e l ( ”K c l u s t e r s na camada e s c o n d i d a ” , f o n t s i z e =16)
p l t . y l a b e l ( ” A c u r c i a s Medias ” , f o n t s i z e =16)
p l t . l e g e n d ( f o n t s i z e = 16)
f i g . s e t s i z e i n c h e s ( 1 4 . 5 , 8 . 5 , f o r w a r d =True )
# f i g . s u b p l o t s a d j u s t ( l e f t = 0 . 0 , bot tom = 0 . 1 , r i g h t = 1 . 0 , t o p = 0 . 9 , wspace = 0 . 2 , h sp a ce = 0 . 2 )
f i g
p l t . show ( )
	Introdução
	Revisão de Literatura
	DetalhesTécnicos para a Implementação da Rede Neural
	Algoritmos de Inicialização
	Algoritmo Random
	Algoritmo k-means
	Algoritmo Homogeneous Clustering (HC)
	Resultados
	Dataset BreastCancer
	Dataset Statlog
	Dataset Iris
	Dataset Wine
	Desempenho do Homogeneus Clustering (HC)
	Conclusão
	Appendix