diff --git a/.gitignore b/.gitignore index 8c2b884..c7c39b7 100644 --- a/.gitignore +++ b/.gitignore @@ -11,4 +11,5 @@ # Built Visual Studio Code Extensions *.vsix - +/data +/aimvenv diff --git a/Lab_2/lab_2.ipynb b/Lab_2/lab_2.ipynb new file mode 100644 index 0000000..57ce4ca --- /dev/null +++ b/Lab_2/lab_2.ipynb @@ -0,0 +1,936 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Выбранные темы: прогнозирование стоимости страховки, данные о населении, цены на автомобили." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Выделим вспомогательные функции" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from imblearn.over_sampling import RandomOverSampler\n", + "from imblearn.under_sampling import RandomUnderSampler\n", + "import seaborn as sns\n", + "import numpy as np\n", + "\n", + "label_encoder = LabelEncoder()\n", + "\n", + "# Функция для применения oversampling\n", + "def apply_oversampling(X, y):\n", + " oversampler = RandomOverSampler(random_state=42)\n", + " X_resampled, y_resampled = oversampler.fit_resample(X, y)\n", + " return X_resampled, y_resampled\n", + "\n", + "# Функция для применения undersampling\n", + "def apply_undersampling(X, y):\n", + " undersampler = RandomUnderSampler(random_state=42)\n", + " X_resampled, y_resampled = undersampler.fit_resample(X, y)\n", + " return X_resampled, y_resampled\n", + "\n", + "def split_stratified_into_train_val_test(\n", + " df_input,\n", + " stratify_colname=\"y\",\n", + " frac_train=0.6,\n", + " frac_val=0.15,\n", + " frac_test=0.25,\n", + " random_state=None,\n", + "):\n", + " \"\"\"\n", + " Splits a Pandas dataframe into three subsets (train, val, and test)\n", + " following fractional ratios provided by the user, where each subset is\n", + " stratified by the values in a specific column (that is, each subset has\n", + " the same relative frequency of the values in the column). It performs this\n", + " splitting by running train_test_split() twice.\n", + "\n", + " Parameters\n", + " ----------\n", + " df_input : Pandas dataframe\n", + " Input dataframe to be split.\n", + " stratify_colname : str\n", + " The name of the column that will be used for stratification. Usually\n", + " this column would be for the label.\n", + " frac_train : float\n", + " frac_val : float\n", + " frac_test : float\n", + " The ratios with which the dataframe will be split into train, val, and\n", + " test data. The values should be expressed as float fractions and should\n", + " sum to 1.0.\n", + " random_state : int, None, or RandomStateInstance\n", + " Value to be passed to train_test_split().\n", + "\n", + " Returns\n", + " -------\n", + " df_train, df_val, df_test :\n", + " Dataframes containing the three splits.\n", + " \"\"\"\n", + "\n", + " if frac_train + frac_val + frac_test != 1.0:\n", + " raise ValueError(\n", + " \"fractions %f, %f, %f do not add up to 1.0\"\n", + " % (frac_train, frac_val, frac_test)\n", + " )\n", + "\n", + " if stratify_colname not in df_input.columns:\n", + " raise ValueError(\"%s is not a column in the dataframe\" % (stratify_colname))\n", + "\n", + " X = df_input # Contains all columns.\n", + " y = df_input[\n", + " [stratify_colname]\n", + " ] # Dataframe of just the column on which to stratify.\n", + "\n", + " # Split original dataframe into train and temp dataframes.\n", + " df_train, df_temp, y_train, y_temp = train_test_split(\n", + " X, y, stratify=y, test_size=(1.0 - frac_train), random_state=random_state\n", + " )\n", + "\n", + " # Split the temp dataframe into val and test dataframes.\n", + " relative_frac_test = frac_test / (frac_val + frac_test)\n", + " df_val, df_test, y_val, y_test = train_test_split(\n", + " df_temp,\n", + " y_temp,\n", + " stratify=y_temp,\n", + " test_size=relative_frac_test,\n", + " random_state=random_state,\n", + " )\n", + "\n", + " assert len(df_input) == len(df_train) + len(df_val) + len(df_test)\n", + "\n", + " return df_train, df_val, df_test" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Анализ наборов данных" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1) Прогнозирование стоимости страховки" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Проблемная область: Медицинское страхование.\n", + "\n", + "Описание: Набор данных содержит информацию о клиентах медицинского страхования, включая возраст, пол, индекс массы тела (ИМТ), количество детей, курение, регион и стоимость страхового взноса.\n", + "\n", + "Связи между объектами: Нет явных связей, кроме того, что все объекты относятся к клиентам медицинского страхования.\n", + "\n", + "Бизнес-цель: Оптимизация тарифов страховых взносов.\n", + "\n", + "Эффект для бизнеса: Снижение рисков и повышение прибыльности за счет более точного определения стоимости страхования для разных групп клиентов.\n", + "\n", + "Цель технического проекта: Разработка модели машинного обучения для прогнозирования стоимости страхового взноса на основе характеристик клиента.\n", + "\n", + "Входные признаки: Возраст, пол, ИМТ, количество детей, курение, регион.\n", + "\n", + "Целевой признак: Стоимость страхового взноса." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Данный график позволят увидеть изменения стоимости страховки от возраста." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 2772 entries, 0 to 2771\n", + "Data columns (total 7 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 age 2772 non-null int64 \n", + " 1 sex 2772 non-null object \n", + " 2 bmi 2772 non-null float64\n", + " 3 children 2772 non-null int64 \n", + " 4 smoker 2772 non-null object \n", + " 5 region 2772 non-null object \n", + " 6 charges 2772 non-null float64\n", + "dtypes: float64(2), int64(2), object(3)\n", + "memory usage: 151.7+ KB\n", + "age 0\n", + "sex 0\n", + "bmi 0\n", + "children 0\n", + "smoker 0\n", + "region 0\n", + "charges 0\n", + "dtype: int64\n", + " age bmi children charges\n", + "count 2772.000000 2772.000000 2772.000000 2772.000000\n", + "mean 39.109668 30.701349 1.101732 13261.369959\n", + "std 14.081459 6.129449 1.214806 12151.768945\n", + "min 18.000000 15.960000 0.000000 1121.873900\n", + "25% 26.000000 26.220000 0.000000 4687.797000\n", + "50% 39.000000 30.447500 1.000000 9333.014350\n", + "75% 51.000000 34.770000 2.000000 16577.779500\n", + "max 64.000000 53.130000 5.000000 63770.428010\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df1 = pd.read_csv(\"../data/Medical_insurance.csv\")\n", + "df1.info()\n", + "print(df1.isnull().sum())\n", + "print(df1.describe())\n", + "\n", + "plt.scatter(df1[\"charges\"], df1[\"age\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Зашумленность: Возможны ошибки в данных, например, некорректные значения ИМТ.\n", + "\n", + "Смещение: Может быть смещение в данных, например, если выборка нерепрезентативна по полу или региону.\n", + "\n", + "Актуальность: Данные должны быть актуальными, чтобы модель давала точные прогнозы.\n", + "\n", + "Выбросы: Выбросы в данных, например, очень высокие значения стоимости страхового взноса.\n", + "\n", + "Просачивание данных: Не должно быть просачивания данных, например, если стоимость страхового взноса используется в качестве признака." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Примеры решения обнаруженных проблем:\n", + "\n", + "Зашумленность: Очистка данных, удаление или исправление ошибочных значений.\n", + "\n", + "Смещение: Балансировка данных, использование техники выборки.\n", + "\n", + "Актуальность: Использование актуальных данных.\n", + "\n", + "Выбросы: Удаление выбросов или использование техники обработки выбросов.\n", + "\n", + "Просачивание данных: Удаление целевого признака из обучающих данных." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Оценка:\n", + "\n", + "Информативность: Высокая, так как данные содержат много релевантных признаков для прогнозирования стоимости страхового взноса.\n", + "\n", + "Степень покрытия: Высокая, так как данные содержат информацию о большом количестве клиентов.\n", + "\n", + "Соответствие реальным данным: Высокое, так как данные взяты из реальной базы данных медицинского страхования.\n", + "\n", + "Согласованность меток: Высокая, так как данные имеют четко определенные метки." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Чтобы устранить проблемы прощенных строк, необходимо удалить строки с пропущенными значениями." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Разбиение набора данных на обучающую, контрольную и тестовую выборки\n", + "\n", + "Также потребуется приращение данных, если выборки несбалансированы по какому-либо признаку" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Обучающая выборка: (1663, 4)\n", + "Charges_Grouped\n", + "0 386\n", + "4 277\n", + "1 271\n", + "2 251\n", + "3 244\n", + "5 234\n", + "Name: count, dtype: int64\n", + "Обучающая выборка после oversampling: (2316, 4)\n", + "Charges_Grouped\n", + "3 386\n", + "5 386\n", + "0 386\n", + "1 386\n", + "4 386\n", + "2 386\n", + "Name: count, dtype: int64\n", + "Контрольная выборка: (554, 4)\n", + "Charges_Grouped\n", + "0 129\n", + "4 92\n", + "1 90\n", + "2 84\n", + "3 81\n", + "5 78\n", + "Name: count, dtype: int64\n", + "Тестовая выборка: (555, 4)\n", + "Charges_Grouped\n", + "0 129\n", + "4 93\n", + "1 91\n", + "2 83\n", + "3 81\n", + "5 78\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "data = df1[[\"age\", \"charges\", \"children\"]].copy()\n", + "data[\"Charges_Grouped\"] = pd.cut(data[\"age\"], bins=6, labels=False)\n", + "\n", + "interval_counts = data[\"Charges_Grouped\"].value_counts().sort_index()\n", + "\n", + "min_samples_per_interval = 10\n", + "for interval, count in interval_counts.items():\n", + " if count < min_samples_per_interval:\n", + " data.loc[data[\"Charges_Grouped\"] == interval, \"Charges_Grouped\"] = -1\n", + "\n", + "\n", + "df_insurance_train, df_insurance_val, df_insurance_test = split_stratified_into_train_val_test(\n", + " data, stratify_colname=\"Charges_Grouped\", frac_train=0.60, frac_val=0.20, frac_test=0.20)\n", + "\n", + "print(\"Обучающая выборка: \", df_insurance_train.shape)\n", + "print(df_insurance_train[\"Charges_Grouped\"].value_counts())\n", + "\n", + "X_resampled, y_resampled = apply_oversampling(df_insurance_train, df_insurance_train[\"Charges_Grouped\"])\n", + "df_insurance_train_adasyn = pd.DataFrame(X_resampled)\n", + "\n", + "print(\"Обучающая выборка после oversampling: \", df_insurance_train_adasyn.shape)\n", + "print(df_insurance_train_adasyn[\"Charges_Grouped\"].value_counts())\n", + "\n", + "print(\"Контрольная выборка: \", df_insurance_val.shape)\n", + "print(df_insurance_val[\"Charges_Grouped\"].value_counts())\n", + "\n", + "print(\"Тестовая выборка: \", df_insurance_test.shape)\n", + "print(df_insurance_test[\"Charges_Grouped\"].value_counts())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Данные хорошо подходят для построения модели прогнозирования стоимости страхового взноса. Возможны проблемы с зашумленностью и смещением данных." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Цены на автомобили" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Проблемная область: Автомобильная индустрия.\n", + "\n", + "Описание: Набор данных содержит информацию о характеристиках автомобилей, таких как марка, модель, год выпуска, пробег, тип топлива, тип трансмиссии и цена продажи. Нет явных связей, кроме того, что все объекты относятся к автомобилям.\n", + "\n", + "Бизнес-цель: Оптимизация ценообразования на вторичном рынке автомобилей.\n", + "\n", + "Эффект для бизнеса: Увеличение продаж и прибыли за счет более точной оценки рыночной стоимости автомобилей.\n", + "\n", + "Цель технического проекта: Разработка модели машинного обучения для прогнозирования рыночной стоимости автомобиля на основе его характеристик.\n", + "\n", + "Входные признаки: Марка, модель, год выпуска, пробег, тип топлива, тип трансмиссии.\n", + "\n", + "Целевой признак: Цена продажи." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 19237 entries, 0 to 19236\n", + "Data columns (total 18 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 ID 19237 non-null int64 \n", + " 1 Price 19237 non-null int64 \n", + " 2 Levy 19237 non-null object \n", + " 3 Manufacturer 19237 non-null object \n", + " 4 Model 19237 non-null object \n", + " 5 Prod. year 19237 non-null int64 \n", + " 6 Category 19237 non-null object \n", + " 7 Leather interior 19237 non-null object \n", + " 8 Fuel type 19237 non-null object \n", + " 9 Engine volume 19237 non-null object \n", + " 10 Mileage 19237 non-null object \n", + " 11 Cylinders 19237 non-null float64\n", + " 12 Gear box type 19237 non-null object \n", + " 13 Drive wheels 19237 non-null object \n", + " 14 Doors 19237 non-null object \n", + " 15 Wheel 19237 non-null object \n", + " 16 Color 19237 non-null object \n", + " 17 Airbags 19237 non-null int64 \n", + "dtypes: float64(1), int64(4), object(13)\n", + "memory usage: 2.6+ MB\n", + "ID 0\n", + "Price 0\n", + "Levy 0\n", + "Manufacturer 0\n", + "Model 0\n", + "Prod. year 0\n", + "Category 0\n", + "Leather interior 0\n", + "Fuel type 0\n", + "Engine volume 0\n", + "Mileage 0\n", + "Cylinders 0\n", + "Gear box type 0\n", + "Drive wheels 0\n", + "Doors 0\n", + "Wheel 0\n", + "Color 0\n", + "Airbags 0\n", + "dtype: int64\n", + " ID Price Prod. year Cylinders Airbags\n", + "count 1.923700e+04 1.923700e+04 19237.000000 19237.000000 19237.000000\n", + "mean 4.557654e+07 1.855593e+04 2010.912824 4.582991 6.582627\n", + "std 9.365914e+05 1.905813e+05 5.668673 1.199933 4.320168\n", + "min 2.074688e+07 1.000000e+00 1939.000000 1.000000 0.000000\n", + "25% 4.569837e+07 5.331000e+03 2009.000000 4.000000 4.000000\n", + "50% 4.577231e+07 1.317200e+04 2012.000000 4.000000 6.000000\n", + "75% 4.580204e+07 2.207500e+04 2015.000000 4.000000 12.000000\n", + "max 4.581665e+07 2.630750e+07 2020.000000 16.000000 16.000000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df2 = pd.read_csv(\"../data/car_price_prediction.csv\")\n", + "df2.info()\n", + "print(df2.isnull().sum())\n", + "print(df2.describe())\n", + "\n", + "mean_price_per_year = df2.groupby('Prod. year')['Price'].mean()\n", + "plt.figure(figsize=(8, 6))\n", + "mean_price_per_year.plot(kind='line', marker='o', color='blue')\n", + "plt.title('Зависимость средней цены от года выпуска автомобиля')\n", + "plt.xlabel('Год выпуска')\n", + "plt.ylabel('Средняя цена ($)')\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Зашумленность: Возможны ошибки в данных, например, некорректные значения пробега.\n", + "\n", + "Смещение: Может быть смещение в данных, например, если выборка нерепрезентативна по марке или модели автомобиля.\n", + "\n", + "Актуальность: Данные должны быть актуальными, чтобы модель давала точные прогнозы.\n", + "\n", + "Выбросы: Возможны выбросы в данных, например, очень высокие или низкие значения цены продажи.\n", + "\n", + "Просачивание данных: Не должно быть просачивания данных, например, если цена продажи используется в качестве признака.\n", + "\n", + "Решение этих проблем:\n", + "\n", + "Зашумленность: Очистка данных, удаление или исправление ошибочных значений.\n", + "\n", + "Смещение: Балансировка данных, использование техники выборки.\n", + "\n", + "Актуальность: Использование актуальных данных.\n", + "\n", + "Выбросы: Удаление выбросов или использование техники обработки выбросов.\n", + "\n", + "Просачивание данных: Удаление целевого признака из обучающих данных." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Оценка:\n", + "\n", + "Информативность: Высокая, так как данные содержат много релевантных признаков для прогнозирования стоимости страхового взноса.\n", + "\n", + "Степень покрытия: Высокая, так как данные содержат информацию о большом количестве клиентов.\n", + "\n", + "Соответствие реальным данным: Высокое, так как данные взяты из реальной базы данных медицинского страхования.\n", + "\n", + "Согласованность меток: Высокая, так как данные имеют четко определенные метки." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Разбиение набора данных на обучающую, контрольную и тестовую выборки\n", + "\n", + "Также потребуется приращение данных, если выборки несбалансированы по какому-либо признаку" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Обучающая выборка: (11541, 4)\n", + "Price_Grouped\n", + " 0 7371\n", + " 1 2761\n", + " 2 935\n", + " 3 272\n", + " 4 96\n", + " 5 50\n", + " 6 22\n", + " 7 13\n", + "-1 9\n", + " 8 8\n", + " 9 4\n", + "Name: count, dtype: int64\n", + "Обучающая выборка после oversampling: (81081, 4)\n", + "Price_Grouped\n", + " 0 7371\n", + " 1 7371\n", + " 2 7371\n", + " 5 7371\n", + " 3 7371\n", + " 4 7371\n", + " 7 7371\n", + " 6 7371\n", + " 8 7371\n", + "-1 7371\n", + " 9 7371\n", + "Name: count, dtype: int64\n", + "Контрольная выборка: (3847, 4)\n", + "Price_Grouped\n", + " 0 2457\n", + " 1 920\n", + " 2 311\n", + " 3 91\n", + " 4 32\n", + " 5 17\n", + " 6 8\n", + " 7 4\n", + " 8 3\n", + "-1 3\n", + " 9 1\n", + "Name: count, dtype: int64\n", + "Тестовая выборка: (3848, 4)\n", + "Price_Grouped\n", + " 0 2458\n", + " 1 921\n", + " 2 312\n", + " 3 90\n", + " 4 32\n", + " 5 17\n", + " 6 7\n", + " 7 4\n", + " 8 3\n", + "-1 3\n", + " 9 1\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "df2 = df2[df2['Price'] <= 10000000]\n", + "\n", + "data = df2[[\"Price\", \"Prod. year\", \"Airbags\"]].copy()\n", + "data[\"Price_Grouped\"] = pd.cut(data[\"Price\"], bins=50, labels=False)\n", + "\n", + "interval_counts = data[\"Price_Grouped\"].value_counts().sort_index()\n", + "\n", + "min_samples_per_interval = 5\n", + "for interval, count in interval_counts.items():\n", + " if count < min_samples_per_interval:\n", + " data.loc[data[\"Price_Grouped\"] == interval, \"Price_Grouped\"] = -1\n", + "\n", + "df_price_train, df_price_val, df_price_test = split_stratified_into_train_val_test(\n", + " data, stratify_colname=\"Price_Grouped\", frac_train=0.60, frac_val=0.20, frac_test=0.20)\n", + "\n", + "print(\"Обучающая выборка: \", df_price_train.shape)\n", + "print(df_price_train[\"Price_Grouped\"].value_counts())\n", + "\n", + "\n", + "X_resampled, y_resampled = apply_oversampling(df_price_train, df_price_train[\"Price_Grouped\"])\n", + "df_price_train_adasyn = pd.DataFrame(X_resampled)\n", + "\n", + "print(\"Обучающая выборка после oversampling: \", df_price_train_adasyn.shape)\n", + "print(df_price_train_adasyn[\"Price_Grouped\"].value_counts())\n", + "\n", + "\n", + "print(\"Контрольная выборка: \", df_price_val.shape)\n", + "print(df_price_val[\"Price_Grouped\"].value_counts())\n", + "\n", + "print(\"Тестовая выборка: \", df_price_test.shape)\n", + "print(df_price_test[\"Price_Grouped\"].value_counts())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Данные хорошо подходят для построения модели прогнозирования цены продажи автомобиля. Возможны проблемы с зашумленностью и смещением данных." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Цены на кофе" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Проблемная область: Финансы и инвестиции.\n", + "\n", + "Описание: Набор данных содержит исторические данные о ценах на акции Starbucks (тикер: SBUX) с 1992 по 2021 год. Данные включают информацию о ценах открытия, закрытия, максимальных и минимальных ценах, объеме торгов и скорректированных ценах закрытия.\n", + "\n", + "Связи между объектами: Данные представлены временным рядом, где каждая строка соответствует одному торговому дню. Между объектами существует временная зависимость, так как цены на акции зависят от предыдущих значений.\n", + "\n", + "Бизнес-цель: Прогнозирование будущих цен на акции Starbucks.\n", + "\n", + "Эффект для бизнеса:\n", + "\n", + "Для инвесторов: Повышение точности прогнозов позволяет инвесторам принимать более обоснованные решения о покупке и продаже акций, что может привести к увеличению прибыли.\n", + "\n", + "Для компании Starbucks: Понимание динамики цен на акции может помочь в разработке стратегий привлечения инвестиций и повышения рыночной стоимости компании." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Цель технического проекта: Разработка модели машинного обучения для прогнозирования цены закрытия акций Starbucks на следующий день.\n", + "\n", + "Входные признаки:\n", + "\n", + "Open (цена открытия)\n", + "\n", + "High (максимальная цена)\n", + "\n", + "Low (минимальная цена)\n", + "\n", + "Close (цена закрытия)\n", + "\n", + "Volume (объем торгов)\n", + "\n", + "Adj Close (скорректированная цена закрытия)\n", + "\n", + "Целевой признак: Close (цена закрытия на следующий день)." + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 8036 entries, 0 to 8035\n", + "Data columns (total 7 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Date 8036 non-null object \n", + " 1 Open 8036 non-null float64\n", + " 2 High 8036 non-null float64\n", + " 3 Low 8036 non-null float64\n", + " 4 Close 8036 non-null float64\n", + " 5 Adj Close 8036 non-null float64\n", + " 6 Volume 8036 non-null int64 \n", + "dtypes: float64(5), int64(1), object(1)\n", + "memory usage: 439.6+ KB\n", + "Date 0\n", + "Open 0\n", + "High 0\n", + "Low 0\n", + "Close 0\n", + "Adj Close 0\n", + "Volume 0\n", + "dtype: int64\n", + " Open High Low Close Adj Close \\\n", + "count 8036.000000 8036.000000 8036.000000 8036.000000 8036.000000 \n", + "mean 30.054280 30.351487 29.751322 30.058857 26.674025 \n", + "std 33.615577 33.906613 33.314569 33.615911 31.728090 \n", + "min 0.328125 0.347656 0.320313 0.335938 0.260703 \n", + "25% 4.392031 4.531250 4.304922 4.399610 3.414300 \n", + "50% 13.325000 13.493750 13.150000 13.330000 10.352452 \n", + "75% 55.250000 55.722501 54.852499 55.267499 47.464829 \n", + "max 126.080002 126.320000 124.809998 126.059998 118.010414 \n", + "\n", + " Volume \n", + "count 8.036000e+03 \n", + "mean 1.470459e+07 \n", + "std 1.340021e+07 \n", + "min 1.504000e+06 \n", + "25% 7.817750e+06 \n", + "50% 1.169815e+07 \n", + "75% 1.778795e+07 \n", + "max 5.855088e+08 \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df3 = pd.read_csv(\"../data/Starbucks Dataset.csv\")\n", + "df3.info()\n", + "print(df3.isnull().sum())\n", + "print(df3.describe())\n", + "\n", + "plt.plot(df3[\"Date\"], df3[\"High\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Зашумленность: Возможны случайные колебания цен, которые могут быть вызваны внешними факторами.\n", + "\n", + "Смещение: Нет явного смещения, так как данные представляют собой временной ряд.\n", + "\n", + "Актуальность: Данные актуальны до 2021 года, но для более точного прогнозирования могут потребоваться более свежие данные.\n", + "\n", + "Выбросы: Возможны выбросы в данных, например, резкие скачки цен, вызванные внешними событиями (кризисы, слияния и поглощения).\n", + "\n", + "Просачивание данных: Не должно быть просачивания данных, так как целевой признак (цена закрытия на следующий день) не должен использоваться в качестве признака." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Примеры их решений:\n", + "\n", + "Зашумленность: Использование методов сглаживания временных рядов, таких как скользящее среднее или экспоненциальное сглаживание.\n", + "\n", + "Выбросы: Удаление выбросов или использование техники обработки выбросов, такой как Winsorization.\n", + "\n", + "Актуальность: Обновление данных до последней доступной даты." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Оценка набора данных:\n", + "\n", + "Информативность: Высокая, так как данные содержат много релевантных признаков для прогнозирования цен на акции.\n", + "\n", + "Степень покрытия: Высокая, так как данные охватывают длительный период времени (1992-2021).\n", + "\n", + "Соответствие реальным данным: Высокое, так как данные взяты из реальной торговой платформы.\n", + "\n", + "Согласованность меток: Высокая, так как данные имеют четко определенные метки." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Выборки сбалансированы, так как данные представляют собой временной ряд, и каждая строка соответствует одному торговому дню.\n", + "Данные представлены в виде временного ряда, поэтому не требуется исмпользовать методы приращения данных." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Для временных рядов методы oversampling и undersampling обычно не применяются, так как они могут нарушить временную структуру данных." + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Обучающая выборка: (4821, 4)\n", + "Volume_Grouped\n", + " 0 2802\n", + " 1 1460\n", + " 2 369\n", + " 3 111\n", + " 4 40\n", + " 5 18\n", + "-1 10\n", + " 6 7\n", + " 7 4\n", + "Name: count, dtype: int64\n", + "Контрольная выборка: (1607, 4)\n", + "Volume_Grouped\n", + " 0 934\n", + " 1 487\n", + " 2 123\n", + " 3 37\n", + " 4 13\n", + " 5 6\n", + "-1 4\n", + " 6 2\n", + " 7 1\n", + "Name: count, dtype: int64\n", + "Тестовая выборка: (1608, 4)\n", + "Volume_Grouped\n", + " 0 934\n", + " 1 487\n", + " 2 124\n", + " 3 37\n", + " 4 14\n", + " 5 6\n", + "-1 3\n", + " 6 2\n", + " 7 1\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "data = df3[[\"Volume\", \"High\", \"Low\"]].copy()\n", + "data[\"Volume_Grouped\"] = pd.cut(data[\"Volume\"], bins=50, labels=False)\n", + "\n", + "interval_counts = data[\"Volume_Grouped\"].value_counts().sort_index()\n", + "\n", + "min_samples_per_interval = 5\n", + "for interval, count in interval_counts.items():\n", + " if count < min_samples_per_interval:\n", + " data.loc[data[\"Volume_Grouped\"] == interval, \"Volume_Grouped\"] = -1\n", + "\n", + "\n", + "df_coffee_train, df_coffee_val, df_coffee_test = split_stratified_into_train_val_test(\n", + " data, stratify_colname=\"Volume_Grouped\", frac_train=0.60, frac_val=0.20, frac_test=0.20)\n", + "\n", + "print(\"Обучающая выборка: \", df_coffee_train.shape)\n", + "print(df_coffee_train[\"Volume_Grouped\"].value_counts())\n", + "\n", + "print(\"Контрольная выборка: \", df_coffee_val.shape)\n", + "print(df_coffee_val[\"Volume_Grouped\"].value_counts())\n", + "\n", + "print(\"Тестовая выборка: \", df_coffee_test.shape)\n", + "print(df_coffee_test[\"Volume_Grouped\"].value_counts())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Вывод:\n", + "\n", + "Данные хорошо подходят для построения модели прогнозирования цен на акции Starbucks.\n", + "\n", + "Возможны проблемы с зашумленностью и выбросами в данных.\n", + "\n", + "Для улучшения качества модели можно использовать методы сглаживания временных рядов и обработки выбросов." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "aimvenv", + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}