Skip to content
The Chat Archive
gpt-4o-mini-2024-07-18· OpenAI WildChat-4.8M (AI2)

первый код: Импортируем необходимые библиотеки import pandas as pd import numpy as np…

  1. User

    первый код:

    Импортируем необходимые библиотеки

    import pandas as pd import numpy as np import statsmodels.api as sm from sklearn.linear_model import LinearRegression, LassoCV, RidgeCV from sklearn.preprocessing import PolynomialFeatures, StandardScaler from sklearn.model_selection import train_test_split, cross_val_score

    Загрузка данных

    df = pd.read_excel('diseasesDataset__kopia.xlsx', engine='openpyxl', header=None) df = df.iloc[1:].reset_index(drop=True) # Удаляем первую строку и сбрасываем индексы

    Проверка и преобразование столбцов

    for column in df.columns: # Преобразование в числовой формат, ошибки преобразуем в NaN df[column] = pd.to_numeric(df[column], errors='coerce')

    Вывод первых строк данных для проверки

    #print("Первые строки данных:") #print(df.head()) # Проверка структуры данных

    Удаление строк с отсутствующими значениями

    df.dropna(inplace=True)

    Преобразуем данные на отрезок [2, 102]

    def transform_data(x, old_min, old_max, new_min=2, new_max=102): return new_min + (x - old_min) * (new_max - new_min) / (old_max - old_min)

    Определяем целевой столбец

    target_column = 0 # Индекс столбца с целевым значением (например, если это первый столбец)

    Применяем преобразование ко всем управляющим факторам

    for column in df.columns: if column != target_column: old_min = df[column].min() old_max = df[column].max() df[column] = transform_data(df[column], old_min, old_max)

    2. Масштабируем данные

    X = df.drop(columns=[target_column]) # Управляющие факторы y = df[target_column] # Целевой фактор

    Масштабирование данных

    scaler = StandardScaler() X_scaled = scaler.fit_transform(X)

    3. Генерация новых признаков

    def generate_features(X): features = [] poly = PolynomialFeatures(degree=4, interaction_only=True) # Используем полиномиальные взаимодействия X_poly = poly.fit_transform(X) return X_poly # Возвращаем новые сгенерированные признаки

    X_transformed = generate_features(X_scaled)

    Удаление выбросов

    def remove_outliers(data): Q1 = np.percentile(data, 25) Q3 = np.percentile(data, 75) IQR = Q3 - Q1 lower_bound = Q1 - 1.5 * IQR upper_bound = Q3 + 1.5 * IQR return (data >= lower_bound) & (data <= upper_bound)

    Применяем удаление выбросов для всех признаков, включая целевой фактор

    mask = np.all(remove_outliers(X_scaled), axis=1) & remove_outliers(y) X_scaled = X_scaled[mask] y = y[mask].reset_index(drop=True)

    X_transformed = generate_features(X_scaled)

    Обучаем модель линейной регрессии

    model = LinearRegression() model.fit(X_transformed, y)

    Выводим регрессионное уравнение

    coefficients = model.coef_ intercept = model.intercept_

    Формируем регрессионное уравнение

    equation = "y = " + str(round(intercept, 5)) # Округляем для уменьшения количества знаков for i, coef in enumerate(coefficients[:6]): # Указано [:6], чтобы ограничить вывод до X_6 equation += f" + {round(coef, 7)}*X_{i + 1}" # Здесь индекс с 1, чтобы избежать путаницы

    print("Регрессионное уравнение модели:") print(equation)

    5. Кросс-валидация с помощью Lasso

    X_train, X_test, y_train, y_test = train_test_split(X_transformed, y, test_size=0.2, random_state=42)

    6. Проверка адекватности модели

    errors = model.predict(X_transformed) - y mean_error = np.mean(errors) std_error = np.std(errors) skewness = (np.mean((errors - mean_error) ** 3) / (std_error ** 3)) if std_error != 0 else 0 kurtosis = (np.mean((errors - mean_error) ** 4) / (std_error ** 4)) - 3 if std_error != 0 else 0

    print(f"Средняя ошибка: {mean_error}") print(f"Стандартное отклонение ошибки: {std_error}") print(f"Асимметрия: {skewness}") print(f"Eксцесс: {kurtosis}") создает такую модель: Регрессионное уравнение модели: y = 2.0447 + 0.0002219X_1 + 0.0008867X_2 + 0.0073615X_3 + 0.0217541X_4 + 0.0157804X_5 + 0.0104506X_6 Средняя ошибка: -3.3826369601345195e-16 Стандартное отклонение ошибки: 4.270379347846599e-15 Асимметрия: -0.18484236528699316 Eксцесс: 0.28910333596336013 жди второй код

  2. Assistant

    Хорошо, я жду второй код. Пожалуйста, предоставьте его, когда будете готовы.

  3. User

    второй код : import numpy as np import pandas as pd import matplotlib.pyplot as plt from scipy.stats import pearsonr from sklearn.linear_model import LinearRegression

    Преобразование X на отрезке [a, b] на отрезок [2, 102]

    def transform_to_range(X, old_min, old_max, new_min=2, new_max=102): return new_min + (X - old_min) * (new_max - new_min) / (old_max - old_min)

    Основная логика блока

    def functional_preprocessing(X, y): old_min = X.min() old_max = X.max() X_transformed = transform_to_range(X, old_min, old_max)

    a_values = np.array([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1,
                         0.001, 0.01, 0.1, 0.5, 1, 1.5, 2,
                         2.5, 3, 3.5, 4, 4.5, 5, 6, 7, 8, 9, 10])
    
    while True:
        max_correlation = 0
        best_function = None
    
        for a in a_values:
            functions = transformation_functions(X_transformed, a)
    
            for func_name, func_values in functions.items():
                if not np.all(np.isfinite(func_values)):
                    continue  # Пропускаем функцию
    
                valid_mask = np.isfinite(y)
                valid_func_values = func_values[valid_mask]
                valid_y = y[valid_mask]
    
                if len(valid_func_values) > 0 and len(valid_func_values) == len(valid_y):
                    if np.all(np.isfinite(valid_func_values)) and np.all(np.isfinite(valid_y)):
                        correlation, _ = pearsonr(valid_func_values, valid_y)
    
                        if abs(correlation) > abs(max_correlation):
                            max_correlation = correlation
                            best_function = func_name
                            best_values = func_values
    
        #print(f"Максимальная корреляция: {max_correlation:.5f} для функции {best_function}")
    
        if max_correlation > 0.01:
            X_transformed = best_values
        else:
            break
    
    return X_transformed
    

    Обработка DataFrame

    df = df.dropna()

    Пример использования

    X = df.drop(columns=[target_column]).values # Получаем управляющие факторы (матрица) y = df[target_column].values # Получаем целевой фактор (вектор)

    Инициализация списка для обработанных признаков

    X_processed = []

    Применяем функциональную предобработку ко всем столбцам X

    for i in range(X.shape[1]): X_col = X[:, i] # Получаем i-й столбец processed_column = functional_preprocessing(X_col, y) # Применяем предобработку X_processed.append(processed_column) # Добавляем в список

    Конвертация списка обратно в массив

    X_processed = np.array(X_processed).T # Транспонируем

    print(f"Размер X: {X_processed.shape}") print(f"Размер y: {y.shape}")

    Обучение модели линейной регрессии

    model = LinearRegression() model.fit(X_processed, y)

    Предсказания модели

    y_pred = model.predict(X_processed)

    Получаем коэффициенты регрессии и формируем уравнение

    coefficients = model.coef_ intercept = model.intercept_

    Создание строкового представления уравнения

    equation_terms = [f'{coefficients[i]:.5f} * x{i + 1}' for i in range(X_processed.shape[1])] equation = "y = {:.5f} + {}".format(intercept, " + ".join(equation_terms))

    print("Многомерное нелинейное регрессионное уравнение:") print(equation)

    Проверка адекватности модели

    errors = y_pred - y mean_error = np.mean(errors) std_error = np.std(errors) skewness = (np.mean((errors - mean_error) ** 3) / (std_error ** 3)) if std_error != 0 else 0 kurtosis = (np.mean((errors - mean_error) ** 4) / (std_error ** 4)) - 3 if std_error != 0 else 0

    print(f"Средняя ошибка: {mean_error}") print(f"Стандартное отклонение ошибки: {std_error}") print(f"Асимметрия: {skewness}") print(f"Eксцесс: {kurtosis}") создает такую модель: Многомерное нелинейное регрессионное уравнение: y = -105.71358 + -0.00002 * x1 + -0.00995 * x2 + 293.95999 * x3 + 665.96320 * x4 + 13.87618 * x5 + -0.04160 * x6 + -0.00000 * x7 + -0.01771 * x8 + -0.00816 * x9 + 70.61709 * x10 + -0.00055 * x11 + 0.03780 * x12 + -0.02372 * x13 + 0.00261 * x14 + 1.73660 * x15 + 0.00452 * x16 + -0.00000 * x17 + 0.09396 * x18 + 0.38878 * x19 + 0.01016 * x20 + -0.00500 * x21 + 72.31516 * x22 + -0.00619 * x23 + -0.00273 * x24 + -0.00000 * x25 + 0.00232 * x26 + 0.00587 * x27 + 0.00642 * x28 + -0.00382 * x29 + -0.01668 * x30 + 0.17313 * x31 + -0.00145 * x32 + -0.00683 * x33 + 0.86223 * x34 + 0.00352 * x35 + 5.58589 * x36 + 14161.14825 * x37 Средняя ошибка: 1.0214875739742256e-14 Стандартное отклонение ошибки: 1.0618811626510802 Асимметрия: -0.8240824258216405 Eксцесс: 0.3867679122842307 жди задания

  4. Assistant

    Спасибо за предоставление второго кода. Пожалуйста, сообщите, какие задания или вопросы у вас есть по этому коду или его результатам. Я готов помочь!

  5. User

    В общем-то первая модель неплохая, но второй код должен ее улучшить, но ты сам видишь, что модель стала хуже. Это надо как-то исправить. второй код - это БЛОК1 – блок, реализующий метод функциональной предобработки статистических данных.

  6. Assistant

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

    1. Проверка данных: Убедитесь, что данные, которые подаются на вход обеим моделям, одинаковые. Разные манипуляции с данными (например, удаление NaN, выбросы) могут привести к различиям между моделями.

    2. Трансформация данных: Функция transform_to_range используется для преобразования данных на отрезке [a, b] на отрезок [2, 102]. Возможно, стоит попробовать иные методы масштабирования, такие как MinMaxScaler, RobustScaler или StandardScaler, чтобы посмотреть, как это повлияет на производительность модели.

    3. Выбор подходящих функций трансформации: Возможно, стоит улучшить процесс выбора функций в functional_preprocessing. Можно использовать больше функций, попробовать разные типы функций (например, логарифмические, экспоненциальные и т.д.), а не только линейные.

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

    5. Обновление модели: Убедитесь, что регрессия действительно производится на обработанных признаках; возможно, проблемы могут заключаться в том, что обработанные данные не столь информативны.

    6. Кросс-валидация: Добавьте кросс-валидацию для оценки модели. Это поможет получить устойчивую метрику производительности и избежать переобучения.

    7. Сравнение с первой моделью: Включите код из первой модели в ваш второй код, чтобы вы могли как минимум сравнить показатели производительности каждой модели: можно, например, создать флаг в коде, чтобы выбирать между первой и второй реализацией.

    Пример улучшения второго блока кода

    Вот как можно улучшить второй блок:

    from sklearn.preprocessing import MinMaxScaler, PolynomialFeatures
    from sklearn.model_selection import train_test_split, cross_val_score
    from sklearn.pipeline import Pipeline
    
    # Обработка DataFrame
    df = df.dropna()
    
    X = df.drop(columns=[target_column]).values  # Получаем управляющие факторы (матрица)
    y = df[target_column].values  # Получаем целевой фактор (вектор)
    
    # Разделение на обучающую и тестовую выборки
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    # Применение MinMaxScaler и PolynomialFeatures в одном пайплайне
    pipeline = Pipeline([
        ('scaler', MinMaxScaler(feature_range=(2, 102))), 
        ('poly_features', PolynomialFeatures(degree=4, include_bias=False)), 
        ('lin_reg', LinearRegression())
    ])
    
    # Обучение модели с кросс-валидацией
    pipeline.fit(X_train, y_train)
    cv_scores = cross_val_score(pipeline, X_train, y_train, cv=5)
    
    print(f"Среднее значение кросс-валидации: {np.mean(cv_scores)}")
    
    # Предсказания
    y_pred = pipeline.predict(X_test)
    
    # Проверка адекватности модели
    errors = y_pred - y_test
    mean_error = np.mean(errors)
    std_error = np.std(errors)
    
    print(f"Средняя ошибка: {mean_error}")
    print(f"Стандартное отклонение ошибки: {std_error}")
    

    Следующие шаги

    1. Проверьте качество данных, выбросы и их удаление.
    2. Проведите эксперименты с различными функциями и масштабированием.
    3. Оцените модели с помощью кросс-валидации для выбора лучших параметров.

    Если у вас есть конкретные шаги, которые вы хотите реализовать или вопросы по коду, дайте знать, и я с радостью помогу!

  7. User

    там второй код содержит алгоритм, мне нужно, чтобы он присуствовал и дальше.

  8. Assistant

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

    Вот обновленный вариант второго кода, который сохраняет функциональную предобработку и добавляет некоторые улучшения:

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    from scipy.stats import pearsonr
    from sklearn.linear_model import LinearRegression
    from sklearn.preprocessing import MinMaxScaler, StandardScaler, PolynomialFeatures
    from sklearn.model_selection import train_test_split, cross_val_score
    
    # Преобразование X на отрезке [a, b] на отрезок [2, 102]
    def transform_to_range(X, old_min, old_max, new_min=2, new_max=102):
        return new_min + (X - old_min) * (new_max - new_min) / (old_max - old_min)
    
    # Основная логика блока
    def functional_preprocessing(X, y):
        old_min = X.min()
        old_max = X.max()
        X_transformed = transform_to_range(X, old_min, old_max)
    
        a_values = np.array([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1,
                             0.001, 0.01, 0.1, 0.5, 1, 1.5, 2,
                             2.5, 3, 3.5, 4, 4.5, 5, 6, 7, 8, 9, 10])
    
        while True:
            max_correlation = 0
            best_function = None
    
            for a in a_values:
                functions = transformation_functions(X_transformed, a)  # Сделайте процесс более гибким
    
                for func_name, func_values in functions.items():
                    if not np.all(np.isfinite(func_values)):
                        continue  # Пропускаем функцию
    
                    valid_mask = np.isfinite(y)
                    valid_func_values = func_values[valid_mask]
                    valid_y = y[valid_mask]
    
                    if len(valid_func_values) > 0 and len(valid_func_values) == len(valid_y):
                        if np.all(np.isfinite(valid_func_values)) and np.all(np.isfinite(valid_y)):
                            correlation, _ = pearsonr(valid_func_values, valid_y)
    
                            if abs(correlation) > abs(max_correlation):
                                max_correlation = correlation
                                best_function = func_name
                                best_values = func_values
    
            # Вывод максимальной корреляции
            print(f"Максимальная корреляция: {max_correlation:.5f} для функции {best_function}")
    
            if max_correlation > 0.01:
                X_transformed = best_values
            else:
                break
    
        return X_transformed
    
    # Обработка DataFrame
    df = pd.read_excel('diseasesDataset__kopia.xlsx', engine='openpyxl', header=None)
    df = df.iloc[1:].reset_index(drop=True)  # Удаляем первую строку и сбрасываем индексы
    df.dropna(inplace=True)  # Удаление строк с отсутствующими значениями
    
    # Определяем целевой столбец
    target_column = 0  # Индекс столбца с целевым значением
    
    X = df.drop(columns=[target_column]).values  # Получаем управляющие факторы (матрица)
    y = df[target_column].values  # Получаем целевой фактор (вектор)
    
    # Инициализация списка для обработанных признаков
    X_processed = []
    
    # Применяем функциональную предобработку ко всем столбцам X
    for i in range(X.shape[1]):
        X_col = X[:, i]  # Получаем i-й столбец
        processed_column = functional_preprocessing(X_col, y)  # Применяем предобработку
        X_processed.append(processed_column)  # Добавляем в список
    
    # Конвертация списка обратно в массив
    X_processed = np.array(X_processed).T  # Транспонируем
    
    # Масштабирование данных
    scaler = MinMaxScaler(feature_range=(2, 102))
    X_scaled = scaler.fit_transform(X_processed)
    
    # Обучение модели линейной регрессии
    model = LinearRegression()
    model.fit(X_scaled, y)
    
    # Предсказания модели
    y_pred = model.predict(X_scaled)
    
    # Получаем коэффициенты регрессии и формируем уравнение
    coefficients = model.coef_
    intercept = model.intercept_
    
    # Создание строкового представления уравнения
    equation_terms = [f'{coefficients[i]:.5f} * x{i + 1}' for i in range(X_scaled.shape[1])]
    equation = "y = {:.5f} + {}".format(intercept, " + ".join(equation_terms))
    
    print("Многомерное нелинейное регрессионное уравнение:")
    print(equation)
    
    # Проверка адекватности модели
    errors = y_pred - y
    mean_error = np.mean(errors)
    std_error = np.std(errors)
    skewness = (np.mean((errors - mean_error) ** 3) / (std_error ** 3)) if std_error != 0 else 0
    kurtosis = (np.mean((errors - mean_error) ** 4) / (std_error ** 4)) - 3 if std_error != 0 else 0
    
    print(f"Средняя ошибка: {mean_error}")
    print(f"Стандартное отклонение ошибки: {std_error}")
    print(f"Асимметрия: {skewness}")
    print(f"Eксцесс: {kurtosis}")
    

    Основные изменения:

    1. Масштабирование: Мы используем MinMaxScaler для масштаба данных. Вы также можете попробовать StandardScaler.

    2. Функциональная предобработка: Основной алгоритм функциональной предобработки остается без изменений.

    3. Корреляция: Введен вывод максимальной корреляции и использован для добавления ясности процесса предобработки.

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

    Пожалуйста, дайте знать, если у вас есть дополнительные пожелания или вопросы!

  9. User

    помоги разобраться что не так: import numpy as np import pandas as pd

    БЛОК3 – блок, устанавливающий область определения для каждого управляющего фактора.

    def empirical_bounds(X, percentage=0.90): """Находит эмпирические границы для каждого фактора в X.""" min_bounds = [] max_bounds = []

    for column in range(X.shape[1]):
        a = np.min(X[:, column])  # Минимальное значение
        b = np.max(X[:, column])  # Максимальное значение
    
        # Расчет границ
        min_bound = a - (b - a) * (1 - percentage) / 2
        max_bound = b + (b - a) * (1 - percentage) / 2
    
        min_bounds.append(min_bound)
        max_bounds.append(max_bound)
    
    return np.array(min_bounds), np.array(max_bounds)
    

    def theoretical_bounds(X): """Находит теоретические границы для каждого фактора в X на основе среднего и стандартного отклонения.""" mean_bounds = [] std_dev_bounds = []

    for column in range(X.shape[1]):
        mean = np.mean(X[:, column])  # Среднее значение
        std_dev = np.std(X[:, column])  # Стандартное отклонение
    
        # Расчет границ
        min_bound = mean - 3 * std_dev
        max_bound = mean + 3 * std_dev
    
        mean_bounds.append(min_bound)
        std_dev_bounds.append(max_bound)
    
    return np.array(mean_bounds), np.array(std_dev_bounds)
    

    def combined_bounds(empirical_min, empirical_max, theoretical_min, theoretical_max): """Объединяет эмпирическую и теоретическую области определения.""" final_min = np.maximum(empirical_min, theoretical_min) # Берем максимум из минимальных final_max = np.minimum(empirical_max, theoretical_max) # Берем минимум из максимальных

    return final_min, final_max
    

    Применение функций к вашим данным

    X = X_processed # Преобразованный массив управляющих факторов

    Вывод результатов с форматом

    print("\nЭмпирические границы:") for i in range(len(emp_min)): print(f"Фактор x_{i}: Минимум = {emp_min[i]}, Максимум = {emp_max[i]}")

    print("\nТеоретические границы:") for i in range(len(theory_min)): print(f"Фактор x_{i}: Минимум = {theory_min[i]}, Максимум = {theory_max[i]}")

    print("\nОбъединенные границы:") for i in range(len(final_min)): print(f"Фактор x_{i}: Минимум = {final_min[i]}, Максимум = {final_max[i]}") ошибка: name 'emp_min' is not defined

  10. Assistant

    Ошибка, которую вы получаете ("name 'emp_min' is not defined"), связана с тем, что вы пытаетесь использовать переменные emp_min, emp_max, theory_min, и theory_max, но они не определены в вашем коде до того, как вы их пытаетесь вывести.

    Давайте исправим этот код, чтобы он корректно вычислял границы и выводил результаты. Нужно выполнить следующее:

    1. Сначала вызовите функции для расчета эмпирических и теоретических границ и сохраните результаты в переменные.
    2. Проверьте, что переменная X_processed инициализирована и содержит данные до вызова функций.

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

    import numpy as np
    import pandas as pd
    
    # БЛОК3 – блок, устанавливающий область определения для каждого управляющего фактора.
    
    def empirical_bounds(X, percentage=0.90):
        """Находит эмпирические границы для каждого фактора в X."""
        min_bounds = []
        max_bounds = []
    
        for column in range(X.shape[1]):
            a = np.min(X[:, column])  # Минимальное значение
            b = np.max(X[:, column])  # Максимальное значение
    
            # Расчет границ
            min_bound = a - (b - a) * (1 - percentage) / 2
            max_bound = b + (b - a) * (1 - percentage) / 2
    
            min_bounds.append(min_bound)
            max_bounds.append(max_bound)
    
        return np.array(min_bounds), np.array(max_bounds)
    
    def theoretical_bounds(X):
        """Находит теоретические границы для каждого фактора в X на основе среднего и стандартного отклонения."""
        mean_bounds = []
        std_dev_bounds = []
    
        for column in range(X.shape[1]):
            mean = np.mean(X[:, column])  # Среднее значение
            std_dev = np.std(X[:, column])  # Стандартное отклонение
    
            # Расчет границ
            min_bound = mean - 3 * std_dev
            max_bound = mean + 3 * std_dev
    
            mean_bounds.append(min_bound)
            std_dev_bounds.append(max_bound)
    
        return np.array(mean_bounds), np.array(std_dev_bounds)
    
    def combined_bounds(empirical_min, empirical_max, theoretical_min, theoretical_max):
        """Объединяет эмпирическую и теоретическую области определения."""
        final_min = np.maximum(empirical_min, theoretical_min)  # Берем максимум из минимальных
        final_max = np.minimum(empirical_max, theoretical_max)  # Берем минимум из максимальных
    
        return final_min, final_max
    
    # Применение функций к вашим данным
    X = X_processed  # Преобразованный массив управляющих факторов
    
    # Вычисление границ
    emp_min, emp_max = empirical_bounds(X)
    theory_min, theory_max = theoretical_bounds(X)
    final_min, final_max = combined_bounds(emp_min, emp_max, theory_min, theory_max)
    
    # Вывод результатов с форматом
    print("\nЭмпирические границы:")
    for i in range(len(emp_min)):
        print(f"Фактор x_{i}: Минимум = {emp_min[i]}, Максимум = {emp_max[i]}")
    
    print("\nТеоретические границы:")
    for i in range(len(theory_min)):
        print(f"Фактор x_{i}: Минимум = {theory_min[i]}, Максимум = {theory_max[i]}")
    
    print("\nОбъединенные границы:")
    for i in range(len(final_min)):
        print(f"Фактор x_{i}: Минимум = {final_min[i]}, Максимум = {final_max[i]}")
    

    В чем изменился код:

    • Добавлены вычисления emp_min, emp_max, theory_min, и theory_max, чтобы они соответствовали результатам вызовов функций empirical_bounds и theoretical_bounds.
    • Убедитесь, что данные в X_processed определены перед вызовом этих функций.

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