Existe uma função no R que leva os centros de clusters encontrados e atribui clusters a um novo conjunto de dados


14

Eu tenho duas partes de um conjunto de dados multidimensionais, vamos chamá-los traine test. E quero criar um modelo com base no conjunto de dados do trem e validá-lo no conjunto de dados de teste. O número de clusters é conhecido.

Tentei aplicar o agrupamento k-means no R e obtive um objeto que contém os centros de clusters:

kClust <- kmeans(train, centers=N, nstart=M)

Existe uma função no R que pega os centros de clusters encontrados e atribui clusters ao meu conjunto de dados de teste?

Quais são os outros métodos / algoritmos que posso tentar?


Bem-vindo ao site, @ user2598356. Você pode enquadrar isso de uma maneira mais geral (não específica de R)? Se você está solicitando apenas uma função R, essa pergunta não é relevante para o CV (consulte nossa página de ajuda ). Além disso, seria fora de tópico também no Stack Overflow , já que não possui um exemplo reproduzível . Se você pode editar isso para torná-lo no tópico aqui ou no SO, faça-o. Caso contrário, este Q pode ser fechado.
gung - Restabelece Monica

Esta pergunta parece estar fora de tópico, porque se trata de encontrar uma função R.
gung - Restabelece Monica

1
Mas qual é a última pergunta: "Quais são os outros métodos / algoritmos que posso tentar?". Na verdade, a resposta que obtive diz respeito à implementação dos métodos que é um tópico do CV, ou estou errado?
user2598356

1
@gung Você pode estar certo. Nesse caso, convido o user259 ... a sinalizar esta pergunta para migração. No entanto, a última parte da pergunta sobre outros métodos e algoritmos sugere que nossa comunidade pode estar em uma boa posição para oferecer ajuda e conselhos úteis.
whuber

Obrigado! A função funciona bem, mas leva muito tempo se você tiver mais de 50 mil linhas. Alguma idéia para torná-lo mais leve?

Respostas:


11

Você pode calcular as atribuições de cluster para um novo conjunto de dados com a seguinte função:

clusters <- function(x, centers) {
  # compute squared euclidean distance from each sample to each cluster center
  tmp <- sapply(seq_len(nrow(x)),
                function(i) apply(centers, 1,
                                  function(v) sum((x[i, ]-v)^2)))
  max.col(-t(tmp))  # find index of min distance
}

# create a simple data set with two clusters
set.seed(1)
x <- rbind(matrix(rnorm(100, sd = 0.3), ncol = 2),
           matrix(rnorm(100, mean = 1, sd = 0.3), ncol = 2))
colnames(x) <- c("x", "y")
x_new <- rbind(matrix(rnorm(10, sd = 0.3), ncol = 2),
               matrix(rnorm(10, mean = 1, sd = 0.3), ncol = 2))
colnames(x_new) <- c("x", "y")

cl <- kmeans(x, centers=2)

all.equal(cl[["cluster"]], clusters(x, cl[["centers"]]))
# [1] TRUE
clusters(x_new, cl[["centers"]])
# [1] 2 2 2 2 2 1 1 1 1 1

plot(x, col=cl$cluster, pch=3)
points(x_new, col= clusters(x_new, cl[["centers"]]), pch=19)
points(cl[["centers"]], pch=4, cex=2, col="blue")

atribuição de cluster

ou você pode usar o pacote flexclust , que possui um predictmétodo implementado para k-means:

library("flexclust")
data("Nclus")

set.seed(1)
dat <- as.data.frame(Nclus)
ind <- sample(nrow(dat), 50)

dat[["train"]] <- TRUE
dat[["train"]][ind] <- FALSE

cl1 = kcca(dat[dat[["train"]]==TRUE, 1:2], k=4, kccaFamily("kmeans"))
cl1    
#
# call:
# kcca(x = dat[dat[["train"]] == TRUE, 1:2], k = 4)
#
# cluster sizes:
#
#  1   2   3   4 
#130 181  98  91 

pred_train <- predict(cl1)
pred_test <- predict(cl1, newdata=dat[dat[["train"]]==FALSE, 1:2])

image(cl1)
points(dat[dat[["train"]]==TRUE, 1:2], col=pred_train, pch=19, cex=0.3)
points(dat[dat[["train"]]==FALSE, 1:2], col=pred_test, pch=22, bg="orange")

plotagem flexclust

Também existem métodos de conversão para converter os resultados de funções de cluster como stats::kmeansou cluster::pamem objetos de classe kccae vice-versa:

as.kcca(cl, data=x)
# kcca object of family ‘kmeans’ 
#
# call:
# as.kcca(object = cl, data = x)
#
# cluster sizes:
#
#  1  2 
#  50 50 

Muito obrigado! Apenas uma pergunta: como o método kcca lida com o número de partidas (ele otimiza a análise em relação aos pontos de partida)?
precisa saber é o seguinte

O que você quer dizer com número de partidas? A stepFlexclustfunção executa algoritmos de clustering repetidamente para diferentes números de clusters e retorna a solução mínima dentro da distância do cluster para cada um.
amigos estão dizendo sobre rcs

1

step1: uma função que calcula a distância entre um vetor e cada linha de uma matriz

calc_vec2mat_dist = function(x, ref_mat) {
    # compute row-wise vec2vec distance 
    apply(ref_mat, 1, function(r) sum((r - x)^2))
}

etapa 2: uma função que aplica o computador vec2mat a todas as linhas do input_matrix

calc_mat2mat_dist = function(input_mat, ref_mat) {

    dist_mat = apply(input_mat, 1, function(r) calc_vec2mat_dist(r, ref_mat))

    # transpose to have each row for each input datapoint
    # each column for each centroids
    cbind(t(dist_mat), max.col(-t(dist_mat)))
}

etapa 3. aplique a função mat2mat

calc_mat2mat_dist(my_input_mat, kmeans_model$centers)

Passo 4. Opcionalmente, use plyr :: ddply e doMC para paralelizar mat2mat para grandes conjuntos de dados

library(doMC)
library(plyr)

pred_cluster_para = function(input_df, center_mat, cl_feat, id_cols, use_ncore = 8) {
    # assign cluster lables for each individual (row) in the input_df 
    # input: input_df   - dataframe with all features used in clustering, plus some id/indicator columns
    # input: center_mat - matrix of centroid, K rows by M features
    # input: cl_feat    - list of features (col names)
    # input: id_cols    - list of index cols (e.g. id) to include in output 
    # output: output_df - dataframe with same number of rows as input, 
    #         K columns of distances to each clusters
    #         1 column of cluster_labels
    #         x column of indices in idx_cols

    n_cluster = nrow(center_mat)
    n_feat = ncol(center_mat)
    n_input = nrow(input_df)

    if(!(typeof(center_mat) %in% c('double','interger') & is.matrix(center_mat))){
        stop('The argument "center_mat" must be numeric matrix')
    } else if(length(cl_feat) != n_feat) {
        stop(sprintf('cl_feat size: %d , center_mat n_col: %d, they have to match!',length(cl_feat), n_feat))
    } else {
        # register MultiCore backend through doMC and foreach package
        doMC::registerDoMC(cores = use_ncore)

        # create job_key for mapping/spliting the input data
        input_df[,'job_idx'] = sample(1:use_ncore, n_input, replace = TRUE)

        # create row_key for tracing the original row order which will be shuffled by mapreduce
        input_df[,'row_idx'] = seq(n_input)

        # use ddply (df input, df output) to split-process-combine
        output_df = ddply(
            input_df[, c('job_idx','row_idx',cl_feat,id_cols)], # input big data 
            'job_idx',                       # map/split by job_idx
            function(chunk) {                # work on each chunk
                dist = data.frame(calc_mat2mat_dist(chunk[,cl_feat], center_mat))
                names(dist) = c(paste0('dist2c_', seq(n_cluster)), 'pred_cluster')
                dist[,id_cols] = chunk[,id_cols]
                dist[,'row_idx'] = chunk[,'row_idx']
                dist                        # product of mapper
                        }, .parallel = TRUE) # end of ddply
        # sort back to original row order

        output_df = output_df[order(output_df$row_idx),]
        output_df[c('job_idx')] = NULL
        return(output_df)
    }

}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.