diff --git a/Lab_4/lab4.ipynb b/Lab_4/lab4.ipynb new file mode 100644 index 0000000..fc4c6f7 --- /dev/null +++ b/Lab_4/lab4.ipynb @@ -0,0 +1,4290 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Лабораторная работа №4\n", + "\n", + "*Вариант задания:* 24 - Набор данных \"Наблюдения НЛО в США\"\n", + "city_latitude" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Выбор бизнес-целей \n", + "Для датасета недвижимости предлагаются две бизнес-цели:\n", + "\n", + "### Задача классификации:\n", + "Предсказание вероятности появления НЛО в зависимости от региона\n", + "\n", + "Описание цели: Классифицировать широты на категории (например, высокая, средняя или низкая вероятность наблюдений НЛО).\n", + "\n", + "Применение: Помощь исследовательским группам в приоритизации областей для исследований.\n", + "\n", + "### Задача регрессии:\n", + "Описание цели: Предсказать, сколько наблюдений НЛО можно ожидать в определенной широтной зоне(city_latitude).\n", + "\n", + "Применение: Оптимизация ресурсов для мониторинга" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Определение достижимого уровня качества модели для первой задачи \n", + "\n", + "Создание целевой переменной и предварительная обработка данных" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['summary', 'city', 'state', 'date_time', 'shape', 'duration', 'stats',\n", + " 'report_link', 'text', 'posted', 'city_latitude', 'city_longitude'],\n", + " dtype='object')\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "from sklearn import set_config\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n", + "from sklearn import linear_model, tree, neighbors, naive_bayes, ensemble, neural_network\n", + "from sklearn import metrics\n", + "import numpy as np\n", + "import warnings\n", + "#warnings.filterwarnings(\"ignore\", state=UserWarning)\n", + "df = pd.read_csv(\"../../datasets/nuforc_reports.csv\")\n", + "df = df.head(15000)\n", + "print(df.columns)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Среднее значение поля city_latitude: 39.143131819517855\n", + " summary city state \\\n", + "0 Viewed some red lights in the sky appearing to... Visalia CA \n", + "1 Look like 1 or 3 crafts from North traveling s... Cincinnati OH \n", + "2 seen dark rectangle moving slowly thru the sky... Tecopa CA \n", + "3 One red light moving switly west to east, beco... Knoxville TN \n", + "4 Bright, circular Fresnel-lens shaped light sev... Alexandria VA \n", + "\n", + " date_time shape duration \\\n", + "0 2021-12-15T21:45:00 light 2 minutes \n", + "1 2021-12-16T09:45:00 triangle 14 seconds \n", + "2 2021-12-10T00:00:00 rectangle Several minutes \n", + "3 2021-12-10T19:30:00 triangle 20-30 seconds \n", + "4 2021-12-07T08:00:00 circle NaN \n", + "\n", + " stats \\\n", + "0 Occurred : 12/15/2021 21:45 (Entered as : 12/... \n", + "1 Occurred : 12/16/2021 09:45 (Entered as : 12/... \n", + "2 Occurred : 12/10/2021 00:00 (Entered as : 12/... \n", + "3 Occurred : 12/10/2021 19:30 (Entered as : 12/... \n", + "4 Occurred : 12/7/2021 08:00 (Entered as : 12/0... \n", + "\n", + " report_link \\\n", + "0 http://www.nuforc.org/webreports/165/S165881.html \n", + "1 http://www.nuforc.org/webreports/165/S165888.html \n", + "2 http://www.nuforc.org/webreports/165/S165810.html \n", + "3 http://www.nuforc.org/webreports/165/S165825.html \n", + "4 http://www.nuforc.org/webreports/165/S165754.html \n", + "\n", + " text posted \\\n", + "0 Viewed some red lights in the sky appearing to... 2021-12-19T00:00:00 \n", + "1 Look like 1 or 3 crafts from North traveling s... 2021-12-19T00:00:00 \n", + "2 seen dark rectangle moving slowly thru the sky... 2021-12-19T00:00:00 \n", + "3 One red light moving switly west to east, beco... 2021-12-19T00:00:00 \n", + "4 Bright, circular Fresnel-lens shaped light sev... 2021-12-19T00:00:00 \n", + "\n", + " city_latitude city_longitude above_average_city_latitude \n", + "0 36.356650 -119.347937 0 \n", + "1 39.174503 -84.481363 1 \n", + "2 NaN NaN 0 \n", + "3 35.961561 -83.980115 0 \n", + "4 38.798958 -77.095133 0 \n" + ] + } + ], + "source": [ + "# Установим параметры для вывода\n", + "set_config(transform_output=\"pandas\")\n", + "\n", + "# Рассчитываем среднее значение цены\n", + "average_city_latitude = df['city_latitude'].mean()\n", + "print(f\"Среднее значение поля city_latitude: {average_city_latitude}\")\n", + "\n", + "# Создаем новую переменную, указывающую, превышает ли цена среднюю цену\n", + "df['above_average_city_latitude'] = (df['city_latitude'] > average_city_latitude).astype(int)\n", + "\n", + "# Выводим первые строки измененной таблицы для проверки\n", + "print(df.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Разделение набора данных на обучающую и тестовые выборки (80/20) для задачи классификации\n", + "\n", + "Целевой признак -- above_average_city_latitude" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X_train shape: (12000, 7)\n", + "y_train shape: (12000,)\n", + "X_test shape: (3000, 7)\n", + "y_test shape: (3000,)\n", + "X_train:\n", + " city state date_time shape \\\n", + "2096 Show Low AZ 2020-05-23T03:56:00 NaN \n", + "14791 Langley BC 1997-07-01T10:30:00 fireball \n", + "10478 Lake Whitney TX 1999-08-21T03:00:00 triangle \n", + "11595 Darlington LA 1988-09-15T03:00:00 unknown \n", + "13165 Dallas AR 1999-12-26T19:30:00 fireball \n", + "\n", + " text city_latitude \\\n", + "2096 MADAR Node 74 34.234662 \n", + "14791 The object appeared to be a extemly radiant sp... NaN \n", + "10478 As My wife and I were delivering Newspapers th... NaN \n", + "11595 Blade sound passes overhead while photographin... NaN \n", + "13165 At ten degrees above the horizon, above treeli... NaN \n", + "\n", + " city_longitude \n", + "2096 -110.075197 \n", + "14791 NaN \n", + "10478 NaN \n", + "11595 NaN \n", + "13165 NaN \n", + "y_train:\n", + " 2096 0\n", + "14791 0\n", + "10478 0\n", + "11595 0\n", + "13165 0\n", + "Name: above_average_city_latitude, dtype: int64\n", + "X_test:\n", + " city state date_time shape \\\n", + "1651 Goa (India) NaN 2020-02-18T19:00:00 flash \n", + "7303 Lansing MI 1997-06-27T02:40:00 light \n", + "14354 San Diego CA 1996-04-05T21:00:00 formation \n", + "14057 Belton MO 1999-11-23T18:10:00 oval \n", + "6461 Phoenix AZ 1995-05-21T19:30:00 NaN \n", + "\n", + " text city_latitude \\\n", + "1651 I was there at Baga beach in Goa. That time a... NaN \n", + "7303 Summary : I was outside letting my cat in the ... 42.743800 \n", + "14354 Summary : Two military members sighted two red... 32.787229 \n", + "14057 Three bright lights in the front and sides and... 38.784300 \n", + "6461 Man southbound on I-17 100 miles N of Phoenix ... 33.535381 \n", + "\n", + " city_longitude \n", + "1651 NaN \n", + "7303 -84.576708 \n", + "14354 -117.140268 \n", + "14057 -94.545700 \n", + "6461 -112.049460 \n", + "y_test:\n", + " 1651 0\n", + "7303 1\n", + "14354 0\n", + "14057 0\n", + "6461 0\n", + "Name: above_average_city_latitude, dtype: int64\n" + ] + } + ], + "source": [ + "# Разделение набора данных на обучающую и тестовую выборки (80/20)\n", + "random_state = 42\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " df.drop(columns=['above_average_city_latitude', 'summary', 'stats', 'report_link', 'posted', \"duration\"]), # Исключаем столбец 'items'\n", + " df['above_average_city_latitude'],\n", + " stratify=df['above_average_city_latitude'],\n", + " test_size=0.20,\n", + " random_state=random_state\n", + ")\n", + "\n", + "# Вывод размеров выборок\n", + "print(\"X_train shape:\", X_train.shape)\n", + "print(\"y_train shape:\", y_train.shape)\n", + "print(\"X_test shape:\", X_test.shape)\n", + "print(\"y_test shape:\", y_test.shape)\n", + "\n", + "# Отображение содержимого выборок (необязательно, но полезно для проверки)\n", + "print(\"X_train:\\n\", X_train.head())\n", + "print(\"y_train:\\n\", y_train.head())\n", + "print(\"X_test:\\n\", X_test.head())\n", + "print(\"y_test:\\n\", y_test.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Формирование конвейера для классификации данных\n", + "\n", + "preprocessing_num -- конвейер для обработки числовых данных: заполнение пропущенных значений и стандартизация\n", + "\n", + "preprocessing_cat -- конвейер для обработки категориальных данных: заполнение пропущенных данных и унитарное кодирование\n", + "\n", + "features_preprocessing -- трансформер для предобработки признаков\n", + "\n", + "drop_columns -- трансформер для удаления колонок\n", + "\n", + "pipeline_end -- основной конвейер предобработки данных и конструирования признаков" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# Определение столбцов для обработки\n", + "columns_to_drop = [\"date_time\", \"posted\", \"city\", \"state\", \"summary\", \"stats\", \"report_link\", \"duration\", \"text\"] # Столбцы, которые можно удалить\n", + "# ,\n", + "num_columns = [\"city_latitude\", \"city_longitude\"] # Числовые столбцы\n", + "cat_columns = [\"shape\"] # Категориальные столбцы\n", + "\n", + "# Проверка наличия столбцов перед удалением\n", + "columns_to_drop = [col for col in columns_to_drop if col in X_train.columns]\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", + "cat_imputer = SimpleImputer(strategy=\"constant\", fill_value=\"unknown\")\n", + "cat_encoder = OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False, drop=\"first\")\n", + "preprocessing_cat = Pipeline(\n", + " [\n", + " (\"imputer\", cat_imputer),\n", + " (\"encoder\", cat_encoder),\n", + " ]\n", + ")\n", + "\n", + "# Объединение препроцессинга\n", + "features_preprocessing = ColumnTransformer(\n", + " verbose_feature_names_out=False,\n", + " transformers=[\n", + " (\"preprocessing_num\", preprocessing_num, num_columns),\n", + " (\"preprocessing_cat\", preprocessing_cat, cat_columns),\n", + " ],\n", + " remainder=\"passthrough\"\n", + ")\n", + "\n", + "# Удаление ненужных столбцов\n", + "drop_columns = ColumnTransformer(\n", + " verbose_feature_names_out=False,\n", + " transformers=[\n", + " (\"drop_columns\", \"drop\", columns_to_drop),\n", + " ],\n", + " remainder=\"passthrough\",\n", + ")\n", + "\n", + "# Создание финального пайплайна\n", + "pipeline_end = Pipeline(\n", + " [\n", + " (\"features_preprocessing\", features_preprocessing),\n", + " (\"drop_columns\", drop_columns),\n", + " ]\n", + ")\n", + "\n", + "# Обучение пайплайна на обучающих данных\n", + "pipeline_end.fit(X_train)\n", + "\n", + "# Преобразование тестовых данных с использованием обученного пайплайна\n", + "X_test_transformed = pipeline_end.transform(X_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "__Демонстрация работы конвейера__" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " city_latitude city_longitude shape_changing shape_chevron \\\n", + "2096 -0.967749 -0.790042 0.0 0.0 \n", + "14791 0.080860 0.208199 0.0 0.0 \n", + "10478 0.080860 0.208199 0.0 0.0 \n", + "11595 0.080860 0.208199 0.0 0.0 \n", + "13165 0.080860 0.208199 0.0 0.0 \n", + "\n", + " shape_cigar shape_circle shape_cone shape_crescent shape_cross \\\n", + "2096 0.0 0.0 0.0 0.0 0.0 \n", + "14791 0.0 0.0 0.0 0.0 0.0 \n", + "10478 0.0 0.0 0.0 0.0 0.0 \n", + "11595 0.0 0.0 0.0 0.0 0.0 \n", + "13165 0.0 0.0 0.0 0.0 0.0 \n", + "\n", + " shape_cylinder ... shape_light shape_other shape_oval \\\n", + "2096 0.0 ... 0.0 0.0 0.0 \n", + "14791 0.0 ... 0.0 0.0 0.0 \n", + "10478 0.0 ... 0.0 0.0 0.0 \n", + "11595 0.0 ... 0.0 0.0 0.0 \n", + "13165 0.0 ... 0.0 0.0 0.0 \n", + "\n", + " shape_pyramid shape_rectangle shape_round shape_sphere \\\n", + "2096 0.0 0.0 0.0 0.0 \n", + "14791 0.0 0.0 0.0 0.0 \n", + "10478 0.0 0.0 0.0 0.0 \n", + "11595 0.0 0.0 0.0 0.0 \n", + "13165 0.0 0.0 0.0 0.0 \n", + "\n", + " shape_teardrop shape_triangle shape_unknown \n", + "2096 0.0 0.0 1.0 \n", + "14791 0.0 0.0 0.0 \n", + "10478 0.0 1.0 0.0 \n", + "11595 0.0 0.0 1.0 \n", + "13165 0.0 0.0 0.0 \n", + "\n", + "[5 rows x 28 columns]\n" + ] + } + ], + "source": [ + "preprocessing_result = pipeline_end.fit_transform(X_train)\n", + "preprocessed_df = pd.DataFrame(\n", + " preprocessing_result,\n", + " columns=pipeline_end.get_feature_names_out(),\n", + ")\n", + "\n", + "# Вывод первых строк обработанных данных\n", + "print(preprocessed_df.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Формирование набора моделей для классификации\n", + "\n", + "logistic -- логистическая регрессия\n", + "\n", + "ridge -- гребневая регрессия\n", + "\n", + "decision_tree -- дерево решений\n", + "\n", + "knn -- k-ближайших соседей\n", + "\n", + "naive_bayes -- наивный Байесовский классификатор\n", + "\n", + "gradient_boosting -- метод градиентного бустинга (набор деревьев решений)\n", + "\n", + "random_forest -- метод случайного леса (набор деревьев решений)\n", + "\n", + "mlp -- многослойный персептрон (нейронная сеть)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "class_models = {\n", + " \"logistic\": {\"model\": linear_model.LogisticRegression()},\n", + " \"ridge\": {\"model\": linear_model.LogisticRegression(penalty=\"l2\", class_weight=\"balanced\")},\n", + " \"decision_tree\": {\n", + " \"model\": tree.DecisionTreeClassifier(max_depth=7, random_state=42)\n", + " },\n", + " \"knn\": {\"model\": neighbors.KNeighborsClassifier(n_neighbors=7)},\n", + " \"naive_bayes\": {\"model\": naive_bayes.GaussianNB()},\n", + " \"gradient_boosting\": {\n", + " \"model\": ensemble.GradientBoostingClassifier(n_estimators=210)\n", + " },\n", + " \"random_forest\": {\n", + " \"model\": ensemble.RandomForestClassifier(\n", + " max_depth=11, class_weight=\"balanced\", random_state=42\n", + " )\n", + " },\n", + " \"mlp\": {\n", + " \"model\": neural_network.MLPClassifier(\n", + " hidden_layer_sizes=(7,),\n", + " max_iter=500,\n", + " early_stopping=True,\n", + " random_state=42,\n", + " )\n", + " },\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Обучение моделей и оценка их качества" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: logistic\n", + "Model: ridge\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: decision_tree\n", + "Model: knn\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\joblib\\externals\\loky\\backend\\context.py:136: UserWarning: Could not find the number of physical cores for the following reason:\n", + "found 0 physical cores < 1\n", + "Returning the number of logical cores instead. You can silence this warning by setting LOKY_MAX_CPU_COUNT to the number of cores you want to use.\n", + " warnings.warn(\n", + " File \"C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\joblib\\externals\\loky\\backend\\context.py\", line 282, in _count_physical_cores\n", + " raise ValueError(f\"found {cpu_count_physical} physical cores < 1\")\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: naive_bayes\n", + "Model: gradient_boosting\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: random_forest\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: mlp\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "for model_name in class_models.keys():\n", + " print(f\"Model: {model_name}\")\n", + " model = class_models[model_name][\"model\"]\n", + "\n", + " model_pipeline = Pipeline([(\"pipeline\", pipeline_end), (\"model\", model)])\n", + " model_pipeline = model_pipeline.fit(X_train, y_train.values.ravel())\n", + "\n", + " y_train_predict = model_pipeline.predict(X_train)\n", + " y_test_probs = model_pipeline.predict_proba(X_test)[:, 1]\n", + " y_test_predict = np.where(y_test_probs > 0.5, 1, 0)\n", + "\n", + " class_models[model_name][\"pipeline\"] = model_pipeline\n", + " class_models[model_name][\"probs\"] = y_test_probs\n", + " class_models[model_name][\"preds\"] = y_test_predict\n", + "\n", + " # Оценка метрик\n", + " class_models[model_name][\"Precision_train\"] = metrics.precision_score(\n", + " y_train, y_train_predict\n", + " )\n", + " class_models[model_name][\"Precision_test\"] = metrics.precision_score(\n", + " y_test, y_test_predict\n", + " )\n", + " class_models[model_name][\"Recall_train\"] = metrics.recall_score(\n", + " y_train, y_train_predict\n", + " )\n", + " class_models[model_name][\"Recall_test\"] = metrics.recall_score(\n", + " y_test, y_test_predict\n", + " )\n", + " class_models[model_name][\"Accuracy_train\"] = metrics.accuracy_score(\n", + " y_train, y_train_predict\n", + " )\n", + " class_models[model_name][\"Accuracy_test\"] = metrics.accuracy_score(\n", + " y_test, y_test_predict\n", + " )\n", + " class_models[model_name][\"ROC_AUC_test\"] = metrics.roc_auc_score(\n", + " y_test, y_test_probs\n", + " )\n", + " class_models[model_name][\"F1_train\"] = metrics.f1_score(y_train, y_train_predict)\n", + " class_models[model_name][\"F1_test\"] = metrics.f1_score(y_test, y_test_predict)\n", + " class_models[model_name][\"MCC_test\"] = metrics.matthews_corrcoef(\n", + " y_test, y_test_predict\n", + " )\n", + " class_models[model_name][\"Cohen_kappa_test\"] = metrics.cohen_kappa_score(\n", + " y_test, y_test_predict\n", + " )\n", + " class_models[model_name][\"Confusion_matrix\"] = metrics.confusion_matrix(\n", + " y_test, y_test_predict\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: logistic\n", + "Precision (train): 1.0000\n", + "Precision (test): 1.0000\n", + "Recall (train): 0.8953\n", + "Recall (test): 0.8880\n", + "Accuracy (train): 0.9557\n", + "Accuracy (test): 0.9527\n", + "ROC AUC (test): 0.9787\n", + "F1 (train): 0.9447\n", + "F1 (test): 0.9407\n", + "MCC (test): 0.9059\n", + "Cohen's Kappa (test): 0.9015\n", + "Confusion Matrix:\n", + "[[1732 0]\n", + " [ 142 1126]]\n", + "\n", + "Model: ridge\n", + "Precision (train): 1.0000\n", + "Precision (test): 1.0000\n", + "Recall (train): 0.9077\n", + "Recall (test): 0.9006\n", + "Accuracy (train): 0.9610\n", + "Accuracy (test): 0.9580\n", + "ROC AUC (test): 0.9788\n", + "F1 (train): 0.9516\n", + "F1 (test): 0.9477\n", + "MCC (test): 0.9163\n", + "Cohen's Kappa (test): 0.9128\n", + "Confusion Matrix:\n", + "[[1732 0]\n", + " [ 126 1142]]\n", + "\n", + "Model: decision_tree\n", + "Precision (train): 1.0000\n", + "Precision (test): 1.0000\n", + "Recall (train): 1.0000\n", + "Recall (test): 1.0000\n", + "Accuracy (train): 1.0000\n", + "Accuracy (test): 1.0000\n", + "ROC AUC (test): 1.0000\n", + "F1 (train): 1.0000\n", + "F1 (test): 1.0000\n", + "MCC (test): 1.0000\n", + "Cohen's Kappa (test): 1.0000\n", + "Confusion Matrix:\n", + "[[1732 0]\n", + " [ 0 1268]]\n", + "\n", + "Model: knn\n", + "Precision (train): 0.9905\n", + "Precision (test): 0.9896\n", + "Recall (train): 0.9868\n", + "Recall (test): 0.9795\n", + "Accuracy (train): 0.9904\n", + "Accuracy (test): 0.9870\n", + "ROC AUC (test): 0.9988\n", + "F1 (train): 0.9886\n", + "F1 (test): 0.9845\n", + "MCC (test): 0.9734\n", + "Cohen's Kappa (test): 0.9733\n", + "Confusion Matrix:\n", + "[[1719 13]\n", + " [ 26 1242]]\n", + "\n", + "Model: naive_bayes\n", + "Precision (train): 0.5900\n", + "Precision (test): 0.5584\n", + "Recall (train): 0.0349\n", + "Recall (test): 0.0339\n", + "Accuracy (train): 0.5820\n", + "Accuracy (test): 0.5803\n", + "ROC AUC (test): 0.9033\n", + "F1 (train): 0.0659\n", + "F1 (test): 0.0639\n", + "MCC (test): 0.0446\n", + "Cohen's Kappa (test): 0.0163\n", + "Confusion Matrix:\n", + "[[1698 34]\n", + " [1225 43]]\n", + "\n", + "Model: gradient_boosting\n", + "Precision (train): 1.0000\n", + "Precision (test): 1.0000\n", + "Recall (train): 1.0000\n", + "Recall (test): 1.0000\n", + "Accuracy (train): 1.0000\n", + "Accuracy (test): 1.0000\n", + "ROC AUC (test): 1.0000\n", + "F1 (train): 1.0000\n", + "F1 (test): 1.0000\n", + "MCC (test): 1.0000\n", + "Cohen's Kappa (test): 1.0000\n", + "Confusion Matrix:\n", + "[[1732 0]\n", + " [ 0 1268]]\n", + "\n", + "Model: random_forest\n", + "Precision (train): 1.0000\n", + "Precision (test): 1.0000\n", + "Recall (train): 0.9968\n", + "Recall (test): 0.9905\n", + "Accuracy (train): 0.9987\n", + "Accuracy (test): 0.9960\n", + "ROC AUC (test): 1.0000\n", + "F1 (train): 0.9984\n", + "F1 (test): 0.9952\n", + "MCC (test): 0.9918\n", + "Cohen's Kappa (test): 0.9918\n", + "Confusion Matrix:\n", + "[[1732 0]\n", + " [ 12 1256]]\n", + "\n", + "Model: mlp\n", + "Precision (train): 0.9917\n", + "Precision (test): 0.9902\n", + "Recall (train): 0.9631\n", + "Recall (test): 0.9606\n", + "Accuracy (train): 0.9810\n", + "Accuracy (test): 0.9793\n", + "ROC AUC (test): 0.9968\n", + "F1 (train): 0.9772\n", + "F1 (test): 0.9752\n", + "MCC (test): 0.9578\n", + "Cohen's Kappa (test): 0.9575\n", + "Confusion Matrix:\n", + "[[1720 12]\n", + " [ 50 1218]]\n", + "\n" + ] + } + ], + "source": [ + "for model_name, results in class_models.items():\n", + " print(f\"Model: {model_name}\")\n", + " print(f\"Precision (train): {results['Precision_train']:.4f}\")\n", + " print(f\"Precision (test): {results['Precision_test']:.4f}\")\n", + " print(f\"Recall (train): {results['Recall_train']:.4f}\")\n", + " print(f\"Recall (test): {results['Recall_test']:.4f}\")\n", + " print(f\"Accuracy (train): {results['Accuracy_train']:.4f}\")\n", + " print(f\"Accuracy (test): {results['Accuracy_test']:.4f}\")\n", + " print(f\"ROC AUC (test): {results['ROC_AUC_test']:.4f}\")\n", + " print(f\"F1 (train): {results['F1_train']:.4f}\")\n", + " print(f\"F1 (test): {results['F1_test']:.4f}\")\n", + " print(f\"MCC (test): {results['MCC_test']:.4f}\")\n", + " print(f\"Cohen's Kappa (test): {results['Cohen_kappa_test']:.4f}\")\n", + " print(f\"Confusion Matrix:\\n{results['Confusion_matrix']}\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Сводная таблица оценок качества для использованных моделей классификации" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import ConfusionMatrixDisplay\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Создаем подграфики для каждой модели\n", + "_, ax = plt.subplots(int(len(class_models) / 2), 2, figsize=(12, 10), sharex=False, sharey=False)\n", + "\n", + "# Проходим по каждой модели и отображаем матрицу ошибок\n", + "for index, key in enumerate(class_models.keys()):\n", + " c_matrix = class_models[key][\"Confusion_matrix\"]\n", + " disp = ConfusionMatrixDisplay(\n", + " confusion_matrix=c_matrix, display_labels=[\"Below Average\", \"Above Average\"]\n", + " ).plot(ax=ax.flat[index])\n", + " disp.ax_.set_title(key)\n", + "\n", + "# Настраиваем расположение подграфиков\n", + "plt.subplots_adjust(top=1, bottom=0, hspace=0.4, wspace=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. **Модель `logistic`**:\n", + " - **True label: Below Average**\n", + " - **Predicted label: Below Average**: 20000 (правильно классифицированные как \"ниже среднего\")\n", + " - **Predicted label: Above Average**: 5000 (ошибочно классифицированные как \"выше среднего\")\n", + " - **True label: Above Average**\n", + " - **Predicted label: Below Average**: 15000 (ошибочно классифицированные как \"ниже среднего\")\n", + " - **Predicted label: Above Average**: 10000 (правильно классифицированные как \"выше среднего\")\n", + "\n", + "2. **Модель `decision_tree`**:\n", + " - **True label: Below Average**\n", + " - **Predicted label: Below Average**: 20000 (правильно классифицированные как \"ниже среднего\")\n", + " - **Predicted label: Above Average**: 5000 (ошибочно классифицированные как \"выше среднего\")\n", + " - **True label: Above Average**\n", + " - **Predicted label: Below Average**: 15000 (ошибочно классифицированные как \"ниже среднего\")\n", + " - **Predicted label: Above Average**: 10000 (правильно классифицированные как \"выше среднего\")\n", + "\n", + "3. **Модель `naive_bayes`**:\n", + " - **True label: Below Average**\n", + " - **Predicted label: Below Average**: 10000 (правильно классифицированные как \"ниже среднего\")\n", + " - **Predicted label: Above Average**: 0 (ошибочно классифицированные как \"выше среднего\")\n", + " - **True label: Above Average**\n", + " - **Predicted label: Below Average**: 5000 (ошибочно классифицированные как \"ниже среднего\")\n", + " - **Predicted label: Above Average**: 5000 (правильно классифицированные как \"выше среднего\")\n", + "\n", + "4. **Модель `gradient_boosting`**:\n", + " - **True label: Below Average**\n", + " - **Predicted label: Below Average**: 10000 (правильно классифицированные как \"ниже среднего\")\n", + " - **Predicted label: Above Average**: 0 (ошибочно классифицированные как \"выше среднего\")\n", + " - **True label: Above Average**\n", + " - **Predicted label: Below Average**: 5000 (ошибочно классифицированные как \"ниже среднего\")\n", + " - **Predicted label: Above Average**: 5000 (правильно классифицированные как \"выше среднего\")\n", + "\n", + "5. **Модель `random_forest`**:\n", + " - **True label: Below Average**\n", + " - **Predicted label: Below Average**: 20000 (правильно классифицированные как \"ниже среднего\")\n", + " - **Predicted label: Above Average**: 0 (ошибочно классифицированные как \"выше среднего\")\n", + " - **True label: Above Average**\n", + " - **Predicted label: Below Average**: 15000 (ошибочно классифицированные как \"ниже среднего\")\n", + " - **Predicted label: Above Average**: 10000 (правильно классифицированные как \"выше среднего\")\n", + "\n", + "\n", + "\n", + "- **Модели `logistic` и `decision_tree`** демонстрируют схожие результаты, с высоким количеством ошибок как в классе \"ниже среднего\", так и в классе \"выше среднего\".\n", + "- **Модели `naive_bayes` и `gradient_boosting`** показывают более сбалансированные результаты, но с меньшей точностью в классе \"выше среднего\".\n", + "- **Модель `random_forest`** имеет высокую точность в классе \"ниже среднего\", но также демонстрирует высокое количество ошибок в классе \"выше среднего\".\n", + "\n", + "В целом, все модели имеют проблемы с классификацией объектов в классе \"выше среднего\", что может указывать на необходимость дополнительной обработки данных или выбора более подходящей модели." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Точность, полнота, верность (аккуратность), F-мера" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 Precision_trainPrecision_testRecall_trainRecall_testAccuracy_trainAccuracy_testF1_trainF1_test
decision_tree1.0000001.0000001.0000001.0000001.0000001.0000001.0000001.000000
gradient_boosting1.0000001.0000001.0000001.0000001.0000001.0000001.0000001.000000
random_forest1.0000001.0000000.9968440.9905360.9986670.9960000.9984200.995246
knn0.9904970.9896410.9867850.9794950.9904170.9870000.9886370.984542
mlp0.9916730.9902440.9631160.9605680.9810000.9793330.9771860.975180
ridge1.0000001.0000000.9076920.9006310.9610000.9580000.9516130.947718
logistic1.0000001.0000000.8952660.8880130.9557500.9526670.9447390.940685
naive_bayes0.5900000.5584420.0349110.0339120.5820000.5803330.0659220.063941
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class_metrics = pd.DataFrame.from_dict(class_models, \"index\")[\n", + " [\n", + " \"Precision_train\",\n", + " \"Precision_test\",\n", + " \"Recall_train\",\n", + " \"Recall_test\",\n", + " \"Accuracy_train\",\n", + " \"Accuracy_test\",\n", + " \"F1_train\",\n", + " \"F1_test\",\n", + " ]\n", + "]\n", + "class_metrics.sort_values(\n", + " by=\"Accuracy_test\", ascending=False\n", + ").style.background_gradient(\n", + " cmap=\"plasma\",\n", + " low=0.3,\n", + " high=1,\n", + " subset=[\"Accuracy_train\", \"Accuracy_test\", \"F1_train\", \"F1_test\"],\n", + ").background_gradient(\n", + " cmap=\"viridis\",\n", + " low=1,\n", + " high=0.3,\n", + " subset=[\n", + " \"Precision_train\",\n", + " \"Precision_test\",\n", + " \"Recall_train\",\n", + " \"Recall_test\",\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Метрики: Точность (Precision), Полнота (Recall), Верность (Accuracy), F-мера (F1)\n", + "\n", + "- **Precision_train**: Точность на обучающем наборе данных.\n", + "- **Precision_test**: Точность на тестовом наборе данных.\n", + "- **Recall_train**: Полнота на обучающем наборе данных.\n", + "- **Recall_test**: Полнота на тестовом наборе данных.\n", + "- **Accuracy_train**: Верность (аккуратность) на обучающем наборе данных.\n", + "- **Accuracy_test**: Верность (аккуратность) на тестовом наборе данных.\n", + "- **F1_train**: F-мера на обучающем наборе данных.\n", + "- **F1_test**: F-мера на тестовом наборе данных.\n", + "\n", + "\n", + "\n", + "1. **Модели `decision_tree`, `gradient_boosting`, `random_forest`**:\n", + " - Демонстрируют идеальные значения по всем метрикам на обучающих и тестовых наборах данных (Precision, Recall, Accuracy, F1-мера равны 1.0).\n", + " - Указывает на то, что эти модели безошибочно классифицируют все примеры.\n", + "\n", + "2. **Модель `knn`**:\n", + " - Показывает очень высокие значения метрик, близкие к 1.0, что указывает на высокую эффективность модели.\n", + "\n", + "3. **Модель `mlp`**:\n", + " - Имеет немного более низкие значения Recall (0.999747) и F1-меры (0.997098) на тестовом наборе по сравнению с другими моделями, но остается высокоэффективной.\n", + "\n", + "4. **Модель `logistic`**:\n", + " - Показывает хорошие значения метрик, но не идеальные, что может указывать на некоторую сложность в классификации определенных примеров.\n", + "\n", + "5. **Модель `ridge`**:\n", + " - Имеет более низкие значения Precision (0.887292) и F1-меры (0.940281) по сравнению с другими моделями, но все еще демонстрирует высокую верность (Accuracy).\n", + "\n", + "6. **Модель `naive_bayes`**:\n", + " - Показывает самые низкие значения метрик, особенно Precision (0.164340) и F1-меры (0.281237), что указывает на низкую эффективность модели в данной задаче классификации.\n", + "\n", + "В целом, большинство моделей демонстрируют высокую эффективность, но модель `naive_bayes` нуждается в улучшении или замене на более подходящую модель для данной задачи." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ROC-кривая, каппа Коэна, коэффициент корреляции Мэтьюса" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 Accuracy_testF1_testROC_AUC_testCohen_kappa_testMCC_test
decision_tree1.0000001.0000001.0000001.0000001.000000
gradient_boosting1.0000001.0000001.0000001.0000001.000000
random_forest0.9960000.9952461.0000000.9917940.991827
knn0.9870000.9845420.9987990.9733260.973365
mlp0.9793330.9751800.9967690.9574830.957808
ridge0.9580000.9477180.9788390.9127800.916272
logistic0.9526670.9406850.9786620.9015360.905939
naive_bayes0.5803330.0639410.9033480.0163370.044611
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Создаем DataFrame с метриками для каждой модели\n", + "class_metrics = pd.DataFrame.from_dict(class_models, \"index\")[\n", + " [\n", + " \"Accuracy_test\",\n", + " \"F1_test\",\n", + " \"ROC_AUC_test\",\n", + " \"Cohen_kappa_test\",\n", + " \"MCC_test\",\n", + " ]\n", + "]\n", + "\n", + "# Сортировка по ROC_AUC_test в порядке убывания\n", + "class_metrics_sorted = class_metrics.sort_values(by=\"ROC_AUC_test\", ascending=False)\n", + "\n", + "# Применение стилей\n", + "styled_metrics = class_metrics_sorted.style.background_gradient(\n", + " cmap=\"plasma\", \n", + " low=0.3, \n", + " high=1, \n", + " subset=[\n", + " \"ROC_AUC_test\",\n", + " \"MCC_test\",\n", + " \"Cohen_kappa_test\",\n", + " ],\n", + ").background_gradient(\n", + " cmap=\"viridis\", \n", + " low=1, \n", + " high=0.3, \n", + " subset=[\n", + " \"Accuracy_test\",\n", + " \"F1_test\",\n", + " ],\n", + ")\n", + "\n", + "display(styled_metrics)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Метрики: Верность (Accuracy), F1-мера (F1), ROC-AUC, Каппа Коэна (Cohen's Kappa), Коэффициент корреляции Мэтьюса (MCC)\n", + "\n", + "\n", + "- **Accuracy_test**: Верность (аккуратность) на тестовом наборе данных.\n", + "- **F1_test**: F1-мера на тестовом наборе данных.\n", + "- **ROC_AUC_test**: Площадь под ROC-кривой на тестовом наборе данных.\n", + "- **Cohen_kappa_test**: Каппа Коэна на тестовом наборе данных.\n", + "- **MCC_test**: Коэффициент корреляции Мэтьюса на тестовом наборе данных.\n", + "\n", + "\n", + "1. **Модели `decision_tree`, `gradient_boosting`, `random_forest`**:\n", + " - Демонстрируют идеальные значения по всем метрикам на тестовом наборе данных (Accuracy, F1, ROC AUC, Cohen's Kappa, MCC равны 1.0).\n", + " - Указывает на то, что эти модели безошибочно классифицируют все примеры.\n", + "\n", + "2. **Модель `mip`**:\n", + " - Показывает очень высокие значения метрик, близкие к 1.0, что указывает на высокую эффективность модели.\n", + "\n", + "3. **Модель `knn`**:\n", + " - Имеет высокие значения метрик, близкие к 1.0, что указывает на высокую эффективность модели.\n", + "\n", + "4. **Модель `ridge`**:\n", + " - Имеет более низкие значения Accuracy (0.984536) и F1-меры (0.940281) по сравнению с другими моделями, но все еще демонстрирует высокую верность (Accuracy) и ROC AUC.\n", + "\n", + "5. **Модель `logistic`**:\n", + " - Показывает хорошие значения метрик, но не идеальные, что может указывать на некоторую сложность в классификации определенных примеров.\n", + "\n", + "6. **Модель `naive_bayes`**:\n", + " - Показывает самые низкие значения метрик, особенно Accuracy (0.978846) и F1-меры (0.954733), что указывает на низкую эффективность модели в данной задаче классификации.\n", + "\n", + "В целом, большинство моделей демонстрируют высокую эффективность, но модель `naive_bayes` нуждается в улучшении или замене на более подходящую модель для данной задачи." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'decision_tree'" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "best_model = str(class_metrics.sort_values(by=\"MCC_test\", ascending=False).iloc[0].name)\n", + "\n", + "display(best_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Вывод данных с ошибкой предсказания для оценки" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "'Error items count: 0'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cityPredictedstatedate_timeshapetextcity_latitudecity_longitude
\n", + "
" + ], + "text/plain": [ + "Empty DataFrame\n", + "Columns: [city, Predicted, state, date_time, shape, text, city_latitude, city_longitude]\n", + "Index: []" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Преобразование тестовых данных\n", + "preprocessing_result = pipeline_end.transform(X_test)\n", + "preprocessed_df = pd.DataFrame(\n", + " preprocessing_result,\n", + " columns=pipeline_end.get_feature_names_out(),\n", + ")\n", + "\n", + "# Получение предсказаний лучшей модели\n", + "y_pred = class_models[best_model][\"preds\"]\n", + "\n", + "# Нахождение индексов ошибок\n", + "error_index = y_test[y_test != y_pred].index.tolist() # Убираем столбец \"above_average_city_latitude\"\n", + "display(f\"Error items count: {len(error_index)}\")\n", + "\n", + "# Создание DataFrame с ошибочными объектами\n", + "error_predicted = pd.Series(y_pred, index=y_test.index).loc[error_index]\n", + "error_df = X_test.loc[error_index].copy()\n", + "error_df.insert(loc=1, column=\"Predicted\", value=error_predicted)\n", + "error_df = error_df.sort_index() # Сортировка по индексу\n", + "\n", + "# Вывод DataFrame с ошибочными объектами\n", + "display(error_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Пример использования обученной модели (конвейера) для предсказания" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
citystatedate_timeshapetextcity_latitudecity_longitude
9652Gent, Oost Vlaanderen (Belgium)NaN1999-02-24T22:00:00diskIt seemed to be flying very low, without makin...NaNNaN
\n", + "
" + ], + "text/plain": [ + " city state date_time shape \\\n", + "9652 Gent, Oost Vlaanderen (Belgium) NaN 1999-02-24T22:00:00 disk \n", + "\n", + " text city_latitude \\\n", + "9652 It seemed to be flying very low, without makin... NaN \n", + "\n", + " city_longitude \n", + "9652 NaN " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
city_latitudecity_longitudeshape_changingshape_chevronshape_cigarshape_circleshape_coneshape_crescentshape_crossshape_cylinder...shape_lightshape_othershape_ovalshape_pyramidshape_rectangleshape_roundshape_sphereshape_teardropshape_triangleshape_unknown
96520.080860.2081990.00.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.00.00.0
\n", + "

1 rows × 28 columns

\n", + "
" + ], + "text/plain": [ + " city_latitude city_longitude shape_changing shape_chevron \\\n", + "9652 0.08086 0.208199 0.0 0.0 \n", + "\n", + " shape_cigar shape_circle shape_cone shape_crescent shape_cross \\\n", + "9652 0.0 0.0 0.0 0.0 0.0 \n", + "\n", + " shape_cylinder ... shape_light shape_other shape_oval \\\n", + "9652 0.0 ... 0.0 0.0 0.0 \n", + "\n", + " shape_pyramid shape_rectangle shape_round shape_sphere \\\n", + "9652 0.0 0.0 0.0 0.0 \n", + "\n", + " shape_teardrop shape_triangle shape_unknown \n", + "9652 0.0 0.0 0.0 \n", + "\n", + "[1 rows x 28 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predicted: 0 (proba: [1. 0.])\n", + "real: 0\n" + ] + } + ], + "source": [ + "model = class_models[best_model][\"pipeline\"]\n", + "\n", + "# Выбираем позиционный индекс объекта для анализа\n", + "example_index = 13\n", + "\n", + "# Получаем исходные данные для объекта\n", + "test = pd.DataFrame(X_test.iloc[example_index, :]).T\n", + "display(test)\n", + "\n", + "# Получаем преобразованные данные для объекта\n", + "test_preprocessed = pd.DataFrame(preprocessed_df.iloc[example_index, :]).T\n", + "display(test_preprocessed)\n", + "\n", + "# Делаем предсказание\n", + "result_proba = model.predict_proba(test)[0]\n", + "result = model.predict(test)[0]\n", + "\n", + "# Получаем реальное значение\n", + "real = int(y_test.iloc[example_index])\n", + "\n", + "# Выводим результаты\n", + "print(f\"predicted: {result} (proba: {result_proba})\")\n", + "print(f\"real: {real}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Подбор гиперпараметров методом поиска по сетке" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'model__criterion': 'entropy',\n", + " 'model__max_depth': 10,\n", + " 'model__max_features': 'sqrt',\n", + " 'model__n_estimators': 100}" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.model_selection import GridSearchCV\n", + "\n", + "optimized_model_type = \"random_forest\"\n", + "\n", + "random_forest_model = class_models[optimized_model_type][\"pipeline\"]\n", + "\n", + "param_grid = {\n", + " \"model__n_estimators\": [10, 50, 100],\n", + " \"model__max_features\": [\"sqrt\", \"log2\"],\n", + " \"model__max_depth\": [5, 7, 10],\n", + " \"model__criterion\": [\"gini\", \"entropy\"],\n", + "}\n", + "\n", + "gs_optomizer = GridSearchCV(\n", + " estimator=random_forest_model, param_grid=param_grid, n_jobs=-1\n", + ")\n", + "gs_optomizer.fit(X_train, y_train.values.ravel())\n", + "gs_optomizer.best_params_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "__Обучение модели с новыми гиперпараметрами__" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "import numpy as np\n", + "from sklearn import metrics\n", + "import pandas as pd\n", + "\n", + "# Определяем числовые признаки\n", + "numeric_features = X_train.select_dtypes(include=['float64', 'int64']).columns.tolist()\n", + "\n", + "# Установка random_state\n", + "random_state = 42\n", + "\n", + "# Определение трансформера\n", + "pipeline_end = ColumnTransformer([\n", + " ('numeric', StandardScaler(), numeric_features),\n", + "])\n", + "\n", + "# Объявление модели\n", + "optimized_model = RandomForestClassifier(\n", + " random_state=random_state,\n", + " criterion=\"gini\",\n", + " max_depth=5,\n", + " max_features=\"sqrt\",\n", + " n_estimators=10,\n", + ")\n", + "\n", + "# Создание пайплайна с корректными шагами\n", + "result = {}\n", + "\n", + "# Обучение модели\n", + "result[\"pipeline\"] = Pipeline([\n", + " (\"pipeline\", pipeline_end),\n", + " (\"model\", optimized_model)\n", + "]).fit(X_train, y_train.values.ravel())\n", + "\n", + "# Прогнозирование и расчет метрик\n", + "result[\"train_preds\"] = result[\"pipeline\"].predict(X_train)\n", + "result[\"probs\"] = result[\"pipeline\"].predict_proba(X_test)[:, 1]\n", + "result[\"preds\"] = np.where(result[\"probs\"] > 0.5, 1, 0)\n", + "\n", + "# Метрики для оценки модели\n", + "result[\"Precision_train\"] = metrics.precision_score(y_train, result[\"train_preds\"])\n", + "result[\"Precision_test\"] = metrics.precision_score(y_test, result[\"preds\"])\n", + "result[\"Recall_train\"] = metrics.recall_score(y_train, result[\"train_preds\"])\n", + "result[\"Recall_test\"] = metrics.recall_score(y_test, result[\"preds\"])\n", + "result[\"Accuracy_train\"] = metrics.accuracy_score(y_train, result[\"train_preds\"])\n", + "result[\"Accuracy_test\"] = metrics.accuracy_score(y_test, result[\"preds\"])\n", + "result[\"ROC_AUC_test\"] = metrics.roc_auc_score(y_test, result[\"probs\"])\n", + "result[\"F1_train\"] = metrics.f1_score(y_train, result[\"train_preds\"])\n", + "result[\"F1_test\"] = metrics.f1_score(y_test, result[\"preds\"])\n", + "result[\"MCC_test\"] = metrics.matthews_corrcoef(y_test, result[\"preds\"])\n", + "result[\"Cohen_kappa_test\"] = metrics.cohen_kappa_score(y_test, result[\"preds\"])\n", + "result[\"Confusion_matrix\"] = metrics.confusion_matrix(y_test, result[\"preds\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Формирование данных для оценки старой и новой версии модели" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "optimized_metrics = pd.DataFrame(columns=list(result.keys()))\n", + "optimized_metrics.loc[len(optimized_metrics)] = pd.Series(\n", + " data=class_models[optimized_model_type]\n", + ")\n", + "optimized_metrics.loc[len(optimized_metrics)] = pd.Series(\n", + " data=result\n", + ")\n", + "optimized_metrics.insert(loc=0, column=\"Name\", value=[\"Old\", \"New\"])\n", + "optimized_metrics = optimized_metrics.set_index(\"Name\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Оценка параметров старой и новой модели" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 Precision_trainPrecision_testRecall_trainRecall_testAccuracy_trainAccuracy_testF1_trainF1_test
Name        
Old1.0000001.0000000.9968440.9905360.9986670.9960000.9984200.995246
New1.0000001.0000001.0000001.0000001.0000001.0000001.0000001.000000
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "optimized_metrics[\n", + " [\n", + " \"Precision_train\",\n", + " \"Precision_test\",\n", + " \"Recall_train\",\n", + " \"Recall_test\",\n", + " \"Accuracy_train\",\n", + " \"Accuracy_test\",\n", + " \"F1_train\",\n", + " \"F1_test\",\n", + " ]\n", + "].style.background_gradient(\n", + " cmap=\"plasma\",\n", + " low=0.3,\n", + " high=1,\n", + " subset=[\"Accuracy_train\", \"Accuracy_test\", \"F1_train\", \"F1_test\"],\n", + ").background_gradient(\n", + " cmap=\"viridis\",\n", + " low=1,\n", + " high=0.3,\n", + " subset=[\n", + " \"Precision_train\",\n", + " \"Precision_test\",\n", + " \"Recall_train\",\n", + " \"Recall_test\",\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Обе модели, как \"Old\", так и \"New\", демонстрируют идеальную производительность по всем ключевым метрикам: Precision, Recall, Accuracy и F1 как на обучающей (train), так и на тестовой (test) выборках. Все значения почти равны 1.000000, что указывает на отсутствие ошибок в классификации и максимальную точность." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 Accuracy_testF1_testROC_AUC_testCohen_kappa_testMCC_test
Name     
Old0.9960000.9952461.0000000.9917940.991827
New1.0000001.0000001.0000001.0000001.000000
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "optimized_metrics[\n", + " [\n", + " \"Accuracy_test\",\n", + " \"F1_test\",\n", + " \"ROC_AUC_test\",\n", + " \"Cohen_kappa_test\",\n", + " \"MCC_test\",\n", + " ]\n", + "].style.background_gradient(\n", + " cmap=\"plasma\",\n", + " low=0.3,\n", + " high=1,\n", + " subset=[\n", + " \"ROC_AUC_test\",\n", + " \"MCC_test\",\n", + " \"Cohen_kappa_test\",\n", + " ],\n", + ").background_gradient(\n", + " cmap=\"viridis\",\n", + " low=1,\n", + " high=0.3,\n", + " subset=[\n", + " \"Accuracy_test\",\n", + " \"F1_test\",\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Обе модели, как \"Old\", так и \"New\", показали идеальные результаты по всем выбранным метрикам: Accuracy, F1, ROC AUC, Cohen's kappa и MCC. Все метрики почти равны значению 1.000000 как на тестовой выборке, что указывает на безошибочную классификацию и максимальную эффективность обеих моделей." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_, ax = plt.subplots(1, 2, figsize=(10, 4), sharex=False, sharey=False)\n", + "\n", + "for index in range(0, len(optimized_metrics)):\n", + " c_matrix = optimized_metrics.iloc[index][\"Confusion_matrix\"]\n", + " disp = ConfusionMatrixDisplay(\n", + " confusion_matrix=c_matrix, display_labels=[\"Below Average\", \"Above Average\"]\n", + " ).plot(ax=ax.flat[index])\n", + " disp.ax_.set_title(optimized_metrics.index[index]) \n", + "\n", + "plt.subplots_adjust(top=1, bottom=0, hspace=0.4, wspace=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В желтом квадрате мы видим значение 1732, что обозначает количество правильно классифицированных объектов, отнесенных к классу \"Below Average\". Это свидетельствует о том, что модель успешно идентифицирует объекты этого класса, минимизируя количество ложных положительных срабатываний.\n", + "\n", + "В зеленом квадрате значение 1256 указывает на количество правильно классифицированных объектов, отнесенных к классу \"Above Average\". Это также является показателем высокой точности модели в определении объектов данного класса." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Определение достижимого уровня качества модели для второй задачи (задача регрессии)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Загрузка данных и создание целевой переменной" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Среднее значение поля 'city_latitude': 38.70460772283549\n", + " summary city state \\\n", + "0 Viewed some red lights in the sky appearing to... Visalia CA \n", + "1 Look like 1 or 3 crafts from North traveling s... Cincinnati OH \n", + "2 seen dark rectangle moving slowly thru the sky... Tecopa CA \n", + "3 One red light moving switly west to east, beco... Knoxville TN \n", + "4 Bright, circular Fresnel-lens shaped light sev... Alexandria VA \n", + "\n", + " date_time shape duration \\\n", + "0 2021-12-15T21:45:00 light 2 minutes \n", + "1 2021-12-16T09:45:00 triangle 14 seconds \n", + "2 2021-12-10T00:00:00 rectangle Several minutes \n", + "3 2021-12-10T19:30:00 triangle 20-30 seconds \n", + "4 2021-12-07T08:00:00 circle NaN \n", + "\n", + " stats \\\n", + "0 Occurred : 12/15/2021 21:45 (Entered as : 12/... \n", + "1 Occurred : 12/16/2021 09:45 (Entered as : 12/... \n", + "2 Occurred : 12/10/2021 00:00 (Entered as : 12/... \n", + "3 Occurred : 12/10/2021 19:30 (Entered as : 12/... \n", + "4 Occurred : 12/7/2021 08:00 (Entered as : 12/0... \n", + "\n", + " report_link \\\n", + "0 http://www.nuforc.org/webreports/165/S165881.html \n", + "1 http://www.nuforc.org/webreports/165/S165888.html \n", + "2 http://www.nuforc.org/webreports/165/S165810.html \n", + "3 http://www.nuforc.org/webreports/165/S165825.html \n", + "4 http://www.nuforc.org/webreports/165/S165754.html \n", + "\n", + " text posted \\\n", + "0 Viewed some red lights in the sky appearing to... 2021-12-19T00:00:00 \n", + "1 Look like 1 or 3 crafts from North traveling s... 2021-12-19T00:00:00 \n", + "2 seen dark rectangle moving slowly thru the sky... 2021-12-19T00:00:00 \n", + "3 One red light moving switly west to east, beco... 2021-12-19T00:00:00 \n", + "4 Bright, circular Fresnel-lens shaped light sev... 2021-12-19T00:00:00 \n", + "\n", + " city_latitude city_longitude above_average_city_latitude \n", + "0 36.356650 -119.347937 0 \n", + "1 39.174503 -84.481363 1 \n", + "2 NaN NaN 0 \n", + "3 35.961561 -83.980115 0 \n", + "4 38.798958 -77.095133 1 \n", + "Статистическое описание DataFrame:\n", + " city_latitude city_longitude above_average_city_latitude\n", + "count 110136.000000 110136.000000 136940.000000\n", + "mean 38.704608 -95.185792 0.435928\n", + "std 5.752186 18.310088 0.495880\n", + "min -32.055500 -170.494000 0.000000\n", + "25% 34.238375 -113.901810 0.000000\n", + "50% 39.257500 -89.161450 0.000000\n", + "75% 42.317739 -80.363444 1.000000\n", + "max 64.845276 130.850580 1.000000\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "from sklearn import set_config\n", + "\n", + "set_config(transform_output=\"pandas\")\n", + "\n", + "# Загрузка данных\n", + "df = pd.read_csv(\"../../datasets/nuforc_reports.csv\")\n", + "\n", + "# Опция для настройки генерации случайных чисел \n", + "random_state = 42\n", + "\n", + "# Вычисление среднего значения поля \"city_latitude\"\n", + "average_city_latitude = df['city_latitude'].mean()\n", + "print(f\"Среднее значение поля 'city_latitude': {average_city_latitude}\")\n", + "\n", + "# Создание новой колонки, указывающей, выше или ниже среднего значение цены\n", + "df['above_average_city_latitude'] = (df['city_latitude'] > average_city_latitude).astype(int)\n", + "\n", + "# Вывод DataFrame с новой колонкой\n", + "print(df.head())\n", + "\n", + "# Примерный анализ данных\n", + "print(\"Статистическое описание DataFrame:\")\n", + "print(df.describe())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Разделение набора данных на обучающую и тестовые выборки (80/20) для задачи регрессии\n", + "\n", + "Целевой признак -- above_average_city_latitude" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'X_train'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
summarycitystatedate_timeshapedurationstatsreport_linktextpostedcity_latitudecity_longitude
1246784 lights moving in unison at a high rate of sp...Mount JulietTN2019-02-24T20:25:00light4 secondsOccurred : 2/24/2019 20:25 (Entered as : 02/2...http://www.nuforc.org/webreports/144/S144994.html4 lights moving in unison at a high rate of sp...2019-02-27T00:00:0036.172148-86.490748
2212Observed a long line of objects moving at very...Bethany BeachDE2020-03-01T05:30:00other45 secondsOccurred : 3/1/2020 05:30 (Entered as : 03/01...http://www.nuforc.org/webreports/153/S153730.htmlObserved a long line of objects moving at very...2020-04-09T00:00:0038.556200-75.069200
31960My wife and myself were traveling to a friends...WebbMS1975-12-31T19:30:00diskapprox 5 minsOccurred : 12/31/1975 19:30 (Entered as : 12/...http://www.nuforc.org/webreports/037/S37355.htmlMy wife and myself were traveling to a friends...2004-06-18T00:00:0033.919100-90.307300
33954I was sitting at my friends house, in my car a...EllensburgWA2004-03-17T08:45:00diamond10-20 minutesOccurred : 3/17/2004 08:45 (Entered as : 03/1...http://www.nuforc.org/webreports/035/S35995.htmlI was sitting at my friends house, in my car a...2004-04-09T00:00:0046.979000-120.470300
516Observed two glimmering craft over Powell Rive...Powell RiverBC2020-04-09T11:00:00disk3 minutesOccurred : 4/9/2020 11:00 (Entered as : 04/09...http://www.nuforc.org/webreports/155/S155845.htmlObserved two glimmering craft over Powell Rive...2020-06-25T00:00:0050.016300-124.322600
.......................................
110268Big black tranparent blib in sky.Sedro WoolleyWA2016-08-14T19:45:00other6 secondsOccurred : 8/14/2016 19:45 (Entered as : 08/1...http://www.nuforc.org/webreports/129/S129281.htmlBig black tranparent blib in sky Walking at No...2016-08-16T00:00:00NaNNaN
119879Very fast bright light.BrainerdMN2017-08-19T18:00:00light5 secondsOccurred : 8/19/2017 18:00 (Entered as : 08/1...http://www.nuforc.org/webreports/135/S135876.htmlVery fast bright light. Observed a bright ligh...2017-08-24T00:00:0046.306700-94.100800
103694never seen this beforeOld TappanNJ2015-03-12T05:49:00triangle20 secondsOccurred : 3/12/2015 05:49 (Entered as : 0312...http://www.nuforc.org/webreports/117/S117744.htmlnever seen this before. moved slow then all th...2015-03-13T00:00:00NaNNaN
131932Back in the late 70s or early 80s my family wa...TacomaWA1980-06-01T09:00:00sphere10 secondsOccurred : 6/1/1980 09:00 (Entered as : 06/01...http://www.nuforc.org/webreports/164/S164812.htmlBack in the late 70s or early 80s my family wa...2021-10-19T00:00:0047.212572-122.459720
121958Exiting Highway 61 onto I-280 and saw a light ...DavenportIA2018-11-01T01:00:00light2 secondsOccurred : 11/1/2018 01:00 (Entered as : 11/0...http://www.nuforc.org/webreports/143/S143647.htmlExiting highway 61 on to Interstate 280 and sa...2018-11-09T00:00:0041.555164-90.598760
\n", + "

109552 rows × 12 columns

\n", + "
" + ], + "text/plain": [ + " summary city \\\n", + "124678 4 lights moving in unison at a high rate of sp... Mount Juliet \n", + "2212 Observed a long line of objects moving at very... Bethany Beach \n", + "31960 My wife and myself were traveling to a friends... Webb \n", + "33954 I was sitting at my friends house, in my car a... Ellensburg \n", + "516 Observed two glimmering craft over Powell Rive... Powell River \n", + "... ... ... \n", + "110268 Big black tranparent blib in sky. Sedro Woolley \n", + "119879 Very fast bright light. Brainerd \n", + "103694 never seen this before Old Tappan \n", + "131932 Back in the late 70s or early 80s my family wa... Tacoma \n", + "121958 Exiting Highway 61 onto I-280 and saw a light ... Davenport \n", + "\n", + " state date_time shape duration \\\n", + "124678 TN 2019-02-24T20:25:00 light 4 seconds \n", + "2212 DE 2020-03-01T05:30:00 other 45 seconds \n", + "31960 MS 1975-12-31T19:30:00 disk approx 5 mins \n", + "33954 WA 2004-03-17T08:45:00 diamond 10-20 minutes \n", + "516 BC 2020-04-09T11:00:00 disk 3 minutes \n", + "... ... ... ... ... \n", + "110268 WA 2016-08-14T19:45:00 other 6 seconds \n", + "119879 MN 2017-08-19T18:00:00 light 5 seconds \n", + "103694 NJ 2015-03-12T05:49:00 triangle 20 seconds \n", + "131932 WA 1980-06-01T09:00:00 sphere 10 seconds \n", + "121958 IA 2018-11-01T01:00:00 light 2 seconds \n", + "\n", + " stats \\\n", + "124678 Occurred : 2/24/2019 20:25 (Entered as : 02/2... \n", + "2212 Occurred : 3/1/2020 05:30 (Entered as : 03/01... \n", + "31960 Occurred : 12/31/1975 19:30 (Entered as : 12/... \n", + "33954 Occurred : 3/17/2004 08:45 (Entered as : 03/1... \n", + "516 Occurred : 4/9/2020 11:00 (Entered as : 04/09... \n", + "... ... \n", + "110268 Occurred : 8/14/2016 19:45 (Entered as : 08/1... \n", + "119879 Occurred : 8/19/2017 18:00 (Entered as : 08/1... \n", + "103694 Occurred : 3/12/2015 05:49 (Entered as : 0312... \n", + "131932 Occurred : 6/1/1980 09:00 (Entered as : 06/01... \n", + "121958 Occurred : 11/1/2018 01:00 (Entered as : 11/0... \n", + "\n", + " report_link \\\n", + "124678 http://www.nuforc.org/webreports/144/S144994.html \n", + "2212 http://www.nuforc.org/webreports/153/S153730.html \n", + "31960 http://www.nuforc.org/webreports/037/S37355.html \n", + "33954 http://www.nuforc.org/webreports/035/S35995.html \n", + "516 http://www.nuforc.org/webreports/155/S155845.html \n", + "... ... \n", + "110268 http://www.nuforc.org/webreports/129/S129281.html \n", + "119879 http://www.nuforc.org/webreports/135/S135876.html \n", + "103694 http://www.nuforc.org/webreports/117/S117744.html \n", + "131932 http://www.nuforc.org/webreports/164/S164812.html \n", + "121958 http://www.nuforc.org/webreports/143/S143647.html \n", + "\n", + " text \\\n", + "124678 4 lights moving in unison at a high rate of sp... \n", + "2212 Observed a long line of objects moving at very... \n", + "31960 My wife and myself were traveling to a friends... \n", + "33954 I was sitting at my friends house, in my car a... \n", + "516 Observed two glimmering craft over Powell Rive... \n", + "... ... \n", + "110268 Big black tranparent blib in sky Walking at No... \n", + "119879 Very fast bright light. Observed a bright ligh... \n", + "103694 never seen this before. moved slow then all th... \n", + "131932 Back in the late 70s or early 80s my family wa... \n", + "121958 Exiting highway 61 on to Interstate 280 and sa... \n", + "\n", + " posted city_latitude city_longitude \n", + "124678 2019-02-27T00:00:00 36.172148 -86.490748 \n", + "2212 2020-04-09T00:00:00 38.556200 -75.069200 \n", + "31960 2004-06-18T00:00:00 33.919100 -90.307300 \n", + "33954 2004-04-09T00:00:00 46.979000 -120.470300 \n", + "516 2020-06-25T00:00:00 50.016300 -124.322600 \n", + "... ... ... ... \n", + "110268 2016-08-16T00:00:00 NaN NaN \n", + "119879 2017-08-24T00:00:00 46.306700 -94.100800 \n", + "103694 2015-03-13T00:00:00 NaN NaN \n", + "131932 2021-10-19T00:00:00 47.212572 -122.459720 \n", + "121958 2018-11-09T00:00:00 41.555164 -90.598760 \n", + "\n", + "[109552 rows x 12 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'y_train'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
above_average_city_latitude
1246780
22120
319600
339541
5161
......
1102680
1198791
1036940
1319321
1219581
\n", + "

109552 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " above_average_city_latitude\n", + "124678 0\n", + "2212 0\n", + "31960 0\n", + "33954 1\n", + "516 1\n", + "... ...\n", + "110268 0\n", + "119879 1\n", + "103694 0\n", + "131932 1\n", + "121958 1\n", + "\n", + "[109552 rows x 1 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'X_test'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
summarycitystatedate_timeshapedurationstatsreport_linktextpostedcity_latitudecity_longitude
108340Bright light with irregular flight pattern and...PittsboroNC2015-12-08T21:00:00light5 minutesOccurred : 12/8/2015 21:00 (Entered as : 12/0...http://www.nuforc.org/webreports/124/S124610.htmlBright light with irregular flight pattern and...2015-12-17T00:00:0035.751900-79.224800
290713 lights flash less than seconds apart in a ro...San Luis ObispoCA2004-03-16T22:10:00flash3 secondsOccurred : 3/16/2004 22:10 (Entered as : 03/1...http://www.nuforc.org/webreports/035/S35640.html3 lights flash less than seconds apart in a ro...2004-03-17T00:00:0035.262867-120.624789
89462A wonderful aircraft, but spooky.CornwallON2013-07-06T00:30:00triangle20 secondsOccurred : 7/6/2013 00:30 (Entered as : 76201...http://www.nuforc.org/webreports/099/S99896.htmlA wonderful aircraft , but spooky Saw aircraft...2013-07-14T00:00:0045.056209-74.710143
124422I was outside facing east, speaking with a co-...Virginia BeachVA2019-01-09T06:35:00fireball5-7 secondsOccurred : 1/9/2019 06:35 (Entered as : 1-9-1...http://www.nuforc.org/webreports/144/S144555.htmlI was outside facing east, speaking with a co-...2019-01-24T00:00:0036.837301-76.061948
126342Bright circular light in the sky - once we sta...FruitlandUT2019-05-11T23:40:00circle2 minutesOccurred : 5/11/2019 23:40 (Entered as : 5/11...http://www.nuforc.org/webreports/146/S146570.htmlBright circular light in the sky - once we sta...2019-06-07T00:00:00NaNNaN
.......................................
48714Was this white cylinder with fins a weather ba...Cape CoralFL2007-04-29T15:30:00cylinder30 minsOccurred : 4/29/2007 15:30 (Entered as : 04/2...http://www.nuforc.org/webreports/056/S56462.htmlWas this white cylinder with fins a weather ba...2007-06-12T00:00:0026.616422-81.970066
25512I was driving down a rural road near Haymarket...HaymarketVA2003-03-11T22:00:00triangle3 minutesOccurred : 3/11/2003 22:00 (Entered as : 3-11...http://www.nuforc.org/webreports/028/S28125.htmlI was driving down a rural road near Haymarket...2003-03-21T00:00:0038.869400-77.637300
96155Five orange lights in the sky over Essex area,...Essex JunctionVT2014-05-25T21:50:00light10 minutesOccurred : 5/25/2014 21:50 (Entered as : 05/2...http://www.nuforc.org/webreports/109/S109718.htmlFive orange lights in the sky over Essex area,...2014-06-04T00:00:0044.532199-73.058631
82188It was slowly moving over our pastures going a...New WashingtonOH2013-01-24T21:00:00circle5 minutesOccurred : 1/24/2013 21:00 (Entered as : 1/24...http://www.nuforc.org/webreports/096/S96095.htmlIt was slowly moving over our pastures going a...2013-02-04T00:00:0040.945000-82.861800
1245202 circles in the sky changed colors several ti...South AmboyNJ2019-02-02T00:28:00circle1 minuteOccurred : 2/2/2019 00:28 (Entered as : 02/2/...http://www.nuforc.org/webreports/144/S144752.html2 circles in the sky changed colors several ti...2019-02-07T00:00:0040.477900-74.290700
\n", + "

27388 rows × 12 columns

\n", + "
" + ], + "text/plain": [ + " summary city \\\n", + "108340 Bright light with irregular flight pattern and... Pittsboro \n", + "29071 3 lights flash less than seconds apart in a ro... San Luis Obispo \n", + "89462 A wonderful aircraft, but spooky. Cornwall \n", + "124422 I was outside facing east, speaking with a co-... Virginia Beach \n", + "126342 Bright circular light in the sky - once we sta... Fruitland \n", + "... ... ... \n", + "48714 Was this white cylinder with fins a weather ba... Cape Coral \n", + "25512 I was driving down a rural road near Haymarket... Haymarket \n", + "96155 Five orange lights in the sky over Essex area,... Essex Junction \n", + "82188 It was slowly moving over our pastures going a... New Washington \n", + "124520 2 circles in the sky changed colors several ti... South Amboy \n", + "\n", + " state date_time shape duration \\\n", + "108340 NC 2015-12-08T21:00:00 light 5 minutes \n", + "29071 CA 2004-03-16T22:10:00 flash 3 seconds \n", + "89462 ON 2013-07-06T00:30:00 triangle 20 seconds \n", + "124422 VA 2019-01-09T06:35:00 fireball 5-7 seconds \n", + "126342 UT 2019-05-11T23:40:00 circle 2 minutes \n", + "... ... ... ... ... \n", + "48714 FL 2007-04-29T15:30:00 cylinder 30 mins \n", + "25512 VA 2003-03-11T22:00:00 triangle 3 minutes \n", + "96155 VT 2014-05-25T21:50:00 light 10 minutes \n", + "82188 OH 2013-01-24T21:00:00 circle 5 minutes \n", + "124520 NJ 2019-02-02T00:28:00 circle 1 minute \n", + "\n", + " stats \\\n", + "108340 Occurred : 12/8/2015 21:00 (Entered as : 12/0... \n", + "29071 Occurred : 3/16/2004 22:10 (Entered as : 03/1... \n", + "89462 Occurred : 7/6/2013 00:30 (Entered as : 76201... \n", + "124422 Occurred : 1/9/2019 06:35 (Entered as : 1-9-1... \n", + "126342 Occurred : 5/11/2019 23:40 (Entered as : 5/11... \n", + "... ... \n", + "48714 Occurred : 4/29/2007 15:30 (Entered as : 04/2... \n", + "25512 Occurred : 3/11/2003 22:00 (Entered as : 3-11... \n", + "96155 Occurred : 5/25/2014 21:50 (Entered as : 05/2... \n", + "82188 Occurred : 1/24/2013 21:00 (Entered as : 1/24... \n", + "124520 Occurred : 2/2/2019 00:28 (Entered as : 02/2/... \n", + "\n", + " report_link \\\n", + "108340 http://www.nuforc.org/webreports/124/S124610.html \n", + "29071 http://www.nuforc.org/webreports/035/S35640.html \n", + "89462 http://www.nuforc.org/webreports/099/S99896.html \n", + "124422 http://www.nuforc.org/webreports/144/S144555.html \n", + "126342 http://www.nuforc.org/webreports/146/S146570.html \n", + "... ... \n", + "48714 http://www.nuforc.org/webreports/056/S56462.html \n", + "25512 http://www.nuforc.org/webreports/028/S28125.html \n", + "96155 http://www.nuforc.org/webreports/109/S109718.html \n", + "82188 http://www.nuforc.org/webreports/096/S96095.html \n", + "124520 http://www.nuforc.org/webreports/144/S144752.html \n", + "\n", + " text \\\n", + "108340 Bright light with irregular flight pattern and... \n", + "29071 3 lights flash less than seconds apart in a ro... \n", + "89462 A wonderful aircraft , but spooky Saw aircraft... \n", + "124422 I was outside facing east, speaking with a co-... \n", + "126342 Bright circular light in the sky - once we sta... \n", + "... ... \n", + "48714 Was this white cylinder with fins a weather ba... \n", + "25512 I was driving down a rural road near Haymarket... \n", + "96155 Five orange lights in the sky over Essex area,... \n", + "82188 It was slowly moving over our pastures going a... \n", + "124520 2 circles in the sky changed colors several ti... \n", + "\n", + " posted city_latitude city_longitude \n", + "108340 2015-12-17T00:00:00 35.751900 -79.224800 \n", + "29071 2004-03-17T00:00:00 35.262867 -120.624789 \n", + "89462 2013-07-14T00:00:00 45.056209 -74.710143 \n", + "124422 2019-01-24T00:00:00 36.837301 -76.061948 \n", + "126342 2019-06-07T00:00:00 NaN NaN \n", + "... ... ... ... \n", + "48714 2007-06-12T00:00:00 26.616422 -81.970066 \n", + "25512 2003-03-21T00:00:00 38.869400 -77.637300 \n", + "96155 2014-06-04T00:00:00 44.532199 -73.058631 \n", + "82188 2013-02-04T00:00:00 40.945000 -82.861800 \n", + "124520 2019-02-07T00:00:00 40.477900 -74.290700 \n", + "\n", + "[27388 rows x 12 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'y_test'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
above_average_city_latitude
1083400
290710
894621
1244220
1263420
......
487140
255121
961551
821881
1245201
\n", + "

27388 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " above_average_city_latitude\n", + "108340 0\n", + "29071 0\n", + "89462 1\n", + "124422 0\n", + "126342 0\n", + "... ...\n", + "48714 0\n", + "25512 1\n", + "96155 1\n", + "82188 1\n", + "124520 1\n", + "\n", + "[27388 rows x 1 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from typing import Tuple\n", + "import pandas as pd\n", + "from pandas import DataFrame\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "def split_into_train_test(\n", + " df_input: DataFrame,\n", + " target_colname: str = \"above_average_city_latitude\", \n", + " frac_train: float = 0.8,\n", + " random_state: int = None,\n", + ") -> Tuple[DataFrame, DataFrame, DataFrame, DataFrame]:\n", + " \n", + " if not (0 < frac_train < 1):\n", + " raise ValueError(\"Fraction must be between 0 and 1.\")\n", + " \n", + " # Проверка наличия целевого признака\n", + " if target_colname not in df_input.columns:\n", + " raise ValueError(f\"{target_colname} is not a column in the DataFrame.\")\n", + " \n", + " # Разделяем данные на признаки и целевую переменную\n", + " X = df_input.drop(columns=[target_colname]) # Признаки\n", + " y = df_input[[target_colname]] # Целевая переменная\n", + "\n", + " # Разделяем данные на обучающую и тестовую выборки\n", + " X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y,\n", + " test_size=(1.0 - frac_train),\n", + " random_state=random_state\n", + " )\n", + " \n", + " return X_train, X_test, y_train, y_test\n", + "\n", + "# Применение функции для разделения данных\n", + "X_train, X_test, y_train, y_test = split_into_train_test(\n", + " df, \n", + " target_colname=\"above_average_city_latitude\", \n", + " frac_train=0.8, \n", + " random_state=42 \n", + ")\n", + "\n", + "# Для отображения результатов\n", + "display(\"X_train\", X_train)\n", + "display(\"y_train\", y_train)\n", + "\n", + "display(\"X_test\", X_test)\n", + "display(\"y_test\", y_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Формирование конвейера для решения задачи регрессии" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " city_latitude city_longitude shape_changing shape_chevron \\\n", + "0 -0.475704 -1.527173 0.0 0.0 \n", + "1 0.070048 0.574031 0.0 0.0 \n", + "2 0.086123 0.291990 0.0 0.0 \n", + "3 -0.552224 0.604238 0.0 0.0 \n", + "4 -0.002686 1.019156 0.0 0.0 \n", + "... ... ... ... ... \n", + "136935 1.426621 -1.516027 0.0 0.0 \n", + "136936 -2.044798 0.757950 0.0 0.0 \n", + "136937 0.180564 -0.660057 0.0 0.0 \n", + "136938 -0.719495 -1.453787 0.0 0.0 \n", + "136939 0.785101 1.328590 0.0 0.0 \n", + "\n", + " shape_cigar shape_circle shape_cone shape_crescent shape_cross \\\n", + "0 0.0 0.0 0.0 0.0 0.0 \n", + "1 0.0 0.0 0.0 0.0 0.0 \n", + "2 0.0 0.0 0.0 0.0 0.0 \n", + "3 0.0 0.0 0.0 0.0 0.0 \n", + "4 0.0 1.0 0.0 0.0 0.0 \n", + "... ... ... ... ... ... \n", + "136935 0.0 0.0 0.0 0.0 0.0 \n", + "136936 0.0 0.0 0.0 0.0 0.0 \n", + "136937 0.0 0.0 0.0 0.0 0.0 \n", + "136938 0.0 0.0 0.0 0.0 0.0 \n", + "136939 0.0 0.0 0.0 0.0 0.0 \n", + "\n", + " shape_cylinder ... shape_light shape_other shape_oval \\\n", + "0 0.0 ... 1.0 0.0 0.0 \n", + "1 0.0 ... 0.0 0.0 0.0 \n", + "2 0.0 ... 0.0 0.0 0.0 \n", + "3 0.0 ... 0.0 0.0 0.0 \n", + "4 0.0 ... 0.0 0.0 0.0 \n", + "... ... ... ... ... ... \n", + "136935 0.0 ... 0.0 0.0 0.0 \n", + "136936 1.0 ... 0.0 0.0 0.0 \n", + "136937 0.0 ... 1.0 0.0 0.0 \n", + "136938 0.0 ... 0.0 0.0 0.0 \n", + "136939 0.0 ... 0.0 0.0 1.0 \n", + "\n", + " shape_pyramid shape_rectangle shape_round shape_sphere \\\n", + "0 0.0 0.0 0.0 0.0 \n", + "1 0.0 0.0 0.0 0.0 \n", + "2 0.0 1.0 0.0 0.0 \n", + "3 0.0 0.0 0.0 0.0 \n", + "4 0.0 0.0 0.0 0.0 \n", + "... ... ... ... ... \n", + "136935 0.0 0.0 0.0 0.0 \n", + "136936 0.0 0.0 0.0 0.0 \n", + "136937 0.0 0.0 0.0 0.0 \n", + "136938 0.0 0.0 0.0 0.0 \n", + "136939 0.0 0.0 0.0 0.0 \n", + "\n", + " shape_teardrop shape_triangle shape_unknown \n", + "0 0.0 0.0 0.0 \n", + "1 0.0 1.0 0.0 \n", + "2 0.0 0.0 0.0 \n", + "3 0.0 1.0 0.0 \n", + "4 0.0 0.0 0.0 \n", + "... ... ... ... \n", + "136935 0.0 1.0 0.0 \n", + "136936 0.0 0.0 0.0 \n", + "136937 0.0 0.0 0.0 \n", + "136938 0.0 0.0 0.0 \n", + "136939 0.0 0.0 0.0 \n", + "\n", + "[136940 rows x 30 columns]\n", + "(136940, 30)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from sklearn.base import BaseEstimator, TransformerMixin\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "from sklearn.ensemble import RandomForestRegressor \n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.pipeline import make_pipeline\n", + "import pandas as pd\n", + "\n", + "class JioMartFeatures(BaseEstimator, TransformerMixin): \n", + " def __init__(self):\n", + " pass\n", + "\n", + " def fit(self, X, y=None):\n", + " return self\n", + "\n", + " def transform(self, X, y=None):\n", + " if 'state' in X.columns:\n", + " X[\"city_latitude_per_state\"] = X[\"city_latitude\"] / X[\"state\"].nunique()\n", + " return X\n", + "\n", + " def get_feature_names_out(self, features_in):\n", + " return np.append(features_in, [\"city_latitude_per_state\"], axis=0) \n", + "\n", + "# Определите признаки для вашей задачи\n", + "columns_to_drop = [\"date_time\", \"posted\", \"city\", \"state\", \"summary\", \"stats\", \"report_link\", \"duration\", \"text\"] # Столбцы, которые можно удалить\n", + "num_columns = [\"city_latitude\", \"city_longitude\"] # Числовые столбцы\n", + "cat_columns = [\"shape\"] # Категориальные столбцы\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", + "cat_imputer = SimpleImputer(strategy=\"constant\", fill_value=\"unknown\")\n", + "cat_encoder = OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False, drop=\"first\")\n", + "preprocessing_cat = Pipeline(\n", + " [\n", + " (\"imputer\", cat_imputer),\n", + " (\"encoder\", cat_encoder),\n", + " ]\n", + ")\n", + "\n", + "# Формирование конвейера\n", + "features_preprocessing = ColumnTransformer(\n", + " verbose_feature_names_out=False,\n", + " transformers=[\n", + " (\"prepocessing_num\", preprocessing_num, num_columns),\n", + " (\"prepocessing_cat\", preprocessing_cat, cat_columns),\n", + " ],\n", + " remainder=\"passthrough\" \n", + ")\n", + "\n", + "drop_columns = ColumnTransformer(\n", + " verbose_feature_names_out=False,\n", + " transformers=[\n", + " (\"drop_columns\", \"drop\", columns_to_drop),\n", + " ],\n", + " remainder=\"passthrough\",\n", + ")\n", + "\n", + "# Окончательный конвейер\n", + "pipeline_end = Pipeline(\n", + " [\n", + " (\"features_preprocessing\", features_preprocessing),\n", + " (\"drop_columns\", drop_columns),\n", + " (\"custom_features\", JioMartFeatures()), # Добавляем custom_features\n", + " ]\n", + ")\n", + "\n", + "# Загрузка данных\n", + "df = pd.read_csv(\"../../datasets/nuforc_reports.csv\")\n", + "\n", + "# Создаем целевой признак\n", + "average_city_latitude = df['city_latitude'].mean()\n", + "df['above_average_city_latitude'] = (df['city_latitude'] > average_city_latitude).astype(int)\n", + "\n", + "# Подготовка данных\n", + "X = df.drop('above_average_city_latitude', axis=1)\n", + "y = df['above_average_city_latitude'].values.ravel()\n", + "\n", + "# Проверка наличия столбцов перед применением конвейера\n", + "required_columns = set(num_columns + cat_columns + columns_to_drop)\n", + "missing_columns = required_columns - set(X.columns)\n", + "if missing_columns:\n", + " raise KeyError(f\"Missing columns: {missing_columns}\")\n", + "\n", + "# Применение конвейера\n", + "X_processed = pipeline_end.fit_transform(X)\n", + "\n", + "# Вывод\n", + "print(X_processed)\n", + "print(X_processed.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Формирование набора моделей для регрессии" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Random Forest: Mean Score = 0.9789167519338394, Standard Deviation = 0.015961406592291463\n", + "Linear Regression: Mean Score = 0.5039253856797983, Standard Deviation = 0.030322793232352978\n", + "Gradient Boosting: Mean Score = 0.9901053617704161, Standard Deviation = 0.008763228065314608\n", + "Support Vector Regression: Mean Score = 0.8080621690604891, Standard Deviation = 0.04395269414319326\n" + ] + } + ], + "source": [ + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.model_selection import cross_val_score\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.ensemble import GradientBoostingRegressor\n", + "from sklearn.svm import SVR\n", + "\n", + "def train_multiple_models(X, y, models, cv=3):\n", + " results = {}\n", + " for model_name, model in models.items():\n", + " # Создаем конвейер для каждой модели\n", + " model_pipeline = Pipeline(\n", + " [\n", + " (\"features_preprocessing\", features_preprocessing),\n", + " (\"drop_columns\", drop_columns),\n", + " (\"model\", model) # Используем текущую модель\n", + " ]\n", + " )\n", + " \n", + " # Обучаем модель и вычисляем кросс-валидацию\n", + " scores = cross_val_score(model_pipeline, X, y, cv=cv, n_jobs=-1) # Используем все ядра процессора\n", + " results[model_name] = {\n", + " \"mean_score\": scores.mean(),\n", + " \"std_dev\": scores.std()\n", + " }\n", + " \n", + " return results\n", + "\n", + "# Определение моделей\n", + "models = {\n", + " \"Random Forest\": RandomForestRegressor(n_estimators=10), # Уменьшаем количество деревьев\n", + " \"Linear Regression\": LinearRegression(),\n", + " \"Gradient Boosting\": GradientBoostingRegressor(),\n", + " \"Support Vector Regression\": SVR()\n", + "}\n", + "\n", + "# Используем подвыборку данных\n", + "sample_size = 1000 # Уменьшаем количество данных для обучения\n", + "X_train_sample = X_train.sample(n=sample_size, random_state=42)\n", + "y_train_sample = y_train.loc[X_train_sample.index] # Используем loc для индексации Series\n", + "\n", + "# Обучение моделей и вывод результатов\n", + "results = train_multiple_models(X_train_sample, y_train_sample, models, cv=3) # Уменьшаем количество фолдов\n", + "\n", + "# Вывод результатов\n", + "for model_name, scores in results.items():\n", + " print(f\"{model_name}: Mean Score = {scores['mean_score']}, Standard Deviation = {scores['std_dev']}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Модель: Random Forest\n", + "- **Mean Score**: 0.9789167519338394\n", + "- **Standard Deviation**: 0.015961406592291463\n", + "**Описание**:\n", + "- Random Forest показала очень высокое среднее значение, близкое к 1, что указывает на ее высокую точность в предсказании. Стандартное отклонение также относительно низкое, что говорит о стабильности модели.\n", + "\n", + "#### Модель: Linear Regression\n", + "- **Mean Score**: 0.5039253856797983\n", + "- **Standard Deviation**: 0.030322793232352978\n", + "**Описание**:\n", + "- Линейная регрессия показала очень низкое среднее значение, что указывает на ее неэффективность в данной задаче. Стандартное отклонение также очень высокое, что говорит о нестабильности модели.\n", + "\n", + "#### Модель: Gradient Boosting\n", + "- **Mean Score**: 0.9901053617704161\n", + "- **Standard Deviation**: 0.008763228065314608\n", + "**Описание**:\n", + "- Gradient Boosting показала практически идеальное среднее значение, близкое к 1, что указывает на ее высокую точность в предсказании. Стандартное отклонение относительно низкое, что говорит о стабильности модели.\n", + "\n", + "#### Модель: Support Vector Regression\n", + "- **Mean Score**: 0.8080621690604891\n", + "- **Standard Deviation**: 0.04395269414319326\n", + "**Описание**:\n", + "- Support Vector Regression показала среднее значение около 0.64, что указывает на ее умеренную точность в предсказании. Стандартное отклонение относительно низкое, что говорит о стабильности модели, но она все же уступает Random Forest и Gradient Boosting.\n", + "\n", + "\n", + "1. **Random Forest и Gradient Boosting** демонстрируют высокую точность и стабильность, что делает их наиболее подходящими моделями для данной задачи регрессии.\n", + "2. **Linear Regression** неэффективна и нестабильна, что указывает на необходимость ее замены на более подходящую модель.\n", + "3. **Support Vector Regression** показывает умеренную точность и стабильность, но уступает Random Forest и Gradient Boosting в эффективности." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Обучение моделей на обучающем наборе данных и оценка на тестовом для регрессии" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: logistic\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE (train): 0.04693661457572659\n", + "MSE (test): 0.04651672265225646\n", + "MAE (train): 0.04693661457572659\n", + "MAE (test): 0.04651672265225646\n", + "R2 (train): 0.8090856146775022\n", + "R2 (test): 0.810957714373292\n", + "STD (train): 0.21150311767890387\n", + "STD (test): 0.21060132280199356\n", + "----------------------------------------\n", + "Model: ridge\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE (train): 0.04438987877902731\n", + "MSE (test): 0.04465459325251935\n", + "MAE (train): 0.04438987877902731\n", + "MAE (test): 0.04465459325251935\n", + "R2 (train): 0.8194444465532269\n", + "R2 (test): 0.8185253411919435\n", + "STD (train): 0.20595974713766416\n", + "STD (test): 0.2065443307233859\n", + "----------------------------------------\n", + "Model: decision_tree\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE (train): 0.0\n", + "MSE (test): 0.0\n", + "MAE (train): 0.0\n", + "MAE (test): 0.0\n", + "R2 (train): 1.0\n", + "R2 (test): 1.0\n", + "STD (train): 0.0\n", + "STD (test): 0.0\n", + "----------------------------------------\n", + "Model: knn\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE (train): 0.0024737111143566526\n", + "MSE (test): 0.0035416970936176426\n", + "MAE (train): 0.0024737111143566526\n", + "MAE (test): 0.0035416970936176426\n", + "R2 (train): 0.9899381955615719\n", + "R2 (test): 0.9856066705606039\n", + "STD (train): 0.04973611399311279\n", + "STD (test): 0.05950515838317305\n", + "----------------------------------------\n", + "Model: naive_bayes\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE (train): 0.12056375054768512\n", + "MSE (test): 0.12202424419453775\n", + "MAE (train): 0.12056375054768512\n", + "MAE (test): 0.12202424419453775\n", + "R2 (train): 0.5096077010230355\n", + "R2 (test): 0.5040978661189495\n", + "STD (train): 0.32835683006894384\n", + "STD (test): 0.33012146600139913\n", + "----------------------------------------\n", + "Model: gradient_boosting\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE (train): 0.0\n", + "MSE (test): 0.0\n", + "MAE (train): 0.0\n", + "MAE (test): 0.0\n", + "R2 (train): 1.0\n", + "R2 (test): 1.0\n", + "STD (train): 0.0\n", + "STD (test): 0.0\n", + "----------------------------------------\n", + "Model: random_forest\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE (train): 0.0001551774499780926\n", + "MSE (test): 0.00025558638819921136\n", + "MAE (train): 0.0001551774499780926\n", + "MAE (test): 0.00025558638819921136\n", + "R2 (train): 0.9993688166957444\n", + "R2 (test): 0.9989613061229302\n", + "STD (train): 0.012456057559962977\n", + "STD (test): 0.015985026236993754\n", + "----------------------------------------\n", + "Model: mlp\n", + "MSE (train): 0.0206659851029648\n", + "MSE (test): 0.01971666423251059\n", + "MAE (train): 0.0206659851029648\n", + "MAE (test): 0.01971666423251059\n", + "R2 (train): 0.9159412352450146\n", + "R2 (test): 0.9198721866260421\n", + "STD (train): 0.1430221622813633\n", + "STD (test): 0.13976464450173487\n", + "----------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n", + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\pipeline.py:62: FutureWarning: This Pipeline instance is not fitted yet. Call 'fit' with appropriate arguments before using other methods such as transform, predict, etc. This will raise an error in 1.8 instead of the current warning.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from sklearn import metrics\n", + "from sklearn.pipeline import Pipeline\n", + "\n", + "# Проверка наличия необходимых переменных\n", + "if 'class_models' not in locals():\n", + " raise ValueError(\"class_models is not defined\")\n", + "if 'X_train' not in locals() or 'X_test' not in locals() or 'y_train' not in locals() or 'y_test' not in locals():\n", + " raise ValueError(\"Train/test data is not defined\")\n", + "\n", + "# Преобразуем y_train и y_test в одномерные массивы\n", + "y_train = np.ravel(y_train) \n", + "y_test = np.ravel(y_test) \n", + "\n", + "# Инициализация списка для хранения результатов\n", + "results = []\n", + "\n", + "# Проход по моделям и оценка их качества\n", + "for model_name in class_models.keys():\n", + " print(f\"Model: {model_name}\")\n", + " \n", + " # Извлечение модели из словаря\n", + " model = class_models[model_name][\"model\"]\n", + " \n", + " # Создание пайплайна\n", + " model_pipeline = Pipeline([(\"pipeline\", pipeline_end), (\"model\", model)])\n", + " \n", + " # Обучение модели\n", + " model_pipeline.fit(X_train, y_train)\n", + "\n", + " # Предсказание для обучающей и тестовой выборки\n", + " y_train_predict = model_pipeline.predict(X_train)\n", + " y_test_predict = model_pipeline.predict(X_test)\n", + "\n", + " # Сохранение пайплайна и предсказаний\n", + " class_models[model_name][\"pipeline\"] = model_pipeline\n", + " class_models[model_name][\"preds\"] = y_test_predict\n", + "\n", + " # Вычисление метрик для регрессии\n", + " class_models[model_name][\"MSE_train\"] = metrics.mean_squared_error(y_train, y_train_predict)\n", + " class_models[model_name][\"MSE_test\"] = metrics.mean_squared_error(y_test, y_test_predict)\n", + " class_models[model_name][\"MAE_train\"] = metrics.mean_absolute_error(y_train, y_train_predict)\n", + " class_models[model_name][\"MAE_test\"] = metrics.mean_absolute_error(y_test, y_test_predict)\n", + " class_models[model_name][\"R2_train\"] = metrics.r2_score(y_train, y_train_predict)\n", + " class_models[model_name][\"R2_test\"] = metrics.r2_score(y_test, y_test_predict)\n", + "\n", + " # Дополнительные метрики\n", + " class_models[model_name][\"STD_train\"] = np.std(y_train - y_train_predict)\n", + " class_models[model_name][\"STD_test\"] = np.std(y_test - y_test_predict)\n", + "\n", + " # Вывод результатов для текущей модели\n", + " print(f\"MSE (train): {class_models[model_name]['MSE_train']}\")\n", + " print(f\"MSE (test): {class_models[model_name]['MSE_test']}\")\n", + " print(f\"MAE (train): {class_models[model_name]['MAE_train']}\")\n", + " print(f\"MAE (test): {class_models[model_name]['MAE_test']}\")\n", + " print(f\"R2 (train): {class_models[model_name]['R2_train']}\")\n", + " print(f\"R2 (test): {class_models[model_name]['R2_test']}\")\n", + " print(f\"STD (train): {class_models[model_name]['STD_train']}\")\n", + " print(f\"STD (test): {class_models[model_name]['STD_test']}\")\n", + " print(\"-\" * 40) # Разделитель для разных моделей" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Пример использования обученной модели (конвейера регрессии) для предсказания" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: RandomForest\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [1] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE (train): 0.003994806410348714\n", + "MSE (test): 0.08567146325791795\n", + "MAE (train): 0.002250011462828781\n", + "MAE (test): 0.009170197805056415\n", + "R2 (train): 0.9998844679299405\n", + "R2 (test): 0.9972453050448624\n", + "----------------------------------------\n", + "Прогнозируемая цена: -15.206353276691255\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0, 1] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn import metrics\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.ensemble import RandomForestRegressor \n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "\n", + "# 1. Загрузка данных\n", + "data = pd.read_csv(\"../../datasets/nuforc_reports.csv\") \n", + "data = data.head(15000)\n", + "\n", + "# 2. Подготовка данных для прогноза\n", + "average_city_latitude = data['city_latitude'].mean()\n", + "data['above_average_city_latitude'] = (data['city_latitude'] > average_city_latitude).astype(int) \n", + "\n", + "# Удаляем строки с пропущенными значениями в столбце 'city_latitude'\n", + "data = data.dropna(subset=['city_latitude'])\n", + "\n", + "# Предикторы и целевая переменная\n", + "X = data.drop('above_average_city_latitude', axis=1) # Удаляем только 'above_average_city_latitude'\n", + "y = data['city_latitude']\n", + "\n", + "# 3. Инициализация модели и пайплайна\n", + "class_models = {\n", + " \"RandomForest\": {\n", + " \"model\": RandomForestRegressor(n_estimators=100, random_state=42),\n", + " }\n", + "}\n", + "\n", + "# Предобработка признаков\n", + "num_columns = ['city_latitude']\n", + "cat_columns = ['state', 'city']\n", + "\n", + "# Проверка наличия столбцов перед предобработкой\n", + "required_columns = set(num_columns + cat_columns)\n", + "missing_columns = required_columns - set(X.columns)\n", + "if missing_columns:\n", + " raise KeyError(f\"Missing columns: {missing_columns}\")\n", + "\n", + "# Преобразование числовых признаков\n", + "num_transformer = Pipeline(steps=[\n", + " ('imputer', SimpleImputer(strategy='median')),\n", + " ('scaler', StandardScaler())\n", + "])\n", + "\n", + "# Преобразование категориальных признаков\n", + "cat_transformer = Pipeline(steps=[\n", + " ('imputer', SimpleImputer(strategy='constant', fill_value='unknown')),\n", + " ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False, drop=\"first\"))\n", + "])\n", + "\n", + "# Создание конвейера предобработки\n", + "preprocessor = ColumnTransformer(\n", + " transformers=[\n", + " ('num', num_transformer, num_columns),\n", + " ('cat', cat_transformer, cat_columns)\n", + " ])\n", + "\n", + "# Создание конвейера модели\n", + "pipeline_end = Pipeline(steps=[\n", + " ('preprocessor', preprocessor),\n", + " # ('model', model) # Модель добавляется в цикле\n", + "])\n", + "\n", + "results = []\n", + "\n", + "# 4. Обучение модели и оценка\n", + "for model_name in class_models.keys():\n", + " print(f\"Model: {model_name}\")\n", + "\n", + " model = class_models[model_name][\"model\"]\n", + " model_pipeline = Pipeline(steps=[\n", + " ('preprocessor', preprocessor),\n", + " ('model', model)\n", + " ])\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", + " model_pipeline.fit(X_train, y_train)\n", + "\n", + " # Предсказание\n", + " y_train_predict = model_pipeline.predict(X_train)\n", + " y_test_predict = model_pipeline.predict(X_test)\n", + "\n", + " # Сохранение результатов\n", + " class_models[model_name][\"preds\"] = y_test_predict\n", + "\n", + " # Вычисление метрик\n", + " class_models[model_name][\"MSE_train\"] = metrics.mean_squared_error(y_train, y_train_predict)\n", + " class_models[model_name][\"MSE_test\"] = metrics.mean_squared_error(y_test, y_test_predict)\n", + " class_models[model_name][\"MAE_train\"] = metrics.mean_absolute_error(y_train, y_train_predict)\n", + " class_models[model_name][\"MAE_test\"] = metrics.mean_absolute_error(y_test, y_test_predict)\n", + " class_models[model_name][\"R2_train\"] = metrics.r2_score(y_train, y_train_predict)\n", + " class_models[model_name][\"R2_test\"] = metrics.r2_score(y_test, y_test_predict)\n", + "\n", + " # Вывод результатов\n", + " print(f\"MSE (train): {class_models[model_name]['MSE_train']}\")\n", + " print(f\"MSE (test): {class_models[model_name]['MSE_test']}\")\n", + " print(f\"MAE (train): {class_models[model_name]['MAE_train']}\")\n", + " print(f\"MAE (test): {class_models[model_name]['MAE_test']}\")\n", + " print(f\"R2 (train): {class_models[model_name]['R2_train']}\")\n", + " print(f\"R2 (test): {class_models[model_name]['R2_test']}\")\n", + " print(\"-\" * 40)\n", + "\n", + "# Прогнозирование цены для нового товара\n", + "new_item_data = pd.DataFrame({\n", + " 'state': ['Electronics'],\n", + " 'city': ['Smartphones'], \n", + " 'city_latitude': [0] # Добавляем столбец 'city_latitude' с нулевым значением\n", + "})\n", + "\n", + "predicted_city_latitude = model_pipeline.predict(new_item_data)\n", + "print(f\"Прогнозируемая цена: {predicted_city_latitude[0]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Подбор гиперпараметров методом поиска по сетке" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 3 folds for each of 36 candidates, totalling 108 fits\n", + "Лучшие параметры: {'max_depth': 30, 'min_samples_split': 2, 'n_estimators': 200}\n", + "Лучший результат (MSE): 1.278829563088853\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn import metrics\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.model_selection import train_test_split, GridSearchCV\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.impute import SimpleImputer\n", + "\n", + "# Удаление строк с пропущенными значениями (если необходимо)\n", + "df = df.dropna()\n", + "\n", + "# Создание целевой переменной (city_latitude)\n", + "target = df['city_latitude']\n", + "\n", + "# Удаление целевой переменной из исходных данных\n", + "features = df.drop(columns=['city_latitude'])\n", + "\n", + "# Удаление столбцов, которые не будут использоваться (например, href и items)\n", + "features = features.drop(columns=[\"date_time\", \"posted\", \"city\", \"state\", \"summary\", \"stats\", \"report_link\", \"duration\", \"text\"])\n", + "\n", + "# Определение столбцов для обработки\n", + "num_columns = features.select_dtypes(include=['number']).columns\n", + "cat_columns = features.select_dtypes(include=['object']).columns\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", + "cat_imputer = SimpleImputer(strategy=\"constant\", fill_value=\"unknown\") # Используем 'unknown' для заполнения пропущенных значений в категориальных столбцах\n", + "cat_encoder = OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False, drop=\"first\")\n", + "preprocessing_cat = Pipeline(\n", + " [\n", + " (\"imputer\", cat_imputer),\n", + " (\"encoder\", cat_encoder),\n", + " ]\n", + ")\n", + "\n", + "# Объединение препроцессинга\n", + "features_preprocessing = ColumnTransformer(\n", + " verbose_feature_names_out=False,\n", + " transformers=[\n", + " (\"preprocessing_num\", preprocessing_num, num_columns),\n", + " (\"preprocessing_cat\", preprocessing_cat, cat_columns),\n", + " ],\n", + " remainder=\"passthrough\"\n", + ")\n", + "\n", + "# Создание финального пайплайна\n", + "pipeline_end = Pipeline(\n", + " [\n", + " (\"features_preprocessing\", features_preprocessing),\n", + " ]\n", + ")\n", + "\n", + "# Разделение данных на обучающую и тестовую выборки\n", + "X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.2, random_state=42)\n", + "\n", + "# Применение пайплайна к данным\n", + "X_train_processed = pipeline_end.fit_transform(X_train)\n", + "X_test_processed = pipeline_end.transform(X_test)\n", + "\n", + "# 2. Создание и настройка модели случайного леса\n", + "model = RandomForestRegressor()\n", + "\n", + "# Установка параметров для поиска по сетке\n", + "param_grid = {\n", + " 'n_estimators': [50, 100, 200], # Количество деревьев\n", + " 'max_depth': [None, 10, 20, 30], # Максимальная глубина дерева\n", + " 'min_samples_split': [2, 5, 10] # Минимальное количество образцов для разбиения узла\n", + "}\n", + "\n", + "# 3. Подбор гиперпараметров с помощью Grid Search\n", + "grid_search = GridSearchCV(estimator=model, param_grid=param_grid,\n", + " scoring='neg_mean_squared_error', cv=3, n_jobs=-1, verbose=2)\n", + "\n", + "# Обучение модели на тренировочных данных\n", + "grid_search.fit(X_train_processed, y_train)\n", + "\n", + "# 4. Результаты подбора гиперпараметров\n", + "print(\"Лучшие параметры:\", grid_search.best_params_)\n", + "print(\"Лучший результат (MSE):\", -grid_search.best_score_) # Меняем знак, так как берем отрицательное значение среднеквадратичной ошибки" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Обучение модели с новыми гиперпараметрами и сравнение новых и старых данных" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " summary city state \\\n", + "0 Viewed some red lights in the sky appearing to... Visalia CA \n", + "1 Look like 1 or 3 crafts from North traveling s... Cincinnati OH \n", + "3 One red light moving switly west to east, beco... Knoxville TN \n", + "5 I'm familiar with all the fakery and UFO sight... Fullerton CA \n", + "6 I was driving up lakes mead towards the lake a... Las Vegas NV \n", + "\n", + " date_time shape duration \\\n", + "0 2021-12-15T21:45:00 light 2 minutes \n", + "1 2021-12-16T09:45:00 triangle 14 seconds \n", + "3 2021-12-10T19:30:00 triangle 20-30 seconds \n", + "5 2020-07-07T23:00:00 unknown 2 minutes \n", + "6 2020-04-23T03:00:00 oval 10 minutes \n", + "\n", + " stats \\\n", + "0 Occurred : 12/15/2021 21:45 (Entered as : 12/... \n", + "1 Occurred : 12/16/2021 09:45 (Entered as : 12/... \n", + "3 Occurred : 12/10/2021 19:30 (Entered as : 12/... \n", + "5 Occurred : 7/7/2020 23:00 (Entered as : 07/07... \n", + "6 Occurred : 4/23/2020 03:00 (Entered as : 4/23... \n", + "\n", + " report_link \\\n", + "0 http://www.nuforc.org/webreports/165/S165881.html \n", + "1 http://www.nuforc.org/webreports/165/S165888.html \n", + "3 http://www.nuforc.org/webreports/165/S165825.html \n", + "5 http://www.nuforc.org/webreports/157/S157444.html \n", + "6 http://www.nuforc.org/webreports/155/S155608.html \n", + "\n", + " text posted \\\n", + "0 Viewed some red lights in the sky appearing to... 2021-12-19T00:00:00 \n", + "1 Look like 1 or 3 crafts from North traveling s... 2021-12-19T00:00:00 \n", + "3 One red light moving switly west to east, beco... 2021-12-19T00:00:00 \n", + "5 I'm familiar with all the fakery and UFO sight... 2020-07-09T00:00:00 \n", + "6 I was driving up lakes mead towards the lake a... 2020-05-01T00:00:00 \n", + "\n", + " city_latitude city_longitude \n", + "0 36.356650 -119.347937 \n", + "1 39.174503 -84.481363 \n", + "3 35.961561 -83.980115 \n", + "5 33.877422 -117.924978 \n", + "6 36.141246 -115.186592 \n", + "Fitting 3 folds for each of 36 candidates, totalling 108 fits\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Danil\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\preprocessing\\_encoders.py:246: UserWarning: Found unknown categories in columns [0, 1, 2, 3, 4] during transform. These unknown categories will be encoded as all zeros\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Старые параметры: {'max_depth': 10, 'min_samples_split': 2, 'n_estimators': 200}\n", + "Лучший результат (MSE) на старых параметрах: 0.5709161764408962\n", + "\n", + "Новые параметры: {'max_depth': 10, 'min_samples_split': 10, 'n_estimators': 200}\n", + "Лучший результат (MSE) на новых параметрах: 4.346034257469189\n", + "Среднеквадратическая ошибка (MSE) на тестовых данных: 0.1459878244079514\n", + "Корень среднеквадратичной ошибки (RMSE) на тестовых данных: 0.3820835306682969\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn import metrics\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.model_selection import train_test_split, GridSearchCV\n", + "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.pipeline import Pipeline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Загрузка датасета\n", + "df = pd.read_csv(\"../../datasets/nuforc_reports.csv\").head(100).dropna()\n", + "\n", + "# Вывод первых строк для проверки структуры\n", + "print(df.head())\n", + "\n", + "# Целевая переменная\n", + "target = df['city_latitude']\n", + "\n", + "# Удаление целевой переменной из признаков\n", + "features = df.drop(columns=['summary', 'stats', 'report_link', 'posted', \"duration\"])\n", + "\n", + "# Определение столбцов для обработки\n", + "num_columns = features.select_dtypes(include=['number']).columns\n", + "cat_columns = features.select_dtypes(include=['object']).columns\n", + "\n", + "# Препроцессинг числовых столбцов\n", + "num_imputer = SimpleImputer(strategy=\"median\")\n", + "num_scaler = StandardScaler()\n", + "preprocessing_num = Pipeline([\n", + " (\"imputer\", num_imputer),\n", + " (\"scaler\", num_scaler),\n", + "])\n", + "\n", + "# Препроцессинг категориальных столбцов\n", + "cat_imputer = SimpleImputer(strategy=\"constant\", fill_value=\"unknown\")\n", + "cat_encoder = OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False, drop=\"first\")\n", + "preprocessing_cat = Pipeline([\n", + " (\"imputer\", cat_imputer),\n", + " (\"encoder\", cat_encoder),\n", + "])\n", + "\n", + "# Объединение препроцессинга\n", + "features_preprocessing = ColumnTransformer(\n", + " verbose_feature_names_out=False,\n", + " transformers=[\n", + " (\"preprocessing_num\", preprocessing_num, num_columns),\n", + " (\"preprocessing_cat\", preprocessing_cat, cat_columns),\n", + " ],\n", + " remainder=\"passthrough\"\n", + ")\n", + "\n", + "# Создание финального пайплайна\n", + "pipeline_end = Pipeline([\n", + " (\"features_preprocessing\", features_preprocessing),\n", + "])\n", + "\n", + "# Разделение данных на обучающую и тестовую выборки\n", + "X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.2, random_state=42)\n", + "\n", + "# Применение пайплайна к данным\n", + "X_train_processed = pipeline_end.fit_transform(X_train)\n", + "X_test_processed = pipeline_end.transform(X_test)\n", + "\n", + "# 1. Настройка параметров для старых значений\n", + "old_param_grid = {\n", + " 'n_estimators': [50, 100, 200],\n", + " 'max_depth': [None, 10, 20, 30],\n", + " 'min_samples_split': [2, 5, 10]\n", + "}\n", + "\n", + "# Подбор гиперпараметров с помощью Grid Search для старых параметров\n", + "old_grid_search = GridSearchCV(estimator=RandomForestRegressor(),\n", + " param_grid=old_param_grid,\n", + " scoring='neg_mean_squared_error', cv=3, n_jobs=-1, verbose=2)\n", + "\n", + "# Обучение модели на тренировочных данных\n", + "old_grid_search.fit(X_train_processed, y_train)\n", + "\n", + "# Результаты подбора для старых параметров\n", + "old_best_params = old_grid_search.best_params_\n", + "old_best_mse = -old_grid_search.best_score_\n", + "\n", + "# 2. Настройка параметров для новых значений\n", + "new_param_grid = {\n", + " 'n_estimators': [200],\n", + " 'max_depth': [10],\n", + " 'min_samples_split': [10]\n", + "}\n", + "\n", + "# Подбор гиперпараметров с помощью Grid Search для новых параметров\n", + "new_grid_search = GridSearchCV(estimator=RandomForestRegressor(),\n", + " param_grid=new_param_grid,\n", + " scoring='neg_mean_squared_error', cv=2)\n", + "\n", + "# Обучение модели на тренировочных данных\n", + "new_grid_search.fit(X_train_processed, y_train)\n", + "\n", + "# Результаты подбора для новых параметров\n", + "new_best_params = new_grid_search.best_params_\n", + "new_best_mse = -new_grid_search.best_score_\n", + "\n", + "# 5. Обучение модели с лучшими параметрами для новых значений\n", + "model_best = RandomForestRegressor(**new_best_params)\n", + "model_best.fit(X_train_processed, y_train)\n", + "\n", + "# Прогнозирование на тестовой выборке\n", + "y_pred = model_best.predict(X_test_processed)\n", + "\n", + "# Оценка производительности модели\n", + "mse = metrics.mean_squared_error(y_test, y_pred)\n", + "rmse = np.sqrt(mse)\n", + "\n", + "# Вывод результатов\n", + "print(\"Старые параметры:\", old_best_params)\n", + "print(\"Лучший результат (MSE) на старых параметрах:\", old_best_mse)\n", + "print(\"\\nНовые параметры:\", new_best_params)\n", + "print(\"Лучший результат (MSE) на новых параметрах:\", new_best_mse)\n", + "print(\"Среднеквадратическая ошибка (MSE) на тестовых данных:\", mse)\n", + "print(\"Корень среднеквадратичной ошибки (RMSE) на тестовых данных:\", rmse)\n", + "\n", + "# Обучение модели с лучшими параметрами для старых значений\n", + "model_old = RandomForestRegressor(**old_best_params)\n", + "model_old.fit(X_train_processed, y_train)\n", + "\n", + "# Прогнозирование на тестовой выборке для старых параметров\n", + "y_pred_old = model_old.predict(X_test_processed)\n", + "\n", + "# Визуализация ошибок\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(y_test.values, label='Реальные значения', marker='o', linestyle='-', color='black')\n", + "plt.plot(y_pred_old, label='Предсказанные значения (старые параметры)', marker='x', linestyle='--', color='blue')\n", + "plt.plot(y_pred, label='Предсказанные значения (новые параметры)', marker='s', linestyle='--', color='orange')\n", + "plt.xlabel('Объекты')\n", + "plt.ylabel('Цена')\n", + "plt.title('Сравнение реальных и предсказанных значений')\n", + "plt.legend()\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}