import numpy as np
import matplotlib.pyplot as plt

# Історичні дані продажів Марії
np.random.seed(42)
temperatures = np.linspace(5, 35, 30)  # Температура в Цельсіях
# Справжній патерн: Холодна погода = більше замовлень, з деякою кривизною
true_sales = 150 - 2 * temperatures + 0.05 * temperatures**2
actual_sales = true_sales + np.random.normal(0, 12, 30)  # Реальний шум

print("🌡️ Діапазон температур: 5°C до 35°C")
print(f"🍕 Діапазон продажів: {actual_sales.min():.0f} до {actual_sales.max():.0f} піц")

from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import make_pipeline

# Модель 1: Ледар (занадто проста)
model_slacker = make_pipeline(
    PolynomialFeatures(degree=1),  # Просто пряма лінія
    LinearRegression()
)

# Модель 2: Розумний студент (в самий раз)
model_smart = make_pipeline(
    PolynomialFeatures(degree=2),  # Схоплює криву
    LinearRegression()
)

# Модель 3: Зубрило (занадто складна)
model_memorizer = make_pipeline(
    PolynomialFeatures(degree=15),  # Звивається через кожну точку
    LinearRegression()
)

# Тренуємо всі моделі
X = temperatures.reshape(-1, 1)
for model in [model_slacker, model_smart, model_memorizer]:
    model.fit(X, actual_sales)

from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# Розділяємо дані — 70% для тренування, 30% для тестування
X_train, X_test, y_train, y_test = train_test_split(
    X, actual_sales, test_size=0.3, random_state=42
)

results = []
for name, model in [("Ледар", model_slacker),
                     ("Розумний", model_smart),
                     ("Зубрило", model_memorizer)]:
    model.fit(X_train, y_train)

    train_rmse = np.sqrt(mean_squared_error(y_train, model.predict(X_train)))
    test_rmse = np.sqrt(mean_squared_error(y_test, model.predict(X_test)))
    gap = test_rmse - train_rmse

    results.append((name, train_rmse, test_rmse, gap))

print("\n🍕 Діагностика моделі Марії")
print("=" * 65)
print(f"{'Модель':<12} {'Трен. помилка':>15} {'Тест. помилка':>15} {'Розрив':>12}")
print("-" * 65)
for name, train, test, gap in results:
    status = "✅" if gap < 5 else "⚠️" if gap < 15 else "❌"
    print(f"{name:<12} {train:>13.1f} {test:>15.1f} {gap:>10.1f}   {status}")

🍕 Діагностика моделі Марії
=================================================================
Модель        Трен. помилка   Тест. помилка       Розрив
-----------------------------------------------------------------
Ледар               15.8            17.2          1.4   ✅
Розумний             9.2            10.5          1.3   ✅
Зубрило              0.1            48.3         48.2   ❌

from sklearn.tree import DecisionTreeRegressor

# Занадто проста — недонавчання
simple_tree = DecisionTreeRegressor(max_depth=2)

# Краще — схоплює більше патернів
deeper_tree = DecisionTreeRegressor(max_depth=6)

# Оригінал: Тільки температура
X_simple = df[['temperature']]

# Покращено: Бізнес-контекст важливий!
df['is_weekend'] = df['day_of_week'].isin([5, 6]).astype(int)
df['is_holiday'] = df['date'].isin(holidays).astype(int)
df['temp_squared'] = df['temperature'] ** 2  # Схоплюємо криву!
df['marketing_active'] = df['ad_spend'] > 0

X_enhanced = df[['temperature', 'temp_squared', 'is_weekend',
                  'is_holiday', 'marketing_active']]

# Проста: Лінійна регресія (може недонавчитися на складних патернах)
from sklearn.linear_model import LinearRegression

# Потужніша: Random Forest (обробляє нелінійні патерни)
from sklearn.ensemble import RandomForestRegressor

# Ще потужніша: Gradient Boosting
from sklearn.ensemble import GradientBoostingRegressor

from sklearn.linear_model import Ridge

# Занадто багато регуляризації → недонавчання
model = Ridge(alpha=1000)  # Перебір!

# Кращий баланс
model = Ridge(alpha=1)

# Якщо 500 зразків → модель запам'ятовує
# Спробуйте 2000+ зразків → модель вчиться патернам

from sklearn.tree import DecisionTreeRegressor

# Перенавчання: Занадто глибоке, запам'ятовує все
deep_tree = DecisionTreeRegressor(max_depth=20)

# Краще: Контрольована складність
controlled_tree = DecisionTreeRegressor(
    max_depth=5,           # Обмежуємо глибину
    min_samples_split=20,  # Потрібно 20+ зразків для розділення
    min_samples_leaf=10    # Потрібно 10+ зразків у кожному листку
)

# Занадто багато ознак (деякі — шум)
X_noisy = df[['temperature', 'order_id', 'cashier_name', 'random_number']]

# Тільки чисті ознаки
from sklearn.feature_selection import SelectKBest, f_regression

selector = SelectKBest(f_regression, k=5)
X_clean = selector.fit_transform(X_all, y)

from sklearn.linear_model import Ridge

# alpha контролює силу регуляризації
ridge_light = Ridge(alpha=0.01)   # Мінімальне стиснення
ridge_medium = Ridge(alpha=1.0)   # Помірне
ridge_strong = Ridge(alpha=100)   # Сильне стиснення

from sklearn.linear_model import Lasso

lasso = Lasso(alpha=0.1)
lasso.fit(X_train, y_train)

# Перевіряємо, які ознаки були видалені
print("🔍 Аналіз ознак:")
for name, coef in zip(feature_names, lasso.coef_):
    status = "✅ ЗАЛИШЕНО" if coef != 0 else "❌ ВИДАЛЕНО"
    print(f"  {name}: {coef:.4f} ({status})")

from sklearn.linear_model import ElasticNet

# l1_ratio: 0 = чистий Ridge, 1 = чистий Lasso, 0.5 = збалансований
elastic = ElasticNet(alpha=0.1, l1_ratio=0.5)

print("\n🍕 Порівняння регуляризації для моделі Марії")
print("=" * 70)
print(f"{'Метод':<15} {'Трен. RMSE':>12} {'Тест. RMSE':>12} {'Розрив':>10} {'Ознак':>10}")
print("-" * 70)

# Результати після застосування кожного методу
# Без рег.        2.1          48.3       46.2         20
# Ridge           8.2          10.1        1.9         20
# Lasso           8.9           9.8        0.9         12  ← 8 марних ознак видалено!
# Elastic         8.5           9.9        1.4         15

from sklearn.model_selection import cross_val_score

def evaluate_model(model, X, y):
    """5-fold крос-валідація для надійних оцінок."""
    scores = cross_val_score(
        model, X, y,
        cv=5,  # 5 різних розподілів train/test
        scoring='neg_mean_squared_error'
    )
    rmse_scores = np.sqrt(-scores)
    return rmse_scores.mean(), rmse_scores.std()

# Порівнюємо моделі надійно
models = [
    ("Проста (depth=2)", DecisionTreeRegressor(max_depth=2)),
    ("Збалансована (depth=5)", DecisionTreeRegressor(max_depth=5)),
    ("Глибока (depth=15)", DecisionTreeRegressor(max_depth=15)),
]

print("\n📊 Результати крос-валідації (5-fold)")
print("=" * 55)
for name, model in models:
    mean_rmse, std_rmse = evaluate_model(model, X, y)
    print(f"{name}: {mean_rmse:.1f} ± {std_rmse:.1f} піц")

📊 Результати крос-валідації (5-fold)
=======================================================
Проста (depth=2): 12.5 ± 1.2 піц
Збалансована (depth=5): 8.7 ± 0.9 піц   ← Переможець!
Глибока (depth=15): 15.2 ± 3.5 піц

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error

# Очищений датасет Марії
np.random.seed(42)
n = 500

data = {
    'temperature': np.random.uniform(5, 35, n),
    'is_weekend': np.random.choice([0, 1], n, p=[0.7, 0.3]),
    'is_holiday': np.random.choice([0, 1], n, p=[0.95, 0.05]),
    'hour': np.random.choice(range(10, 23), n),
    'marketing_active': np.random.choice([0, 1], n, p=[0.8, 0.2]),
}

df = pd.DataFrame(data)
df['is_peak'] = ((df['hour'] >= 18) & (df['hour'] <= 21)).astype(int)

# Справжня залежність (що відкрила Марія)
df['sales'] = (
    80 +                                    # Базовий попит
    -0.8 * df['temperature'] +              # Холод = більше замовлень
    25 * df['is_weekend'] +                 # Вихідні +25
    45 * df['is_holiday'] +                 # Свята +45
    15 * df['is_peak'] +                    # Вечірній пік +15
    10 * df['marketing_active'] +           # Маркетинг +10
    np.random.normal(0, 12, n)              # Реальний шум
).clip(30, 200)

X = df[['temperature', 'is_weekend', 'is_holiday', 'hour', 'is_peak', 'marketing_active']]
y = df['sales']

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

# Порівняння: Стара модель vs Нова модель
models = {
    '❌ Стара (Зубрило)': DecisionTreeRegressor(max_depth=None),  # Без обмежень!
    '✅ Нова (Збалансована)': RandomForestRegressor(n_estimators=50, max_depth=5, random_state=42)
}

print("\n🍕 ТРАНСФОРМАЦІЯ МОДЕЛІ МАРІЇ")
print("=" * 75)
print(f"{'Модель':<28} {'Трен. RMSE':>12} {'Тест. RMSE':>12} {'Розрив':>10} {'Статус':>10}")
print("-" * 75)

for name, model in models.items():
    model.fit(X_train, y_train)

    train_rmse = np.sqrt(mean_squared_error(y_train, model.predict(X_train)))
    test_rmse = np.sqrt(mean_squared_error(y_test, model.predict(X_test)))
    gap = test_rmse - train_rmse

    status = "ХВОРА" if gap > 10 else "ЗДОРОВА"
    print(f"{name:<28} {train_rmse:>10.1f} {test_rmse:>12.1f} {gap:>10.1f}   {status}")

🍕 ТРАНСФОРМАЦІЯ МОДЕЛІ МАРІЇ
===========================================================================
Модель                        Трен. RMSE   Тест. RMSE     Розрив     Статус
---------------------------------------------------------------------------
❌ Стара (Зубрило)                 2.1         28.4        26.3      ХВОРА
✅ Нова (Збалансована)             9.8         11.2         1.4    ЗДОРОВА

# Тестування різних alpha на ТЕСТОВОМУ наборі ❌
for alpha in [0.01, 0.1, 1, 10, 100]:
    model = Ridge(alpha=alpha)
    model.fit(X_train, y_train)
    test_score = model.score(X_test, y_test)  # Підглядаємо!
    print(f"Alpha {alpha}: {test_score}")
# Тепер ваш тестовий набір забруднений!

# Використовуємо крос-валідацію на ТРЕНУВАЛЬНОМУ наборі ✅
from sklearn.model_selection import GridSearchCV

param_grid = {'alpha': [0.01, 0.1, 1, 10, 100]}
grid_search = GridSearchCV(Ridge(), param_grid, cv=5)
grid_search.fit(X_train, y_train)  # Тільки тренувальні дані!

print(f"Найкращий alpha: {grid_search.best_params_['alpha']}")
# Тестовий набір залишається недоторканим для фінальної оцінки