Níveis de fator de queda em um quadro de dados subconjuntos

Eu tenho um quadro de dados contendo um factor. Quando eu crio um subconjunto desse quadro de dados usando subsetou outra função de indexação, um novo quadro de dados é criado. No entanto, a factorvariável mantém todos os seus níveis originais, mesmo quando / se eles não existirem no novo quadro de dados.

Isso causa problemas ao fazer plotagens facetadas ou ao usar funções que dependem de níveis de fatores.

Qual é a maneira mais sucinta de remover níveis de um fator no novo quadro de dados?

Aqui está um exemplo:

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"

Tudo o que você deve fazer é aplicar o fator () à sua variável novamente após o 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

No exemplo da página de fatores:

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

Para eliminar níveis de todas as colunas de fatores em um quadro de dados, você pode usar:

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

Desde a versão 2.12 do R, há uma droplevels()função.

levels(droplevels(subdf$letters))

Se você não deseja esse comportamento, não use fatores, use vetores de caracteres. Eu acho que isso faz mais sentido do que consertar as coisas depois. Tente o seguinte antes de carregar seus dados com read.tableou read.csv:

options(stringsAsFactors = FALSE)

A desvantagem é que você está restrito à ordem alfabética. (reordenar é seu amigo para terrenos)

É um problema conhecido, e um possível remédio é fornecido drop.levels()no pacote gdata em que seu exemplo se torna

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

Há também a dropUnusedLevelsfunção no pacote Hmisc . No entanto, ele funciona apenas alterando o operador de subconjunto [e não é aplicável aqui.

Como corolário, uma abordagem direta por coluna é simples 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"

Outra maneira de fazer o mesmo, mas com dplyr

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

Editar:

Também funciona! Graças a agenis

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

Por uma questão de completude, agora também existe fct_dropno forcatspacote http://forcats.tidyverse.org/reference/fct_drop.html .

Difere da droplevelsmaneira como lida com 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

Aqui está outra maneira, que acredito ser equivalente à factor(..)abordagem:

> 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"

Isso é desagradável. É assim que eu costumo fazer isso, para evitar carregar outros pacotes:

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

que você recebe:

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

Observe que os novos níveis substituirão o que ocupa seu índice nos níveis antigos (subdf $ letters), então algo como:

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

não vai funcionar.

Obviamente, isso não é ideal quando você tem muitos níveis, mas, para alguns, é rápido e fácil.

Observando o código dos droplevelsmétodos na fonte R, você pode vê- lo factorfuncionar. Isso significa que você pode basicamente recriar a coluna com a factorfunção
Abaixo da maneira data.table para reduzir os níveis de todas as colunas de fatores.

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"

aqui está uma maneira de fazer isso

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

Eu escrevi funções utilitárias para fazer isso. Agora que eu sei sobre o drop.levels do gdata, parece bastante semelhante. Aqui estão eles ( daqui ):

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
}

Tópico muito interessante, gostei especialmente da ideia de fatorar novamente a subseleção. Eu tive o problema semelhante antes e acabei de converter em caractere e depois voltar ao fator.

   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))

Infelizmente, factor () parece não funcionar ao usar o rxDataStep do RevoScaleR. Eu faço isso em duas etapas: 1) Converta em caractere e armazene no quadro de dados externo temporário (.xdf). 2) Converta de volta ao fator e armazene no quadro de dados externo definitivo. Isso elimina qualquer nível de fator não utilizado, sem carregar todos os dados na memória.

# 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)

Tentei a maioria dos exemplos aqui, se não todos, mas nenhum parece estar funcionando no meu caso. Depois de lutar por algum tempo, tentei usar as.character () na coluna de fator para alterá-lo para um col com strings que parece estar funcionando bem.

Não tenho certeza sobre problemas de desempenho.