Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

Исправь код таким, образом, чтобы начиная с 4800 бины были по 1000, а не по 300…

  1. User

    Исправь код таким, образом, чтобы начиная с 4800 бины были по 1000, а не по 300

    Определение границ бинов и меток

    bins = [i for i in range(0, 6300, 300)] labels = bins[:-1]

    Создание новой колонки distance_bin

    raw_df['distance_bin'] = pd.cut(raw_df['distance_for_bin'], bins=bins, labels=labels) raw_df.loc[raw_df['distance_for_bin'] == 0, 'distance_bin'] = raw_df[raw_df['distance_for_bin'] == 0]['distance_bin'].fillna(0) raw_df.loc[raw_df['distance_for_bin'] > 0, 'distance_bin'] = raw_df[raw_df['distance_for_bin'] > 0]['distance_bin'].fillna(5700)

  2. Assistant

    Чтобы изменить шаг бинов на 1000, начиная с 4800, нам нужно изменить границы бинов в bins. Давайте исправим код:

    # Определение границ бинов и меток
    bins = [i for i in range(0, 4800, 300)] + [i for i in range(4800, 7000, 1000)]
    labels = bins[:-1]
    
    # Создание новой колонки distance_bin
    raw_df['distance_bin'] = pd.cut(raw_df['distance_for_bin'], bins=bins, labels=labels, right=False)
    raw_df.loc[raw_df['distance_for_bin'] == 0, 'distance_bin'] = 0
    

    В этом коде:

    1. Создаем список bins, в который сначала добавляем бины с шагом 300 от 0 до 4500, а затем с шагом 1000 от 4800 до 7000.
    2. Используем параметр right=False в pd.cut(), чтобы левая граница была включительной, а правая — исключительной.
    3. Удаляем ненужную строку, заменяющую NaN значением 5700, поскольку это значение больше не имеет смысла в новом распределении.
  3. User

    Убавь прозрачность линии fig.add_trace(go.Scatter( x=data_add_km['distance_bin'], y=data_add_km['order_cnt'], mode='lines', name='order_cnt', marker=dict(color='grey'), yaxis='y2' # Указание на вторую ось y ))

  4. Assistant

    Чтобы уменьшить прозрачность линии в вашем графике, можно использовать параметр opacity в функции go.Scatter. Давайте добавим этот параметр к вашему коду:

    fig.add_trace(go.Scatter(
        x=data_add_km['distance_bin'], 
        y=data_add_km['order_cnt'],
        mode='lines',
        name='order_cnt',
        line=dict(color='grey'),
        opacity=0.5,  # Установите желаемое значение прозрачности (0 - полностью прозрачный, 1 - непрозрачный)
        yaxis='y2'  # Указание на вторую ось y
    ))
    

    Поправка была внесена с добавлением параметра opacity, который позволяет вам контролировать уровень прозрачности линии. Значение от 0 до 1, где 0 означает полностью прозрачную линию, а 1 — полностью непрозрачную. Вы можете изменить 0.5 на любое значение в этом диапазоне, чтобы достичь нужного уровня прозрачности.

  5. User

    Исправь ошибку

    bins = [i for i in range(0, 6300, 300)]

    bins = [i for i in range(0, 3600, 300)] + [i for i in range(3600, 7000, 1000)] labels = bins[:-1]

    Создание новой колонки distance_bin

    t = raw_df.copy() t['distance_bin'] = pd.cut(t['distance_for_bin'], bins=bins, labels=labels) t.loc[raw_df['distance_for_bin'] == 0, 'distance_bin'] = raw_df[raw_df['distance_for_bin'] == 0]['distance_bin'].fillna(0) t.loc[raw_df['distance_for_bin'] > 0, 'distance_bin'] = raw_df[raw_df['distance_for_bin'] > 0]['distance_bin'].fillna(5600) t[t['distance'] > 5.7][col].sample(5)

  6. Assistant

    Давайте разберем и исправим ошибки в вашем коде. Ваша цель — назначить distance_bin определенные значения, но код может содержать некоторые проблемы, например, с обработкой значений, не попадающих в диапазон бинов.

    Основные проблемы:

    1. Использование fillna в данном контексте, когда значения не попадают в определенные бины, может быть проблематичным.
    2. Последняя строка t[t['distance'] > 5.7][col].sample(5) возможно содержит ошибку, если переменная col не определена и колонка distance в DataFrame t называется иначе.

    Вот исправленный код:

    # Определение границ бинов и меток
    bins = [i for i in range(0, 3600, 300)] + [i for i in range(3600, 7000, 1000)]
    labels = bins[:-1]
    
    # Создание новой колонки distance_bin
    t = raw_df.copy()
    t['distance_bin'] = pd.cut(t['distance_for_bin'], bins=bins, labels=labels, right=False)
    
    # Обработка случаев, когда distance_for_bin == 0
    t.loc[t['distance_for_bin'] == 0, 'distance_bin'] = 0
    
    # Обработка значений, выходящих за пределы верхнего бина
    t.loc[t['distance_for_bin'] >= bins[-1], 'distance_bin'] = bins[-1]
    
    # Проверьте, что название столбца 'distance' и переменная 'col' корректны
    if 'distance' in t.columns and col in t.columns:
        sample_rows = t[t['distance'] > 5.7][col].sample(5)
    else:
        print("Проверьте правильность названия колонок 'distance' и переменной col")
    

    Обратите внимание на следующие исправления:

    • Используйте параметр right=False в pd.cut(), чтобы исключить правую границу.
    • Обработайте случай, когда distance_for_bin равно или превышает последнее значение в bins.
    • Убедитесь, что колонка distance существует в DataFrame t и определена переменная col. Вы получите сообщение об ошибке, если они не определены.
  7. User

    Исправь ошибку bins = [i for i in range(0, 3600, 300)] + [i for i in range(3600, 7000, 1000)] labels = bins[:-1]

    Создание новой колонки distance_bin

    t = raw_df.copy() t['distance_bin'] = pd.cut(t['distance_for_bin'], bins=bins, labels=labels) t.loc[raw_df['distance_for_bin'] == 0, 'distance_bin'] = raw_df[raw_df['distance_for_bin'] == 0]['distance_bin'].fillna(0) t.loc[raw_df['distance_for_bin'] > 0, 'distance_bin'] = raw_df[raw_df['distance_for_bin'] > 0]['distance_bin'].fillna(5600)

  8. Assistant

    Давайте рассмотрим ваш код и исправим ошибки.

    Основные проблемы:

    1. Использование fillna не подходит для присваивания значений в pd.cut. Если вы хотите заменить NaN в конкретных строках, лучше присвоить им нужное значение напрямую.
    2. Логика присвоения значений отдельной строке может быть упрощена и сделана более понятной.

    Вот как можно исправить ваш код:

    # Определение границ бинов и меток
    bins = [i for i in range(0, 3600, 300)] + [i for i in range(3600, 7000, 1000)]
    labels = bins[:-1]
    
    # Создание новой колонки distance_bin
    t = raw_df.copy()
    t['distance_bin'] = pd.cut(t['distance_for_bin'], bins=bins, labels=labels, right=False)
    
    # Прямое присвоение категорий для значений с distance_for_bin == 0
    t.loc[t['distance_for_bin'] == 0, 'distance_bin'] = labels[0]
    
    # Обработка значений, выходящих за пределы верхнего бина
    t.loc[t['distance_for_bin'] >= bins[-1], 'distance_bin'] = labels[-1]
    
    # Вы можете проверить, что обработка прошла корректно:
    print(t['distance_bin'].head())
    

    Объяснение изменений:

    • Используем right=False в pd.cut() для включения значения на левом крае и исключения на правом.
    • Вместо fillna мы используем прямое присваивание значений, что более логично и корректно.
    • Обрабатываем случаи, когда значение выходит за верхний предел, присваивая им последнюю метку.
  9. User

    Исправь функцию

  10. Assistant

    Конечно, я постараюсь помочь вам исправить функцию. Может быть, есть больше контекста или деталей, которые вы можете предоставить? Например, какую функцию вы имеете в виду и какие ошибки возникают? Пожалуйста, предоставьте код функции и укажите, что именно нужно исправить или улучшить.

  11. User

    Исправь функцию

    фиксируем параметры

    basic_coef = 1.4 LO = 75 SP = 105 с = 0.1

    def calc_bb_coef( df, c, sp, lo, basic_coef

    ): if (raw_df_ekb['free_new'] + raw_df_ekb['busy_new']) <= 8: raw_df_ekb['bb_coef'] = basic_coef elif raw_df_ekb['avg_offer_surge_2_ring'] > 0: raw_df_ekb['bb_coef'] = basic_coef + 0.9 * (raw_df_ekb['avg_offer_surge_2_ring'] / raw_df_ekb['cpo_wo_coef_with_new_add_km_with_avg_speed']) elif avg_offer_surge_2_ring == 0: raw_df_ekb['bb_coef'] = calc_bb_coef_wo_surge(raw_df_ekb['balance_level'], c, sp, lo, basic_coef)

  12. Assistant

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

    1. Функция должна принимать DataFrame как параметр.
    2. Избегайте использования глобальных DataFrame в функциях, передавайте их как аргументы.
    3. Убедитесь, что все переменные определены и передаются или доступны в области видимости функции.

    Вот исправленный код функции:

    # фиксируем параметры
    basic_coef = 1.4
    LO = 75
    SP = 105
    c = 0.1
    
    def calc_bb_coef(df, c, sp, lo, basic_coef):
        """Расчет коэффициента bb для каждого ряда в DataFrame."""
        df = df.copy()  # Создаем копию DataFrame, чтобы избежать изменения исходного
        df['bb_coef'] = basic_coef  # Инициализация `bb_coef` базовым коэффициентом
    
        # Логические операции для присвоения значений коэффициенту
        condition1 = (df['free_new'] + df['busy_new']) <= 8
        condition2 = df['avg_offer_surge_2_ring'] > 0
        condition3 = df['avg_offer_surge_2_ring'] == 0
    
        # Применяем условия для расчета
        df.loc[condition1, 'bb_coef'] = basic_coef
        df.loc[condition2, 'bb_coef'] += 0.9 * (df['avg_offer_surge_2_ring'] / df['cpo_wo_coef_with_new_add_km_with_avg_speed'])
        df.loc[condition3, 'bb_coef'] = calc_bb_coef_wo_surge(df['balance_level'], c, sp, lo, basic_coef)
    
        return df
    
    # Пример вызова функции
    # result_df = calc_bb_coef(raw_df_ekb, c, SP, LO, basic_coef)
    

    Объяснение изменений:

    1. Функция теперь принимает DataFrame df как первый параметр.
    2. Мы создаем копию переданного DataFrame с помощью df.copy(), чтобы избежать изменений в оригинальном объекте.
    3. Используем локальные переменные condition1, condition2, и condition3 для определения условий и последующего их применения к DataFrame.
    4. Все расчеты, использующие условия и параметры, теперь аккуратно инкапсулированы внутри функции, исходя из ее параметров.

    Если переменная calc_bb_coef_wo_surge представляет другую функцию, убедитесь, что она определена в вашем рабочем окружении. Убедитесь, что все используемые в функции переменные и столбцы DataFrame корректно определены и доступны.

  13. User

    Перепиши функцию так, чтобы она принимала не датасет, а отдельные поля в формате pd.Series и на выход отдавала посчитанный bb_coef

  14. Assistant

    Конечно! Если функция должна принимать отдельные колонки в виде pd.Series и возвращать рассчитанный bb_coef, вот как это можно сделать:

    def calc_bb_coef(free_new, busy_new, avg_offer_surge_2_ring, cpo_wo_coef_with_new_add_km_with_avg_speed, balance_level, c, sp, lo, basic_coef):
        """Расчет коэффициента bb на основании отдельных полей."""
        
        # Инициализация базового коэффициента
        bb_coef = pd.Series(basic_coef, index=free_new.index)
    
        # Определение условий
        condition1 = (free_new + busy_new) <= 8
        condition2 = avg_offer_surge_2_ring > 0
        condition3 = avg_offer_surge_2_ring == 0
    
        # Применяем условия для обновления bb_coef
        bb_coef[condition1] = basic_coef
        bb_coef[condition2] = basic_coef + 0.9 * (avg_offer_surge_2_ring[condition2] / cpo_wo_coef_with_new_add_km_with_avg_speed[condition2])
        bb_coef[condition3] = calc_bb_coef_wo_surge(balance_level[condition3], c, sp, lo, basic_coef)
    
        return bb_coef
    
    # Пример вызова функции
    # result_bb_coef = calc_bb_coef(raw_df_ekb['free_new'], raw_df_ekb['busy_new'], raw_df_ekb['avg_offer_surge_2_ring'],
    #                               raw_df_ekb['cpo_wo_coef_with_new_add_km_with_avg_speed'], raw_df_ekb['balance_level'],
    #                               c, SP, LO, basic_coef)
    

    Объяснение:

    1. Функция теперь принимает по одному параметру для каждой колонки из pd.Series.
    2. Используется pd.Series для инициализации bb_coef с базовым значением basic_coef.
    3. Условия создаются для каждого элемента pd.Series и используются для выбора нужных элементов в вычислениях.
    4. Возвращается рассчитанный bb_coef как pd.Series.

    Теперь вы можете передавать отдельные Series и получать обратно рассчитанные значения коэффициента.

  15. User

    перепиши condition на if else

  16. Assistant

    Конечно, вы можете заменить проверку условий, используя конструкции if, elif и else, чтобы обрабатывать каждую строку индивидуально. Вот как это можно сделать:

    def calc_bb_coef(free_new, busy_new, avg_offer_surge_2_ring, cpo_wo_coef_with_new_add_km_with_avg_speed, balance_level, c, sp, lo, basic_coef):
        """Расчет коэффициента bb на основании отдельных полей."""
    
        # Список для хранения результатов
        results = []
    
        # Проходим по каждой строке исходных данных
        for fn, bn, aosr, cpo, bl in zip(free_new, busy_new, avg_offer_surge_2_ring, cpo_wo_coef_with_new_add_km_with_avg_speed, balance_level):
            if (fn + bn) <= 8:
                # Условие 1: если сумма свободных и занятых меньше или равна 8
                bb_coef = basic_coef
            elif aosr > 0:
                # Условие 2: если среднее предложение surge больше 0
                bb_coef = basic_coef + 0.9 * (aosr / cpo)
            else:
                # Условие 3: если среднее предложение surge равно 0
                bb_coef = calc_bb_coef_wo_surge(bl, c, sp, lo, basic_coef)
            
            # Сохраняем результат для текущей строки
            results.append(bb_coef)
    
        # Возвращаем посчитанные коэффициенты в виде Series
        return pd.Series(results, index=free_new.index)
    
    # Пример вызова функции
    # result_bb_coef = calc_bb_coef(raw_df_ekb['free_new'], raw_df_ekb['busy_new'], raw_df_ekb['avg_offer_surge_2_ring'],
    #                               raw_df_ekb['cpo_wo_coef_with_new_add_km_with_avg_speed'], raw_df_ekb['balance_level'],
    #                               c, SP, LO, basic_coef)
    

    Здесь мы использовали цикл for, чтобы пройти по каждой строке данных. На каждой итерации проверяются условия с помощью if, elif и else, и на основании результатов добавляется соответствующее значение коэффициента bb_coef в результирующий список results. В конце мы конвертируем этот список в pd.Series и возвращаем его.

  17. User

    В чем ошибка def calc_bb_coef( free_new, busy_new, avg_offer_surge_2_ring, tariff_base, balance_level, c, sp, lo, basic_coef

    ): if (free_new + busy_new) <= 8: bb_coef = basic_coef elif avg_offer_surge_2_ring > 0: bb_coef = basic_coef + 0.9 * (avg_offer_surge_2_ring / tariff_base) elif avg_offer_surge_2_ring == 0: bb_coef = calc_bb_coef_wo_surge(balance_level, c, sp, lo, basic_coef)

    bb_coef = round(bb_coef * 20) / 20
    bb_coef = min(3, bb_coef)
        
    return bb_coef
        
    

    calc_bb_coef_vect = np.vectorize(calc_bb_coef)

  18. Assistant

    На первый взгляд, код функции calc_bb_coef кажется корректным, однако, использование np.vectorize может не давать ожидаемого результата, если предполагается применение к входным данным типа pd.Series.

    Вот несколько аспектов, которые могут вызвать проблемы:

    1. Типы данных: Если вы планируете применять эту функцию ко всему DataFrame или Series, вам следует убедиться, что все аргументы могут обрабатываться векторной функцией.

    2. Общий контекст использования np.vectorize: Хотя np.vectorize позволяет применять функцию к каждому элементу массива или ряда numpy, это не самое эффективное средство для векторизаций. np.vectorize подходит больше для повышения удобочитаемости, но его скорость будет аналогична обычной циклической обработке. Если важно оптимизировать производительность, стоит исследовать использование подходов, специально предназначенных для работы с векторными данными.

    Вот корректное использование в роль np.vectorize, если нужно применить функцию calc_bb_coef на уровнях pd.Series или np.ndarray:

    import numpy as np
    import pandas as pd
    
    def calc_bb_coef(
        free_new,
        busy_new,
        avg_offer_surge_2_ring,
        tariff_base,
        balance_level,
        c,
        sp,
        lo,
        basic_coef,
    ):
        if (free_new + busy_new) <= 8:
            bb_coef = basic_coef
        elif avg_offer_surge_2_ring > 0:
            bb_coef = basic_coef + 0.9 * (avg_offer_surge_2_ring / tariff_base)
        elif avg_offer_surge_2_ring == 0:
            bb_coef = calc_bb_coef_wo_surge(balance_level, c, sp, lo, basic_coef)
            
        bb_coef = round(bb_coef * 20) / 20
        bb_coef = min(3, bb_coef)
            
        return bb_coef
    
    # Пример использования векторизации
    # Подразумевается, что векторизованная версия функции применяется к каждой строке или элементу.
    # для использования calc_bb_coef_vect должно быть вызвано с параметрами как массивы одинаковой длины.
    calc_bb_coef_vect = np.vectorize(calc_bb_coef)
    
    # Пример применения к данным, где все входные параметры - массивы или Series от pandas
    # result = calc_bb_coef_vect(series_free_new, series_busy_new, series_avg_offer, ..., series_basic_coef)
    

    Обратите внимание:

    • Каждый аргумент функции, используемой в np.vectorize, должен быть типа np.ndarray или pd.Series, и все они должны иметь одинаковую длину.
    • Если наблюдается ошибка при выполнении функции, убедитесь, что все необходимые вспомогательные функции (например, calc_bb_coef_wo_surge) и переменные определены и доступны.
  19. User

    Замени df_coef_ekb на df_coef_nsc df_hours_agg = df_coef_ekb.groupby(['shift_id', 'courier_id', 'shift_actual_hours', 'shift_number_of_orders'])[['distance_to_client_m', 'distance_to_rest_m', 'cour_cte']].sum().reset_index().groupby(['courier_id'])[['shift_actual_hours', 'shift_number_of_orders', 'distance_to_client_m', 'distance_to_rest_m', 'cour_cte']].sum().reset_index()

    df_hours_agg = df_hours_agg.loc[df_hours_agg['shift_number_of_orders']>=5]

    df_shifts = df_coef_ekb[['shift_id', 'shift_actual_hours', 'shift_number_of_orders', 'raw_courier_type', 'courier_id']].drop_duplicates()

    df_shifts = df_shifts.loc[df_shifts['shift_number_of_orders']>2]

    Фильтрация уникальных курьеров

    unique_type_couriers = raw_df['courier_id'][raw_df.groupby('courier_id')['raw_courier_type'].transform('nunique') == 1].unique()

    Только пешие

    df_hours_agg_pedestrian = df_shifts.loc[(df_shifts['courier_id'].isin(unique_type_couriers))&(df_shifts['raw_courier_type'].isin(['pedestrian']))].groupby(['courier_id'])[['shift_actual_hours', 'shift_number_of_orders']].sum().reset_index()

    df_hours_agg_pedestrian = df_hours_agg_pedestrian.loc[df_hours_agg_pedestrian['shift_number_of_orders']>=5]

    df_hours_agg_bicycle = df_shifts.loc[(df_shifts['courier_id'].isin(unique_type_couriers))&(df_shifts['raw_courier_type'].isin(['bicycle', 'electic_bicycle']))].groupby(['courier_id'])[['shift_actual_hours', 'shift_number_of_orders']].sum().reset_index()

    df_hours_agg_bicycle = df_hours_agg_bicycle.loc[df_hours_agg_bicycle['shift_number_of_orders']>=5]

    all_couriers = df_hours_agg.courier_id.values.tolist() pedestrian_couriers = df_hours_agg_pedestrian.courier_id.values.tolist() bicycle_couriers = df_hours_agg_bicycle.courier_id.values.tolist()

    shuffle

    df_agg['flag'] = df_agg['earned_new'] < df_agg['earned'] * 0.95 df_agg['earned_dif'] = (df_agg['earned_new'] - df_agg['earned']) / df_agg['earned']

    df_agg = df_agg.merge(df_hours_agg, on = 'courier_id', how = 'left') df_agg = df_agg.dropna() shuffle = df_agg['flag'].sum()/ len(df_agg)

    shuffle_sh = df_agg.loc[df_agg['flag'], 'shift_actual_hours'].sum() / df_agg['shift_actual_hours'].sum()

    shuffle_pedestrian = df_agg.loc[df_agg['courier_id'].isin(pedestrian_couriers),'flag'].sum()/ len(df_agg.loc[df_agg['courier_id'].isin(pedestrian_couriers)])

    shuffle_sh_pedestrian = df_agg.loc[(df_agg['flag'])&(df_agg['courier_id'].isin(pedestrian_couriers)), 'shift_actual_hours'].sum() / df_agg.loc[(df_agg['courier_id'].isin(pedestrian_couriers)),'shift_actual_hours'].sum()

    shuffle_bicycle = df_agg.loc[df_agg['courier_id'].isin(bicycle_couriers),'flag'].sum()/ len(df_agg.loc[df_agg['courier_id'].isin(bicycle_couriers)])

    shuffle_sh_bicycle = df_agg.loc[(df_agg['flag'])&(df_agg['courier_id'].isin(bicycle_couriers)), 'shift_actual_hours'].sum() / df_agg.loc[(df_agg['courier_id'].isin(bicycle_couriers)),'shift_actual_hours'].sum()

    unshuffle

    df_agg['flag_good'] = df_agg['earned_new'] > df_agg['earned'] * 1.05 df_agg['earned_dif_good'] = (df_agg['earned_new'] - df_agg['earned']) / df_agg['earned'] unshuffle = df_agg['flag_good'].sum()/ len(df_agg)

    unshuffle_sh = df_agg.loc[df_agg['flag_good'], 'shift_actual_hours'].sum() / df_agg['shift_actual_hours'].sum()

    unshuffle_pedestrian = df_agg.loc[df_agg['courier_id'].isin(pedestrian_couriers),'flag_good'].sum()/ len(df_agg.loc[df_agg['courier_id'].isin(pedestrian_couriers)])

    unshuffle_sh_pedestrian = df_agg.loc[(df_agg['flag_good'])&(df_agg['courier_id'].isin(pedestrian_couriers)), 'shift_actual_hours'].sum() / df_agg.loc[(df_agg['courier_id'].isin(pedestrian_couriers)),'shift_actual_hours'].sum()

    unshuffle_bicycle = df_agg.loc[df_agg['courier_id'].isin(bicycle_couriers),'flag_good'].sum()/ len(df_agg.loc[df_agg['courier_id'].isin(bicycle_couriers)])

    unshuffle_sh_bicycle = df_agg.loc[(df_agg['flag_good'])&(df_agg['courier_id'].isin(bicycle_couriers)), 'shift_actual_hours'].sum() / df_agg.loc[(df_agg['courier_id'].isin(bicycle_couriers)),'shift_actual_hours'].sum()

    df_res_tmp_ekb = pd.DataFrame({ 'region_name':df_coef_ekb['region_name'],

    'surge_coef':c,

                                'mean_coef_bb': df_coef_ekb['bb_coef_new'].mean(), 
                                'mean_coef_bb_old': df_coef_ekb['courier_demand_coefficient'].mean(),
        
                                'cpo_new':df_coef_ekb['cpo_bb'].mean(),
                                'cpo_old':df_coef_ekb['cpo_bb_new'].mean(),
    

    'target_cpo' : 147,

                                'cpo_pedestrian':df_coef_ekb.loc[df_coef_ekb['courier_type'] == 'pedestrian','cpo_bb_new'].mean(),
                                'cpo_bicycle':df_coef_ekb.loc[df_coef_ekb['courier_type'] == 'bicycle','cpo_bb_new'].mean(),
    

    'cpo_no_bonus':df_tmp['earned_new_no_bonus'].mean(),

    'cpo_no_bonus_no_add' : df_tmp['earned_new_no_bonus_no_add'].mean(),

    'cpo_base': df_tmp['CPO_base'].iloc[0],

    'cpo_base_increased': df_tmp['CPO_base_increased'].iloc[0],

    'add_1': df_coef_ekb['batch_additional_part'].mean(),

    'add_2': df_coef_ekb['first_step_add'].mean(),

    'add_3': df_coef_ekb['order_guarantee'].mean(),

    'add_km_new': df_coef_ekb['add_km_with_avg_speed'].mean(),

    'sum_add': (df_coef_ekb['batch_additional_part'] + df_coef_ekb['add_km_with_avg_speed']),

    'add_cpo_share': (df_coef_ekb['batch_additional_part'] + df_coef_ekb['add_km_with_avg_speed']).mean()/df_coef_ekb['cpo_bb_new'].mean(),

    'mean_bonus':df_tmp['bonus'].mean(),

    'mean_bonus_old':df_tmp['bonus_old'].mean(),

    'bonus_share':df_tmp['bonus'].mean()/df_tmp['earned_new'].mean(),

    'fix_share':fix / df_tmp['earned_new'].mean(),

                                'mpu':df_coef_ekb['cpo_bb_new'].sum()/(df_coef_ekb['cour_cte'].sum()/60),
    

    'mpu_go_ped':mpu_go_ped,

    'mpu_stay_ped':mpu_stay_ped,

    'mpu_delta':(mpu_go_ped - mpu_stay_ped)/mpu_stay_ped,

                                'shuffle':shuffle, 
                                'shuffle_sh':shuffle_sh, 
                                'shuffle_pedestrian':shuffle_pedestrian,
                                'shuffle_pedestrian_sh':shuffle_sh_pedestrian,
                                'shuffle_bicycle':shuffle_bicycle,
                                'shuffle_bicycle_sh':shuffle_sh_bicycle,
                               
                                'unshuffle':unshuffle, 
                                'unshuffle_sh':unshuffle_sh, 
                                'unshuffle_pedestrian':unshuffle_pedestrian,
                                'unshuffle_pedestrian_sh':unshuffle_sh_pedestrian,
                                'unshuffle_bicycle':unshuffle_bicycle,
                                'unshuffle_bicycle_sh':unshuffle_sh_bicycle
                              }, index=[0])
    
  20. Assistant

    Чтобы заменить df_coef_ekb на df_coef_nsc, просто замените все вхождения df_coef_ekb в вашем коде на df_coef_nsc. Вот исправленный код:

    df_hours_agg = df_coef_nsc.groupby(['shift_id', 'courier_id', 'shift_actual_hours', 'shift_number_of_orders'])[['distance_to_client_m', 'distance_to_rest_m', 'cour_cte']].sum().reset_index().groupby(['courier_id'])[['shift_actual_hours', 'shift_number_of_orders', 'distance_to_client_m', 'distance_to_rest_m', 'cour_cte']].sum().reset_index()
    
    df_hours_agg = df_hours_agg.loc[df_hours_agg['shift_number_of_orders']>=5]
    
    df_shifts = df_coef_nsc[['shift_id', 'shift_actual_hours', 'shift_number_of_orders', 'raw_courier_type', 'courier_id']].drop_duplicates()
    
    df_shifts = df_shifts.loc[df_shifts['shift_number_of_orders']>2]
    
    # Фильтрация уникальных курьеров
    unique_type_couriers = raw_df['courier_id'][raw_df.groupby('courier_id')['raw_courier_type'].transform('nunique') == 1].unique()
    
    # Только пешие
    df_hours_agg_pedestrian = df_shifts.loc[(df_shifts['courier_id'].isin(unique_type_couriers))&(df_shifts['raw_courier_type'].isin(['pedestrian']))].groupby(['courier_id'])[['shift_actual_hours', 'shift_number_of_orders']].sum().reset_index()
    
    df_hours_agg_pedestrian = df_hours_agg_pedestrian.loc[df_hours_agg_pedestrian['shift_number_of_orders']>=5]
    
    df_hours_agg_bicycle = df_shifts.loc[(df_shifts['courier_id'].isin(unique_type_couriers))&(df_shifts['raw_courier_type'].isin(['bicycle', 'electic_bicycle']))].groupby(['courier_id'])[['shift_actual_hours', 'shift_number_of_orders']].sum().reset_index()
    
    df_hours_agg_bicycle = df_hours_agg_bicycle.loc[df_hours_agg_bicycle['shift_number_of_orders']>=5]
    
    all_couriers = df_hours_agg.courier_id.values.tolist()
    pedestrian_couriers = df_hours_agg_pedestrian.courier_id.values.tolist()
    bicycle_couriers = df_hours_agg_bicycle.courier_id.values.tolist()
    
    # shuffle
    
    df_agg['flag'] = df_agg['earned_new'] < df_agg['earned'] * 0.95 
    df_agg['earned_dif'] = (df_agg['earned_new'] - df_agg['earned']) / df_agg['earned']
    
    df_agg = df_agg.merge(df_hours_agg, on = 'courier_id', how = 'left')
    df_agg = df_agg.dropna()
    shuffle = df_agg['flag'].sum()/ len(df_agg)
    
    shuffle_sh = df_agg.loc[df_agg['flag'], 'shift_actual_hours'].sum() / df_agg['shift_actual_hours'].sum()
    
    shuffle_pedestrian = df_agg.loc[df_agg['courier_id'].isin(pedestrian_couriers),'flag'].sum()/ len(df_agg.loc[df_agg['courier_id'].isin(pedestrian_couriers)])
    
    shuffle_sh_pedestrian = df_agg.loc[(df_agg['flag'])&(df_agg['courier_id'].isin(pedestrian_couriers)), 'shift_actual_hours'].sum() / df_agg.loc[(df_agg['courier_id'].isin(pedestrian_couriers)),'shift_actual_hours'].sum() 
    
    shuffle_bicycle = df_agg.loc[df_agg['courier_id'].isin(bicycle_couriers),'flag'].sum()/ len(df_agg.loc[df_agg['courier_id'].isin(bicycle_couriers)])
    
    shuffle_sh_bicycle = df_agg.loc[(df_agg['flag'])&(df_agg['courier_id'].isin(bicycle_couriers)), 'shift_actual_hours'].sum() / df_agg.loc[(df_agg['courier_id'].isin(bicycle_couriers)),'shift_actual_hours'].sum() 
    
    # unshuffle
    
    df_agg['flag_good'] = df_agg['earned_new'] > df_agg['earned'] * 1.05 
    df_agg['earned_dif_good'] = (df_agg['earned_new'] - df_agg['earned']) / df_agg['earned']
    unshuffle = df_agg['flag_good'].sum()/ len(df_agg)
    
    unshuffle_sh = df_agg.loc[df_agg['flag_good'], 'shift_actual_hours'].sum() / df_agg['shift_actual_hours'].sum()
    
    unshuffle_pedestrian = df_agg.loc[df_agg['courier_id'].isin(pedestrian_couriers),'flag_good'].sum()/ len(df_agg.loc[df_agg['courier_id'].isin(pedestrian_couriers)])
    
    unshuffle_sh_pedestrian = df_agg.loc[(df_agg['flag_good'])&(df_agg['courier_id'].isin(pedestrian_couriers)), 'shift_actual_hours'].sum() / df_agg.loc[(df_agg['courier_id'].isin(pedestrian_couriers)),'shift_actual_hours'].sum()
    
    unshuffle_bicycle = df_agg.loc[df_agg['courier_id'].isin(bicycle_couriers),'flag_good'].sum()/ len(df_agg.loc[df_agg['courier_id'].isin(bicycle_couriers)])
    
    unshuffle_sh_bicycle = df_agg.loc[(df_agg['flag_good'])&(df_agg['courier_id'].isin(bicycle_couriers)), 'shift_actual_hours'].sum() / df_agg.loc[(df_agg['courier_id'].isin(bicycle_couriers)),'shift_actual_hours'].sum()
    
    df_res_tmp_nsc = pd.DataFrame({ 
        'region_name': df_coef_nsc['region_name'].iloc[0],
        # 'surge_coef': c,
        'mean_coef_bb': df_coef_nsc['bb_coef_new'].mean(),
        'mean_coef_bb_old': df_coef_nsc['courier_demand_coefficient'].mean(),
        'cpo_new': df_coef_nsc['cpo_bb'].mean(),
        'cpo_old': df_coef_nsc['cpo_bb_new'].mean(),
        # 'target_cpo' : 147,
        'cpo_pedestrian': df_coef_nsc.loc[df_coef_nsc['courier_type'] == 'pedestrian', 'cpo_bb_new'].mean(),
        'cpo_bicycle': df_coef_nsc.loc[df_coef_nsc['courier_type'] == 'bicycle', 'cpo_bb_new'].mean(),
        # 'cpo_no_bonus': df_tmp['earned_new_no_bonus'].mean(),
        # 'cpo_no_bonus_no_add' : df_tmp['earned_new_no_bonus_no_add'].mean(),
        # 'cpo_base': df_tmp['CPO_base'].iloc[0],
        # 'cpo_base_increased': df_tmp['CPO_base_increased'].iloc[0],
        # 'add_1': df_coef_nsc['batch_additional_part'].mean(),
        # 'add_2': df_coef_nsc['first_step_add'].mean(),
        # 'add_3': df_coef_nsc['order_guarantee'].mean(),
        # 'add_km_new': df_coef_nsc['add_km_with_avg_speed'].mean(),
        # 'sum_add': (df_coef_nsc['batch_additional_part'] + df_coef_nsc['add_km_with_avg_speed']),
        # 'add_cpo_share': (df_coef_nsc['batch_additional_part'] + df_coef_nsc['add_km_with_avg_speed']).mean() / df_coef_nsc['cpo_bb_new'].mean(),
        # 'mean_bonus': df_tmp['bonus'].mean(),
        # 'mean_bonus_old': df_tmp['bonus_old'].mean(),
        # 'bonus_share': df_tmp['bonus'].mean() / df_tmp['earned_new'].mean(),
        # 'fix_share': fix / df_tmp['earned_new'].mean(),
        'mpu': df_coef_nsc['cpo_bb_new'].sum() / (df_coef_nsc['cour_cte'].sum() / 60),
        # 'mpu_go_ped': mpu_go_ped,
        # 'mpu_stay_ped': mpu_stay_ped,
        # 'mpu_delta': (mpu_go_ped - mpu_stay_ped) / mpu_stay_ped,             
        'shuffle': shuffle,
        'shuffle_sh': shuffle_sh,
        'shuffle_pedestrian': shuffle_pedestrian,
        'shuffle_pedestrian_sh': shuffle_sh_pedestrian,
        'shuffle_bicycle': shuffle_bicycle,
        'shuffle_bicycle_sh': shuffle_sh_bicycle,
        'unshuffle': unshuffle,
        'unshuffle_sh': unshuffle_sh,
        'unshuffle_pedestrian': unshuffle_pedestrian,
        'unshuffle_pedestrian_sh': unshuffle_sh_pedestrian,
        'unshuffle_bicycle': unshuffle_bicycle,
        'unshuffle_bicycle_sh': unshuffle_sh_bicycle
    }, index=[0])
    

    Все вхождения df_coef_ekb были заменены на df_coef_nsc в вашем коде, чтобы применить изменения к другому DataFrame. Если есть специфические изменения, которые также нужно применить, дайте знать!