Skip to content
The Chat Archive
gemini-2.5-pro-preview-05-06· Google LMArena Human Preference 140K

import matplotlib.pyplot as plt import numpy as np import pandas as pd from sklearn.base…

  1. User

    import matplotlib.pyplot as plt import numpy as np import pandas as pd from sklearn.base import OutlierMixin from sklearn.metrics import mean_absolute_error

    from .base import PrepBase from .utils import array_to_df, check_input_data, fillna

    class OutlierDetector(PrepBase, OutlierMixin): """ Поиск вылетов, основываясь на разнице между реальными значениями и значениями переданного фильтра.

    Parameters
    ----------
    base_filter : BaseFilter
        Объект, имеющий метод `fit_transform`, который каким-либо образом
        фильтрует, сглаживает данные, снижает их шум
    
    tol : float or int, default 10
        Чувствительность к вылетам. Чем меньше `tol`, тем более мелкие
        отклонения будут восприниматься как вылеты.
    """
    
    def __init__(self, base_filter, tol=10):
        self.base_filter = base_filter
        self.tol = tol
    
    def predict(self, X):
        """
        Вычисление верхней и нижней границ (построение коридора) для каждой
        колонки массива X, значения за пределами которых будут считаться
        вылетами, пометка вылетов -1, а нормальных значений 1.
    
        Parameters
        ----------
        X : numpy.ndarray or pandas.DataFrame
            Данные для поиска вылетов.
    
        Returns
        -------
        outliers : pandas.DataFrame
            Массив, в котором вылеты помечены значением -1, а нормальные
            значения 1.
        """
        check_input_data(X)
        X = array_to_df(X)
        dfq = X.copy()
    
        # из колонок с различными значениями имеет смысл удалить верхние и
        # нижние значения перед построением коридора, чтобы потенциальные
        # вылеты не расширяли коридор
        cols_diff_values = X.columns[abs(X.std()) > 1e-15]
        if not cols_diff_values.empty:
            dfq[cols_diff_values] = dfq[cols_diff_values].mask(X > X.quantile(0.8))
            dfq[cols_diff_values] = dfq[cols_diff_values].mask(X < X.quantile(0.2))
            empty_cols = dfq.columns[dfq.count() == 0]
            if not empty_cols.empty:
                dfq[empty_cols] = X[empty_cols]
            dfq = fillna(dfq)
    
        filter_res = self.base_filter.fit_transform(dfq)
        mae = mean_absolute_error(dfq, filter_res, multioutput="raw_values")
        delta = dfq - filter_res
        delta[delta > delta.quantile(0.99)] = np.nan
        delta[delta < delta.quantile(0.01)] = np.nan
        delta = fillna(delta)
        deviation = np.std(delta)
    
        self.lower_bound_ = filter_res - (mae + self.tol * deviation)
        self.upper_bound_ = filter_res + (mae + self.tol * deviation)
    
        outliers = pd.DataFrame(index=X.index, columns=X.columns)
        outliers[X < self.lower_bound_] = -1
        outliers[X > self.upper_bound_] = -1
        outliers.fillna(1, inplace=True)
    
        return outliers
    

    Метод predict выполняется очень долго, для большого массива данных. Я делал профилирование, setitem от pandas вызывается 9600 раз. Для меня важно чтобы результаты твоего кода и моего сходились. Можешь помочь с кодом? Как его ускорить не меняя логику и результат выполнения?

  2. Assistant

    Отличная задача! Основные узкие места в pandas — это часто повторяющиеся операции setitem (присваивание по индексу/маске) и создание множества промежуточных объектов DataFrame/Series. Мы можем оптимизировать это, объединяя операции и используя более эффективные функции NumPy там, где это возможно, особенно для финального формирования outliers.

    Вот предлагаемые изменения:

    1. Оптимизация маскирования dfq:

      • Вычисляем квантили X.quantile(0.8) и X.quantile(0.2) один раз.
      • Создаем объединенное условие для маскирования и применяем его один раз к dfq[cols_diff_values].
    2. Оптимизация маскирования delta:

      • Аналогично, вычисляем квантили delta.quantile(0.99) и delta.quantile(0.01) один раз.
      • Создаем объединенное условие и присваиваем np.nan по этому условию за один шаг. Вместо .mask(), прямое присваивание delta[condition] = np.nan может быть чуть эффективнее для этой конкретной операции.
    3. Оптимизация создания outliers:

      • Это самое значительное изменение. Вместо создания пустого DataFrame, двух присваиваний -1 и затем fillna(1), мы можем использовать np.where для создания массива значений (-1 или 1) за один проход, а затем обернуть его в DataFrame. Это сократит количество операций setitem с трех (или двух + fillna) до нуля для этой части (не считая самого создания DataFrame).

    Давайте применим эти изменения к коду:

    import matplotlib.pyplot as plt
    import numpy as np
    import pandas as pd
    from sklearn.base import OutlierMixin
    from sklearn.metrics import mean_absolute_error
    
    # Предположим, что эти зависимости доступны в том же контексте
    # from .base import PrepBase
    # from .utils import array_to_df, check_input_data, fillna
    
    # Заглушки для запуска кода локально:
    class PrepBase:
        pass
    
    def check_input_data(X):
        if not isinstance(X, (pd.DataFrame, np.ndarray)):
            raise TypeError("Input data must be a pandas DataFrame or numpy array.")
        if X.ndim == 1:
            X = X.reshape(-1, 1)
        return X
    
    def array_to_df(X, columns=None):
        if isinstance(X, pd.DataFrame):
            return X
        if columns is None and hasattr(X, 'shape'):
            columns = [f'col_{i}' for i in range(X.shape[1])]
        return pd.DataFrame(X, columns=columns)
    
    def fillna(df):
        # Простая реализация fillna для примера, может отличаться от вашей
        # Ваша реализация может быть более сложной (например, ffill().bfill())
        if isinstance(df, pd.DataFrame):
            return df.fillna(method='ffill').fillna(method='bfill').fillna(0) # Добавил .fillna(0) на случай полностью NaN колонки
        elif isinstance(df, pd.Series):
            return df.fillna(method='ffill').fillna(method='bfill').fillna(0)
        return df
    
    
    class OutlierDetector(PrepBase, OutlierMixin):
        """
        Поиск вылетов, основываясь на разнице между реальными значениями и
        значениями переданного фильтра.
    
        Parameters
        ----------
        base_filter : BaseFilter
            Объект, имеющий метод `fit_transform`, который каким-либо образом
            фильтрует, сглаживает данные, снижает их шум
    
        tol : float or int, default 10
            Чувствительность к вылетам. Чем меньше `tol`, тем более мелкие
            отклонения будут восприниматься как вылеты.
        """
    
        def __init__(self, base_filter, tol=10):
            self.base_filter = base_filter
            self.tol = tol
    
        def predict(self, X):
            """
            Вычисление верхней и нижней границ (построение коридора) для каждой
            колонки массива X, значения за пределами которых будут считаться
            вылетами, пометка вылетов -1, а нормальных значений 1.
    
            Parameters
            ----------
            X : numpy.ndarray or pandas.DataFrame
                Данные для поиска вылетов.
    
            Returns
            -------
            outliers : pandas.DataFrame
                Массив, в котором вылеты помечены значением -1, а нормальные
                значения 1.
            """
            X_checked = check_input_data(X) # Сохраняем оригинальный X для check_input_data
            X_df = array_to_df(X_checked) # Работаем с DataFrame копией
            dfq = X_df.copy()
    
            cols_with_variance = X_df.columns[X_df.std(axis=0, ddof=0) > 1e-15] # axis=0, ddof=0 для согласованности
    
            if not cols_with_variance.empty:
                # Вычисляем квантили один раз на оригинальных данных X_df
                q_upper_X = X_df[cols_with_variance].quantile(0.8, axis=0)
                q_lower_X = X_df[cols_with_variance].quantile(0.2, axis=0)
    
                # Создаем условие для маскирования
                # Сравниваем значения из X_df (не dfq) с квантилями X_df
                condition_X_quantiles = (X_df[cols_with_variance] > q_upper_X) | \
                                        (X_df[cols_with_variance] < q_lower_X)
                
                # Применяем маску к dfq[cols_with_variance]
                # .mask заменяет значения там, где condition_X_quantiles Истина
                # Важно: dfq[cols_with_variance].mask(condition, ...) создаст копию этого среза,
                # затем присвоит его обратно. Это нормально.
                dfq[cols_with_variance] = dfq[cols_with_variance].mask(condition_X_quantiles)
                
                empty_cols = dfq.columns[dfq.count(axis=0) == 0]
                if not empty_cols.empty:
                    dfq[empty_cols] = X_df[empty_cols]
            
            dfq = fillna(dfq)
    
            filter_res_np = self.base_filter.fit_transform(dfq)
            # Убедимся, что filter_res это DataFrame с тем же индексом/колонками
            if not isinstance(filter_res_np, pd.DataFrame):
                 filter_res = pd.DataFrame(filter_res_np, index=dfq.index, columns=dfq.columns)
            else:
                 filter_res = filter_res_np
    
    
            mae = mean_absolute_error(dfq, filter_res, multioutput="raw_values") # Возвращает ndarray
            
            delta = dfq - filter_res # df - df = df
    
            # Оптимизация маскирования delta
            delta_q_upper = delta.quantile(0.99, axis=0)
            delta_q_lower = delta.quantile(0.01, axis=0)
            
            condition_delta_quantiles = (delta > delta_q_upper) | (delta < delta_q_lower)
            # delta[condition_delta_quantiles] = np.nan # Прямое присваивание NaN по маске
            # Или, чтобы сохранить структуру и быть более явным при замене на NaN:
            delta = delta.mask(condition_delta_quantiles)
    
    
            delta = fillna(delta)
            
            # np.std(pd.DataFrame) вернет pd.Series, что нам и нужно для корректного выравнивания
            deviation = delta.std(axis=0, ddof=0) # ddof=0 для согласованности с np.std по умолчанию для популяций
    
            # mae - это numpy array, deviation - pandas Series.
            # Pandas корректно обработает их сложение/умножение при выравнивании с filter_res (DataFrame)
            # filter_res (DataFrame) - (mae_array + tol * deviation_series)
            bound_offset = mae + self.tol * deviation
            self.lower_bound_ = filter_res - bound_offset
            self.upper_bound_ = filter_res + bound_offset
    
            # Оптимизация создания outliers с использованием np.where
            # X_df, self.lower_bound_, self.upper_bound_ должны быть совместимы по форме
            # Если они все DataFrame с одинаковыми индексами/колонками, операции будут поэлементными
            is_outlier_condition = (X_df < self.lower_bound_) | (X_df > self.upper_bound_)
            
            # np.where напрямую вернет NumPy массив. Оборачиваем его в DataFrame.
            outlier_values = np.where(is_outlier_condition.values, -1, 1) # .values для работы с NumPy массивами напрямую
            
            outliers = pd.DataFrame(outlier_values, index=X_df.index, columns=X_df.columns)
    
            return outliers
    
    

    Ключевые изменения и пояснения:

    1. X_df и dfq: X_df теперь используется как ссылка на исходные данные (после array_to_df), а dfq — как рабочая копия для модификаций. Это помогает четко разделить, где используются оригинальные значения для квантилей, а где модифицированные.
    2. Квантили для dfq:
      • q_upper_X = X_df[cols_with_variance].quantile(0.8, axis=0) и q_lower_X вычисляются на исходных данных X_df для колонок с вариативностью.
      • Условие condition_X_quantiles также формируется на основе X_df.
      • Затем dfq[cols_with_variance] = dfq[cols_with_variance].mask(condition_X_quantiles) применяет эту маску. Это одна операция setitem на срез dfq[cols_with_variance].
    3. filter_res: Добавлена проверка и возможное преобразование filter_res в DataFrame, если base_filter вдруг вернет NumPy массив. Это важно для корректной работы последующих операций вычитания и сравнения с DataFrame.
    4. Квантили для delta:
      • delta_q_upper = delta.quantile(0.99, axis=0) и delta_q_lower вычисляются.
      • Условие condition_delta_quantiles формируется.
      • delta = delta.mask(condition_delta_quantiles) обновляет delta. Это создает новый DataFrame delta (или изменяет существующий, если бы .mask использовался с inplace=True и это было бы безопасно).
    5. deviation: Используется delta.std(axis=0, ddof=0). ddof=0 (степени свободы) для стандартного отклонения совокупности, что соответствует поведению np.std по умолчанию, если бы delta был NumPy массивом. Если нужен sample std, то ddof=1 (по умолчанию для pd.DataFrame.std()). Для согласованности с вашим np.std(delta) лучше явно указать ddof=0.
    6. bound_offset: Вынес mae + self.tol * deviation в отдельную переменную для читаемости. Pandas корректно выровняет NumPy массив mae и Pandas Series deviation при арифметических операциях.
    7. Создание outliers:
      • is_outlier_condition = (X_df < self.lower_bound_) | (X_df > self.upper_bound_) создает булеву DataFrame.
      • outlier_values = np.where(is_outlier_condition.values, -1, 1): Здесь .values используется для передачи нижележащих NumPy массивов в np.where, что обычно очень эффективно. np.where создает новый NumPy массив.
      • outliers = pd.DataFrame(outlier_values, index=X_df.index, columns=X_df.columns): Оборачиваем результат в DataFrame. Это одна операция создания DataFrame вместо нескольких setitem и fillna.

    Важно по поводу fillna: Я оставил вашу fillna как есть, но реализовал простую заглушку. Эффективность fillna также может влиять на общую производительность. Стандартные df.fillna(method='ffill').fillna(method='bfill') обычно достаточно быстры. Если ваша fillna делает что-то очень сложное или поколоночное в цикле Python, она может быть узким местом.

    Эти изменения должны значительно сократить количество вызовов setitem и операций, создающих промежуточные DataFrame, что приведет к ускорению, особенно на больших данных, сохраняя при этом исходную логику.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.

Identical first prompt