Попередня обробка даних (Data Preprocessing)

import pandas as pd
from sklearn.linear_model import LinearRegression

# Завантажити дані (файл train.csv з попередніх занять)
df = pd.read_csv('train.csv')

# Спробувати навчити модель на всіх ознаках для передбачення ціни SalePrice
X = df.drop('SalePrice', axis=1)  # Всі ознаки крім ціни
y = df['SalePrice']               # SalePrice (ціна продажу) — цільова змінна

model = LinearRegression()
model.fit(X, y)  # Що станеться?

# Дані з викидом (999 — явно некоректне значення)
data_with_outlier = np.array([[10], [12], [11], [np.nan], [13], [999]])

# Стратегія 1: середнє (чутливе до викидів)
imputer_mean = SimpleImputer(strategy='mean')
data_mean = imputer_mean.fit_transform(data_with_outlier)

# Стратегія 2: медіана (стійка до викидів)
imputer_median = SimpleImputer(strategy='median')
data_median = imputer_median.fit_transform(data_with_outlier)

print("Оригінал:", data_with_outlier.flatten())
print(f"Середнє: {imputer_mean.statistics_[0]:.2f}")
print(f"Медіана: {imputer_median.statistics_[0]:.2f}")
print(f"\nПісля заповнення MEAN:", data_mean.flatten())
print(f"Після заповнення MEDIAN:", data_median.flatten())

# Категоріальні дані: типи гаражів
garage_types = np.array([['Attached'], 
                         ['Detached'], 
                         ['Attached'], 
                         [np.nan], 
                         ['Attached'], 
                         [np.nan]])

imputer_mode = SimpleImputer(strategy='most_frequent')
garage_filled = imputer_mode.fit_transform(garage_types)

print("Оригінал:")
print(garage_types.flatten())
print(f"\nМода (найчастіше): {imputer_mode.statistics_[0]}")
print("\nПісля заповнення:")
print(garage_filled.flatten())

# Перевірити пропуски до обробки
print("Пропуски ДО обробки:")
print(f"  LotFrontage: {df['LotFrontage'].isnull().sum()} ({df['LotFrontage'].isnull().sum() / len(df) * 100:.1f}%)")
print(f"  GarageType:  {df['GarageType'].isnull().sum()} ({df['GarageType'].isnull().sum() / len(df) * 100:.1f}%)")

# Заповнити LotFrontage медіаною (числова ознака, можуть бути викиди)
imputer_median = SimpleImputer(strategy='median')
df['LotFrontage'] = imputer_median.fit_transform(df[['LotFrontage']])

# Заповнити GarageType модою (категоріальна ознака)
imputer_mode = SimpleImputer(strategy='most_frequent')
df['GarageType'] = imputer_mode.fit_transform(df[['GarageType']])

# Перевірити результат
print("Пропуски ПІСЛЯ обробки:")
print(f"  LotFrontage: {df['LotFrontage'].isnull().sum()}")
print(f"  GarageType:  {df['GarageType'].isnull().sum()}")
print(f"\nЗаповнено LotFrontage значенням: {imputer_median.statistics_[0]:.1f}")
print(f"Заповнено GarageType значенням: {imputer_mode.statistics_[0]}")

# Приклад категоріальної ознаки з Housing
print("Унікальні значення Neighborhood (район):")
print(df['Neighborhood'].unique()[:10])  # Перші 10
print(f"\nВсього унікальних районів: {df['Neighborhood'].nunique()}")

# Приклад з кольорами
colors = ['red', 'blue', 'red', 'green', 'blue', 'green', 'red']

# Factorize повертає два значення:
# 1. codes — числові коди
# 2. uniques — порядок унікальних значень
codes, uniques = pd.factorize(colors)

print("Оригінал:  ", colors)
print("Codes:     ", codes)
print("Uniques:   ", uniques.tolist())
print("\nІнтерпретація: red=0, blue=1, green=2")

from sklearn.preprocessing import LabelEncoder

encoder = LabelEncoder()

# Fit + Transform
colors_encoded = encoder.fit_transform(colors)

print("Оригінал:        ", colors)
print("Після кодування: ", colors_encoded)
print("Класи:           ", encoder.classes_)

# Зворотнє перетворення: числа → текст
decoded = encoder.inverse_transform([2, 0, 1])
print("Закодовано: [2, 0, 1]")
print("Декодовано:", decoded)

# Створити DataFrame з категоріальною ознакою
df_colors = pd.DataFrame({
    'ID': [1, 2, 3, 4],
    'Color': ['red', 'blue', 'green', 'red']
})

print("Оригінальний DataFrame:")
print(df_colors)
print(f"Форма: {df_colors.shape}\n")

# One-Hot Encoding
df_encoded = pd.get_dummies(df_colors, columns=['Color'], prefix='Color')

print("Після One-Hot Encoding:")
print(df_encoded)
print(f"Форма: {df_encoded.shape}")

from sklearn.preprocessing import OneHotEncoder

# Підготувати дані (OneHotEncoder потребує 2D масив)
colors_array = np.array(['red', 'blue', 'green', 'red']).reshape(-1, 1)

# Створити encoder
encoder = OneHotEncoder(sparse_output=False)  # sklearn 1.2+

# Fit + Transform
colors_onehot = encoder.fit_transform(colors_array)

print("Оригінал:")
print(colors_array.flatten())
print("\nКатегорії (порядок стовпців):")
print(encoder.categories_)
print("\nOne-Hot Encoding (матриця):")
print(colors_onehot)
print(f"\nФорма: {colors_onehot.shape} — 4 рядки, 3 стовпці (blue, green, red)")

# Видалити перший стовпець (drop='first')
encoder_drop = OneHotEncoder(drop='first', sparse_output=False)
colors_onehot_drop = encoder_drop.fit_transform(colors_array)

print("Без drop='first' — 3 стовпці:")
print(colors_onehot)
print(f"Форма: {colors_onehot.shape}\n")

print("З drop='first' — 2 стовпці (видалено 'blue'):")
print(colors_onehot_drop)
print(f"Форма: {colors_onehot_drop.shape}")
print("\nТепер: [0, 0] = blue, [1, 0] = green, [0, 1] = red")

# Перевірити унікальні значення
print(f"Унікальних районів: {df['Neighborhood'].nunique()}")
print(f"Форма датасету ДО кодування: {df.shape}\n")

# One-Hot Encoding з drop_first=True
df_encoded = pd.get_dummies(df, columns=['Neighborhood'], prefix='Neighborhood', drop_first=True)

print(f"Форма датасету ПІСЛЯ кодування: {df_encoded.shape}")
print(f"Додано стовпців: {df_encoded.shape[1] - df.shape[1] + 1}")
print(f"\nНові стовпці (перші 5):")
print([col for col in df_encoded.columns if col.startswith('Neighborhood')][:5])

# Порівняти масштаби різних ознак
print("Статистика числових ознак Housing:\n")
features_to_compare = ['YearBuilt', 'GrLivArea', 'SalePrice']
print(df[features_to_compare].describe())

from sklearn.preprocessing import StandardScaler

# Використати ті самі дані
scaler_std = StandardScaler()

# Fit + Transform
ages_standardized = scaler_std.fit_transform(ages)

print("Оригінальні дані:")
print(ages.flatten())
print(f"\nПараметри scaler:")
print(f"  mean: {scaler_std.mean_[0]:.1f}")
print(f"  std:  {scaler_std.scale_[0]:.2f}")
print(f"\nПісля стандартизації:")
print(ages_standardized.flatten())
print(f"\nПеревірка:")
print(f"  Середнє: {ages_standardized.mean():.10f} (має бути ~0)")
print(f"  Std:     {ages_standardized.std():.10f} (має бути ~1)")

import matplotlib.pyplot as plt

# Використати реальну ознаку з Housing
feature = df[['GrLivArea']].values

# Три варіанти: оригінал, MinMax, Standard
scaler_minmax = MinMaxScaler()
scaler_standard = StandardScaler()

data_minmax = scaler_minmax.fit_transform(feature)
data_standard = scaler_standard.fit_transform(feature)

# Побудувати графіки
fig, axes = plt.subplots(1, 3, figsize=(15, 4))

# Оригінальні дані
axes[0].hist(feature, bins=30, color='skyblue', edgecolor='black', alpha=0.7)
axes[0].set_title('Оригінальні дані\n(GrLivArea)', fontweight='bold')
axes[0].set_xlabel('Площа (кв.фт)')
axes[0].set_ylabel('Частота')
axes[0].axvline(feature.mean(), color='red', linestyle='--', linewidth=2, label=f'Середнє: {feature.mean():.0f}')
axes[0].legend()
axes[0].grid(alpha=0.3)

# MinMaxScaler
axes[1].hist(data_minmax, bins=30, color='lightgreen', edgecolor='black', alpha=0.7)
axes[1].set_title('MinMaxScaler\n[0, 1]', fontweight='bold')
axes[1].set_xlabel('Масштабована площа')
axes[1].set_ylabel('Частота')
axes[1].axvline(data_minmax.mean(), color='red', linestyle='--', linewidth=2, label=f'Середнє: {data_minmax.mean():.2f}')
axes[1].legend()
axes[1].grid(alpha=0.3)

# StandardScaler
axes[2].hist(data_standard, bins=30, color='lightcoral', edgecolor='black', alpha=0.7)
axes[2].set_title('StandardScaler\n(μ=0, σ=1)', fontweight='bold')
axes[2].set_xlabel('Стандартизована площа')
axes[2].set_ylabel('Частота')
axes[2].axvline(0, color='red', linestyle='--', linewidth=2, label=f'Середнє: {data_standard.mean():.2e}')
axes[2].legend()
axes[2].grid(alpha=0.3)

plt.tight_layout()
plt.show()

print("Статистика:")
print(f"Оригінал:   min={feature.min():.0f}, max={feature.max():.0f}, mean={feature.mean():.0f}, std={feature.std():.0f}")
print(f"MinMax:     min={data_minmax.min():.2f}, max={data_minmax.max():.2f}, mean={data_minmax.mean():.2f}, std={data_minmax.std():.2f}")
print(f"Standard:   min={data_standard.min():.2f}, max={data_standard.max():.2f}, mean={data_standard.mean():.2e}, std={data_standard.std():.2f}")