Нелінійні залежності та поліноміальна регресія

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score

# Генеруємо синтетичні дані з квадратичною залежністю
rng = np.random.default_rng(42)
experience = np.linspace(0, 10, 100)  # experience (досвід роботи, роки)
salary = 30000 + 5000 * experience + 800 * experience**2 + rng.normal(0, 5000, 100)  # salary (зарплата, $)

plt.figure(figsize=(10, 6))
plt.scatter(experience, salary, alpha=0.7, s=50, edgecolors='k', linewidths=0.5, color='#2A75D3', label='Спостереження')
plt.xlabel('Досвід роботи (роки)', fontsize=12, fontweight='bold')
plt.ylabel('Річна зарплата ($)', fontsize=12, fontweight='bold')
plt.title('Залежність зарплати від досвіду роботи (параболічний тренд)', fontsize=14, fontweight='bold')
plt.grid(alpha=0.3, linestyle='--')
plt.legend(fontsize=11)
plt.tight_layout()
plt.show()

# Спроба побудувати лінійну регресію
X = experience.reshape(-1, 1)
y = salary

model = LinearRegression()
model.fit(X, y)
y_pred = model.predict(X)

r2 = r2_score(y, y_pred)
print(f"R² для лінійної регресії: {r2:.4f}")

# Візуалізація
plt.figure(figsize=(10, 6))
plt.scatter(experience, salary, alpha=0.6, s=50, label='Реальні дані', edgecolors='k', linewidths=0.5)
plt.plot(experience, y_pred, color='red', linewidth=2.5, label=f'Лінійна регресія (R² = {r2:.2f})')
plt.xlabel('Досвід роботи (роки)', fontsize=12)
plt.ylabel('Зарплата ($)', fontsize=12)
plt.title('Лінійна регресія: погана якість для нелінійних даних', fontsize=14, fontweight='bold')
plt.legend(fontsize=11)
plt.grid(alpha=0.3)
plt.tight_layout()
plt.show()

from sklearn.preprocessing import PolynomialFeatures
import numpy as np

# Вхідні дані
X = np.array([[1], [2], [3], [4]])
print("Початкові дані:")
print(X)

# Генерація поліноміальних ознак ступеня 3
poly = PolynomialFeatures(degree=3, include_bias=True)
X_poly = poly.fit_transform(X)

print("\nПісля застосування PolynomialFeatures(degree=3):")
print(X_poly)
print(f"\nНазви ознак: {poly.get_feature_names_out(['x'])}")

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_absolute_error
import numpy as np
import matplotlib.pyplot as plt

# Генеруємо ті самі дані (досвід-зарплата)
np.random.seed(42)
experience = np.linspace(0, 10, 100).reshape(-1, 1)
salary = 30000 + 5000 * experience.ravel() + 800 * experience.ravel()**2 + np.random.normal(0, 5000, 100)

# Побудова моделей різних ступенів
degrees = [1, 2, 3, 5]
results = {}

plt.figure(figsize=(14, 10))
for i, degree in enumerate(degrees, 1):
    # Створення Pipeline
    model = Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('scaler', StandardScaler()),
        ('regressor', LinearRegression())
    ])
    
    # Навчання
    model.fit(experience, salary)
    y_pred = model.predict(experience)
    
    # Метрики
    r2 = r2_score(salary, y_pred)
    mae = mean_absolute_error(salary, y_pred)
    results[degree] = {'R²': r2, 'MAE': mae}
    
    # Візуалізація
    plt.subplot(2, 2, i)
    plt.scatter(experience, salary, alpha=0.5, s=30, edgecolors='k', linewidths=0.5, label='Реальні дані')
    plt.plot(experience, y_pred, color='red', linewidth=2.5, label=f'Ступінь {degree}')
    plt.xlabel('Досвід (роки)', fontsize=11)
    plt.ylabel('Зарплата ($)', fontsize=11)
    plt.title(f'Поліном ступеня {degree} | R² = {r2:.4f}', fontsize=12, fontweight='bold')
    plt.legend(fontsize=10)
    plt.grid(alpha=0.3)

plt.tight_layout()
plt.show()

print("\nПорівняння моделей:")
for degree, metrics in results.items():
    print(f"Ступінь {degree}: R² = {metrics['R²']:.4f}, MAE = {metrics['MAE']:.2f}")

from sklearn.model_selection import train_test_split

# Розділимо дані на train/test
X_train, X_test, y_train, y_test = train_test_split(
    experience, salary, test_size=0.3, random_state=42
)

# Модель зі ступенем 15
model_overfit = Pipeline([
    ('poly', PolynomialFeatures(degree=15)),
    ('scaler', StandardScaler()),
    ('regressor', LinearRegression())
])

model_overfit.fit(X_train, y_train)

# Прогнози
y_train_pred = model_overfit.predict(X_train)
y_test_pred = model_overfit.predict(X_test)

# Метрики
r2_train = r2_score(y_train, y_train_pred)
r2_test = r2_score(y_test, y_test_pred)

print(f"Поліном ступеня 15:")
print(f"  R² (train): {r2_train:.4f}")
print(f"  R² (test):  {r2_test:.4f}")
print(f"\n⚠️ Величезна різниця! Модель перенавчилась!")

# Візуалізація
X_line = np.linspace(0, 10, 300).reshape(-1, 1)
y_line_pred = model_overfit.predict(X_line)

plt.figure(figsize=(12, 6))
plt.scatter(X_train, y_train, alpha=0.6, s=40, label='Train дані', edgecolors='k', linewidths=0.5)
plt.scatter(X_test, y_test, alpha=0.6, s=40, color='orange', label='Test дані', edgecolors='k', linewidths=0.5)
plt.plot(X_line, y_line_pred, color='red', linewidth=2.5, label=f'Поліном ступеня 15')
plt.xlabel('Досвід (роки)', fontsize=12)
plt.ylabel('Зарплата ($)', fontsize=12)
plt.title(f'Перенавчання: R² train = {r2_train:.2f}, R² test = {r2_test:.2f}', fontsize=14, fontweight='bold')
plt.legend(fontsize=11)
plt.grid(alpha=0.3)
plt.ylim(20000, 140000)
plt.tight_layout()
plt.show()

degrees_range = range(1, 16)
train_scores = []
test_scores = []

for deg in degrees_range:
    model = Pipeline([
        ('poly', PolynomialFeatures(degree=deg)),
        ('scaler', StandardScaler()),
        ('regressor', LinearRegression())
    ])
    
    model.fit(X_train, y_train)
    train_scores.append(model.score(X_train, y_train))
    test_scores.append(model.score(X_test, y_test))

plt.figure(figsize=(10, 6))
plt.plot(degrees_range, train_scores, marker='o', linewidth=2, label='R² (train)', color='blue')
plt.plot(degrees_range, test_scores, marker='s', linewidth=2, label='R² (test)', color='orange')
plt.axvline(x=2, color='green', linestyle='--', alpha=0.7, label='Оптимальний ступінь')
plt.xlabel('Ступінь полінома', fontsize=12)
plt.ylabel('R²', fontsize=12)
plt.title('Вибір ступеня полінома: train vs test', fontsize=14, fontweight='bold')
plt.legend(fontsize=11)
plt.grid(alpha=0.3)
plt.tight_layout()
plt.show()

print(f"Оптимальний ступінь: 2 (R² test = {test_scores[1]:.4f})")

import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error

# Генерація квадратичних даних
np.random.seed(123)
X_quad = np.linspace(-5, 5, 80).reshape(-1, 1)
y_quad = 100 + 20*X_quad.ravel() + 5*X_quad.ravel()**2 + np.random.normal(0, 15, 80)

# Побудова моделей різних ступенів
models_quad = {}
for degree in [1, 2, 3]:
    model = Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('scaler', StandardScaler()),
        ('regressor', LinearRegression())
    ])
    model.fit(X_quad, y_quad)
    y_pred = model.predict(X_quad)
    
    models_quad[degree] = {
        'model': model,
        'R²': r2_score(y_quad, y_pred),
        'MAE': mean_absolute_error(y_quad, y_pred),
        'MSE': mean_squared_error(y_quad, y_pred)
    }

# Візуалізація
plt.figure(figsize=(12, 4))
X_line = np.linspace(-5, 5, 200).reshape(-1, 1)

for i, degree in enumerate([1, 2, 3], 1):
    plt.subplot(1, 3, i)
    plt.scatter(X_quad, y_quad, alpha=0.5, s=25, edgecolors='k', linewidths=0.5)
    y_line = models_quad[degree]['model'].predict(X_line)
    plt.plot(X_line, y_line, color='red', linewidth=2.5)
    plt.xlabel('x', fontsize=11)
    plt.ylabel('y', fontsize=11)
    plt.title(f'Ступінь {degree} | R²={models_quad[degree]["R²"]:.3f}', fontsize=11, fontweight='bold')
    plt.grid(alpha=0.3)

plt.tight_layout()
plt.show()

# Метрики
print("Квадратична функція y = 100 + 20x + 5x² + шум")
print(f"{'Ступінь':<10} {'R²':<10} {'MAE':<12} {'MSE':<12}")
print("-" * 50)
for degree, metrics in models_quad.items():
    print(f"{degree:<10} {metrics['R²']:<10.4f} {metrics['MAE']:<12.2f} {metrics['MSE']:<12.2f}")

# Генерація кубічних даних
rng_c = np.random.default_rng(456)
X_cubic = np.linspace(-3, 3, 80).reshape(-1, 1)
y_cubic = 50 - 10*X_cubic.ravel() + 3*X_cubic.ravel()**2 + 2*X_cubic.ravel()**3 + rng_c.normal(0, 10, 80)

# Побудова моделей
models_cubic = {}
for degree in [1, 2, 3, 4]:
    model = Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('scaler', StandardScaler()),
        ('regressor', LinearRegression())
    ])
    model.fit(X_cubic, y_cubic)
    y_pred = model.predict(X_cubic)
    
    models_cubic[degree] = {
        'model': model,
        'R²': r2_score(y_cubic, y_pred),
        'MAE': mean_absolute_error(y_cubic, y_pred)
    }

# Візуалізація
plt.figure(figsize=(14, 4))
X_line = np.linspace(-3, 3, 200).reshape(-1, 1)

for i, degree in enumerate([1, 2, 3, 4], 1):
    plt.subplot(1, 4, i)
    plt.scatter(X_cubic, y_cubic, alpha=0.5, s=25, edgecolors='k', linewidths=0.5)
    y_line = models_cubic[degree]['model'].predict(X_line)
    plt.plot(X_line, y_line, color='red', linewidth=2.5)
    plt.xlabel('x', fontsize=11)
    plt.ylabel('y', fontsize=11)
    plt.title(f'Ступінь {degree} | R²={models_cubic[degree]["R²"]:.3f}', fontsize=11, fontweight='bold')
    plt.grid(alpha=0.3)

plt.tight_layout()
plt.show()

print("Кубічна функція y = 50 - 10x + 3x² + 2x³ + шум")
print(f"{'Ступінь':<10} {'R²':<10} {'MAE':<12}")
print("-" * 40)
for degree, metrics in models_cubic.items():
    print(f"{degree:<10} {metrics['R²']:<10.4f} {metrics['MAE']:<12.2f}")

# Генерація синусоїдальних даних
rng_s = np.random.default_rng(789)
X_sine = np.linspace(0, 2*np.pi, 100).reshape(-1, 1)
y_sine = np.sin(X_sine.ravel()) * 10 + rng_s.normal(0, 0.5, 100)

# Побудова моделей
models_sine = {}
for degree in [1, 3, 5, 7]:
    model = Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('scaler', StandardScaler()),
        ('regressor', LinearRegression())
    ])
    model.fit(X_sine, y_sine)
    y_pred = model.predict(X_sine)
    
    models_sine[degree] = {
        'model': model,
        'R²': r2_score(y_sine, y_pred),
        'MAE': mean_absolute_error(y_sine, y_pred)
    }

# Візуалізація
plt.figure(figsize=(14, 4))
X_line = np.linspace(0, 2*np.pi, 300).reshape(-1, 1)

for i, degree in enumerate([1, 3, 5, 7], 1):
    plt.subplot(1, 4, i)
    plt.scatter(X_sine, y_sine, alpha=0.5, s=20, edgecolors='k', linewidths=0.5)
    y_line = models_sine[degree]['model'].predict(X_line)
    plt.plot(X_line, y_line, color='red', linewidth=2.5)
    plt.xlabel('x', fontsize=11)
    plt.ylabel('y', fontsize=11)
    plt.title(f'Ступінь {degree} | R²={models_sine[degree]["R²"]:.3f}', fontsize=11, fontweight='bold')
    plt.grid(alpha=0.3)
    plt.ylim(-12, 12)

plt.tight_layout()
plt.show()

print("Синусоїдальна функція y = 10·sin(x) + шум")
print(f"{'Ступінь':<10} {'R²':<10} {'MAE':<12}")
print("-" * 40)
for degree, metrics in models_sine.items():
    print(f"{degree:<10} {metrics['R²']:<10.4f} {metrics['MAE']:<12.2f}")