Skip to content
TheChatArchiveThe Chat Archive
Qwenqwq-32b· Alibaba (Qwen)Hugging Face LMArena Human Preference 140K

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

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro-preview-05-06’s answer.
  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. Qwen Assistant

    Чтобы ускорить метод predict без изменения логики, можно оптимизировать работу с данными, перейдя к использованию numpy вместо pandas там, где это возможно. Вот оптимизированный код:

    import numpy as np
    import pandas as pd
    from sklearn.metrics import mean_absolute_error
    
    class OutlierDetector(PrepBase, OutlierMixin):
        def predict(self, X):
            X = check_input_data(X, return_numpy=True)  # Предполагаем, что check_input_data может возвращать numpy
            X_df = array_to_df(X)  # Если требуется для обработки колонок
            
            # Преобразуем данные в numpy для ускорения
            X_np = X.values if isinstance(X, pd.DataFrame) else X
            n_samples, n_features = X_np.shape
            
            # Определение столбцов с достаточной вариацией
            stds = np.nanstd(X_np, axis=0)
            cols_diff = np.where(stds > 1e-15)[0]
            
            # Создаем копию для обработки
            dfq = X_np.copy()
            
            # Обработка столбцов с высокой вариацией
            if cols_diff.size > 0:
                for col in cols_diff:
                    col_data = X_np[:, col]
                    q80 = np.nanquantile(col_data, 0.8)
                    q20 = np.nanquantile(col_data, 0.2)
                    mask_upper = dfq[:, col] > q80
                    mask_lower = dfq[:, col] < q20
                    dfq[mask_upper, col] = np.nan
                    dfq[mask_lower, col] = np.nan
    
                # Обработка пустых столбцов
                empty_cols = np.all(np.isnan(dfq), axis=0)
                if np.any(empty_cols):
                    dfq[:, empty_cols] = X_np[:, empty_cols]
                    
                # Замена NaN в dfq
                dfq = fillna(dfq)  # Предполагаем, что fillna работает с numpy
                
            # Применение фильтра
            filter_res = self.base_filter.fit_transform(dfq)
            
            # Вычисление MAE
            mae = np.nanmean(np.abs(dfq - filter_res), axis=0)
            
            # Вычисление delta
            delta = dfq - filter_res
            q99 = np.nanquantile(delta, 0.99, axis=0)
            q01 = np.nanquantile(delta, 0.01, axis=0)
            mask_upper = delta > q99
            mask_lower = delta < q01
            delta[mask_upper] = np.nan
            delta[mask_lower] = np.nan
            delta = fillna(delta)  # Заполнение NaN
            
            deviation = np.nanstd(delta, axis=0)
            
            # Вычисление границ
            lower_bound = filter_res - (mae + self.tol * deviation)
            upper_bound = filter_res + (mae + self.tol * deviation)
            
            # Создание массива outliers
            outliers = np.ones_like(X_np, dtype=int)
            mask_out = (X_np < lower_bound) | (X_np > upper_bound)
            outliers[mask_out] = -1
            
            # Преобразование в DataFrame, если нужно
            if isinstance(X, pd.DataFrame):
                outliers_df = pd.DataFrame(outliers, index=X.index, columns=X.columns)
                return outliers_df
            else:
                return pd.DataFrame(outliers)
    

    Основные оптимизации:

    1. Использование numpy:

      • Все операции выполняются с numpy массивами, что ускоряет вычисления.
      • Избежаны множественные setitem операции pandas, замененные на векторизованные операции numpy.
    2. Обработка столбцов:

      • Определение столбцов с высокой вариацией через numpy.
      • Использование масок numpy для установки NaN вместо методов pandas.
    3. Замена fillna:

      • Предполагается, что функция fillna из utils адаптирована для работы с numpy массивами.
    4. Вычисление границ:

      • Вычисления границ и outliers выполняются векторизованными операциями без циклов.

    Важно:

    • Убедитесь, что check_input_data и fillna из utils поддерживают numpy массивы.
    • Если base_filter.fit_transform требует pandas DataFrame, преобразуйте dfq обратно перед его передачей.
    • Если fillna возвращает DataFrame, адаптируйте код для работы с numpy.

    Эти изменения сохраняют логику оригинального кода, но ускоряют выполнение за счет использования numpy и векторизованных операций.

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