Python - для цикла миллионы строк

Ответ 1

Это решение использует pd.DataFrame.isin, который использует numpy.in1d

По-видимому, "isin" не обязательно быстрее для небольших наборов данных (например, этот образец), но значительно быстрее для больших наборов данных. Вам нужно будет запустить его против ваших данных, чтобы определить производительность.

flight_record_linkage.ipynb

Развернул набор данных, используя c = pd.concat([c] * 10000, ignore_index=True)

• Увеличьте длину набора данных на 3 порядка (всего 10000 строк).
  • Оригинальный метод: Настенное время: 8.98s
  • Новый метод: Настенное время: 16,4 с
• Увеличьте длину набора данных на 4 порядка (всего 100000 строк).
  • Оригинальный метод: Настенное время: 8 мин. 17 сек.
  • Новый метод: Настенное время: 1 мин. 14 сек.
• Увеличьте длину набора данных на 5 порядков (всего 1000000 строк).
  • Новый метод: Настенное время: 11мин 33s

Новый метод: использование isin и применение

def apply_do_g(it_row):
    """
    This is your function, but using isin and apply
    """

    keep = {'Operator': [it_row.Operator], 'Terminal': [it_row.Terminal]}  # dict for isin combined mask

    holder1 = arr[list(keep)].isin(keep).all(axis=1)  # create boolean mask
    holder2 = arr.Already_linked.isin([0])  # create boolean mask
    holder3 = arr.hour < it_row.hour_aux  # create boolean mask

    holder = holder1 & holder2 & holder3  # combine the masks

    holder = arr.loc[holder]

    if not holder.empty:

        aux = np.absolute(holder.START - it_row.x).idxmin()

        c.loc[it_row.name, 'a'] = holder.loc[aux].FlightID  # use with apply 'it_row.name'

        arr.loc[aux, 'Already_linked'] = 1


def new_way_2():
    keep = {'A_D': ['D'], 'Already_linked': [0]}
    df_test = c[c[list(keep)].isin(keep).all(axis=1)].copy()  # returns the resultant df
    df_test.apply(lambda row: apply_do_g(row), axis=1)  # g is multiple DataFrames"


#call the function
new_way_2()

Ответ 2

Ваш вопрос был, если есть способ векторизации цикла for, но я думаю, что этот вопрос скрывает то, что вы действительно хотите, что является простым способом ускорить ваш код. Для вопросов производительности хорошая отправная точка всегда профилируется. Однако у меня есть сильное подозрение, что доминирующей операцией в вашем коде является .query(row.query_string). Выполнение этого для каждой строки является дорогостоящим, если arr является большим.

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

• Поскольку вы каждый раз arr.Already_Linked==0 arr каждый раз, поддерживайте представление только arr.Already_Linked==0 чтобы вы arr.Already_Linked==0 итерацию над меньшим объектом.
• Еще лучше, прежде чем делать какой-либо цикл, вы должны сначала сгруппировать arr Terminal и Operator. Затем вместо того, чтобы проходить через весь arr, сначала выберите нужную группу, а затем выполните нарезку и фильтрацию. Это потребовало бы немного переосмыслить точную реализацию query_string, но преимущество в том, что если у вас много терминалов и операторов, вы обычно будете работать над гораздо меньшим объектом, чем arr. Более того, вам даже не придется запрашивать этот объект, поскольку это было неявно сделано группой.
• В зависимости от того, как aux.hour обычно относится к row.hour_aux, у вас могут быть улучшения путем сортировки aux в начале по отношению к hour. Просто используя оператор неравенства, вы, вероятно, не увидите никаких выигрышей, но вы можете связать это с логарифмическим поиском точки отсечки, а затем просто нарезать до этой точки отсечки.
• И так далее. Опять же, я подозреваю, что любой способ реструктуризации запроса, который вы делаете во всех случаях arr для каждой строки, будет иметь значительно больший выигрыш, чем просто переключение фреймворков или векторизация битов и фрагментов.

Несколько расширив некоторые из этих точек и немного адаптировав код @DJK, посмотрите, что происходит, когда мы имеем следующие изменения.

groups = arr.groupby(['Operator', 'Terminal'])

for row in c[(c.A_D == 'D') & (c.Already_linked == 0)].itertuples():
    g = groups.get_group((row.Operator, row.Terminal))
    vb = g[(g.Already_linked==0) & (g.hour<row.hour_aux)]
    try:
        aux = (vb.START - row.x).abs().idxmin()
        print(row.x)
        c.loc[row.Index, 'a'] = vb.loc[aux,'FlightID']
        g.loc[aux, 'Already_linked'] = 1
        continue
    except:
        continue

Причина, по которой ваш запрос настолько медленный, заключается в том, что он каждый раз arr все сообщения. Напротив, .groupby() выполняется примерно в то же время, что и один запрос, но затем для каждой последующей итерации вы можете просто использовать .get_group() для эффективного поиска крошечного подмножества данных, о которых вы заботитесь.

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

Ответ 3

Несмотря на то, что это не решение, ориентированное на vecterized, оно должно быстро ускорить работу, если ваш набор данных образцов подражает вашему истинному набору данных. В настоящее время вы тратите время на все строки, но вам все равно, что они перебирают строки, где ['A_D'] == 'D' и ['Already_linked'] ==0. Вместо этого удалите if и loop по усеченному фреймворку данных, который составляет только 30% от исходного кадра данных

for row in c[(c.A_D == 'D') & (c.Already_linked == 0)].itertuples():

    vb = arr[(arr.Already_linked == 0) & (arr.hour < row.hour_aux)].copy().query(row.query_string)
    try:
        aux = (vb.START - row.x).abs().idxmin()
        print(row.x)
        c.loc[row.Index, 'a'] = vb.loc[aux,'FlightID']
        arr.loc[aux, 'Already_linked'] = 1
        continue
    except:
        continue

Ответ 4

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

У вас очень длинная table со столбцами time, FlightID, Operator, Terminal, A_D. Другие столбцы и даты не имеют значения, если я правильно вас понимаю. Также start_time и end_time одинаковы в каждой строке. Кстати, вы можете получить столбец time с кодом table.loc[:, 'time'] = table.loc[:, 'START'].dt.time.

1. table = table.drop_duplicates(subset=['time', 'FlightID', 'Operator', 'Terminal']). И ваш table станет значительно короче.

2. Разделить table на table_arr и table_dep соответствии со значением A_D: table_arr = table.loc[table.loc[:, 'A_D'] == 'A', ['FlightID', 'Operator', 'Terminal', 'time']], table_dep = table.loc[table.loc[:, 'A_D'] == 'D', ['FlightID', 'Operator', 'Terminal', 'time']]

3. Кажется, что все, что вы пытались получить с помощью циклов, вы можете получить с одной строкой: table_result = table_arr.merge(table_dep, how='right', on=['Operator', 'Terminal'], suffixes=('_arr', '_dep')). Это в основном та же операция, что и JOIN в SQL.

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

  FlightID_arr Operator  Terminal  time_arr FlightID_dep  time_dep
0        DL401       DL         3  06:50:00        DL001  09:30:00
1        DL402       DL         3  07:45:00        DL001  09:30:00
2          NaN       VS         3       NaN        VS001  15:15:00

Конечно, в общем случае (с фактическими данными) вам понадобится еще один шаг - filter table_result при условии time_arr < time_dep или любое другое условие, которое у вас есть. К сожалению, данных, которые вы предоставили, недостаточно, чтобы полностью решить вашу проблему.

Полный код:

import io
import pandas as pd

data = '''
START,END,A_D,Operator,FlightID,Terminal,TROUND_ID,tot
2017-03-26 16:55:00,2017-10-28 16:55:00,A,QR,QR001,4,QR002,70
2017-03-26 09:30:00,2017-06-11 09:30:00,D,DL,DL001,3,,84
2017-03-27 09:30:00,2017-10-28 09:30:00,D,DL,DL001,3,,78
2017-10-08 15:15:00,2017-10-22 15:15:00,D,VS,VS001,3,,45
2017-03-26 06:50:00,2017-06-11 06:50:00,A,DL,DL401,3,,9
2017-03-27 06:50:00,2017-10-28 06:50:00,A,DL,DL401,3,,19
2017-03-29 06:50:00,2017-04-19 06:50:00,A,DL,DL401,3,,3
2017-05-03 06:50:00,2017-10-25 06:50:00,A,DL,DL401,3,,32
2017-06-25 06:50:00,2017-10-22 06:50:00,A,DL,DL401,3,,95
2017-03-26 07:45:00,2017-10-28 07:45:00,A,DL,DL402,3,,58
'''

table = pd.read_csv(io.StringIO(data), parse_dates=[0, 1])
table.loc[:, 'time'] = table.loc[:, 'START'].dt.time
table = table.drop_duplicates(subset=['time', 'FlightID', 'Operator', 'Terminal'])
table_arr = table.loc[table.loc[:, 'A_D'] == 'A', ['FlightID', 'Operator', 'Terminal', 'time']]
table_dep = table.loc[table.loc[:, 'A_D'] == 'D', ['FlightID', 'Operator', 'Terminal', 'time']]

table_result = table_arr.merge(
    table_dep,
    how='right',
    on=['Operator', 'Terminal'],
    suffixes=('_arr', '_dep'))
print(table_result)