424 KiB
424 KiB
Начало лабораторной работы¶
In [85]:
import pandas as pd
df = pd.read_csv("data/Medical_insurance.csv")
print(df.columns)
Бизнес-цели¶
- Прогнозирование стоимости страховых взносов:
Цель: Разработать модель, которая будет предсказывать стоимость страховых взносов для новых клиентов на основе их характеристик (возраст, пол, ИМТ, количество детей, статус курения, регион проживания).
Применение: Клиенты могут получить представление о примерной стоимости страховки до обращения в компанию.
- Оптимизация тарифной сетки:
Цель: Определить оптимальные коэффициенты для различных факторов, влияющих на стоимость страховки (например, возраст, ИМТ, статус курения), чтобы максимизировать прибыль компании при сохранении конкурентоспособных тарифов.
Применение: Страховые компании могут использовать эти коэффициенты для корректировки тарифной сетки и повышения эффективности бизнеса.
- Прогнозирование стоимости страховых взносов:
In [86]:
import pandas as pd
# Загружаем набор данных
df = pd.read_csv("data/Medical_insurance.csv")
# Устанавливаем случайное состояние
random_state = 42
# Рассчитываем среднее значение стоимости страховых взносов
average_charges = df['charges'].mean()
print(f"Среднее значение поля 'charges': {average_charges}")
# Создаем новую переменную, указывающую, превышает ли стоимость страховых взносов среднюю
df['above_average_charges'] = (df['charges'] > average_charges).astype(int)
# Рассчитываем волатильность (разницу между максимальной и минимальной стоимостью страховых взносов)
df['charges_volatility'] = df['charges'].max() - df['charges'].min()
# Выводим первые строки измененной таблицы для проверки
print(df.head())
- Оптимизация тарифной сетки:
In [87]:
import pandas as pd
# Загружаем набор данных
df = pd.read_csv("data/Medical_insurance.csv")
# Рассчитываем среднюю стоимость страховых взносов для каждого значения каждого признака
for column in ['age', 'sex', 'bmi', 'children', 'smoker', 'region']:
print(f"Средняя стоимость страховых взносов для '{column}':")
print(df.groupby(column)['charges'].mean())
print()
# Рассчитываем среднюю стоимость страховых взносов для комбинаций признаков
# для комбинации 'age' и 'smoker'
print("Средняя стоимость страховых взносов для комбинации 'age' и 'smoker':")
print(df.groupby(['age', 'smoker'])['charges'].mean())
print()
# Рассчитываем среднюю стоимость страховых взносов для комбинации 'bmi' и 'smoker'
print("Средняя стоимость страховых взносов для комбинации 'bmi' и 'smoker':")
print(df.groupby(['bmi', 'smoker'])['charges'].mean())
print()
# Рассчитываем среднюю стоимость страховых взносов для комбинации 'region' и 'smoker'
print("Средняя стоимость страховых взносов для комбинации 'region' и 'smoker':")
print(df.groupby(['region', 'smoker'])['charges'].mean())
print()
In [88]:
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
from imblearn.over_sampling import SMOTE
# Загружаем набор данных
df = pd.read_csv("data/Medical_insurance.csv")
# Проверка наличия пропусков
if df.isnull().sum().any():
print("Пропуски обнаружены в следующих столбцах:")
print(df.isnull().sum())
else:
print("Пропуски не обнаружены.")
# Преобразуем категориальные переменные в числовые
df = pd.get_dummies(df, columns=['sex', 'smoker', 'region'], drop_first=True)
# Разделяем данные на признаки (X) и целевую переменную (y)
X = df.drop('charges', axis=1)
y = df['charges']
# Разделяем данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Стандартизируем признаки
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# Обучаем модель линейной регрессии
model = LinearRegression()
model.fit(X_train, y_train)
# Делаем предсказания на тестовой выборке
y_pred = model.predict(X_test)
# Оцениваем качество модели
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = mean_squared_error(y_test, y_pred, squared=False)
r2 = r2_score(y_test, y_pred)
print(f"MAE: {mae}")
print(f"MSE: {mse}")
print(f"RMSE: {rmse}")
print(f"R²: {r2}")
# Проверяем, достигнуты ли ориентиры
if r2 >= 0.75 and mae <= 3000 and rmse <= 5000:
print("Ориентиры для прогнозирования стоимости страховых взносов достигнуты!")
else:
print("Ориентиры для прогнозирования стоимости страховых взносов не достигнуты.")
# Оптимизация тарифной сетки
# Убедитесь, что столбцы существуют
columns_to_group = ['age', 'bmi', 'children', 'sex_male', 'smoker_yes', 'region_northwest', 'region_southeast', 'region_southwest']
# Рассчитываем среднюю стоимость страховых взносов для каждого значения каждого признака
for column in columns_to_group:
print(f"Средняя стоимость страховых взносов для '{column}':")
print(df.groupby(column)['charges'].mean())
print()
# Рассчитываем среднюю стоимость страховых взносов для комбинаций признаков
# Например, для комбинации 'age' и 'smoker_yes'
print("Средняя стоимость страховых взносов для комбинации 'age' и 'smoker_yes':")
print(df.groupby(['age', 'smoker_yes'])['charges'].mean())
print()
# Рассчитываем среднюю стоимость страховых взносов для комбинации 'bmi' и 'smoker_yes'
print("Средняя стоимость страховых взносов для комбинации 'bmi' и 'smoker_yes':")
print(df.groupby(['bmi', 'smoker_yes'])['charges'].mean())
print()
# Рассчитываем среднюю стоимость страховых взносов для комбинации 'region_northwest' и 'smoker_yes'
print("Средняя стоимость страховых взносов для комбинации 'region_northwest' и 'smoker_yes':")
print(df.groupby(['region_northwest', 'smoker_yes'])['charges'].mean())
print()
In [89]:
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from sklearn.ensemble import GradientBoostingRegressor, GradientBoostingClassifier
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score, accuracy_score
# Загружаем набор данных
df = pd.read_csv("data/Medical_insurance.csv")
# Преобразуем категориальные переменные в числовые
df = pd.get_dummies(df, columns=['sex', 'smoker', 'region'], drop_first=True)
# Разделяем данные на признаки (X) и целевую переменную (y) для задачи регрессии
X_reg = df.drop('charges', axis=1)
y_reg = df['charges']
# Разделяем данные на обучающую и тестовую выборки для задачи регрессии
X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)
# Стандартизируем признаки для задачи регрессии
scaler_reg = StandardScaler()
X_train_reg = scaler_reg.fit_transform(X_train_reg)
X_test_reg = scaler_reg.transform(X_test_reg)
# Список моделей для задачи регрессии
models_reg = {
"Linear Regression": LinearRegression(),
"Random Forest Regression": RandomForestRegressor(),
"Gradient Boosting Regression": GradientBoostingRegressor()
}
# Обучаем и оцениваем модели для задачи регрессии
print("Результаты для задачи регрессии:")
for name, model in models_reg.items():
model.fit(X_train_reg, y_train_reg)
y_pred_reg = model.predict(X_test_reg)
mae = mean_absolute_error(y_test_reg, y_pred_reg)
mse = mean_squared_error(y_test_reg, y_pred_reg)
rmse = mean_squared_error(y_test_reg, y_pred_reg, squared=False)
r2 = r2_score(y_test_reg, y_pred_reg)
print(f"Model: {name}")
print(f"MAE: {mae}")
print(f"MSE: {mse}")
print(f"RMSE: {rmse}")
print(f"R²: {r2}")
print()
# Разделяем данные на признаки (X) и целевую переменную (y) для задачи классификации
X_class = df.drop('charges', axis=1)
y_class = (df['charges'] > df['charges'].mean()).astype(int)
# Разделяем данные на обучающую и тестовую выборки для задачи классификации
X_train_class, X_test_class, y_train_class, y_test_class = train_test_split(X_class, y_class, test_size=0.2, random_state=42)
# Стандартизируем признаки для задачи классификации
scaler_class = StandardScaler()
X_train_class = scaler_class.fit_transform(X_train_class)
X_test_class = scaler_class.transform(X_test_class)
# Список моделей для задачи классификации
models_class = {
"Logistic Regression": LogisticRegression(max_iter=1000),
"Random Forest Classification": RandomForestClassifier(),
"Gradient Boosting Classification": GradientBoostingClassifier()
}
# Обучаем и оцениваем модели для задачи классификации
print("Результаты для задачи классификации:")
for name, model in models_class.items():
model.fit(X_train_class, y_train_class)
y_pred_class = model.predict(X_test_class)
accuracy = accuracy_score(y_test_class, y_pred_class)
print(f"Model: {name}")
print(f"Accuracy: {accuracy}")
# Вычисление вероятностей для логистической регрессии
if name == "Logistic Regression":
y_pred_probs = model.predict_proba(X_test_class)[:, 1]
mae = mean_absolute_error(y_test_class, y_pred_probs)
mse = mean_squared_error(y_test_class, y_pred_probs)
rmse = mean_squared_error(y_test_class, y_pred_probs, squared=False)
r2 = r2_score(y_test_class, y_pred_probs)
print(f"MAE: {mae}")
print(f"MSE: {mse}")
print(f"RMSE: {rmse}")
print(f"R²: {r2}")
print()
- Прогнозирование стоимости страховых взносов: Конвейер для задачи регрессии:
In [90]:
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
# Загружаем набор данных
df = pd.read_csv("data/Medical_insurance.csv")
# Определяем категориальные и числовые столбцы
categorical_cols = ['sex', 'smoker', 'region']
numerical_cols = ['age', 'bmi', 'children']
# Создаем преобразователь для категориальных и числовых столбцов
preprocessor = ColumnTransformer(
transformers=[
('cat', OneHotEncoder(), categorical_cols),
('num', StandardScaler(), numerical_cols)
])
# Список моделей для задачи регрессии
models_reg = {
"Linear Regression": LinearRegression(),
"Random Forest Regression": RandomForestRegressor(),
"Gradient Boosting Regression": GradientBoostingRegressor()
}
# Разделяем данные на признаки (X) и целевую переменную (y) для задачи регрессии
X_reg = df[categorical_cols + numerical_cols]
y_reg = df['charges']
# Разделяем данные на обучающую и тестовую выборки для задачи регрессии
X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)
# Обучаем и оцениваем модели для задачи регрессии
print("Результаты для задачи регрессии:")
for name, model in models_reg.items():
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('model', model)
])
pipeline.fit(X_train_reg, y_train_reg)
y_pred_reg = pipeline.predict(X_test_reg)
mae = mean_absolute_error(y_test_reg, y_pred_reg)
mse = mean_squared_error(y_test_reg, y_pred_reg)
rmse = mean_squared_error(y_test_reg, y_pred_reg, squared=False)
r2 = r2_score(y_test_reg, y_pred_reg)
print(f"Model: {name}")
print(f"MAE: {mae}")
print(f"MSE: {mse}")
print(f"RMSE: {rmse}")
print(f"R²: {r2}")
print()
- Оптимизация тарифной сетки: Конвейер для задачи классификации:
In [91]:
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.metrics import accuracy_score
# Загружаем набор данных
df = pd.read_csv("data/Medical_insurance.csv")
# Определяем категориальные и числовые столбцы
categorical_cols = ['sex', 'smoker', 'region']
numerical_cols = ['age', 'bmi', 'children']
# Создаем преобразователь для категориальных и числовых столбцов
preprocessor = ColumnTransformer(
transformers=[
('cat', OneHotEncoder(), categorical_cols),
('num', StandardScaler(), numerical_cols)
])
# Список моделей для задачи классификации
models_class = {
"Logistic Regression": LogisticRegression(),
"Random Forest Classification": RandomForestClassifier(),
"Gradient Boosting Classification": GradientBoostingClassifier()
}
# Разделяем данные на признаки (X) и целевую переменную (y) для задачи классификации
X_class = df[categorical_cols + numerical_cols]
y_class = (df['charges'] > df['charges'].mean()).astype(int)
# Разделяем данные на обучающую и тестовую выборки для задачи классификации
X_train_class, X_test_class, y_train_class, y_test_class = train_test_split(X_class, y_class, test_size=0.2, random_state=42)
# Обучаем и оцениваем модели для задачи классификации
print("Результаты для задачи классификации:")
for name, model in models_class.items():
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('model', model)
])
pipeline.fit(X_train_class, y_train_class)
y_pred_class = pipeline.predict(X_test_class)
accuracy = accuracy_score(y_test_class, y_pred_class)
print(f"Model: {name}")
print(f"Accuracy: {accuracy}")
print()
- Прогнозирование стоимости страховых взносов:
Настройка гиперпараметров для задачи регрессии:
In [92]:
import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
# Загружаем набор данных
df = pd.read_csv("data/Medical_insurance.csv")
# Определяем категориальные и числовые столбцы
categorical_cols = ['sex', 'smoker', 'region']
numerical_cols = ['age', 'bmi', 'children']
# Создаем преобразователь для категориальных и числовых столбцов
preprocessor = ColumnTransformer(
transformers=[
('cat', OneHotEncoder(), categorical_cols),
('num', StandardScaler(), numerical_cols)
])
# Список моделей и их гиперпараметров для задачи регрессии
models_reg = {
"Linear Regression": (LinearRegression(), {}),
"Random Forest Regression": (RandomForestRegressor(), {
'model__n_estimators': [100, 200],
'model__max_depth': [None, 10, 20]
}),
"Gradient Boosting Regression": (GradientBoostingRegressor(), {
'model__n_estimators': [100, 200],
'model__learning_rate': [0.01, 0.1],
'model__max_depth': [3, 5]
})
}
# Разделяем данные на признаки (X) и целевую переменную (y) для задачи регрессии
X_reg = df[categorical_cols + numerical_cols]
y_reg = df['charges']
# Разделяем данные на обучающую и тестовую выборки для задачи регрессии
X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)
# Обучаем и оцениваем модели для задачи регрессии
print("Результаты для задачи регрессии:")
for name, (model, params) in models_reg.items():
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('model', model)
])
grid_search = GridSearchCV(pipeline, params, cv=5, scoring='neg_mean_absolute_error')
grid_search.fit(X_train_reg, y_train_reg)
best_model = grid_search.best_estimator_
y_pred_reg = best_model.predict(X_test_reg)
mae = mean_absolute_error(y_test_reg, y_pred_reg)
mse = mean_squared_error(y_test_reg, y_pred_reg)
rmse = mean_squared_error(y_test_reg, y_pred_reg, squared=False)
r2 = r2_score(y_test_reg, y_pred_reg)
print(f"Model: {name}")
print(f"Best Parameters: {grid_search.best_params_}")
print(f"MAE: {mae}")
print(f"MSE: {mse}")
print(f"RMSE: {rmse}")
print(f"R²: {r2}")
print()
- Оптимизация тарифной сетки:
Настройка гиперпараметров для задачи классификации:
In [93]:
import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.metrics import accuracy_score
# Загружаем набор данных
df = pd.read_csv("data/Medical_insurance.csv")
# Определяем категориальные и числовые столбцы
categorical_cols = ['sex', 'smoker', 'region']
numerical_cols = ['age', 'bmi', 'children']
# Создаем преобразователь для категориальных и числовых столбцов
preprocessor = ColumnTransformer(
transformers=[
('cat', OneHotEncoder(), categorical_cols),
('num', StandardScaler(), numerical_cols)
])
# Список моделей и их гиперпараметров для задачи классификации
models_class = {
"Logistic Regression": (LogisticRegression(), {
'model__C': [0.1, 1, 10],
'model__solver': ['liblinear', 'lbfgs']
}),
"Random Forest Classification": (RandomForestClassifier(), {
'model__n_estimators': [100, 200],
'model__max_depth': [None, 10, 20]
}),
"Gradient Boosting Classification": (GradientBoostingClassifier(), {
'model__n_estimators': [100, 200],
'model__learning_rate': [0.01, 0.1],
'model__max_depth': [3, 5]
})
}
# Разделяем данные на признаки (X) и целевую переменную (y) для задачи классификации
X_class = df[categorical_cols + numerical_cols]
y_class = (df['charges'] > df['charges'].mean()).astype(int)
# Разделяем данные на обучающую и тестовую выборки для задачи классификации
X_train_class, X_test_class, y_train_class, y_test_class = train_test_split(X_class, y_class, test_size=0.2, random_state=42)
# Обучаем и оцениваем модели для задачи классификации
print("Результаты для задачи классификации:")
for name, (model, params) in models_class.items():
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('model', model)
])
grid_search = GridSearchCV(pipeline, params, cv=5, scoring='accuracy')
grid_search.fit(X_train_class, y_train_class)
best_model = grid_search.best_estimator_
y_pred_class = best_model.predict(X_test_class)
accuracy = accuracy_score(y_test_class, y_pred_class)
print(f"Model: {name}")
print(f"Best Parameters: {grid_search.best_params_}")
print(f"Accuracy: {accuracy}")
print()
In [94]:
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from sklearn.ensemble import GradientBoostingRegressor, GradientBoostingClassifier
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.metrics import (mean_absolute_error, mean_squared_error, r2_score,
accuracy_score, precision_score, recall_score,
f1_score, confusion_matrix, ConfusionMatrixDisplay,
roc_curve, auc)
# Загружаем набор данных
df = pd.read_csv("data/Medical_insurance.csv")
# Проверка наличия пропусков
if df.isnull().sum().any():
print("Пропуски обнаружены в следующих столбцах:")
print(df.isnull().sum())
else:
print("Пропуски не обнаружены.")
# Определяем категориальные и числовые столбцы
categorical_cols = ['sex', 'smoker', 'region']
numerical_cols = ['age', 'bmi', 'children']
# Создаем преобразователь для категориальных и числовых столбцов
preprocessor = ColumnTransformer(
transformers=[
('cat', OneHotEncoder(), categorical_cols),
('num', StandardScaler(), numerical_cols)
])
# Список моделей и их гиперпараметров для задачи регрессии
models_reg = {
"Linear Regression": (LinearRegression(), {}),
"Random Forest Regression": (RandomForestRegressor(), {
'model__n_estimators': [100, 200],
'model__max_depth': [None, 10, 20]
}),
"Gradient Boosting Regression": (GradientBoostingRegressor(), {
'model__n_estimators': [100, 200],
'model__learning_rate': [0.01, 0.1],
'model__max_depth': [3, 5]
})
}
# Распределяем данные на признаки и целевую переменную для задачи регрессии
X_reg = df[categorical_cols + numerical_cols]
y_reg = df['charges']
# Разделяем данные на обучающую и тестовую выборки для задачи регрессии
X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)
# Обучаем и оцениваем модели для задачи регрессии
print("Результаты для задачи регрессии:")
for name, (model, params) in models_reg.items():
pipeline = Pipeline(steps=[('preprocessor', preprocessor), ('model', model)])
grid_search = GridSearchCV(pipeline, params, cv=5, scoring='neg_mean_absolute_error')
grid_search.fit(X_train_reg, y_train_reg)
best_model = grid_search.best_estimator_
y_pred_reg = best_model.predict(X_test_reg)
mae = mean_absolute_error(y_test_reg, y_pred_reg)
mse = mean_squared_error(y_test_reg, y_pred_reg)
rmse = mean_squared_error(y_test_reg, y_pred_reg, squared=False)
r2 = r2_score(y_test_reg, y_pred_reg)
print(f"Model: {name}")
print(f"Best Parameters: {grid_search.best_params_}")
print(f"MAE: {mae}")
print(f"MSE: {mse}")
print(f"RMSE: {rmse}")
print(f"R²: {r2}\n")
# Список моделей и их гиперпараметров для задачи классификации
models_class = {
"Logistic Regression": (LogisticRegression(max_iter=1000), {
'model__C': [0.1, 1, 10],
'model__solver': ['liblinear', 'lbfgs']
}),
"Random Forest Classification": (RandomForestClassifier(), {
'model__n_estimators': [100, 200],
'model__max_depth': [None, 10, 20]
}),
"Gradient Boosting Classification": (GradientBoostingClassifier(), {
'model__n_estimators': [100, 200],
'model__learning_rate': [0.01, 0.1],
'model__max_depth': [3, 5]
})
}
# Разделяем данные на признаки и целевую переменную для задачи классификации
X_class = df[categorical_cols + numerical_cols]
y_class = (df['charges'] > df['charges'].mean()).astype(int)
# Разделяем данные на обучающую и тестовую выборки для задачи классификации
X_train_class, X_test_class, y_train_class, y_test_class = train_test_split(X_class, y_class, test_size=0.2, random_state=42)
# Обучаем и оцениваем модели для задачи классификации
print("Результаты для задачи классификации:")
for name, (model, params) in models_class.items():
pipeline = Pipeline(steps=[('preprocessor', preprocessor), ('model', model)])
grid_search = GridSearchCV(pipeline, params, cv=5, scoring='accuracy')
grid_search.fit(X_train_class, y_train_class)
best_model = grid_search.best_estimator_
y_pred_class = best_model.predict(X_test_class)
y_pred_prob = best_model.predict_proba(X_test_class)[:, 1] # Предсказанные вероятности для позитива
accuracy = accuracy_score(y_test_class, y_pred_class)
precision = precision_score(y_test_class, y_pred_class)
recall = recall_score(y_test_class, y_pred_class)
f1 = f1_score(y_test_class, y_pred_class)
roc_auc = auc(*roc_curve(y_test_class, y_pred_prob)[:2]) # Добавляем вычисление AUC
print(f"Model: {name}")
print(f"Best Parameters: {grid_search.best_params_}")
print(f"Accuracy: {accuracy}")
print(f"Precision: {precision}")
print(f"Recall: {recall}")
print(f"F1-score: {f1}")
print(f"AUC: {roc_auc}")
# Вычисляем метрики MAE, MSE, RMSE и R² для логистической регрессии
if name == "Logistic Regression":
mae = mean_absolute_error(y_test_class, y_pred_prob)
mse = mean_squared_error(y_test_class, y_pred_prob)
rmse = mean_squared_error(y_test_class, y_pred_prob, squared=False)
r2 = r2_score(y_test_class, y_pred_prob)
print(f"MAE: {mae}")
print(f"MSE: {mse}")
print(f"RMSE: {rmse}")
print(f"R²: {r2}\n")
# Визуализация матрицы ошибок
cm = confusion_matrix(y_test_class, y_pred_class)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Less', 'More'])
disp.plot(cmap=plt.cm.Blues)
plt.title(f'Confusion Matrix for {name}')
plt.show()
# ROC-кривая
fpr, tpr, thresholds = roc_curve(y_test_class, y_pred_prob)
plt.figure()
plt.plot(fpr, tpr, color='blue', label=f'ROC curve (area = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], color='red', linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title(f'ROC Curve for {name}')
plt.legend(loc="lower right")
plt.show()
Давайте проанализируем полученные значения метрик и определим, являются ли они нормальными или их можно улучшить.
Оценка смещения и дисперсии для задачи регрессии:¶
Вывод для задачи регрессии:¶
- Random Forest Regression демонстрирует наилучшие результаты по метрикам MAE и R², что указывает на высокую точность и стабильность модели.
- Linear Regression и Gradient Boosting Regression также показывают хорошие результаты, но уступают случайному лесу.
Вывод для задачи классификации:¶
- Random Forest Classification демонстрирует наилучшие результаты по всем метрикам (Accuracy, Precision, Recall, F1-score), что указывает на высокую точность и стабильность модели.
- Logistic Regression и Gradient Boosting Classification также показывают хорошие результаты, но уступают случайному лесу.
In [95]:
import pandas as pd
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from sklearn.ensemble import GradientBoostingRegressor, GradientBoostingClassifier
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
# Загружаем набор данных
df = pd.read_csv("data/Medical_insurance.csv")
# Определяем категориальные и числовые столбцы
categorical_cols = ['sex', 'smoker', 'region']
numerical_cols = ['age', 'bmi', 'children']
# Создаем преобразователь для категориальных и числовых столбцов
preprocessor = ColumnTransformer(
transformers=[
('cat', OneHotEncoder(), categorical_cols),
('num', StandardScaler(), numerical_cols)
])
# Разделяем данные на признаки (X) и целевую переменную (y) для задачи регрессии
X_reg = df[categorical_cols + numerical_cols]
y_reg = df['charges']
# Список моделей для задачи регрессии
models_reg = {
"Linear Regression": LinearRegression(),
"Random Forest Regression": RandomForestRegressor(),
"Gradient Boosting Regression": GradientBoostingRegressor()
}
# Оценка смещения и дисперсии для задачи регрессии
print("Оценка смещения и дисперсии для задачи регрессии:")
for name, model in models_reg.items():
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('model', model)
])
mae_scores = -cross_val_score(pipeline, X_reg, y_reg, cv=5, scoring='neg_mean_absolute_error')
r2_scores = cross_val_score(pipeline, X_reg, y_reg, cv=5, scoring='r2')
print(f"Model: {name}")
print(f"MAE (Cross-Validation): Mean = {mae_scores.mean()}, Std = {mae_scores.std()}")
print(f"R² (Cross-Validation): Mean = {r2_scores.mean()}, Std = {r2_scores.std()}")
print()
# Разделяем данные на признаки (X) и целевую переменную (y) для задачи классификации
X_class = df[categorical_cols + numerical_cols]
y_class = (df['charges'] > df['charges'].mean()).astype(int)
# Список моделей для задачи классификации
models_class = {
"Logistic Regression": LogisticRegression(),
"Random Forest Classification": RandomForestClassifier(),
"Gradient Boosting Classification": GradientBoostingClassifier()
}
# Оценка смещения и дисперсии для задачи классификации
print("Оценка смещения и дисперсии для задачи классификации:")
for name, model in models_class.items():
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('model', model)
])
accuracy_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='accuracy')
precision_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='precision')
recall_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='recall')
f1_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='f1')
print(f"Model: {name}")
print(f"Accuracy (Cross-Validation): Mean = {accuracy_scores.mean()}, Std = {accuracy_scores.std()}")
print(f"Precision (Cross-Validation): Mean = {precision_scores.mean()}, Std = {precision_scores.std()}")
print(f"Recall (Cross-Validation): Mean = {recall_scores.mean()}, Std = {recall_scores.std()}")
print(f"F1-score (Cross-Validation): Mean = {f1_scores.mean()}, Std = {f1_scores.std()}")
print()
In [96]:
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from sklearn.ensemble import GradientBoostingRegressor, GradientBoostingClassifier
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
# Загружаем набор данных
df = pd.read_csv("data/Medical_insurance.csv")
# Определяем категориальные и числовые столбцы
categorical_cols = ['sex', 'smoker', 'region']
numerical_cols = ['age', 'bmi', 'children']
# Создаем преобразователь для категориальных и числовых столбцов
preprocessor = ColumnTransformer(
transformers=[
('cat', OneHotEncoder(), categorical_cols),
('num', StandardScaler(), numerical_cols)
])
# Разделяем данные на признаки (X) и целевую переменную (y) для задачи регрессии
X_reg = df[categorical_cols + numerical_cols]
y_reg = df['charges']
# Список моделей для задачи регрессии
models_reg = {
"Linear Regression": LinearRegression(),
"Random Forest Regression": RandomForestRegressor(),
"Gradient Boosting Regression": GradientBoostingRegressor()
}
# Оценка смещения и дисперсии для задачи регрессии
mae_means = []
mae_stds = []
r2_means = []
r2_stds = []
for name, model in models_reg.items():
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('model', model)
])
mae_scores = -cross_val_score(pipeline, X_reg, y_reg, cv=5, scoring='neg_mean_absolute_error')
r2_scores = cross_val_score(pipeline, X_reg, y_reg, cv=5, scoring='r2')
mae_means.append(mae_scores.mean())
mae_stds.append(mae_scores.std())
r2_means.append(r2_scores.mean())
r2_stds.append(r2_scores.std())
# Визуализация результатов для задачи регрессии
fig, ax = plt.subplots(1, 2, figsize=(12, 6))
ax[0].bar(models_reg.keys(), mae_means, yerr=mae_stds, align='center', alpha=0.5, ecolor='black', capsize=10)
ax[0].set_ylabel('MAE')
ax[0].set_title('Mean Absolute Error (MAE) for Regression Models')
ax[0].yaxis.grid(True)
ax[1].bar(models_reg.keys(), r2_means, yerr=r2_stds, align='center', alpha=0.5, ecolor='black', capsize=10)
ax[1].set_ylabel('R²')
ax[1].set_title('R-squared (R²) for Regression Models')
ax[1].yaxis.grid(True)
plt.tight_layout()
plt.show()
# Разделяем данные на признаки (X) и целевую переменную (y) для задачи классификации
X_class = df[categorical_cols + numerical_cols]
y_class = (df['charges'] > df['charges'].mean()).astype(int)
# Список моделей для задачи классификации
models_class = {
"Logistic Regression": LogisticRegression(),
"Random Forest Classification": RandomForestClassifier(),
"Gradient Boosting Classification": GradientBoostingClassifier()
}
# Оценка смещения и дисперсии для задачи классификации
accuracy_means = []
accuracy_stds = []
precision_means = []
precision_stds = []
recall_means = []
recall_stds = []
f1_means = []
f1_stds = []
for name, model in models_class.items():
pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('model', model)
])
accuracy_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='accuracy')
precision_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='precision')
recall_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='recall')
f1_scores = cross_val_score(pipeline, X_class, y_class, cv=5, scoring='f1')
accuracy_means.append(accuracy_scores.mean())
accuracy_stds.append(accuracy_scores.std())
precision_means.append(precision_scores.mean())
precision_stds.append(precision_scores.std())
recall_means.append(recall_scores.mean())
recall_stds.append(recall_scores.std())
f1_means.append(f1_scores.mean())
f1_stds.append(f1_scores.std())
# Визуализация результатов для задачи классификации
fig, ax = plt.subplots(2, 2, figsize=(12, 12))
ax[0, 0].bar(models_class.keys(), accuracy_means, yerr=accuracy_stds, align='center', alpha=0.5, ecolor='black', capsize=10)
ax[0, 0].set_ylabel('Accuracy')
ax[0, 0].set_title('Accuracy for Classification Models')
ax[0, 0].yaxis.grid(True)
ax[0, 1].bar(models_class.keys(), precision_means, yerr=precision_stds, align='center', alpha=0.5, ecolor='black', capsize=10)
ax[0, 1].set_ylabel('Precision')
ax[0, 1].set_title('Precision for Classification Models')
ax[0, 1].yaxis.grid(True)
ax[1, 0].bar(models_class.keys(), recall_means, yerr=recall_stds, align='center', alpha=0.5, ecolor='black', capsize=10)
ax[1, 0].set_ylabel('Recall')
ax[1, 0].set_title('Recall for Classification Models')
ax[1, 0].yaxis.grid(True)
ax[1, 1].bar(models_class.keys(), f1_means, yerr=f1_stds, align='center', alpha=0.5, ecolor='black', capsize=10)
ax[1, 1].set_ylabel('F1-score')
ax[1, 1].set_title('F1-score for Classification Models')
ax[1, 1].yaxis.grid(True)
plt.tight_layout()
plt.show()
