Самый быстрый способ создания столбца pandas условно
В Pandas DataFrame я хочу создать новый столбец условно на основе значения другого столбца. В моем приложении DataFrame обычно имеет несколько миллионов строк, а число уникальных условных значений невелико, порядка единицы. Производительность чрезвычайно важна: какой самый быстрый способ создать новый столбец?
Я создал примерный пример ниже, и уже пытался и сравнивал различные методы. В примере условное заполнение представлено поиском словаря на основе значения label столбца (здесь: один из 1, 2, 3).
lookup_dict = {
1: 100, # arbitrary
2: 200, # arbitrary
3: 300, # arbitrary
}
Затем я ожидаю, что мой DataFrame будет заполнен как:
label output
0 3 300
1 2 200
2 3 300
3 3 300
4 2 200
5 2 200
6 1 100
7 1 100
Ниже приведены 6 различных методов, проверенных на 10- Nlines линиях (параметр Nlines в тестовом коде):
- метод 1:
pandas.groupby().apply() - метод 2:
pandas.groupby().indices.items() - метод 3:
pandas.Series.map - метод 4: для цикла на этикетках
- метод 5:
numpy.select - метод 6: numba
Полный код доступен в конце ответа с моментами выполнения всех методов. Вывод каждого метода считается равным перед сравнением результатов.
метод 1: pandas.groupby().apply()
Я использую pandas.groupby() на label, затем заполняет каждый блок тем же значением, используя apply().
def fill_output(r):
''' called by groupby().apply(): all r.label values are the same '''
r.loc[:, 'output'] = lookup_dict[r.iloc[0]['label']]
return r
df = df.groupby('label').apply(fill_output)
я получил
>>> method_1_groupby ran in 2.29s (average over 3 iterations)
Обратите внимание, что groupby(). Apply() запускается дважды в первой группе, чтобы определить, какой путь кода использовать (см. Pandas # 2936). Это может замедлить работу небольшого числа групп. Я обманул метод 1, добавив первую фиктивную группу, но я не получил большого улучшения.
метод 2: pandas.groupby().indices.items()
Второй вариант: вместо использования apply я обращаюсь к указателю directy с помощью groupby().indices.items(). Это заканчивается в два раза быстрее, чем метод 1, и это метод, который я использовал в течение длительного времени
dgb = df.groupby('label')
for label, idx in dgb.indices.items():
df.loc[idx, 'output'] = lookup_dict[label]
Получил:
method_2_indices ran in 1.21s (average over 3 iterations)
метод 3: pandas.Series.map
Я использовал Pandas.Series.map.
df['output'] = df.label.map(lookup_dict.get)
У меня были очень хорошие результаты в аналогичных случаях, когда количество просмотренных значений было сопоставимо с количеством строк. В данном случае map заканчивается в два раза медленнее, чем метод 1.
method_3_map работает в 3.07s (в среднем более 3 итераций)
Я отношу это к небольшому числу значений поиска, но может возникнуть проблема с тем, как я его реализовал.
метод 4: для цикла на этикетках
4-й метод довольно наивен: я просто перебираю все метки и выбираю соответствующую часть DataFrame.
for label, value in lookup_dict.items():
df.loc[df.label == label, 'output'] = value
Удивительно, но, в конечном итоге, я получил гораздо более быстрые результаты, чем в предыдущих случаях. Я ожидал, что решения на основе groupby будут быстрее, чем это, потому что Pandas должен сделать три сравнения с df.label == label. Результаты доказывают, что я ошибаюсь:
method_4_forloop ran in 0.54s (average over 3 iterations)
метод 5: numpy.select
В пятом методе используется функция select numpy, основанная на этом qaru.site/info/59317/....
conditions = [df.label == k for k in lookup_dict.keys()]
choices = list(lookup_dict.values())
df['output'] = np.select(conditions, choices)
Это дает наилучшие результаты:
method_5_select ran in 0.29s (average over 3 iterations)
В конце концов, я попробовал numba в методе 6.
метод 6: numba
Как раз для примера, условные значения заполнения являются жестким кодом в скомпилированной функции. Я не знаю, как дать Numba список как константу времени выполнения:
@jit(int64[:](int64[:]), nopython=True)
def hardcoded_conditional_filling(column):
output = np.zeros_like(column)
i = 0
for c in column:
if c == 1:
output[i] = 100
elif c == 2:
output[i] = 200
elif c == 3:
output[i] = 300
i += 1
return output
df['output'] = hardcoded_conditional_filling(df.label.values)
Я закончил с лучшим временем, быстрее, чем метод 5 на 50%.
method_6_numba ran in 0.19s (average over 3 iterations)
Я не реализовал это по причине, указанной выше: я не знаю, как дать Numba список в качестве постоянной времени выполнения без существенного снижения производительности.
Полный код
import pandas as pd
import numpy as np
from timeit import timeit
from numba import jit, int64
lookup_dict = {
1: 100, # arbitrary
2: 200, # arbitrary
3: 300, # arbitrary
}
Nlines = int(1e7)
# Generate
label = np.round(np.random.rand(Nlines)*2+1).astype(np.int64)
df0 = pd.DataFrame(label, columns=['label'])
# Now the goal is to assign the look_up_dict values to a new column 'output'
# based on the value of label
# Method 1
# using groupby().apply()
def method_1_groupby(df):
def fill_output(r):
''' called by groupby().apply(): all r.label values are the same '''
#print(r.iloc[0]['label']) # activate to reveal the #2936 issue in Pandas
r.loc[:, 'output'] = lookup_dict[r.iloc[0]['label']]
return r
df = df.groupby('label').apply(fill_output)
return df
def method_2_indices(df):
dgb = df.groupby('label')
for label, idx in dgb.indices.items():
df.loc[idx, 'output'] = lookup_dict[label]
return df
def method_3_map(df):
df['output'] = df.label.map(lookup_dict.get)
return df
def method_4_forloop(df):
''' naive '''
for label, value in lookup_dict.items():
df.loc[df.label == label, 'output'] = value
return df
def method_5_select(df):
''' Based on answer from
/info/59317/pandas-conditional-creation-of-a-seriesdataframe-column/411715#411715
'''
conditions = [df.label == k for k in lookup_dict.keys()]
choices = list(lookup_dict.values())
df['output'] = np.select(conditions, choices)
return df
def method_6_numba(df):
''' This works, but it is hardcoded and i don't really know how
to make it compile with list as runtime constants'''
@jit(int64[:](int64[:]), nopython=True)
def hardcoded_conditional_filling(column):
output = np.zeros_like(column)
i = 0
for c in column:
if c == 1:
output[i] = 100
elif c == 2:
output[i] = 200
elif c == 3:
output[i] = 300
i += 1
return output
df['output'] = hardcoded_conditional_filling(df.label.values)
return df
df1 = method_1_groupby(df0)
df2 = method_2_indices(df0.copy())
df3 = method_3_map(df0.copy())
df4 = method_4_forloop(df0.copy())
df5 = method_5_select(df0.copy())
df6 = method_6_numba(df0.copy())
# make sure we havent modified the input (would bias the results)
assert 'output' not in df0.columns
# Test validity
assert (df1 == df2).all().all()
assert (df1 == df3).all().all()
assert (df1 == df4).all().all()
assert (df1 == df5).all().all()
assert (df1 == df6).all().all()
# Compare performances
Nites = 3
print('Compare performances for {0:.1g} lines'.format(Nlines))
print('-'*30)
for method in [
'method_1_groupby', 'method_2_indices',
'method_3_map', 'method_4_forloop',
'method_5_select', 'method_6_numba']:
print('{0} ran in {1:.2f}s (average over {2} iterations)'.format(
method,
timeit("{0}(df)".format(method), setup="from __main__ import df0, {0}; df=df0.copy()".format(method), number=Nites)/Nites,
Nites))
Выход:
Compare performances for 1e+07 lines
------------------------------
method_1_groupby ran in 2.29s (average over 3 iterations)
method_2_indices ran in 1.21s (average over 3 iterations)
method_3_map ran in 3.07s (average over 3 iterations)
method_4_forloop ran in 0.54s (average over 3 iterations)
method_5_select ran in 0.29s (average over 3 iterations)
method_6_numba ran in 0.19s (average over 3 iterations)
Меня интересовало бы любое другое решение, которое могло бы дать лучшие результаты. Первоначально я искал методы на основе Pandas, но я также принимаю решения на основе numba/cython.
редактировать
Добавление методов Chrisb для сравнения:
def method_3b_mapdirect(df):
''' Suggested by /info/16059216/fastest-way-to-create-a-pandas-column-conditionally/24960318#24960318'''
df['output'] = df.label.map(lookup_dict)
return df
def method_7_take(df):
''' Based on answer from
/info/59317/pandas-conditional-creation-of-a-seriesdataframe-column/411715#411715
Exploiting that labels are continuous integers
'''
lookup_arr = np.array(list(lookup_dict.values()))
df['output'] = lookup_arr.take(df['label'] - 1)
return df
С временем выполнения:
method_3_mapdirect ran in 0.23s (average over 3 iterations)
method_7_take ran in 0.11s (average over 3 iterations)
Что делает # 3 быстрее, чем любой другой метод (# 6 в сторону), а также самый элегантный. Используйте # 7, если ваш случай пользователя совместим.
Ответы
Ответ 1
Я бы рассмотрел .map (# 3) идиоматический способ сделать это, но не передал .get - сам по себе использует словарь и должен увидеть значительное значительное улучшение.
df = pd.DataFrame({'label': np.random.randint(, 4, size=1000000, dtype='i8')})
%timeit df['output'] = df.label.map(lookup_dict.get)
261 ms ± 12.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit df['output'] = df.label.map(lookup_dict)
69.6 ms ± 3.08 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
Если количество условий невелико и сравнение дешево (т.е. Ints и ваша таблица поиска), прямое сравнение значений (4 и особенно 5) выполняется быстрее, чем .map, но это не всегда верно, например, если бы вы набор строк.
Если метки подстановки действительно contigous целых чисел, вы можете использовать это и поиск с использованием take, который должен быть примерно так же быстро, как Numba. Я думаю, что это в основном так быстро, как это может произойти - может написать эквивалент в cython, но не будет быстрее.
%%timeit
lookup_arr = np.array(list(lookup_dict.values()))
df['output'] = lookup_arr.take(df['label'] - 1)
8.68 ms ± 332 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
