K-significa Clusterem R com exemplo

O que é o Cluster análise?

Cluster análise faz parte aprendizado não supervisionado. Um cluster é um grupo de dados que compartilham recursos semelhantes. Podemos dizer que a análise de agrupamento tem mais a ver com descoberta do que com previsão. A máquina procura semelhança nos dados. Por exemplo, você pode usar a análise de cluster para o seguinte aplicativo:

• Segmentação de clientes: procura semelhança entre grupos de clientes
• Agrupamento do mercado de ações: ações do grupo com base no desempenho
• Reduza a dimensionalidade de um conjunto de dados agrupando observações com valores semelhantes

ClusterA análise de dados não é muito difícil de implementar e é significativa e acionável para os negócios.

A diferença mais marcante entre aprendizagem supervisionada e não supervisionada está nos resultados. A aprendizagem não supervisionada cria uma nova variável, o rótulo, enquanto a aprendizagem supervisionada prevê um resultado. A máquina ajuda o profissional na busca de rotular os dados com base no relacionamento próximo. Cabe ao analista fazer uso dos grupos e dar-lhes um nome.

Vamos dar um exemplo para entender o conceito de clustering. Para simplificar, trabalhamos em duas dimensões. Você tem dados sobre o gasto total dos clientes e suas idades. Para melhorar a publicidade, a equipe de marketing deseja enviar e-mails mais direcionados aos seus clientes.

No gráfico a seguir, você traça o gasto total e a idade dos clientes.

library(ggplot2)
df <- data.frame(age = c(18, 21, 22, 24, 26, 26, 27, 30, 31, 35, 39, 40, 41, 42, 44, 46, 47, 48, 49, 54),
    spend = c(10, 11, 22, 15, 12, 13, 14, 33, 39, 37, 44, 27, 29, 20, 28, 21, 30, 31, 23, 24)
)
ggplot(df, aes(x = age, y = spend)) +
    geom_point()

Um padrão é visível neste ponto

1. No canto inferior esquerdo, você pode ver jovens com menor poder aquisitivo
2. Médio-alto reflete pessoas com um emprego que podem pagar e gastar mais
3. Finalmente, pessoas mais velhas com orçamento mais baixo.

Na figura acima, você agrupa as observações manualmente e define cada um dos três grupos. Este exemplo é um tanto direto e altamente visual. Se novas observações forem anexadas ao conjunto de dados, você poderá rotulá-las dentro dos círculos. Você define o círculo com base em nosso julgamento. Em vez disso, você pode usar Machine Learning agrupar os dados objetivamente.

Neste tutorial você aprenderá como usar o k-significa algoritmo.

Algoritmo K-médias

K-mean é, sem dúvida, o método de agrupamento mais popular. Os pesquisadores lançaram o algoritmo há décadas e muitas melhorias foram feitas no k-means.

O algoritmo tenta encontrar grupos minimizando a distância entre as observações, chamado ótimo local soluções. As distâncias são medidas com base nas coordenadas das observações. Por exemplo, em um espaço bidimensional, as coordenadas são simples e.

O algoritmo funciona da seguinte forma:

• Etapa 1: escolha grupos no plano de recursos aleatoriamente
• Passo 2: Minimize a distância entre o centro do cluster e as diferentes observações (centróide). Resulta em grupos com observações
• - Shift o centróide inicial à média das coordenadas dentro de um grupo.
• Passo 4: Minimize a distância de acordo com os novos centróides. Novos limites são criados. Assim, as observações passarão de um grupo para outro
• Repita até que nenhuma observação altere os grupos

K-means geralmente mede a distância euclidiana entre o recurso e o recurso:

Diferentes medidas estão disponíveis, como a distância de Manhattan ou a distância de Minlowski. Observe que K-mean retorna grupos diferentes cada vez que você executa o algoritmo. Lembre-se de que as primeiras estimativas iniciais são aleatórias e calculam as distâncias até que o algoritmo atinja uma homogeneidade dentro dos grupos. Ou seja, k-mean é muito sensível à primeira escolha e, a menos que o número de observações e grupos seja pequeno, é quase impossível obter o mesmo agrupamento.

Selecione o número de clusters

Outra dificuldade encontrada com o k-mean é a escolha do número de clusters. Você pode definir um valor alto, ou seja, um grande número de grupos, para melhorar a estabilidade, mas você pode acabar com sobreajuste De dados. Overfitting significa que o desempenho do modelo diminui substancialmente para novos dados que chegam. A máquina aprendeu os pequenos detalhes do conjunto de dados e se esforçou para generalizar o padrão geral.

O número de clusters depende da natureza do conjunto de dados, da indústria, do negócio e assim por diante. No entanto, existe uma regra prática para selecionar o número apropriado de clusters:

com igual ao número de observações no conjunto de dados.

De modo geral, é interessante gastar tempo buscando o melhor valor para se adequar à necessidade do negócio.

Usaremos o conjunto de dados Preços de Computadores Pessoais para realizar nossa análise de cluster. Este conjunto de dados contém 6259 observações e 10 recursos. O conjunto de dados observa o preço de 1993 a 1995 de 486 computadores pessoais nos EUA. As variáveis ​​são preço, velocidade, memória RAM, tela, cd entre outras.

Você procederá da seguinte forma:

• Datas de importação
• Treine o modelo
• Avalie o modelo

Datas de importação

K significa não é adequado para variáveis ​​de fator porque é baseado na distância e valores discretos não retornam valores significativos. Você pode excluir as três variáveis ​​categóricas em nosso conjunto de dados. Além disso, não há valores ausentes neste conjunto de dados.

library(dplyr)
PATH <-"https://raw.githubusercontent.com/guru99-edu/R-Programming/master/computers.csv"
df <- read.csv(PATH) %>%
select(-c(X, cd, multi, premium))
glimpse(df)

saída

## Observations: 6, 259
## Variables: 7
## $ price < int > 1499, 1795, 1595, 1849, 3295, 3695, 1720, 1995, 2225, 2...
##$ speed < int > 25, 33, 25, 25, 33, 66, 25, 50, 50, 50, 33, 66, 50, 25, ...
##$ hd < int > 80, 85, 170, 170, 340, 340, 170, 85, 210, 210, 170, 210...
##$ ram < int > 4, 2, 4, 8, 16, 16, 4, 2, 8, 4, 8, 8, 4, 8, 8, 4, 2, 4, ...
##$ screen < int > 14, 14, 15, 14, 14, 14, 14, 14, 14, 15, 15, 14, 14, 14, ...
##$ ads < int > 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, ...
## $ trend  <int> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1...

Nas estatísticas resumidas, você pode ver que os dados têm valores grandes. Uma boa prática com cálculo de média e distância k é redimensionar os dados para que a média seja igual a um e o desvio padrão seja igual a zero.

summary(df)

Saída:

##      price          speed              hd              ram        
##  Min.   : 949   Min.   : 25.00   Min.   :  80.0   Min.   : 2.000  
##  1st Qu.:1794   1st Qu.: 33.00   1st Qu.: 214.0   1st Qu.: 4.000  `
##  Median :2144   Median : 50.00   Median : 340.0   Median : 8.000  
##  Mean   :2220   Mean   : 52.01   Mean   : 416.6   Mean   : 8.287  
##  3rd Qu.:2595   3rd Qu.: 66.00   3rd Qu.: 528.0   3rd Qu.: 8.000  
##  Max.   :5399   Max.   :100.00   Max.   :2100.0   Max.   :32.000  
##      screen           ads            trend      
##  Min.   :14.00   Min.   : 39.0   Min.   : 1.00  
##  1st Qu.:14.00   1st Qu.:162.5   1st Qu.:10.00  
##  Median :14.00   Median :246.0   Median :16.00  
##  Mean   :14.61   Mean   :221.3   Mean   :15.93  
##  3rd Qu.:15.00   3rd Qu.:275.0   3rd Qu.:21.50  
##  Max.   :17.00   Max.   :339.0   Max.   :35.00

Você redimensiona as variáveis ​​com a função scale() da biblioteca dplyr. A transformação reduz o impacto de outliers e permite comparar uma única observação com a média. Se um valor padronizado (ou pontuação z) for alto, você pode ter certeza de que esta observação está realmente acima da média (uma pontuação z grande implica que este ponto está longe da média em termos de desvio padrão. Uma pontuação z de dois indica que o valor é 2 padrão desvios da média. Observe que o escore z segue uma distribuição gaussiana e é simétrico em torno da média.

rescale_df <- df % > %
mutate(price_scal = scale(price),
    hd_scal = scale(hd),
    ram_scal = scale(ram),
    screen_scal = scale(screen),
    ads_scal = scale(ads),
    trend_scal = scale(trend)) % > %
select(-c(price, speed, hd, ram, screen, ads, trend))

R base tem uma função para executar o algoritmo k médio. A função básica da média k é:

kmeans(df, k)
arguments:
-df: dataset used to run the algorithm
-k: Number of clusters

Treine o modelo

Na figura três você detalhou como o algoritmo funciona. Você pode ver cada etapa graficamente com o excelente pacote criado por Yi Hui (também criador do Knit for Rmarkdown). A animação do pacote não está disponível na biblioteca conda. Você pode usar a outra maneira de instalar o pacote com install.packages(“animation”). Você pode verificar se o pacote está instalado em nossa pasta Anaconda.

install.packages("animation")

Depois de carregar a biblioteca, você adiciona .ani após kmeans e R irá traçar todas as etapas. Para fins de ilustração, você executa o algoritmo apenas com as variáveis ​​redimensionadas hd e ram com três clusters.

set.seed(2345)
library(animation)
kmeans.ani(rescale_df[2:3], 3)

Explicação do código

• kmeans.ani(rescale_df[2:3], 3): Selecione as colunas 2 e 3 do conjunto de dados rescale_df e execute o algoritmo com k conjuntos para 3. Trace a animação.

Você pode interpretar a animação da seguinte forma:

• Etapa 1: R escolhe três pontos aleatoriamente
• Passo 2: Calcule a distância euclidiana e desenhe os clusters. Você tem um aglomerado verde no canto inferior esquerdo, um aglomerado grande colorido em preto à direita e um vermelho entre eles.
• Etapa 3: Calcule o centróide, ou seja, a média dos clusters
• Repita até que nenhum dado altere o cluster

O algoritmo convergiu após sete iterações. Você pode executar o algoritmo k-mean em nosso conjunto de dados com cinco clusters e chamá-lo de pc_cluster.

pc_cluster <-kmeans(rescale_df, 5)

• A lista pc_cluster contém sete elementos interessantes:
• pc_cluster$cluster: Indica o cluster de cada observação
• pc_cluster$centers: os centros do cluster
• pc_cluster$totss: A soma total dos quadrados
• pc_cluster$withinss: Dentro da soma dos quadrados. O número de componentes retornados é igual a `k`
• pc_cluster$tot.withinss: Soma de dentro de
• pc_clusterbetweenss: soma total dos quadrados menos dentro da soma dos quadrados
• pc_cluster$size: Número de observações dentro de cada cluster

Você usará a soma da soma interna dos quadrados (ou seja, tot.withinss) para calcular o número ideal de clusters k. Encontrar k é de fato uma tarefa substancial.

K ideal

Uma técnica para escolher o melhor k é chamada de método de cotovelo. Este método usa homogeneidade dentro do grupo ou heterogeneidade dentro do grupo para avaliar a variabilidade. Em outras palavras, você está interessado na porcentagem da variância explicada por cada cluster. Você pode esperar que a variabilidade aumente com o número de clusters; alternativamente, a heterogeneidade diminui. Nosso desafio é encontrar o k que está além dos retornos decrescentes. Adicionar um novo cluster não melhora a variabilidade nos dados porque resta muito pouca informação para explicar.

Neste tutorial, encontramos esse ponto usando a medida de heterogeneidade. A soma dos quadrados do total dentro dos clusters é o tot.withinss na lista retornada por kmean().

Você pode construir o gráfico do cotovelo e encontrar o k ideal da seguinte maneira:

• Etapa 1: Construa uma função para calcular a soma dos quadrados do total dentro dos clusters
• Etapa 2: execute os tempos do algoritmo
• Etapa 3: Crie um quadro de dados com os resultados do algoritmo
• Etapa 4: traçar os resultados

Passo 1) Construa uma função para calcular o total dentro da soma dos quadrados dos clusters

Você cria a função que executa o algoritmo k-mean e armazena o total na soma dos quadrados dos clusters

kmean_withinss <- function(k) {
    cluster <- kmeans(rescale_df, k)
    return (cluster$tot.withinss)
}

Explicação do código

• função (k): Defina o número de argumentos na função
• kmeans(rescale_df, k): Execute o algoritmo k vezes
• return (cluster$tot.withinss): Armazena o total dentro da soma dos quadrados dos clusters

Você pode testar a função com igual a 2.

Saída:

## Try with 2 cluster

kmean_withinss(2)

Saída:

## [1] 27087.07

Passo 2) Execute o algoritmo n vezes

Você usará a função sapply() para executar o algoritmo em um intervalo de k. Essa técnica é mais rápida do que criar um loop e armazenar o valor.

# Set maximum cluster 
max_k <-20 
# Run algorithm over a range of k 
wss <- sapply(2:max_k, kmean_withinss)

Explicação do código

• max_k <-20: Defina um número máximo de 20
• sapply(2:max_k, kmean_withinss): Execute a função kmean_withinss() em um intervalo 2:max_k, ou seja, 2 a 20.

Passo 3) Crie um quadro de dados com os resultados do algoritmo

Após a criação e teste de nossa função, você pode executar o algoritmo k-mean em um intervalo de 2 a 20 e armazenar os valores tot.withinss.

# Create a data frame to plot the graph
elbow <-data.frame(2:max_k, wss)

Explicação do código

• data.frame(2:max_k, wss): Crie um quadro de dados com a saída do algoritmo armazenado em wss

Passo 4) Trace os resultados

Você traça o gráfico para visualizar onde está o ponto do cotovelo

# Plot the graph with gglop
ggplot(elbow, aes(x = X2.max_k, y = wss)) +
    geom_point() +
    geom_line() +
    scale_x_continuous(breaks = seq(1, 20, by = 1))

No gráfico, você pode ver que o k ideal é sete, onde a curva está começando a ter um retorno decrescente.

Depois de obter nosso k ideal, você executa novamente o algoritmo com k igual a 7 e avalia os clusters.

Examinando o cluster

pc_cluster_2 <-kmeans(rescale_df, 7)

Como mencionado anteriormente, você pode acessar as demais informações interessantes na lista retornada por kmean().

pc_cluster_2$cluster
pc_cluster_2$centers
pc_cluster_2$size

A parte de avaliação é subjetiva e depende do uso do algoritmo. Nosso objetivo aqui é reunir computadores com recursos semelhantes. Um cara de informática pode fazer o trabalho manualmente e agrupar computadores com base em sua experiência. No entanto, o processo levará muito tempo e estará sujeito a erros. O algoritmo K-mean pode preparar o campo para ele, sugerindo clusters.

Como avaliação prévia, você pode examinar o tamanho dos clusters.

pc_cluster_2$size

Saída:

## [1] 608 1596 1231  580 1003  699  542

O primeiro cluster é composto por 608 observações, enquanto o menor cluster, o número 4, possui apenas 580 computadores. Pode ser bom ter homogeneidade entre os clusters; caso contrário, uma preparação de dados mais refinada pode ser necessária.

Você obtém uma visão mais aprofundada dos dados com o componente central. As linhas referem-se à numeração do cluster e as colunas às variáveis ​​utilizadas pelo algoritmo. Os valores são a pontuação média de cada cluster para a coluna interessada. A padronização facilita a interpretação. Valores positivos indicam que o escore z de um determinado cluster está acima da média geral. Por exemplo, o cluster 2 tem a média de preço mais alta entre todos os clusters.

center <-pc_cluster_2$centers
center

Saída:

##   price_scal    hd_scal     ram_scal screen_scal   ads_scal trend_scal
## 1 -0.6372457 -0.7097995 -0.691520682  -0.4401632  0.6780366 -0.3379751
## 2 -0.1323863  0.6299541  0.004786730   2.6419582 -0.8894946  1.2673184
## 3  0.8745816  0.2574164  0.513105797  -0.2003237  0.6734261 -0.3300536
## 4  1.0912296 -0.2401936  0.006526723   2.6419582  0.4704301 -0.4132057
## 5 -0.8155183  0.2814882 -0.307621003  -0.3205176 -0.9052979  1.2177279
## 6  0.8830191  2.1019454  2.168706085   0.4492922 -0.9035248  1.2069855
## 7  0.2215678 -0.7132577 -0.318050275  -0.3878782 -1.3206229 -1.5490909

Você pode criar um mapa de calor com ggplot para nos ajudar a destacar a diferença entre as categorias.

As cores padrão do ggplot precisam ser alteradas com a biblioteca RColorBrewer. Você pode usar o conda biblioteca e o código para iniciar no terminal:

conda install -cr r-rcolorbrewer

Para criar um mapa de calor, você segue três etapas:

• Construa um data frame com os valores do centro e crie uma variável com o número do cluster
• Remodele os dados com a função Gather() da biblioteca tidyr. Você deseja transformar dados de largos em longos.
• Crie a paleta de cores com corRampFunção paleta()

Passo 1) Construa um quadro de dados

Vamos criar o conjunto de dados remodelado

library(tidyr)

# create dataset with the cluster number

cluster <- c(1: 7)
center_df <- data.frame(cluster, center)

# Reshape the data

center_reshape <- gather(center_df, features, values, price_scal: trend_scal)
head(center_reshape)

Saída:

##   cluster   features     values
## 1       1 price_scal -0.6372457
## 2       2 price_scal -0.1323863
## 3       3 price_scal  0.8745816
## 4       4 price_scal  1.0912296
## 5       5 price_scal -0.8155183
## 6       6 price_scal  0.8830191		

Passo 2) Remodelar os dados

O código abaixo cria a paleta de cores que você usará para traçar o mapa de calor.

library(RColorBrewer)
# Create the palette
hm.palette <-colorRampPalette(rev(brewer.pal(10, 'RdYlGn')),space='Lab')

Etapa 3) Visualizar

Você pode traçar o gráfico e ver a aparência dos clusters.

# Plot the heat map
ggplot(data = center_reshape, aes(x = features, y = cluster, fill = values)) +
    scale_y_continuous(breaks = seq(1, 7, by = 1)) +
    geom_tile() +
    coord_equal() +
    scale_fill_gradientn(colours = hm.palette(90)) +
    theme_classic()

Resumo

Podemos resumir o algoritmo k-mean na tabela abaixo

Pacote	Objetivo	função	Argumento
base	Treine k-média	kmeans ()	df, k
	Cluster de acesso	kmeans()$cluster
	Cluster centros	kmeans()$centros
	Cluster de tamanho	kmeans()$tamanho