Проблема с производительностью, превращающая строки с началом - концом в информационный фрейм с TimeIndex - PullRequest
0 голосов
/ 07 июня 2018

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

    start       end    type value
2015-01-01  2015-01-05  1   3
2015-01-06  2015-01-08  1   2
2015-01-05  2015-01-08  3   3
2015-01-13  2015-01-16  2   1

Я хочу превратить его в ежедневный индексированный по времени фрейм, например:

day       type  value
2015-01-01  1   3
2015-01-02  1   3
2015-01-03  1   3
2015-01-04  1   3
2015-01-05  1   3
2015-01-06  1   2
2015-01-07  1   2
2015-01-08  1   2
2015-01-05  3   3
2015-01-16  3   3
2015-01-07  3   3
2015-01-08  3   3
2015-01-13  2   1
2015-01-14  2   1
2015-01-15  2   1
2015-01-16  2   1

(Обратите внимание, что мы не можем делать никаких предположений относительно интервала:они должны быть смежными и не перекрываться, но мы не можем этого гарантировать)

На основании этих ответов переполнения стека [1] ( Повторная выборка DataFrame для диапазонов дат ) [2] ( pandas: совокупность, основанная на дате начала / окончания ), кажется, существует два метода: один вокруг itertuples, другой вокруг melt (2 выше использованных стека / unstack, но он похож на melt).Давайте сравним их по производительности.

# Creating a big enough dataframe
date_range = pd.date_range(start=dt.datetime(2015,1,1), end=dt.datetime(2019,12,31), freq='4D')
to_concat = []
for val in range(1,50):
    frame_tmp = pd.DataFrame()
    frame_tmp['start'] = date_range
    frame_tmp['end'] = frame_tmp['start']+ dt.timedelta(3)
    frame_tmp['type'] = val
    frame_tmp['value'] = np.random.randint(1, 6, frame_tmp.shape[0])
    to_concat.append(frame_tmp)
df = pd.concat(to_concat, ignore_index=True)

# Method 1 
def method_1(df):
    df1 = (pd.concat([pd.Series(r.Index,
                                pd.date_range(r.start,
                                              r.end,
                                              freq='D'))
                      for r in df.itertuples()])) \
        .reset_index()
    df1.columns = ['start_2', 'idx']

    df2 = df1.set_index('idx').join(df).reset_index(drop=True)

    return df2.set_index('start_2')

df_method_1=df.groupby(['type']).apply(method_1)

# Method 2
df_tmp= df.reset_index()
df1 = (df_tmp.melt(df_tmp.columns.difference(['start','end']),
          ['start', 'end'],
          value_name='current_time')
  )
df_method_2 = df1.set_index('current_time').groupby('index', group_keys=False)\
.resample('D').ffill()

При %%timeit в Jupyter метод 1 занимает ~ 8 с, а метод 2 - ~ 25 с для кадра данных, определенного в качестве примера.Это слишком медленно, поскольку реальный набор данных, с которым я имею дело, намного больше этого.На этом кадре данных метод 1 занимает ~ 20 минут.

У вас есть идеи, как сделать это быстрее?

1 Ответ

0 голосов
/ 07 июня 2018

Это примерно в 1,7 раза быстрее, чем ваш method_1, и немного меньше:

df_expand = pd.DataFrame.from_records(
    (
        (d, r.type, r.value) 
        for r in df.itertuples()
        for d in pd.date_range(start=r.start, end=r.end, freq='D')
    ),
    columns=['day', 'type', 'row']
)

Вы можете получить примерно в 7 раз быстрее, создав собственный диапазон дат вместо вызова pd.date_range():

one_day = dt.timedelta(1)
df_expand = pd.DataFrame.from_records(
    (
        (r.start + i * one_day, r.type, r.value) 
        for r in df.itertuples()
        for i in range(int((r.end-r.start)/one_day)+1)
    ),
    columns=['day', 'type', 'row']
)

Или вы можете получить до 24 раз быстрее, используя функцию arange numpy для генерации дат:

one_day = dt.timedelta(1)
df_expand = pd.DataFrame.from_records(
    (
        (d, r.type, r.value) 
        for r in df.itertuples()
        for d in np.arange(r.start.date(), r.end.date()+one_day, dtype='datetime64[D]')
    ),
    columns=['day', 'type', 'row']
)

Я не удержался, добавив еще один, который немного большечем в два раза быстрее, чем последний.К сожалению, это намного сложнее читать.Это группирует показания в зависимости от того, сколько дней они охватывают ('dur'), ​​а затем использует векторизованные операции с числами, чтобы развернуть каждую группу в одном пакете.

def expand_group(g):
    dur = g.dur.iloc[0] # how many days for each reading in this group?
    return pd.DataFrame({
        'day': (g.start.values[:,None] + np.timedelta64(1, 'D') * np.arange(dur)).ravel(),
        'type': np.repeat(g.type.values, dur),
        'value': np.repeat(g.value.values, dur),
    })
# take all readings with the same duration and process them together using vectorized code
df_expand = (
    df.assign(dur=(df['end']-df['start']).dt.days + 1)
    .groupby('dur').apply(expand_group)
    .reset_index('dur', drop=True)
)

Обновление: Ответ наВаш комментарий ниже представляет собой упрощенную версию векторизованного подхода, который быстрее и проще для чтения.Вместо использования шага groupby это делает одну матрицу шириной самого длинного чтения, а затем отфильтровывает ненужные записи.Это должно быть довольно эффективным, если максимальная продолжительность для ваших показаний не намного больше, чем в среднем.С тестовым фреймом данных (все показания продолжительностью 4 дня) это примерно в 15 раз быстрее, чем решение groupby, и примерно в 700 раз быстрее, чем method_1.

dur = (df['end']-df['start']).max().days + 1
df_expand = pd.DataFrame({
    'day': (
        df['start'].values[:,None] + np.timedelta64(1, 'D') * np.arange(dur)
    ).ravel(),
    'type': np.repeat(df['type'].values, dur),
    'value': np.repeat(df['value'].values, dur),
    'end': np.repeat(df['end'].values, dur),
})
df_expand = df_expand.loc[df_expand['day']<=df_expand['end'], 'day':'value']
Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...