Решающие деревья в Python: метод, реализация, практика, примеры

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report

# Загрузка набора данных (например, Iris)
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target

# Разделение на тренировочную и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Создание экземпляра классификатора
dt_classifier = DecisionTreeClassifier(random_state=42)

# Обучение модели на тренировочных данных
dt_classifier.fit(X_train, y_train)

# Получение предсказаний на тестовых данных
y_pred = dt_classifier.predict(X_test)

# Оценка точности модели
accuracy = accuracy_score(y_test, y_pred)
print(f"Точность модели: {accuracy:.4f}")

# Вывод детального отчета
print(classification_report(y_test, y_pred, target_names=iris.target_names))

# Создание модели с ограниченной глубиной
dt_classifier_pruned = DecisionTreeClassifier(
max_depth=3,
min_samples_split=5,
min_samples_leaf=2,
random_state=42
)

# Обучение модели
dt_classifier_pruned.fit(X_train, y_train)

# Получение предсказаний
y_pred_pruned = dt_classifier_pruned.predict(X_test)

# Оценка точности
accuracy_pruned = accuracy_score(y_test, y_pred_pruned)
print(f"Точность модели с ограниченной глубиной: {accuracy_pruned:.4f}")

# Получение вероятностей принадлежности к каждому классу
probabilities = dt_classifier.predict_proba(X_test)
print("Вероятности для первых 5 тестовых образцов:")
for i in range(5):
print(f"Образец {i+1}: {probabilities[i]}")

# Вывод важности признаков
feature_importance = pd.DataFrame({
'Feature': iris.feature_names,
'Importance': dt_classifier.feature_importances_
}).sort_values(by='Importance', ascending=False)

print(feature_importance)

from sklearn.model_selection import GridSearchCV

# Определение сетки параметров
param_grid = {
'criterion': ['gini', 'entropy'],
'max_depth': [None, 3, 5, 7, 10],
'min_samples_split': [2, 5, 10],
'min_samples_leaf': [1, 2, 4]
}

# Создание базовой модели
dt = DecisionTreeClassifier(random_state=42)

# Настройка поиска по сетке
grid_search = GridSearchCV(
estimator=dt,
param_grid=param_grid,
cv=5, # 5-кратная перекрестная проверка
scoring='accuracy',
n_jobs=-1, # использовать все доступные ядра процессора
verbose=1
)

# Выполнение поиска оптимальных параметров
grid_search.fit(X_train, y_train)

# Вывод лучших параметров и результатов
print(f"Лучшие параметры: {grid_search.best_params_}")
print(f"Лучшая точность при кросс-валидации: {grid_search.best_score_:.4f}")

# Оценка модели с лучшими параметрами на тестовых данных
best_model = grid_search.best_estimator_
y_pred_best = best_model.predict(X_test)
accuracy_best = accuracy_score(y_test, y_pred_best)
print(f"Точность оптимизированной модели на тестовых данных: {accuracy_best:.4f}")

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

# Определение распределений для параметров
param_distributions = {
'criterion': ['gini', 'entropy'],
'max_depth': [None] + list(randint(3, 20).rvs(10)),
'min_samples_split': randint(2, 20).rvs(10),
'min_samples_leaf': randint(1, 10).rvs(10),
'max_features': ['auto', 'sqrt', 'log2', None]
}

# Создание случайного поиска
random_search = RandomizedSearchCV(
estimator=dt,
param_distributions=param_distributions,
n_iter=100, # Количество комбинаций для проверки
cv=5,
scoring='accuracy',
n_jobs=-1,
random_state=42,
verbose=1
)

# Выполнение поиска
random_search.fit(X_train, y_train)

print(f"Лучшие параметры: {random_search.best_params_}")
print(f"Лучшая точность при кросс-валидации: {random_search.best_score_:.4f}")

from sklearn.tree._tree import TREE_LEAF

# Обучение полного дерева
dt_full = DecisionTreeClassifier(random_state=42)
path = dt_full.cost_complexity_pruning_path(X_train, y_train)
ccp_alphas, impurities = path.ccp_alphas, path.impurities

# Обучение деревьев с разными значениями ccp_alpha
dt_models = []
for ccp_alpha in ccp_alphas:
dt = DecisionTreeClassifier(random_state=42, ccp_alpha=ccp_alpha)
dt.fit(X_train, y_train)
dt_models.append(dt)

# Оценка точности моделей
train_scores = [dt.score(X_train, y_train) for dt in dt_models]
test_scores = [dt.score(X_test, y_test) for dt in dt_models]

# Выбор оптимального значения ccp_alpha
optimal_idx = np.argmax(test_scores)
optimal_alpha = ccp_alphas[optimal_idx]
print(f"Оптимальное значение ccp_alpha: {optimal_alpha:.6f}")
print(f"Точность на тестовых данных: {test_scores[optimal_idx]:.4f}")

from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

# Создание и обучение модели на данных Iris
dt = DecisionTreeClassifier(max_depth=3, random_state=42)
dt.fit(X_train, y_train)

# Базовая визуализация дерева
plt.figure(figsize=(15, 10))
plot_tree(dt, 
feature_names=iris.feature_names, 
class_names=iris.target_names,
filled=True, 
rounded=True)
plt.title("Дерево решений для набора данных Iris")
plt.show()

from sklearn.tree import export_graphviz
import graphviz

# Экспорт дерева в DOT формат
dot_data = export_graphviz(
dt,
out_file=None,
feature_names=iris.feature_names,
class_names=iris.target_names,
filled=True,
rounded=True,
special_characters=True,
proportion=True
)

# Создание графического представления
graph = graphviz.Source(dot_data)
graph.render("iris_decision_tree", format="png") # Сохранение изображения
graph # Отображение графа

# Расчет и визуализация важности признаков
importances = dt.feature_importances_
feature_names = iris.feature_names
indices = np.argsort(importances)[::-1]

plt.figure(figsize=(10, 6))
plt.title("Важность признаков в модели дерева решений")
plt.bar(range(len(indices)), importances[indices], align='center')
plt.xticks(range(len(indices)), [feature_names[i] for i in indices], rotation=90)
plt.tight_layout()
plt.show()

# Функция для отслеживания пути через дерево
def trace_path(tree, feature_names, sample):
feature = tree.feature
threshold = tree.threshold
node_indicator = tree.decision_path([sample]).toarray()[0]
leaf_id = tree.apply([sample])[0]

path = []
for node_id in range(len(node_indicator)):
if node_indicator[node_id] == 1:
if leaf_id == node_id:
path.append(f"Лист {node_id}: Предсказание = {tree.value[node_id]}")
else:
feature_name = feature_names[feature[node_id]]
if sample[feature[node_id]] <= threshold[node_id]:
path.append(f"Узел {node_id}: {feature_name} <= {threshold[node_id]:.2f} -> Да")
else:
path.append(f"Узел {node_id}: {feature_name} <= {threshold[node_id]:.2f} -> Нет")
return path

# Отслеживание пути для конкретного примера
sample_idx = 10 # Индекс примера для анализа
sample = X_test[sample_idx]
tree = dt.tree_
path = trace_path(tree, iris.feature_names, sample)
print(f"Путь для примера {sample_idx}:")
for step in path:
print(step)
print(f"Фактический класс: {iris.target_names[y_test[sample_idx]]}")
print(f"Предсказанный класс: {iris.target_names[dt.predict([sample])[0]]}")

# Пример предсказания оттока клиентов
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report, roc_auc_score

# Загрузка данных (пример с телеком-данными)
df = pd.read_csv('telecom_churn.csv')

# Предобработка данных
categorical_cols = df.select_dtypes(include=['object']).columns
for col in categorical_cols:
le = LabelEncoder()
df[col] = le.fit_transform(df[col])

# Разделение на признаки и целевую переменную
X = df.drop('Churn', axis=1)
y = df['Churn']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Создание и обучение модели
dt_churn = DecisionTreeClassifier(
max_depth=5,
min_samples_leaf=50,
class_weight='balanced',
random_state=42
)
dt_churn.fit(X_train, y_train)

# Оценка модели
y_pred = dt_churn.predict(X_test)
y_prob = dt_churn.predict_proba(X_test)[:, 1]

print(classification_report(y_test, y_pred))
print(f"ROC AUC: {roc_auc_score(y_test, y_prob):.4f}")

# Анализ важности признаков
feature_importance = pd.DataFrame({
'Feature': X.columns,
'Importance': dt_churn.feature_importances_
}).sort_values(by='Importance', ascending=False).head(10)

print("Топ-10 факторов, влияющих на отток:")
print(feature_importance)

# Пример диагностики заболеваний сердца
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer

# Загрузка данных о раке молочной железы
cancer = load_breast_cancer()
X = cancer.data
y = cancer.target

# Создание модели
dt_medical = DecisionTreeClassifier(
max_depth=4,
min_samples_split=10,
random_state=42
)

# Оценка с использованием перекрестной проверки
scores = cross_val_score(dt_medical, X, y, cv=5, scoring='accuracy')
print(f"Средняя точность при 5-кратной перекрестной проверке: {scores.mean():.4f}")

# Обучение на всем наборе данных
dt_medical.fit(X, y)

# Создание правил диагностики на основе дерева
def extract_rules(tree, feature_names, class_names):
tree_ = tree.tree_
feature_name = [
feature_names[i] if i != _tree.TREE_UNDEFINED else "undefined!"
for i in tree_.feature
]

paths = []
path = []

def recurse(node, path, paths):
if tree_.feature[node] != _tree.TREE_UNDEFINED:
name = feature_name[node]
threshold = tree_.threshold[node]

# Левый узел (признак <= порога)
path.append(f"({name} <= {threshold:.2f})")
recurse(tree_.children_left[node], path, paths)
path.pop()

# Правый узел (признак > порога)
path.append(f"({name} > {threshold:.2f})")
recurse(tree_.children_right[node], path, paths)
path.pop()
else:
class_idx = np.argmax(tree_.value[node][0])
class_name = class_names[class_idx]
paths.append((path.copy(), class_name))

recurse(0, path, paths)

# Преобразование путей в правила
rules = []
for path, outcome in paths:
rule = "Если " + " И ".join(path) + f", то {outcome}"
rules.append(rule)

return rules

# Получение правил диагностики
rules = extract_rules(dt_medical, cancer.feature_names, ['злокачественная', 'доброкачественная'])
for i, rule in enumerate(rules[:5], 1): # выводим только первые 5 правил
print(f"Правило {i}: {rule}")

# Пример кредитного скоринга
from sklearn.model_selection import KFold
from sklearn.metrics import precision_recall_fscore_support
from imblearn.over_sampling import SMOTE

# Предположим, у нас есть данные о кредитах
# X – признаки клиентов, y – метка дефолта (1 – дефолт, 0 – возврат кредита)

# Обработка несбалансированных классов с помощью SMOTE
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)

# Создание модели с настройкой для несбалансированных данных
dt_credit = DecisionTreeClassifier(
max_depth=6,
min_samples_split=30,
min_samples_leaf=20,
class_weight={0: 1, 1: 5}, # штраф за ложноотрицательные результаты
random_state=42
)

# Обучение модели
dt_credit.fit(X_resampled, y_resampled)

# Оценка с акцентом на precision для класса "дефолт"
y_pred = dt_credit.predict(X_test)
precision, recall, f1, _ = precision_recall_fscore_support(y_test, y_pred)
print(f"Precision для класса 'дефолт': {precision[1]:.4f}")
print(f"Recall для класса 'дефолт': {recall[1]:.4f}")
print(f"F1-score для класса 'дефолт': {f1[1]:.4f}")

# Пример простой рекомендательной системы
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer

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

# Подготовка признаков
categorical_features = ['user_age_group', 'user_gender', 'product_category', 'day_of_week']
numerical_features = ['user_previous_purchases', 'product_price', 'product_rating']

preprocessor = ColumnTransformer(
transformers=[
('num', 'passthrough', numerical_features),
('cat', OneHotEncoder(), categorical_features)
])

X = preprocessor.fit_transform(df_interactions[numerical_features + categorical_features])
y = df_interactions['purchased'] # 1 – купил, 0 – не купил

# Создание и обучение модели
dt_recommender = DecisionTreeClassifier(max_depth=8, random_state=42)
dt_recommender.fit(X, y)

# Функция для получения рекомендаций для пользователя
def get_recommendations(user_id, product_ids, top_n=5):
user_data = df_users[df_users['user_id'] == user_id].iloc[0]
product_data = df_products[df_products['product_id'].isin(product_ids)]

# Создание признаков для всех комбинаций пользователь-товар
interactions = []
for _, product in product_data.iterrows():
interaction = {
'user_age_group': user_data['age_group'],
'user_gender': user_data['gender'],
'user_previous_purchases': user_data['previous_purchases'],
'product_category': product['category'],
'product_price': product['price'],
'product_rating': product['rating'],
'day_of_week': datetime.now().strftime('%A')
}
interactions.append(interaction)

# Преобразование данных
X_pred = preprocessor.transform(pd.DataFrame(interactions))

# Получение вероятностей покупки
purchase_probs = dt_recommender.predict_proba(X_pred)[:, 1]

# Сортировка товаров по вероятности покупки
product_probs = list(zip(product_ids, purchase_probs))
recommendations = sorted(product_probs, key=lambda x: x[1], reverse=True)[:top_n]

return recommendations

# Пример использования
recommended_products = get_recommendations(user_id=123, product_ids=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print("Рекомендуемые товары:")
for product_id, prob in recommended_products:
print(f"Товар {product_id}: вероятность покупки {prob:.4f}")