Caída de niveles de factores en un marco de datos subconjunto

Tengo un marco de datos que contiene a factor. Cuando creo un subconjunto de este marco de datos usando subsetu otra función de indexación, se crea un nuevo marco de datos. Sin embargo, la factorvariable conserva todos sus niveles originales, incluso cuando / si no existen en el nuevo marco de datos.

Esto causa problemas al hacer trazados facetados o al usar funciones que dependen de niveles de factores.

¿Cuál es la forma más sucinta de eliminar niveles de un factor en el nuevo marco de datos?

Aquí hay un ejemplo:

df <- data.frame(letters=letters[1:5],
                    numbers=seq(1:5))

levels(df$letters)
## [1] "a" "b" "c" "d" "e"

subdf <- subset(df, numbers <= 3)
##   letters numbers
## 1       a       1
## 2       b       2
## 3       c       3    

# all levels are still there!
levels(subdf$letters)
## [1] "a" "b" "c" "d" "e"

Todo lo que debe hacer es aplicar factor () a su variable nuevamente después de subconjunto:

> subdf$letters
[1] a b c
Levels: a b c d e
subdf$letters <- factor(subdf$letters)
> subdf$letters
[1] a b c
Levels: a b c

EDITAR

Del ejemplo de la página de factores:

factor(ff)      # drops the levels that do not occur

Para eliminar niveles de todas las columnas de factores en un marco de datos, puede usar:

subdf <- subset(df, numbers <= 3)
subdf[] <- lapply(subdf, function(x) if(is.factor(x)) factor(x) else x)

Desde R versión 2.12, hay una droplevels()función.

levels(droplevels(subdf$letters))

Si no desea este comportamiento, no use factores, use vectores de caracteres en su lugar. Creo que esto tiene más sentido que arreglar las cosas después. Pruebe lo siguiente antes de cargar sus datos con read.tableo read.csv:

options(stringsAsFactors = FALSE)

La desventaja es que está restringido al orden alfabético. (reordenar es tu amigo para las parcelas)

Es un problema conocido, y drop.levels()el paquete gdata proporciona un posible remedio donde su ejemplo se convierte

> drop.levels(subdf)
  letters numbers
1       a       1
2       b       2
3       c       3
> levels(drop.levels(subdf)$letters)
[1] "a" "b" "c"

También existe la dropUnusedLevelsfunción en el paquete Hmisc . Sin embargo, solo funciona alterando el operador del subconjunto [y no es aplicable aquí.

Como corolario, un enfoque directo por columna es simple as.factor(as.character(data)):

> levels(subdf$letters)
[1] "a" "b" "c" "d" "e"
> subdf$letters <- as.factor(as.character(subdf$letters))
> levels(subdf$letters)
[1] "a" "b" "c"

Otra forma de hacer lo mismo pero con dplyr

library(dplyr)
subdf <- df %>% filter(numbers <= 3) %>% droplevels()
str(subdf)

Editar:

También funciona! Gracias a agenis

subdf <- df %>% filter(numbers <= 3) %>% droplevels
levels(subdf$letters)

En aras de la exhaustividad, ahora también hay fct_dropen el forcatspaquete http://forcats.tidyverse.org/reference/fct_drop.html .

Se diferencia de droplevelsla forma en que trata NA:

f <- factor(c("a", "b", NA), exclude = NULL)

droplevels(f)
# [1] a    b    <NA>
# Levels: a b <NA>

forcats::fct_drop(f)
# [1] a    b    <NA>
# Levels: a b

Aquí hay otra forma, que creo que es equivalente al factor(..)enfoque:

> df <- data.frame(let=letters[1:5], num=1:5)
> subdf <- df[df$num <= 3, ]

> subdf$let <- subdf$let[ , drop=TRUE]

> levels(subdf$let)
[1] "a" "b" "c"

Esto es desagradable. Así es como lo hago generalmente, para evitar cargar otros paquetes:

levels(subdf$letters)<-c("a","b","c",NA,NA)

que te lleva a:

> subdf$letters
[1] a b c
Levels: a b c

Tenga en cuenta que los nuevos niveles reemplazarán todo lo que ocupe su índice en los niveles anteriores (subdf $ letras), así que algo como:

levels(subdf$letters)<-c(NA,"a","c",NA,"b")

no funciona

Obviamente, esto no es ideal cuando tienes muchos niveles, pero para unos pocos, es rápido y fácil.

Mirando el código dedroplevels métodos en la fuente R, puede ver que se ajusta para factorfuncionar. Eso significa que básicamente puede recrear la columna con la factorfunción.
Debajo de la forma data.table de eliminar niveles de todas las columnas de factores.

library(data.table)
dt = data.table(letters=factor(letters[1:5]), numbers=seq(1:5))
levels(dt$letters)
#[1] "a" "b" "c" "d" "e"
subdt = dt[numbers <= 3]
levels(subdt$letters)
#[1] "a" "b" "c" "d" "e"

upd.cols = sapply(subdt, is.factor)
subdt[, names(subdt)[upd.cols] := lapply(.SD, factor), .SDcols = upd.cols]
levels(subdt$letters)
#[1] "a" "b" "c"

aquí hay una manera de hacerlo

varFactor <- factor(letters[1:15])
varFactor <- varFactor[1:5]
varFactor <- varFactor[drop=T]

Escribí funciones de utilidad para hacer esto. Ahora que sé sobre los niveles de caída de gdata, se ve bastante similar. Aquí están (desde aquí ):

present_levels <- function(x) intersect(levels(x), x)

trim_levels <- function(...) UseMethod("trim_levels")

trim_levels.factor <- function(x)  factor(x, levels=present_levels(x))

trim_levels.data.frame <- function(x) {
  for (n in names(x))
    if (is.factor(x[,n]))
      x[,n] = trim_levels(x[,n])
  x
}

Hilo muy interesante, me gustó especialmente la idea de factorizar nuevamente la subselección. Tuve el problema similar antes y simplemente me convertí en personaje y luego volví a factorizar.

   df <- data.frame(letters=letters[1:5],numbers=seq(1:5))
   levels(df$letters)
   ## [1] "a" "b" "c" "d" "e"
   subdf <- df[df$numbers <= 3]
   subdf$letters<-factor(as.character(subdf$letters))

Desafortunadamente, el factor () no parece funcionar cuando se usa rxDataStep de RevoScaleR. Lo hago en dos pasos: 1) Convertir a carácter y almacenar en un marco de datos externo temporal (.xdf). 2) Convertir de nuevo a factor y almacenar en un marco de datos externo definitivo. Esto elimina los niveles de factores no utilizados, sin cargar todos los datos en la memoria.

# Step 1) Converts to character, in temporary xdf file:
rxDataStep(inData = "input.xdf", outFile = "temp.xdf", transforms = list(VAR_X = as.character(VAR_X)), overwrite = T)
# Step 2) Converts back to factor:
rxDataStep(inData = "temp.xdf", outFile = "output.xdf", transforms = list(VAR_X = as.factor(VAR_X)), overwrite = T)

He probado la mayoría de los ejemplos aquí, si no todos, pero ninguno parece estar funcionando en mi caso. Después de luchar durante bastante tiempo, he intentado usar as.character () en la columna de factores para cambiarlo a una columna con cadenas que parece funcionar bien.

No estoy seguro de los problemas de rendimiento.