sheet - ¿Por qué las funciones de Lubridate son tan lentas en comparación con as.POSIXct?

posixct to date r

Question

Como dice el título. ¿Por qué la función de lubricación es mucho más lenta?

library(lubridate)
library(microbenchmark)

Dates <- sample(c(dates = format(seq(ISOdate(2010,1,1), by=''day'', length=365), format=''%d-%m-%Y'')), 50000, replace = TRUE)

microbenchmark(as.POSIXct(Dates, format = "%d-%b-%Y %H:%M:%S", tz = "GMT"), times = 100)
microbenchmark(dmy(Dates, tz ="GMT"), times = 100)

Unit: milliseconds
expr                                                            min         lq          median      uq          max
1 as.POSIXct(Dates, format = "%d-%b-%Y %H:%M:%S", tz = "GMT")   103.1902    104.3247    108.675     109.2632    149.871
2 dmy(Dates, tz = "GMT")                                        184.4871    194.1504    197.8422    214.3771    268.4911

Answer 1

La respuesta de @Tyler es correcta. Aquí hay más información, que incluye un consejo para hacer que Lubridate sea más rápido , desde el archivo de ayuda:

"Lubridate tiene un analizador POSIX muy rápido incorporado, portado desde el paquete de fasttime por Simon Urbanek. Esta funcionalidad aún es opcional y podría activarse con opciones (lubridate.fasttime = TRUE). Lubridate detectará automáticamente las cadenas POSIX y usará el analizador rápido en su lugar de la utilidad por defecto strptime ".

Answer 2

Por la misma razón, los automóviles son lentos en comparación con los que se montan sobre cohetes . La facilidad de uso y la seguridad añadidas hacen que los automóviles sean mucho más lentos que un cohete, pero es menos probable que exploten y es más fácil arrancar, manejar y frenar un automóvil. Sin embargo, en la situación correcta (por ejemplo, necesito llegar a la luna), el cohete es la herramienta adecuada para el trabajo. Ahora, si alguien inventara un automóvil con un cohete atado al techo, tendríamos algo.

Comience observando lo que está haciendo dmy y verá la diferencia en la velocidad (por cierto, a partir de sus bechmarks, no diría que el lubridate es mucho más lento, ya que estos están en milisegundos):

dmy escribe esto en la línea de comandos y obtienes:

>dmy
function (..., quiet = FALSE, tz = "UTC") 
{
    dates <- unlist(list(...))
    parse_date(num_to_date(dates), make_format("dmy"), quiet = quiet, 
        tz = tz)
}
<environment: namespace:lubridate>

De inmediato veo parse_date y num_to_date y make_format . Hace que uno se pregunte qué son todos estos chicos. Veamos:

parse_date

> parse_date
function (x, formats, quiet = FALSE, seps = find_separator(x), 
    tz = "UTC") 
{
    fmt <- guess_format(head(x, 100), formats, seps, quiet)
    parsed <- as.POSIXct(strptime(x, fmt, tz = tz))
    if (length(x) > 2 & !quiet) 
        message("Using date format ", fmt, ".")
    failed <- sum(is.na(parsed)) - sum(is.na(x))
    if (failed > 0) {
        message(failed, " failed to parse.")
    }
    parsed
}
<environment: namespace:lubridate>

num_to_date

> getAnywhere(num_to_date)
A single object matching ‘num_to_date’ was found
It was found in the following places
  namespace:lubridate
with value

function (x) 
{
    if (is.numeric(x)) {
        x <- as.character(x)
        x <- paste(ifelse(nchar(x)%%2 == 1, "0", ""), x, sep = "")
    }
    x
}
<environment: namespace:lubridate>

make_format

> getAnywhere(make_format)
A single object matching ‘make_format’ was found
It was found in the following places
  namespace:lubridate
with value

function (order) 
{
    order <- strsplit(order, "")[[1]]
    formats <- list(d = "%d", m = c("%m", "%b"), y = c("%y", 
        "%Y"))[order]
    grid <- expand.grid(formats, KEEP.OUT.ATTRS = FALSE, stringsAsFactors = FALSE)
    lapply(1:nrow(grid), function(i) unname(unlist(grid[i, ])))
}
<environment: namespace:lubridate>

Wow, obtuvimos las strsplit-ting , la expand-ing.grid-s , el paste-ing , la unname-ing , el unname-ing etc. más una Comprobación de Error de Lotta Completa (Reproducir en la canción de Zep). Entonces, lo que tenemos aquí es un buen azúcar sintáctica. Mmmmm sabroso pero viene con un precio, velocidad.

Compare eso con as.POSIXct :

getAnywhere(as.POSIXct)  #tells us to use methods to see the business
methods(''as.POSIXct'')    #tells us all the business
as.POSIXct.date          #what I believe your code is using (I don''t use dates though)

Hay mucha más codificación interna y menos verificación de errores con as.POSICct Entonces, ¿tiene que preguntar si quiero facilidad y seguridad o velocidad y potencia? Depende del trabajo.