Разделение данных временного ряда на получасовые куски

Question

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

Я пробовал некоторый код r data.table, чтобы отделить их, но проблемаостается в переходном периоде от одного периода к другому.

Приведенный ниже df кадр данных является минимальным игрушечным примером этих данных.

library(data.table)
library(lubridate)
driver = rep(c("foo", "bar"), each = 10L)
dt = ymd_hm(c(
  "2015-05-27 07:11", "2015-05-27 07:25", "2015-05-27 07:35", 
  "2015-05-27 07:42", "2015-05-27 07:53",
  "2015-05-27 08:09", "2015-05-27 08:23", "2015-05-27 08:39", 
  "2015-05-27 08:52", "2015-05-27 09:12",
  "2015-05-27 16:12", "2015-05-27 16:31", "2015-05-27 16:39", 
  "2015-05-27 16:53", "2015-05-27 17:29",
  "2015-05-27 17:41", "2015-05-27 17:58", "2015-05-27 18:09", 
  "2015-05-27 18:23", "2015-05-27 18:42")
)
df = data.table(driver, dt)

Я пробовал следующий код для их разделения:

df[,diff := as.integer(difftime(dt, shift(dt, 1), units = "mins")), 
   by = driver]
df[, diff := {diff[1] = 0L; diff}, driver]
df[,cum_mins := cumsum(diff), driver]
df[,cum_halfhour := round(cum_mins/30, 3), driver]
df[,flag := floor(cum_halfhour), driver]

В результате получается таблица

> df
    driver                  dt diff cum_mins cum_halfhour flag
 1:    foo 2015-05-27 07:11:00    0        0        0.000    0
 2:    foo 2015-05-27 07:25:00   14       14        0.467    0
 3:    foo 2015-05-27 07:35:00   10       24        0.800    0
 4:    foo 2015-05-27 07:42:00    7       31        1.033    1
 5:    foo 2015-05-27 07:53:00   11       42        1.400    1
 6:    foo 2015-05-27 08:09:00   16       58        1.933    1
 7:    foo 2015-05-27 08:23:00   14       72        2.400    2
 8:    foo 2015-05-27 08:39:00   16       88        2.933    2
 9:    foo 2015-05-27 08:52:00   13      101        3.367    3
10:    foo 2015-05-27 09:12:00   20      121        4.033    4
11:    bar 2015-05-27 16:12:00    0        0        0.000    0
12:    bar 2015-05-27 16:31:00   19       19        0.633    0
13:    bar 2015-05-27 16:39:00    8       27        0.900    0
14:    bar 2015-05-27 16:53:00   14       41        1.367    1
15:    bar 2015-05-27 17:29:00   36       77        2.567    2
16:    bar 2015-05-27 17:41:00   12       89        2.967    2
17:    bar 2015-05-27 17:58:00   17      106        3.533    3
18:    bar 2015-05-27 18:09:00   11      117        3.900    3
19:    bar 2015-05-27 18:23:00   14      131        4.367    4
20:    bar 2015-05-27 18:42:00   19      150        5.000    5

Столбец flag - это то, что я хочу, но не совсем.Проблема возникает при переходе строк между flag с.Например, в строках 3 и 4 я хочу, чтобы алгоритм помечал строку 4 как 0, потому что строка 4 * ближе к точке получаса, чем строка 3 (cum_halfhour равен 31 по сравнению с 24).Та же проблема остается в строках 9 и 10.

Проблема в этом текущем алгоритме состоит в том, что он всегда этажей совокупное время до 30-минутного периода.Но на практике временные интервалы нерегулярны, поэтому более реалистично размещать точку отсечения в ближайшей 30-минутной точке.Как объяснено в примере 3 и 4 строки выше.

Решение может быть простым, но я не могу придумать его.Любые предложения для достижения этого алгоритма?Спасибо!

Answer 1

Если подумать, здесь действительно нет необходимости в объединении соединений:

Сначала сгенерируйте данные (здесь нет необходимости использовать lubridate, as.POSIXct с правильной строкой формата работает нормально) .

library(data.table)
driver = rep(c("foo", "bar"), each = 10L)
dt = as.POSIXct(c(
  "2015-05-27 07:11", "2015-05-27 07:25", "2015-05-27 07:35", 
  "2015-05-27 07:42", "2015-05-27 07:53",
  "2015-05-27 08:09", "2015-05-27 08:23", "2015-05-27 08:39", 
  "2015-05-27 08:52", "2015-05-27 09:12",
  "2015-05-27 16:12", "2015-05-27 16:31", "2015-05-27 16:39", 
  "2015-05-27 16:53", "2015-05-27 17:29",
  "2015-05-27 17:41", "2015-05-27 17:58", "2015-05-27 18:09", 
  "2015-05-27 18:23", "2015-05-27 18:42")
  , format = "%F %H:%M", tz = "America/Chicago")

df = data.table(driver, dt)

Манипулирование следующим образом должно получить то, что вы ищете:

## Create a column with epoch time so we don't have to worry about
## some of the idiosyncracies of the R `difftime` class
df[,dt_epoch := as.integer(dt)]
## Create a cum_halfhour column based on epoch time
df[,cum_halfhour := round((dt_epoch - min(dt_epoch))/1800,3), by = .(driver)]
## Create a rounded version
df[,nearest_half := round((dt_epoch - min(dt_epoch))/1800,0), by = .(driver)]
## Create a flag for changes using `data.table::rleid` for each driver
df[,flag := rleid(nearest_half) - 1L, by = .(driver)]

df
#     driver                  dt   dt_epoch cum_halfhour nearest_half flag
#  1:    foo 2015-05-27 07:11:00 1432728660        0.000            0    0
#  2:    foo 2015-05-27 07:25:00 1432729500        0.467            0    0
#  3:    foo 2015-05-27 07:35:00 1432730100        0.800            1    1
#  4:    foo 2015-05-27 07:42:00 1432730520        1.033            1    1
#  5:    foo 2015-05-27 07:53:00 1432731180        1.400            1    1
#  6:    foo 2015-05-27 08:09:00 1432732140        1.933            2    2
#  7:    foo 2015-05-27 08:23:00 1432732980        2.400            2    2
#  8:    foo 2015-05-27 08:39:00 1432733940        2.933            3    3
#  9:    foo 2015-05-27 08:52:00 1432734720        3.367            3    3
# 10:    foo 2015-05-27 09:12:00 1432735920        4.033            4    4
# 11:    bar 2015-05-27 16:12:00 1432761120        0.000            0    0
# 12:    bar 2015-05-27 16:31:00 1432762260        0.633            1    1
# 13:    bar 2015-05-27 16:39:00 1432762740        0.900            1    1
# 14:    bar 2015-05-27 16:53:00 1432763580        1.367            1    1
# 15:    bar 2015-05-27 17:29:00 1432765740        2.567            3    2
# 16:    bar 2015-05-27 17:41:00 1432766460        2.967            3    2
# 17:    bar 2015-05-27 17:58:00 1432767480        3.533            4    3
# 18:    bar 2015-05-27 18:09:00 1432768140        3.900            4    3
# 19:    bar 2015-05-27 18:23:00 1432768980        4.367            4    3
# 20:    bar 2015-05-27 18:42:00 1432770120        5.000            5    4

---

Ранее опубликованные (слишком сложные) шаги манипуляции:

## Create a column with epoch time so we don't have to worry about
## some of the idiosyncracies of the R `difftime` class
df[,dt_epoch := as.integer(dt)]
## Create a cum_halfhour column based on epoch time
df[,cum_halfhour := round((dt_epoch - min(dt_epoch))/1800,3), by = .(driver)]

## Create a lookup table with all the possible half hour increments for each driver
Lookup <- df[,.(half_points = seq(from = 0,
                                 to = max(cum_halfhour),
                                 by = 1)), by = .(driver)]

## Create a copy of the target half_points column since the join process
## treats the keys in a way that makes the join columns complicated to access
Lookup[,join_half_points := half_points]

## Set keys on our original table and the Lookup table
setkey(df,driver,cum_halfhour)
setkey(Lookup,driver,join_half_points)

## This one is a doozy. To get an idea of what we're assigning to the
## `half_point` column, run `Lookup[df, roll = "nearest"]`
## to see the table generated by the rolling join. We then pull
## the column `half_points` out of the joined result and assign it to the
## original `df` as a new column,
df[,half_point := Lookup[df,half_points, roll = "nearest"]]

## Create a flag using `data.table::rleid` for each driver
df[,flag := rleid(half_point) - 1L, by = .(driver)]