Baisse des niveaux de facteur dans une trame de données sous-réglée

J'ai un bloc de données contenant un factor. Lorsque je crée un sous-ensemble de cette trame de données à l'aide de subsetou d'une autre fonction d'indexation, une nouvelle trame de données est créée. Cependant, lefactor variable conserve tous ses niveaux d'origine, même si / s'ils n'existent pas dans la nouvelle trame de données.

Cela pose des problèmes lors du traçage à facettes ou de l'utilisation de fonctions qui dépendent des niveaux de facteur.

Quelle est la manière la plus succincte de supprimer des niveaux d'un facteur dans la nouvelle trame de données?

Voici un exemple:

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"

Tout ce que vous devez faire est d'appliquer à nouveau le facteur () à votre variable après le sous-ensemble:

> 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

ÉDITER

Dans l'exemple de la page factorielle:

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

Pour supprimer des niveaux de toutes les colonnes de facteurs dans une trame de données, vous pouvez utiliser:

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

Depuis R version 2.12, il existe une droplevels()fonction.

levels(droplevels(subdf$letters))

Si vous ne voulez pas de ce comportement, n'utilisez pas de facteurs, utilisez plutôt des vecteurs de caractères. Je pense que cela a plus de sens que de rafistoler les choses par la suite. Essayez ce qui suit avant de charger vos données avec read.tableou read.csv:

options(stringsAsFactors = FALSE)

L'inconvénient est que vous êtes limité à l'ordre alphabétique. (réorganiser est votre ami pour les parcelles)

Il s'agit d'un problème connu, et un remède possible est fourni par drop.levels()dans le package gdata où votre exemple devient

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

Il y a aussi la dropUnusedLevelsfonction dans le package Hmisc . Cependant, cela ne fonctionne qu'en modifiant l'opérateur de sous-ensemble [et n'est pas applicable ici.

En corollaire, une approche directe colonne par colonne est 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"

Une autre façon de faire la même chose mais avec dplyr

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

Éditer:

Fonctionne également! Merci à agenis

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

Par souci d'exhaustivité, il y a maintenant également fct_dropdans le forcatspackage http://forcats.tidyverse.org/reference/fct_drop.html .

Il diffère de droplevelsla manière dont il traite 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

Voici une autre façon, qui je crois est équivalente à l' factor(..)approche:

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

C'est désagréable. Voici comment je le fais habituellement, pour éviter de charger d'autres packages:

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

ce qui vous donne:

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

Notez que les nouveaux niveaux remplaceront tout ce qui occupe leur index dans les anciens niveaux (lettres subdf $), donc quelque chose comme:

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

ne fonctionnera pas.

Ce n'est évidemment pas idéal lorsque vous avez beaucoup de niveaux, mais pour certains, c'est rapide et facile.

En regardant le code desdroplevels méthodes dans la source R, vous pouvez voir qu'il factorfonctionne correctement . Cela signifie que vous pouvez recréer la colonne avec une factorfonction.
Sous le moyen data.table pour supprimer les niveaux de toutes les colonnes de facteurs.

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"

voici une façon de le faire

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

J'ai écrit des fonctions utilitaires pour ce faire. Maintenant que je connais les drop.levels de gdata, cela semble assez similaire. Les voici (d' ici ):

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
}

Fil très intéressant, j'ai particulièrement aimé l'idée de simplement factoriser à nouveau la sous-sélection. J'ai eu le même problème avant et je viens de convertir en personnage, puis de nouveau en facteur.

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

Malheureusement, factor () ne semble pas fonctionner lors de l'utilisation de rxDataStep de RevoScaleR. Je le fais en deux étapes: 1) Convertir en caractère et stocker dans un cadre de données externe temporaire (.xdf). 2) Convertissez à nouveau en facteur et stockez dans une trame de données externe définitive. Cela élimine tous les niveaux de facteur inutilisés, sans charger toutes les données en mémoire.

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

J'ai essayé la plupart des exemples ici, sinon tous, mais aucun ne semble fonctionner dans mon cas. Après avoir lutté pendant un certain temps, j'ai essayé d'utiliser as.character () sur la colonne factor pour le changer en un col avec des chaînes qui semble fonctionner très bien.

Pas sûr pour les problèmes de performances.