Почему as.Date замедляет вектор символа?

Ответ 1

Я думаю, что только as.Date преобразует character в Date через POSIXlt, используя strptime. И strptime очень медленный, я считаю.

Чтобы проследить его через себя, введите as.Date, затем methods(as.Date), а затем посмотрите на метод character.

> as.Date
function (x, ...) 
UseMethod("as.Date")
<bytecode: 0x2cf4b20>
<environment: namespace:base>

> methods(as.Date)
[1] as.Date.character as.Date.date      as.Date.dates     as.Date.default  
[5] as.Date.factor    as.Date.IDate*    as.Date.numeric   as.Date.POSIXct  
[9] as.Date.POSIXlt  
   Non-visible functions are asterisked

> as.Date.character
function (x, format = "", ...) 
{
    charToDate <- function(x) {
        xx <- x[1L]
        if (is.na(xx)) {
            j <- 1L
            while (is.na(xx) && (j <- j + 1L) <= length(x)) xx <- x[j]
            if (is.na(xx)) 
                f <- "%Y-%m-%d"
        }
        if (is.na(xx) || !is.na(strptime(xx, f <- "%Y-%m-%d", 
            tz = "GMT")) || !is.na(strptime(xx, f <- "%Y/%m/%d", 
            tz = "GMT"))) 
            return(strptime(x, f))
        stop("character string is not in a standard unambiguous format")
    }
    res <- if (missing(format)) 
        charToDate(x)
    else strptime(x, format, tz = "GMT")       ####  slow part, I think  ####
    as.Date(res)
}
<bytecode: 0x2cf6da0>
<environment: namespace:base>
> 

Почему as.POSIXlt(Date)$year+1900 относительно быстро? Снова проследите его:

> as.POSIXct
function (x, tz = "", ...) 
UseMethod("as.POSIXct")
<bytecode: 0x2936de8>
<environment: namespace:base>

> methods(as.POSIXct)
[1] as.POSIXct.date    as.POSIXct.Date    as.POSIXct.dates   as.POSIXct.default
[5] as.POSIXct.IDate*  as.POSIXct.ITime*  as.POSIXct.numeric as.POSIXct.POSIXlt
   Non-visible functions are asterisked

> as.POSIXlt.Date
function (x, ...) 
{
    y <- .Internal(Date2POSIXlt(x))
    names(y$year) <- names(x)
    y
}
<bytecode: 0x395e328>
<environment: namespace:base>
> 

Заинтригованный, пусть выкапывает в Date2POSIXlt. Для этого бита нам нужно grep main/src узнать, какой файл .c посмотреть на.

~/R/Rtrunk/src/main$ grep Date2POSIXlt *
names.c:{"Date2POSIXlt",do_D2POSIXlt,   0,  11, 1,  {PP_FUNCALL, PREC_FN,   0}},
$

Теперь мы знаем, что нам нужно искать D2POSIXlt:

~/R/Rtrunk/src/main$ grep D2POSIXlt *
datetime.c:SEXP attribute_hidden do_D2POSIXlt(SEXP call, SEXP op, SEXP args, SEXP env)
names.c:{"Date2POSIXlt",do_D2POSIXlt,   0,  11, 1,  {PP_FUNCALL, PREC_FN,   0}},
$

О, мы могли бы предположить datetime.c. В любом случае, посмотрев последнюю живую копию:

datetime.c

Найдите там D2POSIXlt, и вы увидите, как просто перейти от даты (числовой) к POSIXlt. Вы также увидите, как POSIXlt - один реальный вектор (8 байт) плюс семь целых векторов (по 4 байта). Это 40 байт за день!

Итак, суть проблемы (я думаю) в том, почему strptime настолько медленная, и, возможно, это может быть улучшено в R. Или просто избегайте POSIXlt, прямо или косвенно.

Здесь воспроизводимый пример с использованием количества предметов, указанных в вопросе (3 000 000):

> Range = seq(as.Date("2000-01-01"),as.Date("2012-01-01"),by="days")
> Date = format(sample(Range,3000000,replace=TRUE),"%m/%d/%Y")
> system.time(as.Date(Date, "%m/%d/%Y"))
   user  system elapsed 
 21.681   0.060  21.760 
> system.time(strptime(Date, "%m/%d/%Y"))
   user  system elapsed 
 29.594   8.633  38.270 
> system.time(strptime(Date, "%m/%d/%Y", tz="GMT"))
   user  system elapsed 
 19.785   0.000  19.802 

При прохождении tz ускоряется strptime, что делает as.Date.character. Так что, возможно, это зависит от вашего языка. Но strptime оказывается виновником, а не data.table. Возможно, повторите этот пример и посмотрите, требуется ли вам 90 секунд для вас на вашей машине?

Ответ 2

Как упоминалось выше, strptime (преобразование из символа в POSIXlt) является узким местом здесь. Другое простое решение использует пакет lubridate и его метод fast_strptime.

Вот что это похоже на мои данные:

> tables()
     NAME      NROW  MB COLS                                     
[1,] pp   3,718,339 126 session_id,date,user_id,path,num_sessions
     KEY         
[1,] user_id,date
Total: 126MB

> pp[, 2, with = F]
               date
      1: 2013-09-25
      2: 2013-09-25
      3: 2013-09-25
      4: 2013-09-25
      5: 2013-09-25
     ---           
3718335: 2013-09-25
3718336: 2013-09-25
3718337: 2013-09-25
3718338: 2013-10-11
3718339: 2013-10-11

> system.time(pp[, date := as.Date(fast_strptime(date, "%Y-%m-%d"))])
   user  system elapsed 
  0.315   0.026   0.344  

Для сравнения:

> system.time(pp[, date := as.Date(date, "%Y-%m-%d")])
   user  system elapsed 
108.193   0.399 108.844 

Это ~ 316 раз быстрее!

Ответ 3

Спасибо за предложения. Я решил это, написав алгоритм Гаусса для дат сам и получив намного лучшие результаты, см. Ниже.

getWeekDay <- function(year, month, day) {
  # Implementation of the Gaussian algorithm to get weekday 0 - Sunday, ... , 7 - Saturday
  Y <- year
  Y[month<3] <- (Y[month<3] - 1)

  d <- day
  m <- ((month + 9)%%12) + 1
  c <- floor(Y/100)
  y <- Y-c*100
  dayofweek <- (d + floor(2.6*m - 0.2) + y + floor(y/4) + floor(c/4) - 2*c) %% 7
  return(dayofweek)
}

sp500 <- read.csv('../rawdata/GMTSP.csv')
days <- c("Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday")

# Using data.table to get the things much much faster
sp500 <- data.table(sp500, key="Date")
sp500 <- sp500[,Month:=as.integer(substr(Date,1,2))]
sp500 <- sp500[,Day:=as.integer(substr(Date,4,5))]
sp500 <- sp500[,Year:=as.integer(substr(Date,7,10))]
#sp500 <- sp500[,Date:=as.Date(Date, "%m/%d/%Y")]
#sp500 <- sp500[,Weekday:=factor(weekdays(sp500[,Date]), levels=days, ordered=T)]
sp500 <- sp500[,Weekday:=factor(getWeekDay(Year, Month, Day))]
levels(sp500$Weekday) <- days

Запуск всего блока выше дает (включая чтение даты из csv)... Data.table действительно впечатляет.

user  system elapsed 
 19.074   0.803  20.284 

Сроки самого преобразования составляют 3,49.

Ответ 4

Это старый вопрос, но я думаю, что этот крошечный трюк может быть полезен. Если у вас несколько строк с одинаковой датой, вы можете сделать

data[, date := as.Date(date[1]), by = date]

Это намного быстрее, поскольку он обрабатывает каждую дату только один раз (в моем наборе данных из 40 миллионов строк он идет от 25 секунд до 0,5 секунды).

Ответ 5

Я изначально думал: "Аргумент as.Date выше не имеет указанного формата".

Теперь я думаю: я предположил, что значение Date, которое вы использовали, было в стандартном формате. Наверное, нет. Таким образом, вы выполняете два процесса. Вы переформатируете от символа до формата Date, и вы повторно сортируете на основе новых значений, которые имеют совершенно другую последовательность сортировки.