¿Cómo convertir un factor a entero \ numérico sin pérdida de información?

Cuando convierto un factor a un valor numérico o entero, obtengo los códigos de nivel subyacentes, no los valores como números.

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

Tengo que recurrir a pastepara obtener los valores reales:

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

¿Hay una mejor manera de convertir un factor a numérico?

Vea la sección de Advertencia de ?factor:

En particular, as.numericaplicado a un factor no tiene sentido, y puede ocurrir por coerción implícita. Para transformar un factor fa aproximadamente sus valores numéricos originales, as.numeric(levels(f))[f]se recomienda y un poco más eficiente que as.numeric(as.character(f)).

Las preguntas frecuentes sobre R tienen consejos similares .

¿Por qué es as.numeric(levels(f))[f]más eficiente que as.numeric(as.character(f))?

as.numeric(as.character(f))es efectivo as.numeric(levels(f)[f]), por lo que está realizando la conversión a length(x)valores numéricos en lugar de nlevels(x)valores. La diferencia de velocidad será más evidente para los vectores largos con pocos niveles. Si los valores son en su mayoría únicos, no habrá mucha diferencia en la velocidad. Independientemente de cómo realice la conversión, es poco probable que esta operación sea el cuello de botella en su código, así que no se preocupe demasiado por eso.

Algunos horarios

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 tiene varias funciones de conveniencia (no documentadas) para convertir factores:

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

Pero molestamente, no hay nada para manejar el factor -> conversión numérica . Como una extensión de la respuesta de Joshua Ulrich, sugeriría superar esta omisión con la definición de su propia función idiomática:

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

que puede almacenar al comienzo de su secuencia de comandos, o incluso mejor en su .Rprofilearchivo.

La forma más fácil sería usar la unfactorfunción del paquete varhandle

unfactor(your_factor_variable)

Este ejemplo puede ser un comienzo rápido:

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"

Nota: esta respuesta en particular no es para convertir factores de valor numérico a numéricos, es para convertir factores categóricos a sus números de nivel correspondientes.

Cada respuesta en esta publicación no pudo generar resultados para mí, se estaban generando NA.

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

Lo que funcionó para mí es esto:

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

Es posible solamente en el caso en que las etiquetas de los factores coinciden con los valores originales. Lo explicaré con un ejemplo.

Suponga que los datos son vectores x:

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

Ahora crearé un factor con cuatro etiquetas:

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

1) xes con tipo doble, fes con tipo entero. Esta es la primera pérdida inevitable de información. Los factores siempre se almacenan como enteros.

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

2) No es posible volver a los valores originales (10, 20, 30, 40) que solo están fdisponibles. Podemos ver que fsolo contiene valores enteros 1, 2, 3, 4 y dos atributos: la lista de etiquetas ("A", "B", "C", "D") y el atributo de clase "factor". Nada mas.

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

Para volver a los valores originales, debemos conocer los valores de los niveles utilizados para crear el factor. En este caso c(10, 20, 30, 40). Si conocemos los niveles originales (en el orden correcto), podemos volver a los valores originales.

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

Y esto solo funcionará en caso de que se hayan definido etiquetas para todos los valores posibles en los datos originales.

Entonces, si necesita los valores originales, debe conservarlos. De lo contrario, existe una alta probabilidad de que no sea posible volver a ellos solo por un factor.

Puede usar hablar::convertsi tiene un marco de datos. La sintaxis es fácil:

Muestra df

library(hablar)
library(dplyr)

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

Solución

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

te dio:

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

O si desea que una columna sea entera y una numérica:

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

resultados en:

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

Parece que la solución como.numeric (niveles (f)) [f] ya no funciona con R 4.0.

Solución alternativa:

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

factor2number(yourFactor)

De las muchas respuestas que pude leer, la única forma dada fue expandir el número de variables de acuerdo con el número de factores. Si tiene una "mascota" variable con los niveles "perro" y "gato", terminaría con pet_dog y pet_cat.

En mi caso, quería quedarme con el mismo número de variables, simplemente traduciendo la variable del factor a una numérica, de manera que pueda aplicarse a muchas variables con muchos niveles, de modo que cat = 1 y dog ​​= 0, por ejemplo.

Encuentre la solución correspondiente a continuación:

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

tarde al juego, accidentalmente, me encontré trimws()convertido lata factor(3:5)a c("3","4","5"). Entonces puedes llamar as.numeric(). Es decir:

as.numeric(trimws(x_factor_var))