From 75bf27d6c9d60d49fd24dd0f97e50861876f8a56 Mon Sep 17 00:00:00 2001 From: ujijrujijr Date: Fri, 15 Nov 2024 21:25:43 +0400 Subject: [PATCH] =?UTF-8?q?=D0=9B=D0=B0=D0=B1=204?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lab_4/Lab4.ipynb | 872 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 872 insertions(+) create mode 100644 lab_4/Lab4.ipynb diff --git a/lab_4/Lab4.ipynb b/lab_4/Lab4.ipynb new file mode 100644 index 0000000..44f818e --- /dev/null +++ b/lab_4/Lab4.ipynb @@ -0,0 +1,872 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.pipeline import make_pipeline\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.preprocessing import PolynomialFeatures\n", + "from sklearn.metrics import mean_squared_error\n", + "import matplotlib.pyplot as plt\n", + "from scipy import stats\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.tree import DecisionTreeRegressor\n", + "from sklearn.ensemble import GradientBoostingRegressor\n", + "from sklearn import linear_model, tree, neighbors, ensemble, neural_network\n", + "\n", + "df = pd.read_csv(\"..//static//csv//balanced_neo.csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **1-я бизнес-цель (регрессия)**: \n", + "\n", + "Предсказание скорости космического объекта для принятия решения о том, насколько опасным он может быть и стоит ли вести за ним наблюдения" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Целевой признак: скорость космического объекта relative_velocity\n", + "\n", + "Вход: минимальный радиус est_diameter_min, максимальный радиус est_diameter_max, яркость объекта absolute_magnitude, расстояние от Земли miss_distance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Достижимый уровень качества: предсказания должны иметь погрешность в среднем не более 10000 км/с. Для проверки будет использоваться метрика MAE (средняя абсолютная ошибка)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.discriminant_analysis import StandardScaler\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.model_selection import GridSearchCV, train_test_split\n", + "from sklearn.metrics import roc_auc_score, confusion_matrix, accuracy_score\n", + "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier\n", + "import seaborn as sns\n", + "from sklearn.model_selection import cross_val_predict\n", + "from sklearn.metrics import mean_squared_error\n", + "import numpy as np\n", + "from sklearn import metrics\n", + "import sklearn.preprocessing as preproc\n", + "from sklearn.linear_model import LinearRegression, Ridge\n", + "from sklearn.metrics import mean_absolute_error\n", + "from mlxtend.evaluate import bias_variance_decomp\n", + "from sklearn.neural_network import MLPRegressor\n", + "\n", + "# Загрузка данных\n", + "df = pd.read_csv(\"..//static//csv//balanced_neo.csv\")\n", + "data = df[['est_diameter_min', 'est_diameter_max', 'absolute_magnitude', 'miss_distance', 'relative_velocity']]\n", + "\n", + "X = data.drop('relative_velocity', axis=1)\n", + "y = data['relative_velocity']\n", + "\n", + "# Разделение данных на обучающую и тестовую выборки\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "\n", + "# Преобразование числовых данных\n", + "#заполнение пустых значений медианой\n", + "num_imputer = SimpleImputer(strategy=\"median\")\n", + "\n", + "preprocessing_num = Pipeline(\n", + " [\n", + " (\"imputer\", num_imputer)\n", + " ]\n", + ")\n", + "\n", + "#Категориальных данных нет, поэтому преобразовывать их не надо\n", + "\n", + "\n", + "# Общая предобработка (только числовые данные)\n", + "preprocessing = ColumnTransformer(\n", + " [\n", + " (\"nums\", preprocessing_num, X.columns)\n", + " ]\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Линейная регрессия" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Лучшие гиперпараметры: {'preprocessing': MinMaxScaler()}\n", + "Cредняя абсолютная ошибка (MAE) = 19241.554618019443\n", + "Смещение: 616083845.5088656\n", + "Дисперсия: 438598.9204950822\n" + ] + } + ], + "source": [ + "pipeline_lin_reg = Pipeline([\n", + " ('preprocessing', preprocessing),\n", + " ('model', LinearRegression())]\n", + ")\n", + "\n", + "# Определение сетки гиперпараметров (возможных знач-ий гиперпараметров) для перебора\n", + "param_grid = {\n", + " #как будут масштабироваться признаки\n", + " 'preprocessing': [StandardScaler(), preproc.MinMaxScaler(), preproc.MaxAbsScaler(), None]\n", + "}\n", + "\n", + "# Создание объекта GridSearchCV для поиска лучших гиперпараметров по сетке с максимальным знач-ием \n", + "# отрицательного корня из среднеквадратичной ошибки (отриц., чтобы искался не минимум, а максимум)\n", + "grid_search = GridSearchCV(pipeline_lin_reg, param_grid, cv=5, scoring='neg_root_mean_squared_error', n_jobs=-1)\n", + "\n", + "# Обучение модели с перебором гиперпараметров\n", + "grid_search.fit(X_train, y_train)\n", + "\n", + "print(\"Лучшие гиперпараметры: \", grid_search.best_params_)\n", + "\n", + "# Лучшая модель лин. регрессии\n", + "best_model = grid_search.best_estimator_\n", + "\n", + "y_pred = best_model.predict(X_test)\n", + "\n", + "print(f'Cредняя абсолютная ошибка (MAE) = {mean_absolute_error(y_test, y_pred)}')\n", + "\n", + "\n", + "mse, bias, variance = bias_variance_decomp(best_model, X_train.values, y_train.values, X_test.values, y_test.values, loss='mse', num_rounds=200, random_seed=123)\n", + "print(\"Смещение: \", bias)\n", + "print(\"Дисперсия: \", variance)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Гребневая регрессия" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Лучшие гиперпараметры: {'model__alpha': 10.0, 'preprocessing': MinMaxScaler()}\n", + "Cредняя абсолютная ошибка (MAE) = 19239.098934204343\n", + "Смещение: 615921619.3705255\n", + "Дисперсия: 326886.495836047\n" + ] + } + ], + "source": [ + "pipeline_ridge = Pipeline([\n", + " ('preprocessing', preprocessing),\n", + " ('model', Ridge())]\n", + ")\n", + "\n", + "# Определение сетки гиперпараметров (возможных знач-ий гиперпараметров) для перебора\n", + "param_grid = {\n", + " #как будут масштабироваться признаки\n", + " 'preprocessing': [StandardScaler(), preproc.MinMaxScaler(), preproc.MaxAbsScaler(), None],\n", + " #сила регуляризации\n", + " 'model__alpha': [0, 0.5, 1.0, 1.5, 2.0, 5.0, 10.0] \n", + "}\n", + "\n", + "# Создание объекта GridSearchCV для поиска лучших гиперпараметров по сетке с максимальным знач-ием \n", + "# отрицательного корня из среднеквадратичной ошибки (отриц., чтобы искался не минимум, а максимум)\n", + "grid_search = GridSearchCV(pipeline_ridge, param_grid, cv=5, scoring='neg_root_mean_squared_error', n_jobs=-1, verbose=0)\n", + "\n", + "# Обучение модели с перебором гиперпараметров\n", + "grid_search.fit(X_train, y_train)\n", + "\n", + "print(\"Лучшие гиперпараметры: \", grid_search.best_params_)\n", + "\n", + "# Лучшая модель регрессии\n", + "best_model = grid_search.best_estimator_\n", + "\n", + "y_pred = best_model.predict(X_test)\n", + "\n", + "print(f'Cредняя абсолютная ошибка (MAE) = {mean_absolute_error(y_test, y_pred)}')\n", + "\n", + "mse, bias, variance = bias_variance_decomp(best_model, X_train.values, y_train.values, X_test.values, y_test.values, loss='mse', num_rounds=200, random_seed=123)\n", + "print(\"Смещение: \", bias)\n", + "print(\"Дисперсия: \", variance)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Гребневая регрессия показала почти такие же результаты, что и линейная регрессия" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "MLP" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\AI labs\\aimenv\\Lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (500) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Лучшие гиперпараметры: {'model__activation': 'relu', 'model__alpha': 0.0001, 'preprocessing': StandardScaler()}\n", + "Cредняя абсолютная ошибка (MAE) = 19363.27371661712\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\AI labs\\aimenv\\Lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (500) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "c:\\AI labs\\aimenv\\Lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (500) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "c:\\AI labs\\aimenv\\Lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (500) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "c:\\AI labs\\aimenv\\Lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:697: UserWarning: Training interrupted by user.\n", + " warnings.warn(\"Training interrupted by user.\")\n", + "c:\\AI labs\\aimenv\\Lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (500) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "c:\\AI labs\\aimenv\\Lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (500) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "c:\\AI labs\\aimenv\\Lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:697: UserWarning: Training interrupted by user.\n", + " warnings.warn(\"Training interrupted by user.\")\n", + "c:\\AI labs\\aimenv\\Lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (500) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "c:\\AI labs\\aimenv\\Lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (500) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n", + "c:\\AI labs\\aimenv\\Lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (500) reached and the optimization hasn't converged yet.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# Создание пайплайна для модели MLP\n", + "pipeline_mlp = Pipeline([\n", + " ('preprocessing', StandardScaler()), # По умолчанию используем StandardScaler\n", + " ('model', MLPRegressor(random_state=42, max_iter=500)) # MLP модель с фиксированным random_state и количеством итераций\n", + "])\n", + "\n", + "# Определение сетки гиперпараметров для перебора\n", + "param_grid = {\n", + " 'preprocessing': [StandardScaler(), preproc.MinMaxScaler()], # Разные способы масштабирования признаков\n", + " 'model__hidden_layer_sizes': [(50,), (100,)], # Разные конфигурации слоев\n", + " #'model__activation': ['relu', 'tanh'],\n", + " 'model__alpha': [0.0001, 0.001], # Разные значения регуляризации\n", + "}\n", + "\n", + "# Создание объекта GridSearchCV для поиска лучших гиперпараметров\n", + "grid_search = GridSearchCV(pipeline_mlp, param_grid, cv=5, scoring='neg_root_mean_squared_error', n_jobs=-1, verbose=0)\n", + "\n", + "# Обучение модели с перебором гиперпараметров\n", + "grid_search.fit(X_train, y_train)\n", + "\n", + "print(\"Лучшие гиперпараметры: \", grid_search.best_params_)\n", + "\n", + "# Лучшая модель MLP\n", + "best_model = grid_search.best_estimator_\n", + "\n", + "y_pred = best_model.predict(X_test)\n", + "\n", + "print(f'Cредняя абсолютная ошибка (MAE) = {mean_absolute_error(y_test, y_pred)}')\n", + "\n", + "# Расчет смещения и дисперсии\n", + "mse, bias, variance = bias_variance_decomp(best_model, X_train.values, y_train.values, X_test.values, y_test.values, loss='mse', num_rounds=200, random_seed=123)\n", + "print(\"Смещение: \", bias)\n", + "print(\"Дисперсия: \", variance)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Метод градиентного бустинга (набор деревьев решений)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Лучшие гиперпараметры: {'model__learning_rate': 0.1, 'model__max_depth': 3, 'model__n_estimators': 100, 'preprocessing': None}\n", + "Cредняя абсолютная ошибка (MAE) = 18905.987766249527\n", + "Смещение: -3.2312558004292335\n", + "Дисперсия: 162393666.8715257\n" + ] + } + ], + "source": [ + "# Конвейер\n", + "pipeline_grad = Pipeline([\n", + " ('preprocessing', preprocessing),\n", + " ('model', GradientBoostingRegressor())\n", + "])\n", + "\n", + "# Определение сетки гиперпараметров\n", + "param_grid = {\n", + " 'preprocessing': [StandardScaler(), preproc.MinMaxScaler(), preproc.MaxAbsScaler(), None],\n", + " 'model__n_estimators': [100, 200, 300],\n", + " #Скорость обучения\n", + " 'model__learning_rate': [0.1, 0.2],\n", + " #Максимальная глубина дерева\n", + " 'model__max_depth': [3, 5, 7]\n", + "}\n", + "\n", + "# Создание объекта GridSearchCV\n", + "grid_search = GridSearchCV(pipeline_grad, param_grid, cv=2, scoring='neg_root_mean_squared_error', n_jobs=-1)\n", + "\n", + "# Обучение модели с перебором гиперпараметров\n", + "grid_search.fit(X_train, y_train)\n", + "\n", + "print(\"Лучшие гиперпараметры: \", grid_search.best_params_)\n", + "\n", + "# Лучшая модель случайного леса\n", + "best_model = grid_search.best_estimator_\n", + "\n", + "\n", + "y_pred = best_model.predict(X_test)\n", + "\n", + "\n", + "print(f'Cредняя абсолютная ошибка (MAE) = {mean_absolute_error(y_test, y_pred)}')\n", + "\n", + "\n", + "# Получение предсказаний на кросс-валидации\n", + "y_cv_pred = cross_val_predict(best_model, X_train, y_train, cv=3)\n", + "\n", + "# Оценка смещения\n", + "bias = np.mean(y_cv_pred - y_train)\n", + "\n", + "# Оценка дисперсии\n", + "variance = np.var(y_cv_pred)\n", + "\n", + "print(f\"Смещение: {bias}\")\n", + "print(f\"Дисперсия: {variance}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Вывод**: \n", + "\n", + "Все 3 модели регрессии не показали необходимого уровня \"погрешности\". Это означает, что необходимо использовать более сложные модели или что по доступным данным нельзя достичь необходимой погрешности.\n", + "\n", + "Из всех моделей градиентный бустинг показал самую низкую \"погрешность\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **2-я бизнес-цель (классификация):** \n", + "\n", + "Определение опасности космиеского объекта для увеличения безопасности Земли" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Целевой признак: опасность объекта hazardous\n", + "\n", + "Вход: минимальный радиус est_diameter_min, максимальный радиус est_diameter_max, яркость объекта absolute_magnitude, скорость relative_velocity" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Достижимый уровень качества: необходимо, чтобы точность предсказания модели составляла не менее 90%. Для проверки этого будет использована метрика Accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.discriminant_analysis import StandardScaler\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import GridSearchCV, train_test_split\n", + "from sklearn.metrics import roc_auc_score, confusion_matrix, accuracy_score\n", + "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier\n", + "import seaborn as sns\n", + "from sklearn.model_selection import cross_val_predict\n", + "from sklearn.metrics import mean_squared_error\n", + "import numpy as np\n", + "from sklearn import metrics\n", + "# Загрузка данных\n", + "df = pd.read_csv(\"..//static//csv//balanced_neo.csv\")\n", + "data = df[['est_diameter_min', 'est_diameter_max', 'absolute_magnitude', 'relative_velocity', 'hazardous']]\n", + "\n", + "X = data.drop('hazardous', axis=1)\n", + "y = data['hazardous']\n", + "\n", + "# Разделение данных на обучающую и тестовую выборки\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "\n", + "# Преобразование числовых данных\n", + "num_imputer = SimpleImputer(strategy=\"median\")\n", + "num_scaler = StandardScaler()\n", + "preprocessing_num = Pipeline(\n", + " [\n", + " (\"imputer\", num_imputer),\n", + " (\"scaler\", num_scaler),\n", + " ]\n", + ")\n", + "\n", + "# Общая предобработка (только числовые данные)\n", + "preprocessing = ColumnTransformer(\n", + " [\n", + " (\"nums\", preprocessing_num, X.columns),\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Логистическая регрессия" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Лучшие гиперпараметры: {'classifier__C': 0.1, 'classifier__penalty': 'l1', 'classifier__solver': 'liblinear'}\n", + "ROC у логистической регрессии = 0.8670867396912991\n", + "Точность = 0.8591628959276018\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Смещение: 0.852988221106613\n", + "Дисперсия: 0.006548654676149887\n" + ] + } + ], + "source": [ + "# Конвейер для логистической регрессии\n", + "pipeline_logreg = Pipeline([\n", + " ('preprocessing', preprocessing),\n", + " ('classifier', LogisticRegression())\n", + "])\n", + "\n", + "# Определение сетки гиперпараметров (возможных знач-ий гиперпараметров) для перебора\n", + "param_grid = {\n", + " # Параметр регуляризации (сила регуляризации), чем меньше, тем сильнее регуляризация\n", + " 'classifier__C': [0.1, 0.5, 1],\n", + " # Тип регуляризации (ф-ия штрафов)\n", + " 'classifier__penalty': ['l1', 'l2'],\n", + " # Решатель (сам алгоритм?)\n", + " 'classifier__solver': ['liblinear', 'saga']\n", + "}\n", + "\n", + "# Создание объекта GridSearchCV для поиска лучших гиперпараметров по сетке с максимальным знач-ием ROC-кривой\n", + "grid_search = GridSearchCV(pipeline_logreg, param_grid, cv=5, scoring='accuracy', n_jobs=-1)\n", + "\n", + "# Обучение модели с перебором гиперпараметров\n", + "grid_search.fit(X_train, y_train)\n", + "\n", + "print(\"Лучшие гиперпараметры: \", grid_search.best_params_)\n", + "\n", + "# Лучшая модель логистической регрессии\n", + "best_model = grid_search.best_estimator_\n", + "\n", + "# Использование и оценка лучшей логистической модели\n", + "y_pred_proba = best_model.predict_proba(X_test)[:, 1]\n", + "print(f'ROC у логистической регрессии = {roc_auc_score(y_test, y_pred_proba)}')\n", + "\n", + "y_pred = best_model.predict(X_test)\n", + "print(f'Точность = {accuracy_score(y_test, y_pred)}')\n", + "\n", + "fpr, tpr, _ = metrics.roc_curve(y_test, y_pred_proba)\n", + "\n", + "# построение ROC кривой\n", + "plt.plot(fpr, tpr)\n", + "plt.ylabel('True Positive Rate')\n", + "plt.xlabel('False Positive Rate')\n", + "plt.show()\n", + "\n", + "# Построение матрицы ошибок\n", + "conf_matrix = confusion_matrix(y_test, y_pred)\n", + "\n", + "# Визуализация матрицы ошибок\n", + "plt.figure(figsize=(8, 6))\n", + "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', \n", + " xticklabels=['Предсказанный \"безопасный\"', 'Предсказанный \"опасный\"'], \n", + " yticklabels=['Действительно \"безопасный\"', 'Действительно \"опасный\"'])\n", + "plt.title('Confusion Matrix')\n", + "plt.ylabel('Actual')\n", + "plt.xlabel('Predicted')\n", + "plt.show()\n", + "\n", + "# Оценка дисперсии и смещения\n", + "cv_results = grid_search.cv_results_\n", + "mean_test_score = cv_results['mean_test_score']\n", + "std_test_score = cv_results['std_test_score']\n", + "\n", + "print(f\"Смещение: {mean_test_score.mean()}\")\n", + "print(f\"Дисперсия: {std_test_score.mean()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Метод случаного леса (набор деревьев решений)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Лучшие гиперпараметры: {'classifier__max_depth': 20, 'classifier__min_samples_leaf': 4, 'classifier__n_estimators': 200}\n", + "ROC у метода случайного леса = 0.9081081989462431\n", + "Точность = 0.8718891402714932\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Матрица ошибок:\n", + "[[1329 397]\n", + " [ 56 1754]]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Смещение: 0.8686998314031272\n", + "Дисперсия: 0.003095104102985812\n" + ] + } + ], + "source": [ + "# Конвейер для случайного леса\n", + "pipeline_ranfor = Pipeline([\n", + " ('preprocessing', preprocessing),\n", + " ('classifier', RandomForestClassifier())\n", + "])\n", + "\n", + "# Определение сетки гиперпараметров\n", + "param_grid = {\n", + " #Количество деревьев в лесу\n", + " 'classifier__n_estimators': [50, 100, 200],\n", + " #Максимальная глубина дерева\n", + " 'classifier__max_depth': [10, 20, 30],\n", + " #Минимальное количество образцов для листового узла\n", + " 'classifier__min_samples_leaf': [1, 2, 4]\n", + "}\n", + "\n", + "# Создание объекта GridSearchCV\n", + "grid_search = GridSearchCV(pipeline_ranfor, param_grid, cv=5, scoring='accuracy', n_jobs=-1)\n", + "\n", + "# Обучение модели с перебором гиперпараметров\n", + "grid_search.fit(X_train, y_train)\n", + "\n", + "print(\"Лучшие гиперпараметры: \", grid_search.best_params_)\n", + "\n", + "# Лучшая модель случайного леса\n", + "best_model = grid_search.best_estimator_\n", + "\n", + "# Использование и оценка лучшей модели\n", + "y_pred_proba = best_model.predict_proba(X_test)[:, 1]\n", + "print(f'ROC у метода случайного леса = {roc_auc_score(y_test, y_pred_proba)}')\n", + "\n", + "y_pred = best_model.predict(X_test)\n", + "print(f'Точность = {accuracy_score(y_test, y_pred)}')\n", + "\n", + "fpr, tpr, _ = metrics.roc_curve(y_test, y_pred_proba)\n", + "\n", + "# построение ROC кривой\n", + "plt.plot(fpr, tpr)\n", + "plt.ylabel('True Positive Rate')\n", + "plt.xlabel('False Positive Rate')\n", + "plt.show()\n", + "\n", + "# Построение матрицы ошибок\n", + "conf_matrix = confusion_matrix(y_test, y_pred)\n", + "\n", + "# Визуализация матрицы ошибок\n", + "plt.figure(figsize=(8, 6))\n", + "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', \n", + " xticklabels=['Предсказанный \"безопасный\"', 'Предсказанный \"опасный\"'], \n", + " yticklabels=['Действительно \"безопасный\"', 'Действительно \"опасный\"'])\n", + "plt.title('Confusion Matrix')\n", + "plt.ylabel('Actual')\n", + "plt.xlabel('Predicted')\n", + "plt.show()\n", + "\n", + "# Оценка дисперсии и смещения\n", + "cv_results = grid_search.cv_results_\n", + "mean_test_score = cv_results['mean_test_score']\n", + "std_test_score = cv_results['std_test_score']\n", + "\n", + "print(f\"Смещение: {mean_test_score.mean()}\")\n", + "print(f\"Дисперсия: {std_test_score.mean()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Градиентный бустинг" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Лучшие гиперпараметры: {'classifier__learning_rate': 0.1, 'classifier__max_depth': 3, 'classifier__n_estimators': 300, 'classifier__subsample': 0.5}\n", + "ROC у метода градиентного спуска = 0.9012421336337971\n", + "Точность = 0.872737556561086\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABC8klEQVR4nO3dfXzO9eLH8fe12a4N29Da5maam9zlZm7iIIlWVEecTuWUg9TRKTd12lEhLCWcinSinJRUv4rqqJxoDoqDdMisFCY3i7CxsDtsdl3f3x/LVzuGXXNd1/e6rr2ej8f1eHy+332/1/XeF13vvrc2wzAMAQAABIggqwMAAAC4E+UGAAAEFMoNAAAIKJQbAAAQUCg3AAAgoFBuAABAQKHcAACAgFLN6gDe5nQ6dfDgQUVERMhms1kdBwAAVIBhGMrPz1e9evUUFHThfTNVrtwcPHhQ8fHxVscAAACVsH//fjVo0OCCy1S5chMRESGpdONERkZanAYAAFREXl6e4uPjze/xC6ly5ebMoajIyEjKDQAAfqYip5RwQjEAAAgolBsAABBQKDcAACCgUG4AAEBAodwAAICAQrkBAAABhXIDAAACCuUGAAAEFMoNAAAIKJQbAAAQUCwtN//5z3/Ur18/1atXTzabTR9//PFF11m9erU6dOggu92upk2basGCBR7PCQAA/Iel5aawsFDt2rXTnDlzKrT83r17dcstt6hXr15KT0/XX/7yF/3pT3/S8uXLPZwUAAD4C0sfnHnTTTfppptuqvDyc+fOVaNGjTRjxgxJUsuWLbVu3Tq98MIL6tOnj6diAuU6nH9KxSVOq2MAgM8JrRakmIgwyz7fr54KvmHDBiUlJZWZ16dPH/3lL3857zpFRUUqKioyp/Py8jwVDwHktMOpBesz9dl3h1TiNBQeElzm5//de9SiZADg+zo0rKXFI7pb9vl+VW6ysrIUGxtbZl5sbKzy8vJ08uRJhYeHn7POtGnTNHnyZG9FhJ/bkZWnvrPWurSOvRrn5QPAr4UEW/vfRb8qN5Uxbtw4JScnm9N5eXmKj4+3MBF80f6jJ9Tj2S/K/dldnRuqQ8NaCg8tu/cmNjJMVyfU8UY8AIAL/KrcxMXFKTs7u8y87OxsRUZGlrvXRpLsdrvsdrs34sEPFZc41ePZz5WdV1Rmfv1a4fr3I9eqht2v/okAAORn5aZr165atmxZmXkrVqxQ165dLUoEf3fDC2vKFJuklrGaN6SjbDabhakAAJfC0nJTUFCgXbt2mdN79+5Venq66tSpo4YNG2rcuHE6cOCA3nrrLUnSAw88oNmzZ+uxxx7Tvffeq88//1zvv/++li5datWvAD/2RcZh/fjzCXM6Y0pf2asFX2ANAIA/sPSMn6+//lrt27dX+/btJUnJyclq3769Jk2aJEk6dOiQ9u3bZy7fqFEjLV26VCtWrFC7du00Y8YMvfbaa1wGDpdt/vGYhr2xyZz+bnIfig0ABAibYRiG1SG8KS8vT1FRUcrNzVVkZKTVceBlmTmFuu751WXmvXVvZ13b7HJrAgEAKsSV72+uYUWV8c3+4+cUm+E9GlFsACDA+NUJxcCl6D9nvTm+ql6kFo/oxqEoAAhAlBtUCb9+TMJNreP0yh87WpgGAOBJHJZCwDtZ7NCAX+21mX5bWwvTAAA8jT03CGh3zt2gjZllnwMVVT3EojQAAG9gzw0CVkFRyTnF5pOR1j3IDQDgHey5QcC691f3sfkm5UZFhbPHBgCqAvbcICDtPlJQZq8NxQYAqg7KDQJOUYlD189YY06n/qWHhWkAAN5GuUHAmf352eeVtakfpRZx3IkaAKoSyg0CyoL1e/XSr8rNklGcQAwAVQ0nFCMg7D96Qj2e/aLMvGd/31Y2m82iRAAAq7DnBgEhff/xMtPjbmqhOzo1sCYMAMBS7LlBQHjsw28lSS3iIpT6l2stTgMAsBJ7buD3Hnh7s06edkiS6kaFWZwGAGA1yg382pe7cpT6fZY5PXcwD8QEgKqOcgO/dbSwWHe/9l9z+t+PXCt7tWALEwEAfAHlBn6rw9MrzHFKv1ZqFhthYRoAgK+g3MDvNb68hoZ1b2R1DACAj6DcwO/sP3pCCWOXmtMf/LmrhWkAAL6GcgO/k/x+epnpOjVCrQkCAPBJlBv4leISpzZlHjOndzzdl7sQAwDKoNzAr+SePG2O1z7WS2EhXB0FACiLcgO/8t2BXHMcX6e6hUkAAL6KcgO/MmzBJqsjAAB8HOUGfuWyX04eHtY9wdogAACfRbmB3ygoKtHPhcWSpP6J9S1OAwDwVZQb+I2l3x40xy3iuBsxAKB8lBv4jaOFpVdKBdnEVVIAgPOi3MAv5J06rb+l7pAkdW8abXEaAIAvo9zA5x3KPam2T/7bnL7xqjgL0wAAfB3lBj6v67TPzXHnhDoa/JsrLEwDAPB1lBv4tLc3ZJrjGqHBeu/+31gXBgDgF6pZHQA4n9fW7tGUpdvN6a8n3KDgIJ4jBQC4MPbcwCcVFpWUKTbvDf+NwkO5QgoAcHHsuYFP+ve2LHO86P7fqEvjyyxMAwDwJ+y5gU965pe9NmEhQRQbAIBLKDfwOUUlDuUUlD5mIeGyGhanAQD4G8oNfM7/fbXPHL/yx44WJgEA+CPKDXzO059uM8eNotlzAwBwDeUGPmXLvmPmeHTvphYmAQD4K8oNfMrvXv7SHI/sRbkBALiOcgOfkfjU2edHPdqnOU/+BgBUCuUGPuFYYbGOnzhtTo+4romFaQAA/oxyA5/Q/ukV5viHZ26SzcZjFgAAlUO5geUWbjx76XdifC2FBPPXEgBQeXyLwHKT/3X20u+PRnSzMAkAIBBQbmC5OjVCJUkP9GzC4SgAwCWj3MBSye+n68Dxk5Kk3i1iLE4DAAgElBtY5ouMw1qcdsCcbh4bYWEaAECgoNzAMsPe2GSONz5xvaKqh1iYBgAQKCg3sMTJYoc5vqtzQ8VEhFmYBgAQSCg3sMQTH209O76lpYVJAACBhnIDS2zY87Mkqaa9mmraq1mcBgAQSCg38Lqfjp3QodxTkqSPR3a3OA0AINBQbuB11/ztC3PcOLqGhUkAAIGIcgOvOu1wmuPOjeooKIib9gEA3MvycjNnzhwlJCQoLCxMXbp00caNGy+4/KxZs9S8eXOFh4crPj5ejzzyiE6dOuWltLhUa384Yo5fG9rJwiQAgEBlablZtGiRkpOTlZKSorS0NLVr1059+vTR4cOHy13+3Xff1dixY5WSkqLt27fr9ddf16JFizR+/HgvJ0dlFJU4dO+Cr83pGqGcSAwAcD9Ly83MmTM1fPhwDRs2TK1atdLcuXNVvXp1zZ8/v9zlv/zyS3Xv3l133323EhISdOONN+quu+664N6eoqIi5eXllXnBGuP+efby78f7tlAwh6QAAB5gWbkpLi7W5s2blZSUdDZMUJCSkpK0YcOGctfp1q2bNm/ebJaZPXv2aNmyZbr55pvP+znTpk1TVFSU+YqPj3fvLwKXRYWH6IGeja2OAQAIUJYdF8jJyZHD4VBsbGyZ+bGxsdqxY0e569x9993KycnRNddcI8MwVFJSogceeOCCh6XGjRun5ORkczovL4+CY4GDx09q8ZbS50gN7XoFT/8GAHiM5ScUu2L16tWaOnWqXn75ZaWlpWnx4sVaunSpnn766fOuY7fbFRkZWeYF7+s2/XNzfHWjOhYmAQAEOsv23ERHRys4OFjZ2dll5mdnZysuLq7cdSZOnKjBgwfrT3/6kySpTZs2Kiws1P33368nnnhCQUF+1dWqlMsj7DqSX6QWcRHqceXlVscBAAQwy9pAaGioOnbsqFWrVpnznE6nVq1apa5du5a7zokTJ84pMMHBwZIkwzA8FxaX5JP0AzqSXyRJmnlnorVhAAABz9JrcZOTkzV06FB16tRJnTt31qxZs1RYWKhhw4ZJkoYMGaL69etr2rRpkqR+/fpp5syZat++vbp06aJdu3Zp4sSJ6tevn1ly4FtOFJfo4YXp5nR8nXDrwgAAqgRLy83AgQN15MgRTZo0SVlZWUpMTFRqaqp5kvG+ffvK7KmZMGGCbDabJkyYoAMHDujyyy9Xv3799Mwzz1j1K+AinlzyvTl+897OiggLsTANAKAqsBlV7HhOXl6eoqKilJuby8nFXpAwdqk5zpx+i4VJAAD+zJXvb87AhcccP1Fsjt8YdrWFSQAAVQnlBh6xN6dQiU+tMKd7NI22MA0AoCqh3MAj/rIo3Rz3uSpW1YL5qwYA8A6+ceB23/50XN/sPy5Jalinuubc3cHaQACAKoVyA7f78ecT5vjd4V3YawMA8Cq+deB2723cJ0nq2vgyNahd3eI0AICqhnIDt8vMKZQknXY4LU4CAKiKKDdwK4fT0MHcU5Kkv97Y3OI0AICqiHIDt3phxU5z3Cy2poVJAABVFeUGbjX7i12SpMiwarqspt3iNACAqohyA7eK/qXQvDAw0dogAIAqi3IDj6hfm6d/AwCsQbmB2xiGoZyCIqtjAACqOMoN3GbaZzvMcU17NQuTAACqMsoN3CL/1Gm9+p89kqSQYBs37wMAWIZyg0tWUFSiNk/+25x+c1hnC9MAAKo6yg0u2Ze7csxxl0Z11K1ptIVpAABVHeUGl2x6aum5NhH2alr0564WpwEAVHWUG1yyE0UOSdLlkdy0DwBgPcoNLonDaSgrr/RZUo/yLCkAgA+g3OCSFJU4zHHHK2pbmAQAgFKUG1wSp3F2XDOMe9sAAKxHucEl+duvbtwXHGSzMAkAAKUoN7gkb3/1ozm2Vwu2MAkAAKUoN6i0o4XF5vjjkd0tTAIAwFmUG1Tajqw8c5wYX8u6IAAA/ArlBpWyMztfQ+dvtDoGAADn4PIWuOyH7Hzd+MJ/zOnH+nJ/GwCA72DPDVy2asdhc/zQ9VfqwZ5NLEwDAEBZ7LmBy0KCSztx54Q6Sr6hmcVpAAAoiz03cNlHW36SJMVFhVmcBACAc1Fu4LLYiNJSc9rhtDgJAADnotzAZQ6j9JkLvZrHWJwEAIBzXVK5OXXqlLtywE9s/SlXqzOOlE7wtAUAgA9yudw4nU49/fTTql+/vmrWrKk9e/ZIkiZOnKjXX3/d7QHhW/rNXmeOuzW5zMIkAACUz+VyM2XKFC1YsEDPPvusQkNDzfmtW7fWa6+95tZw8C17jhSY4wm3tFSD2tUtTAMAQPlcLjdvvfWWXn31VQ0aNEjBwWcflNiuXTvt2LHjAmvC3x08fvYw5L3dG1mYBACA83O53Bw4cEBNmzY9Z77T6dTp06fdEgq+qcRZenVUi7gIBQVxwg0AwDe5XG5atWqltWvXnjP/ww8/VPv27d0SCr5p0ab9krgEHADg21y+Q/GkSZM0dOhQHThwQE6nU4sXL1ZGRobeeustffrpp57ICB9gGIY++y5LknSy2GFxGgAAzs/lPTf9+/fXv/71L61cuVI1atTQpEmTtH37dv3rX//SDTfc4ImM8AH/99995vixvi0sTAIAwIVV6tlSPXr00IoVK9ydBT5s4sffSZLaxddS/8R6FqcBAOD8XN5z07hxY/3888/nzD9+/LgaN27sllDwLfmnzp4o/scuDWWzcTIxAMB3uVxuMjMz5XCce85FUVGRDhw44JZQ8C0fbzn759qvHXttAAC+rcKHpZYsWWKOly9frqioKHPa4XBo1apVSkhIcGs4+IaZK3ZKkjpdUVthIcEXWRoAAGtVuNwMGDBAkmSz2TR06NAyPwsJCVFCQoJmzJjh1nDwDcdOlB6W+m3buhYnAQDg4ipcbpy/3MCtUaNG2rRpk6Kjoz0WCr7jx58LzfE1V15uYRIAACrG5aul9u7d64kc8FE9n1ttjpvG1LQuCAAAFVSpS8ELCwu1Zs0a7du3T8XFxWV+9tBDD7klGKw3d81uc8zl3wAAf+FyudmyZYtuvvlmnThxQoWFhapTp45ycnJUvXp1xcTEUG4CyMa9R83xrIGJ1gUBAMAFLl8K/sgjj6hfv346duyYwsPD9dVXX+nHH39Ux44d9fzzz3siIyxy8PhJSdKzv2/LvW0AAH7D5XKTnp6uv/71rwoKClJwcLCKiooUHx+vZ599VuPHj/dERlhkR1a+JMmQYXESAAAqzuVyExISoqCg0tViYmK0b1/pM4eioqK0f/9+96aDZU6dPnujxtb1oy6wJAAAvsXlc27at2+vTZs26corr1TPnj01adIk5eTk6O2331br1q09kREW+P5grjluHM1VUgAA/+HynpupU6eqbt3Sm7k988wzql27th588EEdOXJE//jHP9weENb4OvOYJCkqPEThodyVGADgP1zec9OpUydzHBMTo9TUVLcGgm8oKCqRJF1VL9LiJAAAuMblPTfnk5aWpt/+9rcurzdnzhwlJCQoLCxMXbp00caNGy+4/PHjxzVy5EjVrVtXdrtdzZo107JlyyobG+UwDEMvfb5LkpQQXcPiNAAAuMalcrN8+XKNGTNG48eP1549eyRJO3bs0IABA3T11Vebj2ioqEWLFik5OVkpKSlKS0tTu3bt1KdPHx0+fLjc5YuLi3XDDTcoMzNTH374oTIyMjRv3jzVr1/fpc/FhTmcZ6+OujqhtoVJAABwXYUPS73++usaPny46tSpo2PHjum1117TzJkzNXr0aA0cOFDfffedWrZs6dKHz5w5U8OHD9ewYcMkSXPnztXSpUs1f/58jR079pzl58+fr6NHj+rLL79USEiIJF30SeRFRUUqKioyp/Py8lzKWNX1ah5jdQQAAFxS4T03L774ov72t78pJydH77//vnJycvTyyy9r69atmjt3rsvFpri4WJs3b1ZSUtLZMEFBSkpK0oYNG8pdZ8mSJeratatGjhyp2NhYtW7dWlOnTpXD4Sh3eUmaNm2aoqKizFd8fLxLOQEAgH+pcLnZvXu37rjjDknSbbfdpmrVqum5555TgwYNKvXBOTk5cjgcio2NLTM/NjZWWVlZ5a6zZ88effjhh3I4HFq2bJkmTpyoGTNmaMqUKef9nHHjxik3N9d8cS+ei1u69ZA5Dg7izsQAAP9S4cNSJ0+eVPXq1SVJNptNdrvdvCTcW5xOp2JiYvTqq68qODhYHTt21IEDB/Tcc88pJSWl3HXsdrvsdrtXc/q7bYdKD93FRtoVERZicRoAAFzj0qXgr732mmrWLL2hW0lJiRYsWKDo6Ogyy1T0wZnR0dEKDg5WdnZ2mfnZ2dmKi4srd526desqJCREwcFn77vSsmVLZWVlqbi4WKGhoa78OriIfm15EjgAwP9UuNw0bNhQ8+bNM6fj4uL09ttvl1nGZrNVuNyEhoaqY8eOWrVqlQYMGCCpdM/MqlWrNGrUqHLX6d69u9599105nU7zERA7d+5U3bp1KTZu9I81pVfC8axMAIA/qnC5yczMdPuHJycna+jQoerUqZM6d+6sWbNmqbCw0Lx6asiQIapfv76mTZsmSXrwwQc1e/ZsPfzwwxo9erR++OEHTZ06tcKFChc3+PX/muOiEtcu7QcAwBe4fIdidxo4cKCOHDmiSZMmKSsrS4mJiUpNTTVPMt63b5+5h0aS4uPjtXz5cj3yyCNq27at6tevr4cffliPP/64Vb9CQMk/dVprf8gxp8ff7NoVcAAA+AKbYRjGxRcLHHl5eYqKilJubq4iI3m0wK+t/eGIBr9eeofonVNuUmg1t93AGgCAS+LK9zffXjDNW7vXHFNsAAD+im8wmC6vWXrJ/HXNL7c4CQAAlUe5wTm6Nr7M6ggAAFRapcrN7t27NWHCBN11113mQy4/++wzff/9924NB+8pKnHon2k/WR0DAIBL5nK5WbNmjdq0aaP//ve/Wrx4sQoKCiRJ33zzzXnvEgzf13xCqjkOCwm+wJIAAPg2l8vN2LFjNWXKFK1YsaLMjfN69+6tr776yq3h4B1rdh4pM31rO+5MDADwXy7f52br1q169913z5kfExOjnJycctaAr5u6dLs5zpx+i4VJAAC4dC7vualVq5YOHTp0zvwtW7aofv36bgkF78rIzpckXdM0+iJLAgDg+1wuN3/4wx/0+OOPKysrSzabTU6nU+vXr9eYMWM0ZMgQT2SEB2XmFJrjEdc1sTAJAADu4XK5mTp1qlq0aKH4+HgVFBSoVatWuvbaa9WtWzdNmDDBExnhIU6noaSZayRJIcE2dWPPDQAgALh8zk1oaKjmzZuniRMn6rvvvlNBQYHat2+vK6+80hP54EGp32epxFn69I0ujbi3DQAgMLhcbtatW6drrrlGDRs2VMOGDT2RCV5gGIZGvJNmTr82tJOFaQAAcB+XD0v17t1bjRo10vjx47Vt2zZPZIIX9J6xxhxP/V0b7m0DAAgYLpebgwcP6q9//avWrFmj1q1bKzExUc8995x++om72/qL/FOntfdXJxLf1TnewjQAALiXy+UmOjpao0aN0vr167V7927dcccdevPNN5WQkKDevXt7IiPcLP9UiTnePfVm2Ww2C9MAAOBel/TgzEaNGmns2LGaPn262rRpozVr1lx8JVjO8ctJxKHVghQcRLEBAASWSpeb9evXa8SIEapbt67uvvtutW7dWkuXLnVnNnjI1z8elSQVlzgtTgIAgPu5fLXUuHHjtHDhQh08eFA33HCDXnzxRfXv31/Vq1f3RD54QInDsDoCAAAe43K5+c9//qNHH31Ud955p6KjuembPzpzMvF1zS+3OAkAAO7ncrlZv369J3LAi3ZmF0iScgqKLE4CAID7VajcLFmyRDfddJNCQkK0ZMmSCy576623uiUYPMPpNLT/6AlJ3JUYABCYKlRuBgwYoKysLMXExGjAgAHnXc5ms8nhcLgrGzzg3jc3mU8B79U8xuI0AAC4X4XKjdPpLHcM/7M644gkqU39KF1zJedMAQACj8uXgr/11lsqKjr3XI3i4mK99dZbbgkFz3h/035zPOPOdhYmAQDAc1wuN8OGDVNubu458/Pz8zVs2DC3hIJnrNyebY6vjKlpYRIAADzH5XJjGEa5t+v/6aefFBUV5ZZQ8IyfC4slSde3iOGRCwCAgFXhS8Hbt28vm80mm82m66+/XtWqnV3V4XBo79696tu3r0dCwj02/3hMEve3AQAEtgqXmzNXSaWnp6tPnz6qWfPsYY3Q0FAlJCTo97//vdsDwj1Svztkji+PsFuYBAAAz6pwuUlJSZEkJSQkaODAgQoLC/NYKLjfkm8OmuOklrEWJgEAwLNcvkPx0KFDPZEDHrZsa5YkaXiPRqoWfEkPgwcAwKdVqNzUqVNHO3fuVHR0tGrXrn3Bk1GPHj3qtnBwj7R9x8xxv3b1LEwCAIDnVajcvPDCC4qIiDDHXGnjX46fKDbHbRvUsi4IAABeUKFy8+tDUffcc4+nssBDVmw7LElq14BL9QEAgc/lky/S0tK0detWc/qTTz7RgAEDNH78eBUXF19gTVhlyy+HpfbmFFqcBAAAz3O53Pz5z3/Wzp07JUl79uzRwIEDVb16dX3wwQd67LHH3B4Ql6bE4TRv3vfs7W0tTgMAgOe5XG527typxMRESdIHH3ygnj176t1339WCBQv0z3/+0935cInmrtmtI/mlzwJrVZfDUgCAwFepxy+ceTL4ypUrdfPNN0uS4uPjlZOT4950uGQb9vwsSWpQO1wNL6tucRoAADzP5XLTqVMnTZkyRW+//bbWrFmjW265RZK0d+9excZyczhfs35XabkZkFjf4iQAAHiHy+Vm1qxZSktL06hRo/TEE0+oadOmkqQPP/xQ3bp1c3tAVF5BUYk5bhdfy7ogAAB4kct3KG7btm2Zq6XOeO655xQcHOyWUHCPHYfyzHEvHpYJAKgiXC43Z2zevFnbt2+XJLVq1UodOnRwWyi4x+1zN0iSosJDeOQCAKDKcLncHD58WAMHDtSaNWtUq1YtSdLx48fVq1cvLVy4UJdfzh4CX/DlrrMnd7fl5n0AgCrE5f+dHz16tAoKCvT999/r6NGjOnr0qL777jvl5eXpoYce8kRGVMKK7dnm+K17O1uYBAAA73J5z01qaqpWrlypli1bmvNatWqlOXPm6MYbb3RrOFTevp9PSJJubVePZ4EBAKoUl/fcOJ1OhYSEnDM/JCTEvP8NrPfdwVxJUu8WMRYnAQDAu1wuN71799bDDz+sgwcPmvMOHDigRx55RNdff71bw6HyCk6VXgbOJeAAgKrG5XIze/Zs5eXlKSEhQU2aNFGTJk3UqFEj5eXl6aWXXvJERrjIMAwVFjskScEckgIAVDEun3MTHx+vtLQ0rVq1yrwUvGXLlkpKSnJ7OFTOzuwCc1zDzr2HAABVi0vlZtGiRVqyZImKi4t1/fXXa/To0Z7KhUuw+8jZcnNZTbuFSQAA8L4Kl5tXXnlFI0eO1JVXXqnw8HAtXrxYu3fv1nPPPefJfKiEX9+ZGACAqqbC59zMnj1bKSkpysjIUHp6ut588029/PLLnsyGSvghO19//3yXJOmebgnWhgEAwAIVLjd79uzR0KFDzem7775bJSUlOnTokEeCoXIeWphujod1T7AsBwAAVqlwuSkqKlKNGjXOrhgUpNDQUJ08edIjweC6U6cd2pFVekjq9o4NdMVlNS6yBgAAgcelE4onTpyo6tWrm9PFxcV65plnFBV19tlFM2fOdF86uCTtx2MyDKl6aLCm39bG6jgAAFiiwuXm2muvVUZGRpl53bp10549e8xpbvNvrVU7DkuSroypyVPAAQBVVoXLzerVqz0YA+6QmVMoSfrpGIcKAQBVl0/87/2cOXOUkJCgsLAwdenSRRs3bqzQegsXLpTNZtOAAQM8G9APZGTlm3tu7urc0OI0AABYx/Jys2jRIiUnJyslJUVpaWlq166d+vTpo8OHD19wvczMTI0ZM0Y9evTwUlLf9tuX1prjwV2vsDAJAADWsrzczJw5U8OHD9ewYcPUqlUrzZ07V9WrV9f8+fPPu47D4dCgQYM0efJkNW7c2ItpfdOxwmKddhiSpHYNohQbGWZxIgAArGNpuSkuLtbmzZvLPJcqKChISUlJ2rBhw3nXe+qppxQTE6P77rvvop9RVFSkvLy8Mq9A8+2BXHO8eER3C5MAAGA9S8tNTk6OHA6HYmNjy8yPjY1VVlZWueusW7dOr7/+uubNm1ehz5g2bZqioqLMV3x8/CXn9jUHfnUCcXAQV6wBAKq2SpWbtWvX6o9//KO6du2qAwcOSJLefvttrVu3zq3h/ld+fr4GDx6sefPmKTo6ukLrjBs3Trm5ueZr//79Hs3obYZhaPxHWyVJSS1jLE4DAID1XLqJnyT985//1ODBgzVo0CBt2bJFRUVFkqTc3FxNnTpVy5Ytq/B7RUdHKzg4WNnZ2WXmZ2dnKy4u7pzld+/erczMTPXr18+c53Q6S3+RatWUkZGhJk2alFnHbrfLbg/cJ2P/+gng/drVszAJAAC+weU9N1OmTNHcuXM1b948hYSEmPO7d++utLQ0l94rNDRUHTt21KpVq8x5TqdTq1atUteuXc9ZvkWLFtq6davS09PN16233qpevXopPT09IA85XcwP2WfLTf/E+hYmAQDAN7i85yYjI0PXXnvtOfOjoqJ0/PhxlwMkJydr6NCh6tSpkzp37qxZs2apsLBQw4YNkyQNGTJE9evX17Rp0xQWFqbWrVuXWb9WrVqSdM78quBEcYkefKe0UHJvGwAASrlcbuLi4rRr1y4lJCSUmb9u3bpKXZY9cOBAHTlyRJMmTVJWVpYSExOVmppqnmS8b98+BQVZfsW6T9qRlW+Ox93cwsIkAAD4DpfLzfDhw/Xwww9r/vz5stlsOnjwoDZs2KAxY8Zo4sSJlQoxatQojRo1qtyfXeyxDwsWLKjUZwaSmAi7IsNCLr4gAABVgMvlZuzYsXI6nbr++ut14sQJXXvttbLb7RozZoxGjx7tiYw4D6P0vn0KCwm2NggAAD7E5XJjs9n0xBNP6NFHH9WuXbtUUFCgVq1aqWbNmp7IhwtIWfKdJMnhNCxOAgCA73C53JwRGhqqVq1auTMLXLT7cOlTwA8c5yngAACc4XK56dWrl2y2898F9/PPP7+kQLg4p9PQgi8zdfK0Q5L0zwe7WZwIAADf4XK5SUxMLDN9+vRppaen67vvvtPQoUPdlQsX0G/2On1/sPQZWVfG1FTHK2pbnAgAAN/hcrl54YUXyp3/5JNPqqCgoNyfwX2OFRabxUaSpv++jYVpAADwPW67gcwf//hHzZ8/311vh/P4cvfP5njnlJvU8Yo6FqYBAMD3uK3cbNiwQWFhYe56O5zH5zsOm+PQatzcEACA/+XyYanbbrutzLRhGDp06JC+/vrrSt/EDxX3372le24aR9ewOAkAAL7J5XITFRVVZjooKEjNmzfXU089pRtvvNFtwXCuTZlH9dOx0su+R/RqanEaAAB8k0vlxuFwaNiwYWrTpo1q1+YKHW9b+0OOOb6tPU8ABwCgPC6dtBEcHKwbb7yxUk//xqXbfaT0arS+V8UpKOj89xoCAKAqc/mM1NatW2vPnj2eyIKLWPrtIUlSYsNa1gYBAMCHuVxupkyZojFjxujTTz/VoUOHlJeXV+YFz3h+eYY5bsTJxAAAnFeFz7l56qmn9Ne//lU333yzJOnWW28t8xgGwzBks9nkcDjcnxLmVVKSdGOrWAuTAADg2ypcbiZPnqwHHnhAX3zxhSfz4Dxq2kv/qB7v2+KCz/YCAKCqq3C5MQxDktSzZ0+PhcH5fZFxRJJ0Wc1Qi5MAAODbXDrnhj0G1rs8wm51BAAAfJpL97lp1qzZRQvO0aNHLykQznU4/5Q5bhYbYWESAAB8n0vlZvLkyefcoRiet2JbtjmuG8nzuwAAuBCXys0f/vAHxcTEeCoLzuPjLQfMMTfvAwDgwip8zg3n21inxFl6MndSS4olAAAXU+Fyc+ZqKXhfaHDpH9MtbetanAQAAN9X4cNSTqfTkzlQAaHBwVZHAADA57n8+AUAAABfRrkBAAABhXIDAAACCuXGD2zZf9zqCAAA+A3KjY/LyMpXcUnpydxNYmpYnAYAAN9HufFx2XlnH73QIi7SwiQAAPgHyo2faFWXYgMAQEVQbnwct04EAMA1lBsft/KXh2Y6uUM0AAAVQrnxYYZhaPOPxyRJ+adKLE4DAIB/oNz4sM0/HtO2Q3mSpP6J9SxOAwCAf6Dc+LBlW7PM8R2d4i1MAgCA/6Dc+LB9RwslSdE17WoUzT1uAACoCMqND9uTU1puBnVpaHESAAD8B+XGR50oLtHeX8rNDa1iLU4DAID/oNz4qOy8Ip25+vuqetzADwCAiqLc+Ki0Xy4BlySbzWZhEgAA/Avlxked6TOX1Qi1NggAAH6GcuPjrqofZXUEAAD8CuUGAAAEFMoNAAAIKJQbH1Vc4rQ6AgAAfoly46M++6700QunKTkAALiEcuOjLqtZepVUaDX+iAAAcAXfnD5qcdoBSVLXJpdZnAQAAP9CufFB/9l5xBzXqxVuYRIAAPwP5cbHGIahIfM3mtO3tqtnYRoAAPwP5cbHjPngW3P8556NLUwCAIB/otz4kIKiEv0z7SdJUlR4iMbd1NLiRAAA+B/KjQ/ZuPdnc7wyuaeFSQAA8F+UGx/y1Z6jkqQ6NUJ1eYTd4jQAAPgnyo0Psf9yT5v6XCEFAECl+US5mTNnjhISEhQWFqYuXbpo48aN51123rx56tGjh2rXrq3atWsrKSnpgsv7C8Mw9NLnuyRJbRvwJHAAACrL8nKzaNEiJScnKyUlRWlpaWrXrp369Omjw4cPl7v86tWrddddd+mLL77Qhg0bFB8frxtvvFEHDhzwcnL3OnX67GMWOl5R28IkAAD4N5thGIaVAbp06aKrr75as2fPliQ5nU7Fx8dr9OjRGjt27EXXdzgcql27tmbPnq0hQ4ZcdPm8vDxFRUUpNzdXkZGRl5zfXRKf+reOnzgtSdrxdF+FhQRbnAgAAN/hyve3pXtuiouLtXnzZiUlJZnzgoKClJSUpA0bNlToPU6cOKHTp0+rTp065f68qKhIeXl5ZV6+ZvuhPLPYSKLYAABwCSwtNzk5OXI4HIqNjS0zPzY2VllZWRV6j8cff1z16tUrU5B+bdq0aYqKijJf8fHxl5zb3V5Zvdscb5l4g4VJAADwf5afc3Mppk+froULF+qjjz5SWFhYucuMGzdOubm55mv//v1eTnlxNeyle2o6N6qj2jVCLU4DAIB/q2blh0dHRys4OFjZ2dll5mdnZysuLu6C6z7//POaPn26Vq5cqbZt2553ObvdLrvdd+8Zc7LYofc2lhau3zTmCeAAAFwqS/fchIaGqmPHjlq1apU5z+l0atWqVeratet513v22Wf19NNPKzU1VZ06dfJGVI9wOA21nJRqTndoWMu6MAAABAhL99xIUnJysoYOHapOnTqpc+fOmjVrlgoLCzVs2DBJ0pAhQ1S/fn1NmzZNkvS3v/1NkyZN0rvvvquEhATz3JyaNWuqZs2alv0elbHt4NmTm5Naxui65jEWpgEAIDBYXm4GDhyoI0eOaNKkScrKylJiYqJSU1PNk4z37dunoKCzO5heeeUVFRcX6/bbby/zPikpKXryySe9Gf2Sbcw8ao5fG3q1hUkAAAgclpcbSRo1apRGjRpV7s9Wr15dZjozM9PzgbwkJNgmicctAADgTn59tVSgSIyvZXUEAAACBuUGAAAEFMqNhZ5fnmF1BAAAAg7lxkIOZ+ljvSLDfeLUJwAAAgLlxiJOp6HCYock6f5rm1icBgCAwEG5scjOw/nmOCo8xMIkAAAEFsqNRU6XGOa4Ds+TAgDAbSg3FqsXVf4DPwEAQOVQbixiyLj4QgAAwGWUG4tM+XS7JMlhUHIAAHAnyo0F8k+dNp8rVVzitDgNAACBhXJjgY+2HDDHn//1OuuCAAAQgCg3FtiZffYy8NpcKQUAgFtRbizw7++zJUm/a1/f4iQAAAQeyo0FDucXSZIaRdewOAkAAIGHcuNlRSUOc9y9abSFSQAACEyUGy/79ZXfzWJrWhcEAIAARbkBAAABhXLjZfuPnrA6AgAAAY1y42ULN+03xzXt1SxMAgBAYKLceNmq7aWXgTeOriGbzWZxGgAAAg/lxoscTkOZP5celnrguiYWpwEAIDBRbrzo9rlfmuMeV3IZOAAAnkC58ZL/7vlZW/YdN6frRoVbFwYAgABGufGSga9+ZY5Xj7nOuiAAAAQ4yo0XLNt6yBw/3reFEnjsAgAAHkO58YIR76SZ43uvSbAuCAAAVQDlxou6N71M9mrBVscAACCgUW68oEZoaaGZfOtVFicBACDwUW68KCSYzQ0AgKfxbQsAAAIK5cbDThSXqLDYYXUMAACqDMqNh+3MLjDHsZFhFiYBAKBqoNx4WN7J05Kk6Jp2hYVwpRQAAJ5GufGwr388Jqn08BQAAPA8yo2Hnbk7ccM61S1OAgBA1UC58bC4X86zaR4XYXESAACqBsqNh506XXqlVO8WMRYnAQCgaqDceNiW/cclSTabzdogAABUEZQbD3MahiSpXYMoi5MAAFA1UG68pHpoNasjAABQJVBuAABAQKHcAACAgEK58SDDMPTLKTcAAMBLKDce1GjcMnNsD2FTAwDgDXzjesh3B3LLTEeGhViUBACAqoVy4yFZuafM8d5pN1uYBACAqoVy4yGffntQktQuvhY38AMAwIsoNx6y+0ihJOkKHpgJAIBXUW48JDuv9LDUwKvjLU4CAEDVQrnxgJyCIh3OL5IktawbaXEaAACqFsqNBwx7Y5M5rlMj1MIkAABUPZQbN/s686i2/s9l4AAAwHsoN242c8VOc7x+bG8LkwAAUDVRbtzI4TT0deYxSdLYm1qofq1wixMBAFD1UG7c6Ks9P6vY4ZTNJt3TLcHqOAAAVEk+UW7mzJmjhIQEhYWFqUuXLtq4ceMFl//ggw/UokULhYWFqU2bNlq2bNkFl/eWMR98I0myVwtSWEiwxWkAAKiaLC83ixYtUnJyslJSUpSWlqZ27dqpT58+Onz4cLnLf/nll7rrrrt03333acuWLRowYIAGDBig7777zsvJy8opKNKhXx65cO2Vl1uaBQCAqsxmGIZhZYAuXbro6quv1uzZsyVJTqdT8fHxGj16tMaOHXvO8gMHDlRhYaE+/fRTc95vfvMbJSYmau7cuRf9vLy8PEVFRSk3N1eRke67B03avmO67eUvJUmbJyTpspp2t703AABVnSvf35buuSkuLtbmzZuVlJRkzgsKClJSUpI2bNhQ7jobNmwos7wk9enT57zLFxUVKS8vr8zLkxrWqU6xAQDAQpaWm5ycHDkcDsXGxpaZHxsbq6ysrHLXycrKcmn5adOmKSoqynzFx3vmcQg2lZ5rE1rN8iN9AABUaQH/TTxu3Djl5uaar/3793vkc9o3rK2MKTdpZXJPj7w/AAComGpWfnh0dLSCg4OVnZ1dZn52drbi4uLKXScuLs6l5e12u+x2DhMBAFBVWLrnJjQ0VB07dtSqVavMeU6nU6tWrVLXrl3LXadr165llpekFStWnHd5AABQtVi650aSkpOTNXToUHXq1EmdO3fWrFmzVFhYqGHDhkmShgwZovr162vatGmSpIcfflg9e/bUjBkzdMstt2jhwoX6+uuv9eqrr1r5awAAAB9hebkZOHCgjhw5okmTJikrK0uJiYlKTU01Txret2+fgoLO7mDq1q2b3n33XU2YMEHjx4/XlVdeqY8//litW7e26lcAAAA+xPL73Hibp+5zAwAAPMdv7nMDAADgbpQbAAAQUCg3AAAgoFBuAABAQKHcAACAgEK5AQAAAYVyAwAAAgrlBgAABBTKDQAACCiWP37B287ckDkvL8/iJAAAoKLOfG9X5MEKVa7c5OfnS5Li4+MtTgIAAFyVn5+vqKioCy5T5Z4t5XQ6dfDgQUVERMhms7n1vfPy8hQfH6/9+/fz3CoPYjt7B9vZO9jO3sO29g5PbWfDMJSfn6969eqVeaB2earcnpugoCA1aNDAo58RGRnJPxwvYDt7B9vZO9jO3sO29g5PbOeL7bE5gxOKAQBAQKHcAACAgEK5cSO73a6UlBTZ7XarowQ0trN3sJ29g+3sPWxr7/CF7VzlTigGAACBjT03AAAgoFBuAABAQKHcAACAgEK5AQAAAYVy46I5c+YoISFBYWFh6tKlizZu3HjB5T/44AO1aNFCYWFhatOmjZYtW+alpP7Nle08b9489ejRQ7Vr11bt2rWVlJR00T8XlHL17/MZCxculM1m04ABAzwbMEC4up2PHz+ukSNHqm7durLb7WrWrBn/7agAV7fzrFmz1Lx5c4WHhys+Pl6PPPKITp065aW0/uk///mP+vXrp3r16slms+njjz++6DqrV69Whw4dZLfb1bRpUy1YsMDjOWWgwhYuXGiEhoYa8+fPN77//ntj+PDhRq1atYzs7Oxyl1+/fr0RHBxsPPvss8a2bduMCRMmGCEhIcbWrVu9nNy/uLqd7777bmPOnDnGli1bjO3btxv33HOPERUVZfz0009eTu5fXN3OZ+zdu9eoX7++0aNHD6N///7eCevHXN3ORUVFRqdOnYybb77ZWLdunbF3715j9erVRnp6upeT+xdXt/M777xj2O1245133jH27t1rLF++3Khbt67xyCOPeDm5f1m2bJnxxBNPGIsXLzYkGR999NEFl9+zZ49RvXp1Izk52di2bZvx0ksvGcHBwUZqaqpHc1JuXNC5c2dj5MiR5rTD4TDq1atnTJs2rdzl77zzTuOWW24pM69Lly7Gn//8Z4/m9Heubuf/VVJSYkRERBhvvvmmpyIGhMps55KSEqNbt27Ga6+9ZgwdOpRyUwGubudXXnnFaNy4sVFcXOytiAHB1e08cuRIo3fv3mXmJScnG927d/dozkBSkXLz2GOPGVdddVWZeQMHDjT69OnjwWSGwWGpCiouLtbmzZuVlJRkzgsKClJSUpI2bNhQ7jobNmwos7wk9enT57zLo3Lb+X+dOHFCp0+fVp06dTwV0+9Vdjs/9dRTiomJ0X333eeNmH6vMtt5yZIl6tq1q0aOHKnY2Fi1bt1aU6dOlcPh8FZsv1OZ7dytWzdt3rzZPHS1Z88eLVu2TDfffLNXMlcVVn0PVrkHZ1ZWTk6OHA6HYmNjy8yPjY3Vjh07yl0nKyur3OWzsrI8ltPfVWY7/6/HH39c9erVO+cfFM6qzHZet26dXn/9daWnp3shYWCozHbes2ePPv/8cw0aNEjLli3Trl27NGLECJ0+fVopKSneiO13KrOd7777buXk5Oiaa66RYRgqKSnRAw88oPHjx3sjcpVxvu/BvLw8nTx5UuHh4R75XPbcIKBMnz5dCxcu1EcffaSwsDCr4wSM/Px8DR48WPPmzVN0dLTVcQKa0+lUTEyMXn31VXXs2FEDBw7UE088oblz51odLaCsXr1aU6dO1csvv6y0tDQtXrxYS5cu1dNPP211NLgBe24qKDo6WsHBwcrOzi4zPzs7W3FxceWuExcX59LyqNx2PuP555/X9OnTtXLlSrVt29aTMf2eq9t59+7dyszMVL9+/cx5TqdTklStWjVlZGSoSZMmng3thyrz97lu3boKCQlRcHCwOa9ly5bKyspScXGxQkNDPZrZH1VmO0+cOFGDBw/Wn/70J0lSmzZtVFhYqPvvv19PPPGEgoL4f393ON/3YGRkpMf22kjsuamw0NBQdezYUatWrTLnOZ1OrVq1Sl27di13na5du5ZZXpJWrFhx3uVRue0sSc8++6yefvpppaamqlOnTt6I6tdc3c4tWrTQ1q1blZ6ebr5uvfVW9erVS+np6YqPj/dmfL9Rmb/P3bt3165du8zyKEk7d+5U3bp1KTbnUZntfOLEiXMKzJlCafDIRbex7HvQo6crB5iFCxcadrvdWLBggbFt2zbj/vvvN2rVqmVkZWUZhmEYgwcPNsaOHWsuv379eqNatWrG888/b2zfvt1ISUnhUvAKcHU7T58+3QgNDTU+/PBD49ChQ+YrPz/fql/BL7i6nf8XV0tVjKvbed++fUZERIQxatQoIyMjw/j000+NmJgYY8qUKVb9Cn7B1e2ckpJiREREGO+9956xZ88e49///rfRpEkT484777TqV/AL+fn5xpYtW4wtW7YYkoyZM2caW7ZsMX788UfDMAxj7NixxuDBg83lz1wK/uijjxrbt2835syZw6Xgvuill14yGjZsaISGhhqdO3c2vvrqK/NnPXv2NIYOHVpm+ffff99o1qyZERoaalx11VXG0qVLvZzYP7myna+44gpD0jmvlJQU7wf3M67+ff41yk3Fubqdv/zyS6NLly6G3W43GjdubDzzzDNGSUmJl1P7H1e28+nTp40nn3zSaNKkiREWFmbEx8cbI0aMMI4dO+b94H7kiy++KPe/t2e27dChQ42ePXues05iYqIRGhpqNG7c2HjjjTc8ntNmGOx/AwAAgYNzbgAAQECh3AAAgIBCuQEAAAGFcgMAAAIK5QYAAAQUyg0AAAgolBsAABBQKDcAACCgUG4AlLFgwQLVqlXL6hiVZrPZ9PHHH19wmXvuuUcDBgzwSh4A3ke5AQLQPffcI5vNds5r165dVkfTggULzDxBQUFq0KCBhg0bpsOHD7vl/Q8dOqSbbrpJkpSZmSmbzab09PQyy7z44otasGCBWz7vfJ588knz9wwODlZ8fLzuv/9+HT161KX3oYgBrqtmdQAAntG3b1+98cYbZeZdfvnlFqUpKzIyUhkZGXI6nfrmm280bNgwHTx4UMuXL7/k946Li7voMlFRUZf8ORVx1VVXaeXKlXI4HNq+fbvuvfde5ebmatGiRV75fKCqYs8NEKDsdrvi4uLKvIKDgzVz5ky1adNGNWrUUHx8vEaMGKGCgoLzvs8333yjXr16KSIiQpGRkerYsaO+/vpr8+fr1q1Tjx49FB4ervj4eD300EMqLCy8YDabzaa4uDjVq1dPN910kx566CGtXLlSJ0+elNPp1FNPPaUGDRrIbrcrMTFRqamp5rrFxcUaNWqU6tatq7CwMF1xxRWaNm1amfc+c1iqUaNGkqT27dvLZrPpuuuuk1R2b8irr76qevXqyel0lsnYv39/3Xvvveb0J598og4dOigsLEyNGzfW5MmTVVJScsHfs1q1aoqLi1P9+vWVlJSkO+64QytWrDB/7nA4dN9996lRo0YKDw9X8+bN9eKLL5o/f/LJJ/Xmm2/qk08+MfcCrV69WpK0f/9+3XnnnapVq5bq1Kmj/v37KzMz84J5gKqCcgNUMUFBQfr73/+u77//Xm+++aY+//xzPfbYY+ddftCgQWrQoIE2bdqkzZs3a+zYsQoJCZEk7d69W3379tXvf/97ffvtt1q0aJHWrVunUaNGuZQpPDxcTqdTJSUlevHFFzVjxgw9//zz+vbbb9WnTx/deuut+uGHHyRJf//737VkyRK9//77ysjI0DvvvKOEhIRy33fjxo2SpJUrV+rQoUNavHjxOcvccccd+vnnn/XFF1+Y844eParU1FQNGjRIkrR27VoNGTJEDz/8sLZt26Z//OMfWrBggZ555pkK/46ZmZlavny5QkNDzXlOp1MNGjTQBx98oG3btmnSpEkaP3683n//fUnSmDFjdOedd6pv3746dOiQDh06pG7duun06dPq06ePIiIitHbtWq1fv141a9ZU3759VVxcXOFMQMDy+HPHAXjd0KFDjeDgYKNGjRrm6/bbby932Q8++MC47LLLzOk33njDiIqKMqcjIiKMBQsWlLvufffdZ9x///1l5q1du9YICgoyTp48We46//v+O3fuNJo1a2Z06tTJMAzDqFevnvHMM8+UWefqq682RowYYRiGYYwePdro3bu34XQ6y31/ScZHH31kGIZh7N2715BkbNmypcwyQ4cONfr3729O9+/f37j33nvN6X/84x9GvXr1DIfDYRiGYVx//fXG1KlTy7zH22+/bdStW7fcDIZhGCkpKUZQUJBRo0YNIywszJBkSDJmzpx53nUMwzBGjhxp/P73vz9v1jOf3bx58zLboKioyAgPDzeWL19+wfcHqgLOuQECVK9evfTKK6+Y0zVq1JBUuhdj2rRp2rFjh/Ly8lRSUqJTp07pxIkTql69+jnvk5ycrD/96U96++23zUMrTZo0kVR6yOrbb7/VO++8Yy5vGIacTqf27t2rli1blpstNzdXNWvWlNPp1KlTp3TNNdfotddeU15eng4ePKju3buXWb579+765ptvJJUeUrrhhhvUvHlz9e3bV7/97W914403XtK2GjRokIYPH66XX35Zdrtd77zzjv7whz8oKCjI/D3Xr19fZk+Nw+G44HaTpObNm2vJkiU6deqU/u///k/p6ekaPXp0mWXmzJmj+fPna9++fTp58qSKi4uVmJh4wbzffPONdu3apYiIiDLzT506pd27d1diCwCBhXIDBKgaNWqoadOmZeZlZmbqt7/9rR588EE988wzqlOnjtatW6f77rtPxcXF5X5JP/nkk7r77ru1dOlSffbZZ0pJSdHChQv1u9/9TgUFBfrzn/+shx566Jz1GjZseN5sERERSktLU1BQkOrWravw8HBJUl5e3kV/rw4dOmjv3r367LPPtHLlSt15551KSkrShx9+eNF1z6dfv34yDENLly7V1VdfrbVr1+qFF14wf15QUKDJkyfrtttuO2fdsLCw875vaGio+Wcwffp03XLLLZo8ebKefvppSdLChQs1ZswYzZgxQ127dlVERISee+45/fe//71g3oKCAnXs2LFMqTzDV04aB6xEuQGqkM2bN8vpdGrGjBnmXokz53dcSLNmzdSsWTM98sgjuuuuu/TGG2/od7/7nTp06KBt27adU6IuJigoqNx1IiMjVa9ePa1fv149e/Y0569fv16dO3cus9zAgQM1cOBA3X777erbt6+OHj2qOnXqlHm/M+e3OByOC+YJCwvTbbfdpnfeeUe7du1S8+bN1aFDB/PnHTp0UEZGhsu/5/+aMGGCevfurQcffND8Pbt166YRI0aYy/zvnpfQ0NBz8nfo0EGLFi1STEyMIiMjLykTEIg4oRioQpo2barTp0/rpZde0p49e/T2229r7ty5513+5MmTGjVqlFavXq0ff/xR69ev16ZNm8zDTY8//ri+/PJLjRo1Sunp6frhhx/0ySefuHxC8a89+uij+tvf/qZFixYpIyNDY8eOVXp6uh5++GFJ0syZM/Xee+9px44d2rlzpz744APFxcWVe+PBmJgYhYeHKzU1VdnZ2crNzT3v5w4aNEhLly7V/PnzzROJz5g0aZLeeustTZ48Wd9//722b9+uhQsXasKECS79bl27dlXbtm01depUSdKVV16pr7/+WsuXL9fOnTs1ceJEbdq0qcw6CQkJ+vbbb5WRkaGcnBydPn1agwYNUnR0tPr376+1a9dq7969Wr16tR566CH99NNPLmUCApLVJ/0AcL/yTkI9Y+bMmUbdunWN8PBwo0+fPsZbb71lSDKOHTtmGEbZE36LioqMP/zhD0Z8fLwRGhpq1KtXzxg1alSZk4U3btxo3HDDDUbNmjWNGjVqGG3btj3nhOBf+98Tiv+Xw+EwnnzySaN+/fpGSEiI0a5dO+Ozzz4zf/7qq68aiYmJRo0aNYzIyEjj+uuvN9LS0syf61cnFBuGYcybN8+Ij483goKCjJ49e553+zgcDqNu3bqGJGP37t3n5EpNTTW6detmhIeHG5GRkUbnzp2NV1999by/R0pKitGuXbtz5r/33nuG3W439u3bZ5w6dcq45557jKioKKNWrVrGgw8+aIwdO7bMeocPHza3ryTjiy++MAzDMA4dOmQMGTLEiI6ONux2u9G4cWNj+PDhRm5u7nkzAVWFzTAMw9p6BQAA4D4clgIAAAGFcgMAAAIK5QYAAAQUyg0AAAgolBsAABBQKDcAACCgUG4AAEBAodwAAICAQrkBAAABhXIDAAACCuUGAAAElP8HK0zmVyWlGLkAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Матрица ошибок:\n", + "[[1326 400]\n", + " [ 50 1760]]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Смещение: 0.8811650848575816\n", + "Дисперсия: 0.008658656436943876\n" + ] + } + ], + "source": [ + "# Конвейер\n", + "pipeline_grad = Pipeline([\n", + " ('preprocessing', preprocessing),\n", + " ('classifier', GradientBoostingClassifier())\n", + "])\n", + "\n", + "# Определение сетки гиперпараметров\n", + "param_grid = {\n", + " 'classifier__n_estimators': [100, 200, 300],\n", + " #Скорость обучения\n", + " 'classifier__learning_rate': [0.1, 0.2],\n", + " #Максимальная глубина дерева\n", + " 'classifier__max_depth': [3, 5, 7],\n", + " 'classifier__subsample': [0.1, 0.5, 1.0],\n", + "}\n", + "\n", + "# Создание объекта GridSearchCV\n", + "grid_search = GridSearchCV(pipeline_grad, param_grid, cv=2, scoring='roc_auc', n_jobs=-1)\n", + "\n", + "# Обучение модели с перебором гиперпараметров\n", + "grid_search.fit(X_train, y_train)\n", + "\n", + "print(\"Лучшие гиперпараметры: \", grid_search.best_params_)\n", + "\n", + "# Лучшая модель\n", + "best_model = grid_search.best_estimator_\n", + "\n", + "# Использование и оценка лучшей модели\n", + "y_pred_proba = best_model.predict_proba(X_test)[:, 1]\n", + "print(f'ROC у метода градиентного спуска = {roc_auc_score(y_test, y_pred_proba)}')\n", + "\n", + "y_pred = best_model.predict(X_test)\n", + "print(f'Точность = {accuracy_score(y_test, y_pred)}')\n", + "\n", + "fpr, tpr, _ = metrics.roc_curve(y_test, y_pred_proba)\n", + "\n", + "# построение ROC кривой\n", + "plt.plot(fpr, tpr)\n", + "plt.ylabel('True Positive Rate')\n", + "plt.xlabel('False Positive Rate')\n", + "plt.show()\n", + "\n", + "# Построение матрицы ошибок\n", + "conf_matrix = confusion_matrix(y_test, y_pred)\n", + "\n", + "# Визуализация матрицы ошибок\n", + "plt.figure(figsize=(8, 6))\n", + "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', \n", + " xticklabels=['Предсказанный \"безопасный\"', 'Предсказанный \"опасный\"'], \n", + " yticklabels=['Действительно \"безопасный\"', 'Действительно \"опасный\"'])\n", + "plt.title('Confusion Matrix')\n", + "plt.ylabel('Actual')\n", + "plt.xlabel('Predicted')\n", + "plt.show()\n", + "\n", + "# Оценка дисперсии и смещения\n", + "cv_results = grid_search.cv_results_\n", + "mean_test_score = cv_results['mean_test_score']\n", + "std_test_score = cv_results['std_test_score']\n", + "\n", + "print(f\"Смещение: {mean_test_score.mean()}\")\n", + "print(f\"Дисперсия: {std_test_score.mean()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Вывод**:\n", + "\n", + "Все модели классификации показали хорошие результаты, но лучший показатель точности у случайного леса. При этом все рассмотренные модели немного не дотянули до показателя точности в 90%. Дополнительая настройка гиперпараметров могла бы приблизить значение оценки ещё ближе к 90% " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "aimenv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}