Self Organizing Maps - Redes de Kohonen 1. Redes auto organizáveis Existe uma classe de redes neurais artificias que possuem a capacidade de auto organização, sendo por isto chamadas de redes auto organizáveis. A principal característica das redes auto organizáveis refere-se ao processo de aprendizado, que ocorre através do treinamento não supervisionado: a própria estrutura da rede é responsável pelo ajuste dos parâmetros que determinam o aprendizado da rede com relação ao problema em questão. As redes ( mapas ) SOM (Self Organizing Maps) e ART (Adaptive Resonance Theory) são modelos com tal capacidade. 1.1 Redes SOM (Self Organizing Maps) As redes SOM (Self Organizing Maps) foram desenvolvidas por Teuvo Kohonen professor da Faculdade de Ciência da Informação da Universidade de Helsinqui (Finlândia) na década de 80. Em vários trabalhos estas redes são chamadas de redes de Kohonen, o que pode provocar confusão, uma vez que Kohonen também propôs outros modelos de redes neurais. As redes SOM possuem forte inspiração neurofisiológica. Baseiam-se no mapa topológico presente no córtex cerebral. 1
Sabe-se que o cérebro dos animais mais sofisticados possui áreas responsáveis por funções específicas. Existem áreas dedicadas à fala, à visão, ao controle motor, à sensibilidade ao toque, etc. Cada uma dessas áreas contém subáreas. Cada subárea mapeia internamente respostas do órgão sensorial representado por ela. Por exemplo: Córtex auditivo: o mapeamento reflete as diferentes frequências sonoras. Córtex visual: o mapeamento é definido pelas características visuais primitivas, como intensidade de luz, orientação e curvatura de linhas. Observa-se que os neurônios estão espacialmente ordenados dentro destas áreas e, assim, neurônios topologicamente mais próximos tendem a responder a padrões ou estímulos de forma semelhante. Tal ordenação topológica é resultado do uso de feedback lateral entre as células do córtex cerebral. Este feedback lateral é geralmente modelado em redes neurais por uma função conhecida como chapéu mexicano. 2
Segundo a função chapéu mexicano, cada neurônio influencia o estado de ativação de seus neurônios vizinhos de três formas possíveis: excitatória (região R1), inibitória (região R2) e levemente excitatória (região R3) 1.1.1 Funcionamento básico da rede SOM A estrutura básica de uma rede SOM apresenta apenas duas camadas: a camada input e a camada output, esta última representada normalmente como um grid bidimensional. Os nodos da camada input se ligam a todos os nodos da camada ouptut. Os nodos da camada output estão, por sua vez, ligados entre si ao seus vizinhos geograficamente adjacentes. Um padrão p de entrada é apresentado à rede (via camada input). A rede procura a unidade (neurônio) da camada output mais parecida com p. Durante o treinamento, a rede aumenta a semelhança do nodo (neurônio) escolhido e seus vizinhos em relação ao padrão p. 3
Assim, a rede constrói um mapa topológico onde nodos topologicamente mais próximos respondem de forma semelhante a padrões de entrada semelhante. O algoritmo de aprendizado da rede é competitivo: os nodos (neurônios) da camada output competem entre si para serem ativados, ou seja, para ver quem gera o maior valor de saída (resposta) ao padrão p apresentado. 4
2. Clusterização utilizando mapas de Kohonen (Revista InfoGeo Ano 2 N o 6 março/abril 1999 pág 34-36 Segmentação com mapas neurais de Kohonen por Francisco Aranha) Em essência, redes neurais são uma tecnologia de processamento de informações que se inspira no funcionamento do cérebro humano. Apresentadas a uma série de estímulos (os dados a analisar) as redes neurais os organizam e aprendem a reconhecer padrões e fazer previsões. Se as redes neurais recebem informações sobre a magnitude e direção dos erros que cometem na análise, aperfeiçoam seu conhecimento, melhorando as respostas seguintes. 5
Em particular, as redes de Kohonen apresentam uma estrutura de rede em duas camadas distintas de neurônios: uma camada de entrada (camada input ) por onde se apresenta o padrão para a rede e uma camada de processamento (camada kohonen ), onde se forma o mapa (resultado da classificação dos padrões apresentados). Os neurônios da camada input se ligam a todos os neurônios da camada kohonen. Cada neurônio da camada kohonen está diretamente ligado aos seus neurônios diretamente adjacentes. O funcionamento básico do mapa de Kohonen assim se processa: Um padrão p 1 é apresentado à rede, através da camada input. Os neurônios da camada input transmitem estes estímulos aos neurônios da camada de processamento kohonen. O neurônio N i da camada kohonen que reagir mais fortemente aos estímulos do padrão p 1 ganha-o para si. Além disso, reforça suas ligações com os vizinhos mais próximos, sensibilizando-os um pouco mais em relação às características do padrão p 1. 6
Na próxima oportunidade, quando um padrão p k parecido com p 1 for apresentado ao mapa de Kohonen, toda a vizinhança de N i reagirá um pouco mais intensamente em relação às outras áreas do mapa. Cada nova apresentação de um padrão p r à rede faz com que o perfil de sensibilidade dos neurônios da camada kohonen vá se alterando: isto é o que chamamos treinamento da rede. A medida em que o número de padrões de treinamento vai aumentando, as alterações dos neurônios vão gradualmente se reduzindo, até que a configuração do mapa (camada kohonen) converge para uma disposição estável. Dizemos então que o mapa de Kohonen aprendeu a classificar. 7
2.1 Ideias da rede SOM Considere uma pessoa e o seu (virtualmente infinito) vetor de atributos : Considere, que uma determinada livraria gostaria de classificar sua clientela de acordo com apenas duas características (variáveis): sexo e gênero literário de interesse: 8
Usando um mapa de Kohonen para classificar (clusterizar) os clientes: 9
10
11
Após o treinamento da rede (apresentação de todos os padrões à rede), são formados grupos (clusters) de perfis de clientes... 12
2.2 Como funciona o aprendizado da rede SOM? O truque principal de funcionamento da rede SOM está no vetor de pesos... O vetor de pesos liga todos os atributos do padrão (ou seja, toda camada imput) a todos os neurônios da camada output... Assim, o vetor de pesos armazena vários moldes (vários padrões) de entrada de dados... 13
2.3 Como vai surgir o neurônio vencedor (winner neuron)? O primeiro passo do algoritmo de treinamento da rede SOM é inicializar aleatoriamente o vetor de pesos Para simplificar o entendimento e facilitar a visualização, na rede de Kohonem abaixo estamos mostrando apenas os vetores de dois distintos neurônios inicializados aleatoriamente... Denominamos os neurônios de A e B (para fins didáticos OK?)... No exemplo acima, suponha que ao inicializar o vetor de peso de todos os neurônios da camada Kohonen, o neurônio A inicializou com (67,58) e o neurônio B inicializou com (22,31) Agora vamos apresentar um padrão P para a rede SOM. O procedimento consiste em verificar qual dentre todos os neurônios é o molde mais parecido com o padrão apresentado... Lembre-se que no exemplo acima, 14
para fins didáticos vamos analisar apenas os moldes dos neurônios A e B... mas na prática se analisam todos os neurônios... Qual vai ser o neurônio vencedor? Resposta: aquele que apresentar menor distância euclideana!!! 15
No exemplo acima o neurônio A venceu o neurônio B, pois o seu molde (vetor de pesos) e mais parecido com o padrão P do que o molde do neurônio B Aí o neurônio vencedor sensibiliza o vetor de pesos de seus neurônios vizinhos para apresentarem moldes (vetor de pesos) similares ao padrão P. Ou seja, ocorre ajuste de pesos nos neurônios vizinhos!!!! 16
Outro exemplo: se apresentarmos o padrão P(30,40), considerando-se ainda apenas os neurônios A e B, então o vencedor seria B... veja abaixo... Qual vai ser o neurônio vencedor? Resposta: aquele que apresentar menor distância euclideana!!! 17
No exemplo acima o neurônio B venceu o neurônio A, pois o seu molde (vetor de pesos) e mais parecido com o padrão P do que o molde do neurônio A 18
2.4 Ao final do treinamento da rede SOM... 19
2.5 - Exemplo 1 Entendendo SOM Vamos construir um mapa de Kohonen para classificar (agrupar clusterizar) as 14 cidades A, B, C,... N de acordo com o perfil de consumo per capita mensal de laranja e de limão dos habitantes destas cidades. Veja a tabela abaixo: Visualmente podemos notar que existem 3 (ou 4) perfis (padrões) de cidade com relação ao consumo per capita mensal de laranja e de limão. Concorda com isso ou não? Vamos ver como o mapa de Kohonen irá classificar... Obs.: segue anexo o script de execução para treinamento de um mapa de Kohonen para os dados do exemplo usando o software R 20
Vamos usar o software R para executar o algoritmo desta rede SOM. O primeiro passo é normalizar os dados... Uma das razões para normalizar/padronizar os dados deve-se ao fato de termos os atributos dos padrões em unidades de medida distintas e, às vezes, com escalas bem discrepantes entre si. Como exemplos de atributos do padrão podemos ter o peso, idade, valor do lucro, número de dependentes, valor da aplicação financeira, quantidade de leite produzida, salário, sexo, gênero literário, número de filiais, etc, etc... Por isso normalizamos os dados... No exemplo foram realizados 3 tipos de normalização (N1, N2 e N3) e foi escolhida a normalização N3, com base na normalização N2. 21
Normalização de dados uma forma (no exemplo denominada normalização N1) Veja uma forma de normalização de dados através de um exemplo: 22
Normalização de dados outra forma (no exemplo denominada normalização N2) Padronização da variável Veja uma forma de normalização de dados através de um exemplo: Vamos padronizar as variáveis Altura e Peso usando o escore Z: 23
Veja por exemplo a padronização da altura e do peso do indivíduo A Então as variáveis Altura e Peso ficam padronizadas assim: Observe também que toda variável padronizada apresenta média 0 e desvio padrão 1 24
25
Normalização de dados Mais uma outra forma (no exemplo denominada normalização N3) Vamos partir da normalização N2 e calcular a normalização N3... Note que os valores normalizados pela normalização N3 pertencem ao intervalo [0,1] (veja o eixo dos Y da função em formato S (função sigmoidal) Veja o exemplo abaixo 26
A Normalização N2 (é a padronização das variáveis...) veja abaixo o exemplo para a cidade A E agora veja a normalização N3 para a cidade A: 27
Observe os dados normalizados (calculados no ambiente do R) A execução do algoritmo SOM no ambiente do R exige que selecionemos apenas os campos que serão usados para classificação. No caso selecionamos apenas os campos normalizados no formato N3, ou seja, os campos LARANJA_N3 e LIMAO_N3. 28
E vamos alimentar /treinar a rede SOM com os padrões normalizados em formato N3... OK? Então executaremos o algoritmo numa camada (mapa) de dimensão 3 X 3 Pronto... diversos resultados são gerados... 29
2.5.1 Resultado: mapa de treinamento do vetor de pesos 30
2.5.2 Resultado: Total de padrões alocados pelos neurônios da rede 31
2.5.3 Resultado: Padrões alocados nos neurônios 32
2.5.4 Resultado: O vetor de pesos dos neurônios e o mapa do vetor de pesos (code vector) 33
34
2.5.5 Resultado: Cálculo da distância euclideana de um determinado padrão a um determinado neurônio. Um exemplo: 35
2.5.6 Resultado: Mapa de calor por variável 36
37
APÊNDICE I Teste o script em R com o seguinte arquivo: koh_exemplo01.csv CIDADE;LARANJA;LIMAO A;20;20 B;34;34 C;50;50 D;35;55 E;11;31 F;12;10 G;25;11 H;200;200 I;220;220 J;240;240 K;101;103 L;110;90 M;114;103 N;109;112 script em R: R_koh_Exemplo01.R #---> Obs.: para executar este script copie o comando abaixo e execute-o no ambiente do R ##### source("c:/estatistica/kohonen/r_koh_exemplo01.r") #--------------------------------------------------------------------------------------------- # Pegar o diretório atual... initial.dir<-getwd() #--------------------------------------------------------------------------------------------- # Mudar para o diretório de trabalho... setwd("c:/estatistica/kohonen") #--------------------------------------------------------------------------------------------- # Carregar eventuais bibliotecas necessárias ao processamento... library("kohonen") #--------------------------------------------------------------------------------------------- # Definir o arquivo "log" com resultados do processamento... #sink("result01.out", append = FALSE) 38
#--------------------------------------------------------------------------------------------- # Desligar janelas de apresentação de gráficos... # dev.off(2) dev.off(3) dev.off(4) dev.off(5) dev.off(6) dev.off(7) #-------------------------------------------------------------------------------------------- # Palette defined by kohonen package # # Shane Lynn 14-01-2014 coolbluehotred <- function(n, alpha = 1) { rainbow(n, end=4/6, alpha=alpha)[n:1] } #--------------------------------------------------------------------------------------------- # Ler os dados... vdados <- read.csv("koh_exemplo01.csv", sep=";", dec=".", header=true) #--------------------------------------------------------------------------------------------- # Normalização dos dados para uso no algoritmo de Kohonen... #---> Normalização 1: Normalizar os dados de entrada - Padronização das variáveis: xi / raiz(x1^2 + x2^2 +... + xn^2) #------> Para a variavel LARANJA... vnormalizacao = vdados$laranja / sqrt(vdados$laranja^2 + vdados$limao^2) vdados = cbind(vdados,vnormalizacao) names(vdados)[names(vdados)=="vnormalizacao"] = "LARANJA_N1" # renomear a coluna #------> Para a variavel LIMAO... vnormalizacao = vdados$limao / sqrt(vdados$laranja^2 + vdados$limao^2) vdados = cbind(vdados,vnormalizacao) names(vdados)[names(vdados)=="vnormalizacao"] = "LIMAO_N1" # renomear a coluna #---> Normalização 2: Normalizar os dados de entrada - Padronização das variáveis: (x - xmedia) / desvio-padrão #------> Para a variavel LARANJA... vmedia = mean(vdados$laranja) vdesvpad = sd(vdados$laranja) # desvio padrão da amostra vnormalizacao = (vdados$laranja - vmedia) / vdesvpad vdados = cbind(vdados,vnormalizacao) names(vdados)[names(vdados)=="vnormalizacao"] = "LARANJA_N2" # renomear a coluna #------> Para a variavel LIMAO... vmedia = mean(vdados$limao) vdesvpad = sd(vdados$limao) # desvio padrão da amostra vnormalizacao = (vdados$limao - vmedia) / vdesvpad vdados = cbind(vdados,vnormalizacao) names(vdados)[names(vdados)=="vnormalizacao"] = "LIMAO_N2" # renomear a coluna #---> Normalização 3: Normalizar os dados já normalizados (_N2): função sigmoidal 1 / (1 + (exp(-var_n2)) #------> Para a variavel LARANJA... vnormalizacao = 1 / (1 + exp(-vdados$laranja_n2)) vdados = cbind(vdados,vnormalizacao) names(vdados)[names(vdados)=="vnormalizacao"] = "LARANJA_N3" # renomear a coluna #------> Para a variavel LIMAO... vnormalizacao = 1 / (1 + exp(-vdados$limao_n2)) vdados = cbind(vdados,vnormalizacao) 39
#--------------------------------------------------------------------------------------------- names(vdados)[names(vdados)=="vnormalizacao"] # listar dados... apenas para conferência eventual... = "LIMAO_N3" # renomear a coluna cat("dados originais e normalizados \n") cat("----- --------- - ----------- \n") vtotinputs = nrow(vdados) cat(" Normalização 1 Normalização 2 Normalização 3 "); ; cat("cidade LARANJA LIMAO LARANJA (N1) LIMAO (N1) LARANJA (N2) LIMAO (N2) LARANJA (N3) LIMAO (N3) "); ; cat("------- ---------- ---------- -------------- -------------- -------------- -------------- -------------- --------------"); ; for (k in 1:vTotInputs) { vaux = vdados[k,"cidade"] vaux = format(vaux, width = 1, justify="left") cat(" "); cat(vaux); cat(" ") vaux = vdados[k,"laranja"] vaux = format(vaux, width = 7, justify="right") cat(""); cat(vaux); cat(" ") vaux = vdados[k,"limao"] vaux = format(vaux, width = 7, justify="right") cat(""); cat(vaux); cat(" ") vaux = vdados[k,"laranja_n1"] vaux = sprintf("%2.6f", vaux) vaux = format(vaux, width = 9, justify="right") cat(""); cat(vaux); cat(" ") vaux = vdados[k,"limao_n1"] vaux = sprintf("%2.6f", vaux) vaux = format(vaux, width = 9, justify="right") cat(""); cat(vaux); cat(" ") vaux = vdados[k,"laranja_n2"] vaux = sprintf("%2.6f", vaux) vaux = format(vaux, width = 9, justify="right") cat(""); cat(vaux); cat(" ") vaux = vdados[k,"limao_n2"] vaux = sprintf("%2.6f", vaux) vaux = format(vaux, width = 9, justify="right") cat(""); cat(vaux); cat(" ") vaux = vdados[k,"laranja_n3"] vaux = sprintf("%2.6f", vaux) vaux = format(vaux, width = 9, justify="right") cat(""); cat(vaux); cat(" ") vaux = vdados[k,"limao_n3"] vaux = sprintf("%2.6f", vaux) vaux = format(vaux, width = 9, justify="right") cat(""); cat(vaux); cat(" ") } cat("\n\n") cat("vamos usar o terceiro tipo de normalização no algoritmo...'tá ligado'?") cat("\n\n") #--------------------------------------------------------------------------------------------- # #---> Selecionar somente os campos numéricos normalizados pelo terceiro tipo (N3) vkoh = subset(vdados,select=c("laranja_n3","limao_n3")) 40
#---> O algoritmos só funciona se os dados estiverem em formato matrix... então vamos transformar em metrix... vkoh2 = as.matrix(vkoh) #-------------------------------------------------------------------------------------------- # # Executar o algoritmo SOM (Self Organizing Mpas) ################################################################## #---> Definir o lay-out da camada (grid de neurônios) "Kohonen" ################################################################## vgrid_som = somgrid(xdim=3, ydim=3, topo="rectangular") #---> executa efetivamente o algoritmo... set.seed(7) vmapakohonen = som(data = vkoh2, grid = vgrid_som, rlen = 100, alpha = c(0.05,0.01), keep.data = TRUE, n.hood = "circular" ) cat("\n\n") cat("após a execução do algoritmo de treinamento do mapa de Kohonen temos:") cat("\n\n") ########################################################################################## #---> Gráfico da evolução do treinamento da rede... #------> "changes" shows the mean distance to the closest codebook vector during training. # # Training Progress: # As the SOM training iterations progress, the distance from each node s weights to the samples represented by that node is reduced. Ideally, this # distance should reach a minimum plateau. This plot option shows the progress over time. If the curve is continually decreasing, more iterations # are required. # ########################################################################################## dev.new() # Or X11() dev.1 <- as.integer(dev.cur()) dev.set(dev.1) plot(vmapakohonen, type="changes", main = "Perfis de consumo de Laranja/Limão - treinamento") ################################################################################################### ########## #---> Gráfico de alocação dos padrões de entrada (cidades) pelos neurônios da rede... #---> "counts" shows the number of objects mapped to the individual units. Empty units are depicted in gray. # # Node Counts # The Kohonen packages allows us to visualise the count of how many samples are mapped to each node on the map. This metric can be used as # a measure of map quality ideally the sample distribution is relatively uniform. Large values in some map areas suggests that a larger map # would be benificial. Empty nodes indicate that your map size is too big for the number of samples. Aim for at least 5-10 samples per node when # choosing map size. # ################################################################################################### ########## 41
dev.2 <- as.integer(dev.cur()) dev.set(dev.2) dev.new() plot(vmapakohonen, type="counts", main = "Total de objetos (padrões) alocados pela rede") ################################################################################################### ############ #---> Gráfico de distância aos neurônios vizinhos... #---> "dist.neighbours" shows the sum of the distances to all immediate neighbours. This kind of visualisation # is also known as a U-matrix plot. Units near a class boundary can be expected to # have higher average distances to their neighbours. Only available for the "som" and "supersom" # maps, for the moment. # # Neighbour Distance # Often referred to as the U-Matrix, this visualisation is of the distance between each node and its neighbours. Typically viewed with a grayscale # palette, areas of low neighbour distance indicate groups of nodes that are similar. Areas with large distances indicate the nodes are much more # dissimilar and indicate natural boundaries between node clusters. The U-Matrix can be used to identify clusters within the SOM map. # ################################################################################################### ############ dev.new() dev.3 <- as.integer(dev.cur()) dev.set(dev.3) plot(vmapakohonen, type="dist.neighbours", main = "U-Matrix - Matriz de distância aos neurônios vizinhos") ################################################## #---> Gráfico do vetor de pesos... #---> "codes" shows the codebook vectors. # # Codes / Weight vectors # The node weight vectors, or codes, are made up of normalised values of the original variables used to generate the SOM. Each node s weight # vector is representative / similar of the samples mapped to that node. By visualising the weight vectors across the map, we can see patterns in # the distribution of samples and variables. The default visualisation of the weight vectors is a fan diagram, where individual fan representations # of the magnitude of each variable in the weight vector is shown for each node. # ################################################## #####vcores = c("#ff0000", "#00FF00", "#0000FF", "#FF0F0F", "#E0E0E0", "#FF00EE", "#DDCACA", "#CACABB") vcores <- colorramppalette( c('#33cdc7','#f2716b','#e1f505',"#00ff00", "#574DD8", "#FF00EE", "#BFBC30", "#FF0000") ) dev.new() # Or X11() dev.4 <- as.integer(dev.cur()) dev.set(dev.4) plot(vmapakohonen, type="codes", palette.name=vcores, main = "Vetor de pesos dos neurônios") ######################################################### #---> Mapa de calor das variáveis LARANJA e LIMAO... ######################################################### dev.new() # Or X11() dev.5 <- as.integer(dev.cur()) 42
#------> Colocar 2 gráficos na mesma janela... par(mfrow=c(2,1)) dev.set(dev.5) #------> A coluna LARANJA_N3 é a primeira coluna de vmapakohonenen e deve ser referenciada assim: vmapakohonen$codes[,1] plot(vmapakohonen, type = "property", property = vmapakohonen$codes[,1], main="mapa de calor - LARANJA", palette.name=coolbluehotred) #------> A coluna LIMAO_N3 é a segunda coluna de vmapakohonenen e deve ser referenciada assim: vmapakohonen$codes[,2] plot(vmapakohonen, type = "property", property = vmapakohonen$codes[,2], main="mapa de calor - LIMÃO", palette.name=coolbluehotred) par(mfrow=c(1,1)) # manter um gráfico por janela... ################################### #----> Resultados impressos... ################################### cat("(0) Resumo geral\n") cat(" ------------\n") print(summary(vmapakohonen)) cat("===========================================================\n") cat("1) Neurônio vencedor do padrão apresentado") cat(" ---------------------------------------") vneuroniovencedor = vmapakohonen$unit.classif # resultado do algoritmo vtotinputs = nrow(vkoh) cat("cidade LARANJA LIMAO Neurônio vencedor"); ; cat("------- ---------- ---------- ------------------"); ; for (k in 1:vTotInputs) { vaux = vdados[k,"cidade"] vaux = format(vaux, width = 1, justify="left") cat(" "); cat(vaux); cat(" ") vaux = vdados[k,"laranja"] vaux = format(vaux, width = 7, justify="right") cat(""); cat(vaux); cat(" ") vaux = vdados[k,"limao"] vaux = format(vaux, width = 7, justify="right") cat(""); cat(vaux); cat(" ") vaux = vmapakohonen$unit.classif[k] vaux = format(vaux, width = 3, justify="right") cat(" "); cat(vaux); cat(" ") } cat("2) A matriz de vetores-peso (code vectors) do mapa de Kohonen") cat(" ----------------------------------------------------------" ) 43
cat("\n\n") print(vmapakohonen$codes) cat("3) Gráfico do vetor pesos") cat(" -------------------------") cat("-> Em cada neurônio é apresentado seu vetor de pesos que o liga à camada de entrada de dados") cat("-> A imagem do vetor de pesos dentro do neurônio é conhecida como 'diagrama de ventilador'") cat("-> Quanto maior o setor circular de um elemento do vetor de peso, maior é o seu valor") cat("-> Quanto menor o setor circular de um elemento do vetor de peso, menor é o seu valor") cat("-> Note que o vetor de pesos representa, em última instância, um padrão do conjunto de dados de entrada") cat("\n\n") cat("\n\n") cat("4) Gráfico de distância dos vizinhos (gráfico U-Matrix)") cat(" ----------------------------------------------------") cat("-> Conhecido como gráfico 'U-Matrix', permite visualizar a distância entre cada neurônio e seus vizinhos") cat("-> Áreas com baixa distância de vizinhos indica grupo de neurônios similares") cat("-> Áreas com alta distância de vizinhos indica grupo de neurônios disimilares") cat("-> Áreas com alta distância de vizinhos indica então limites 'naturais' entre clusters") cat("-> Desta forma, a U-Matrix serve para identificar clusters no mapa de Kohonen") cat("\n\n") cat("\n\n") cat("5) Mapa de calor da variável LARANJA") cat(" ---------------------------------") cat("-> Observe e interprete o gráfico") cat("\n\n") cat("\n\n") cat("6) Mapa de calor da variável LIMAO") cat(" ---------------------------------") cat("-> Observe e interprete o gráfico") cat("\n\n") cat("7) Distância dos padrões (cidades) ao correspondente neurônio vencedor") cat(" -------------------------------------------------------------------") vneuroniovencedor = vmapakohonen$unit.classif # resultado do algoritmo 44
vtotinputs = nrow(vkoh) vdistanciaaoneuroniovencedor = vmapakohonen$distances # resultado do algoritmo cat("cidade LARANJA LIMAO Neurônio vencedor Distância "); ; cat("------- ---------- ---------- ------------------- -----------------"); ; for (k in 1:vTotInputs) { vaux = vdados[k,"cidade"] vaux = format(vaux, width = 1, justify="left") cat(" "); cat(vaux); cat(" ") vaux = vdados[k,"laranja"] vaux = format(vaux, width = 7, justify="right") cat(""); cat(vaux); cat(" ") vaux = vdados[k,"limao"] vaux = format(vaux, width = 7, justify="right") cat(""); cat(vaux); cat(" ") vaux = vmapakohonen$unit.classif[k] vaux = format(vaux, width = 3, justify="right") cat(" "); cat(vaux); cat(" ") vaux = vmapakohonen$distances[k] vaux = sprintf("%3.6f", vaux) vaux = format(vaux, width = 11, justify="right") cat(" "); cat(vaux); cat(" ") } cat("-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x") cat("===> Unit distances \n\n ") vdists <- unit.distances(vmapakohonen$grid, toroidal=false) print(vmapakohonen$grid$n.hood) print("/n/n acimaa /n") print(vdists) cat("-------------------- \n\n") #-------------------------------------------------------------------------------------------- #---> "mapping" shows where objects are mapped. It needs the "classif" argument, and a "labels" or "pchs" argument. #dev.set(dev.6) #plot(vmapakohonen, type="mapping", labels = vperfil, main = "Perfis ambientais - mapeamento") #---> "quality" shows the mean distance of objects mapped to a unit to the codebook vector of that unit. # The smaller the distances, the better the objects are represented by the codebook vectors. #dev.set(dev.6) #plot(vmapakohonen, type="quality", main = "Perfis ambientais - qualidade da clusterização...") #--------------------------------------------------------------------------------------------- # Para finalizar... 45
#sink() # fechar descarregar o arquivo as bibliotecas de saida eventualemnte usadas... detach("package:kohonen") # volta a apontar ao diretório inicial setwd(initial.dir) #====================================== F I M =============================================== *** FIM *** 46