Оптимизируйте следующий раздел кода Python для затухающих переменных - PullRequest
Новая
       27

Оптимизируйте следующий раздел кода Python для затухающих переменных

0 голосов
/ 26 сентября 2018

Я выполняю следующую операцию для отсортированного набора данных 'df_pre_decay', содержащего набор данных временных рядов для нескольких идентификаторов, и я хочу отклонить мои переменные 'tactic' для каждого идентификатора с разными скоростями (исходя из tactic_decay_dict).

Созданная переменная для затухшей тактической переменной 'xyz' будет иметь то же значение, что и тактическая переменная в 1-м месяце, в то время как для всех остальных месяцев она будет добавлена ​​(((значение затухшей тактической переменной 'xyz 'в предыдущем месяце) умножено на скорость) и ((значение тактической переменной' тактика 'в текущем месяце) умножено на (1 скорость)) 

time_col = 'mnth'
tactic =['overall_details','speaker_total','overall_samples_eu','copay_redemption_count','voucher_redemption_count','dtc']
tactic_decay_dict = dict.fromkeys(tactic,(60,70))

uniq = len(df_pre_decay[time_col].unique())

## Loops for variables and decay rate
for a in tactic_decay_dict:
    for b in tactic_decay_dict[a]:
        xyz = a+'_s'+str(b)
## Loops for iterating over each row in the dataset
        for i in range(len(df_pre_decay)):
            df_pre_decay[xyz] = np.where((i%uniq)!=0,
                                         (df_pre_decay[xyz].iloc[i-1])*b/100+
                                         (df_pre_decay[a].iloc[i])*(100-b)/100,
                                         df_pre_decay[a].iloc[i])

Я хочу оптимизировать этораздел кода, поскольку он занимает более 30 минут для 5 миллионов + строк в моем наборе данных.

Редактировать: Пожалуйста, найдите образец набора данных 

ID  mnth    overall_details speaker_total   overall_samples_eu  copay_redemption_count  voucher_redemption_count    dtc
1   201701  3   1   10  9   3   6
1   201702  6   1   0   7   7   10
1   201703  10  8   7   8   9   10
1   201704  3   9   3   0   1   1
1   201705  9   0   8   9   6   4
1   201706  8   3   2   10  8   9
1   201707  3   10  3   0   5   6
1   201708  2   10  3   9   6   2
1   201709  1   3   7   10  8   0
1   201710  3   8   2   8   0   10
1   201711  6   7   4   8   5   6
1   201712  3   8   2   9   4   10
2   201701  7   4   7   4   10  2
2   201702  10  0   2   2   10  5
2   201703  10  6   4   10  5   3
2   201704  4   3   6   4   0   8
2   201705  7   8   9   10  6   10
2   201706  8   0   2   7   1   8
2   201707  10  2   8   1   9   4
2   201708  10  6   7   0   3   5
2   201709  10  10  3   8   9   0
2   201710  2   0   3   5   5   8
2   201711  1   8   0   7   3   4
2   201712  8   5   1   0   7   9
3   201701  2   2   7   7   1   2
3   201702  2   8   10  9   6   9
3   201703  10  5   8   5   9   4
3   201704  6   1   2   4   6   2
3   201705  6   9   4   4   3   0
3   201706  5   1   6   4   1   7
3   201707  0   7   6   9   5   6
3   201708  10  3   2   0   4   5
3   201709  5   8   6   4   10  4
3   201710  8   3   10  6   7   0
3   201711  7   5   6   3   1   10
3   201712  3   9   8   4   10  0

1 Ответ

0 голосов
/ 26 сентября 2018

Я не думаю, что ваш код будет работать так, как задумано, потому что вы эффективно устанавливаете весь столбец df_pre_decay[xyz] в одно значение в каждом цикле цикла.Вам нужно либо для циклического прохождения каждой строки кадра данных (for i in range(len(df_pre_decay))), либо обрабатывать столбцы как векторы (как это делают np.where и другие простые функции), но вы смешиваете и то, и другое.Векторизованный подход обычно будет намного быстрее.

Для не векторизованной версии установите для столбца xyz то же самое, что и для столбца a, а затем выполните цикл по строкам, задавая, где необходимо, значения накопления.

for a in tactic_decay_dict:
    for b in tactic_decay_dict[a]:
        xyz = a+'_s'+str(b)
## Loops for iterating over each row in the dataset
        df_pre_decay[xyz] = df_pre_decay[a]
        for i in range(len(df_pre_decay)):
            if i % uniq != 0:
                df_pre_decay[xyz].iloc[i] = (df_pre_decay[xyz].iloc[i-1] * b/100
                     + df_pre_decay[a].iloc[i] * (100 - b)/100)

Или альтернативная версия - не уверен, что будет быстрее: 

for a in tactic_decay_dict:
    for b in tactic_decay_dict[a]:
        xyz = a+'_s'+str(b)
        column = []
        for i, x in enumerate(df_pre_decay[a]):
            if i % uniq == 0:
                current = x
            else:
                current = x * b/100 + current * (100-b)/100
            column.append(current)
        df[xyz] = column

Для векторизации вы можете разбить столбцы на куски и применить функцию кумулятивного затухания к каждому, используяnumpy.ufunc.accumulate. 

for a in tactic_decay_dict:
    for b in tactic_decay_dict[a]:
        xyz = a+'_s'+str(b)
        decay_func = np.frompyfunc(lambda u, v: u * b / 100.0 + v * (100-b) / 100.0, 2, 1)
        decayed = np.array([])
        for top in range(0, len(df_pre_decay), uniq):
            chunk = df_pre_decay[a][top:top+uniq]
            decayed = np.concatenate((decayed, 
                                  decay_func.accumulate(chunk, dtype=np.object).astype(np.float)))
        df_pre_decay[xyz] = decayed

Альтернативный способ - вставить пустые строки с нулевыми значениями между различными идентификаторами.Затем вы можете применить одну функцию накопления ко всем столбцам: 

# insert blank rows in the data
df.index = df.index + df.index // uniq
df.reindex(index=range(len(df) + len(df) // uniq))   

def get_decay_func(b):
    def inner(u, v):
        if pd.isnull(u) or pd.isnull(v):
            return v
        else:
            return u * b/100.0 + v * (100-b)/100.0
    return inner

for a in tactic_decay_dict:
   for b in tactic_decay_dict[a]:
        decay = get_decay_func(b).accumulate
        xyz = a+'_s'+str(b)
        df_pre_decay[xyz] = decay(df_pre_decay[a], dtype=np.object).astype(df.float)
...