Comment convertir un facteur en entier \ numérique sans perte d'informations?

Lorsque je convertis un facteur en numérique ou en entier, j'obtiens les codes de niveau sous-jacents, pas les valeurs sous forme de nombres.

f <- factor(sample(runif(5), 20, replace = TRUE))
##  [1] 0.0248644019011408 0.0248644019011408 0.179684827337041 
##  [4] 0.0284090070053935 0.363644931698218  0.363644931698218 
##  [7] 0.179684827337041  0.249704354675487  0.249704354675487 
## [10] 0.0248644019011408 0.249704354675487  0.0284090070053935
## [13] 0.179684827337041  0.0248644019011408 0.179684827337041 
## [16] 0.363644931698218  0.249704354675487  0.363644931698218 
## [19] 0.179684827337041  0.0284090070053935
## 5 Levels: 0.0248644019011408 0.0284090070053935 ... 0.363644931698218

as.numeric(f)
##  [1] 1 1 3 2 5 5 3 4 4 1 4 2 3 1 3 5 4 5 3 2

as.integer(f)
##  [1] 1 1 3 2 5 5 3 4 4 1 4 2 3 1 3 5 4 5 3 2

Je dois y recourir pastepour obtenir les vraies valeurs:

as.numeric(paste(f))
##  [1] 0.02486440 0.02486440 0.17968483 0.02840901 0.36364493 0.36364493
##  [7] 0.17968483 0.24970435 0.24970435 0.02486440 0.24970435 0.02840901
## [13] 0.17968483 0.02486440 0.17968483 0.36364493 0.24970435 0.36364493
## [19] 0.17968483 0.02840901

Existe-t-il une meilleure façon de convertir un facteur en numérique?

Voir la section Avertissement de ?factor:

En particulier, as.numericappliqué à un facteur n'a pas de sens et peut se produire par contrainte implicite. Pour transformer un facteur fà approximativement ses valeurs numériques d'origine, il as.numeric(levels(f))[f]est recommandé et légèrement plus efficace que as.numeric(as.character(f)).

La FAQ sur R contient des conseils similaires .

Pourquoi est as.numeric(levels(f))[f]plus efficace que as.numeric(as.character(f))?

as.numeric(as.character(f))est efficace as.numeric(levels(f)[f]), vous effectuez donc la conversion en numérique sur des length(x)valeurs plutôt que sur des nlevels(x)valeurs. La différence de vitesse sera plus apparente pour les vecteurs longs avec peu de niveaux. Si les valeurs sont pour la plupart uniques, il n'y aura pas beaucoup de différence de vitesse. Quelle que soit la façon dont vous effectuez la conversion, il est peu probable que cette opération soit le goulot d'étranglement dans votre code, alors ne vous en faites pas trop.

Quelques horaires

library(microbenchmark)
microbenchmark(
  as.numeric(levels(f))[f],
  as.numeric(levels(f)[f]),
  as.numeric(as.character(f)),
  paste0(x),
  paste(x),
  times = 1e5
)
## Unit: microseconds
##                         expr   min    lq      mean median     uq      max neval
##     as.numeric(levels(f))[f] 3.982 5.120  6.088624  5.405  5.974 1981.418 1e+05
##     as.numeric(levels(f)[f]) 5.973 7.111  8.352032  7.396  8.250 4256.380 1e+05
##  as.numeric(as.character(f)) 6.827 8.249  9.628264  8.534  9.671 1983.694 1e+05
##                    paste0(x) 7.964 9.387 11.026351  9.956 10.810 2911.257 1e+05
##                     paste(x) 7.965 9.387 11.127308  9.956 11.093 2419.458 1e+05

R a un certain nombre de fonctions pratiques (non documentées) pour convertir les facteurs:

• as.character.factor
• as.data.frame.factor
• as.Date.factor
• as.list.factor
• as.vector.factor
• ...

Mais ennuyeux, il n'y a rien pour gérer le facteur -> conversion numérique . Dans le prolongement de la réponse de Joshua Ulrich, je suggère de surmonter cette omission avec la définition de votre propre fonction idiomatique:

as.numeric.factor <- function(x) {as.numeric(levels(x))[x]}

que vous pouvez stocker au début de votre script, ou mieux encore dans votre .Rprofilefichier.

La façon la plus simple serait d'utiliser la unfactorfonction du package varhandle

unfactor(your_factor_variable)

Cet exemple peut être un démarrage rapide:

x <- rep(c("a", "b", "c"), 20)
y <- rep(c(1, 1, 0), 20)

class(x)  # -> "character"
class(y)  # -> "numeric"

x <- factor(x)
y <- factor(y)

class(x)  # -> "factor"
class(y)  # -> "factor"

library(varhandle)
x <- unfactor(x)
y <- unfactor(y)

class(x)  # -> "character"
class(y)  # -> "numeric"

Remarque: cette réponse particulière n'est pas pour convertir des facteurs à valeur numérique en chiffres, c'est pour convertir des facteurs catégoriels en leurs numéros de niveau correspondants.

Chaque réponse dans ce post n'a pas généré de résultats pour moi, les NA étaient générées.

y2<-factor(c("A","B","C","D","A")); 
as.numeric(levels(y2))[y2] 
[1] NA NA NA NA NA Warning message: NAs introduced by coercion

Ce qui a fonctionné pour moi, c'est ceci -

as.integer(y2)
# [1] 1 2 3 4 1

C'est possible seulement dans le cas où les étiquettes de facteurs correspondent aux valeurs d'origine. Je vais l'expliquer avec un exemple.

Supposons que les données soient vectorielles x:

x <- c(20, 10, 30, 20, 10, 40, 10, 40)

Je vais maintenant créer un facteur avec quatre étiquettes:

f <- factor(x, levels = c(10, 20, 30, 40), labels = c("A", "B", "C", "D"))

1) xest de type double, fest de type entier. Il s'agit de la première perte inévitable d'informations. Les facteurs sont toujours stockés sous forme d'entiers.

> typeof(x)
[1] "double"
> typeof(f)
[1] "integer"

2) Il n'est pas possible de revenir aux valeurs d'origine (10, 20, 30, 40) ayant uniquement fdisponible. Nous pouvons voir que fne contient que les valeurs entières 1, 2, 3, 4 et deux attributs - la liste des étiquettes ("A", "B", "C", "D") et l'attribut de classe "facteur". Rien de plus.

> str(f)
 Factor w/ 4 levels "A","B","C","D": 2 1 3 2 1 4 1 4
> attributes(f)
$levels
[1] "A" "B" "C" "D"

$class
[1] "factor"

Pour revenir aux valeurs d'origine, nous devons connaître les valeurs des niveaux utilisés pour créer le facteur. Dans ce cas c(10, 20, 30, 40). Si nous connaissons les niveaux d'origine (dans le bon ordre), nous pouvons revenir aux valeurs d'origine.

> orig_levels <- c(10, 20, 30, 40)
> x1 <- orig_levels[f]
> all.equal(x, x1)
[1] TRUE

Et cela ne fonctionnera que si des étiquettes ont été définies pour toutes les valeurs possibles dans les données d'origine.

Donc, si vous avez besoin des valeurs d'origine, vous devez les conserver. Sinon, il y a de fortes chances qu'il ne soit pas possible d'y revenir uniquement à partir d'un facteur.

Vous pouvez utiliser hablar::convertsi vous avez un bloc de données. La syntaxe est simple:

Exemple df

library(hablar)
library(dplyr)

df <- dplyr::tibble(a = as.factor(c("7", "3")),
                    b = as.factor(c("1.5", "6.3")))

Solution

df %>% 
  convert(num(a, b))

vous donne:

# A tibble: 2 x 2
      a     b
  <dbl> <dbl>
1    7.  1.50
2    3.  6.30

Ou si vous voulez qu'une colonne soit un entier et un numérique:

df %>% 
  convert(int(a),
          num(b))

résulte en:

# A tibble: 2 x 2
      a     b
  <int> <dbl>
1     7  1.50
2     3  6.30

On dirait que la solution as.numeric (levels (f)) [f] ne fonctionne plus avec R 4.0.

Solution alternative:

factor2number <- function(x){
    data.frame(levels(x), 1:length(levels(x)), row.names = 1)[x, 1]
}

factor2number(yourFactor)

D'après les nombreuses réponses que j'ai pu lire, la seule façon donnée était d'augmenter le nombre de variables en fonction du nombre de facteurs. Si vous avez une variable "animal de compagnie" avec les niveaux "chien" et "chat", vous vous retrouvez avec pet_dog et pet_cat.

Dans mon cas, je voulais rester avec le même nombre de variables, en traduisant simplement la variable facteur en une variable numérique, d'une manière qui peut s'appliquer à de nombreuses variables à plusieurs niveaux, de sorte que cat = 1 et dog = 0 par exemple.

Veuillez trouver la solution correspondante ci-dessous:

crime <- data.frame(city = c("SF", "SF", "NYC"),
                    year = c(1990, 2000, 1990),
                    crime = 1:3)

indx <- sapply(crime, is.factor)

crime[indx] <- lapply(crime[indx], function(x){ 
  listOri <- unique(x)
  listMod <- seq_along(listOri)
  res <- factor(x, levels=listOri)
  res <- as.numeric(res)
  return(res)
}
)

tard dans le jeu, par accident, j'ai trouvé trimws()peut se convertir factor(3:5)en c("3","4","5"). Ensuite, vous pouvez appeler as.numeric(). C'est:

as.numeric(trimws(x_factor_var))