import matplotlib.pyplot as plt

# Plot X vs y
plt.scatter(X, y)
plt.xlabel('Feature')
plt.ylabel('Target')
plt.title('Check for Linearity')
plt.show()

# Look for: straight line pattern ✅
# Watch out for: curved pattern ❌

# For time series: Plot residuals over time
plt.plot(residuals)
plt.xlabel('Time')
plt.ylabel('Residuals')
plt.title('Check for Autocorrelation')
plt.show()

# Look for: random scatter ✅
# Watch out for: patterns or trends ❌

# Plot residuals vs predicted values
plt.scatter(y_pred, residuals)
plt.xlabel('Predicted Values')
plt.ylabel('Residuals')
plt.axhline(y=0, color='r', linestyle='--')
plt.title('Residuals vs Predicted')
plt.show()

# Look for: even spread (rectangle shape) ✅
# Watch out for: funnel shape (cone) ❌

import scipy.stats as stats

# Method 1: Histogram
plt.hist(residuals, bins=30, edgecolor='black')
plt.xlabel('Residuals')
plt.ylabel('Frequency')
plt.title('Distribution of Residuals')
plt.show()

# Method 2: Q-Q Plot (Quantile-Quantile)
stats.probplot(residuals, dist="norm", plot=plt)
plt.title('Q-Q Plot')
plt.show()

# Look for: bell curve in histogram ✅
# Look for: points on diagonal line in Q-Q plot ✅

# Bad model:
Price = 100 + 0.2×(sq_ft) + 0.5×(sq_meters)

# If you increase house size:
# - sq_ft goes up
# - sq_meters also goes up (they're the same!)
# - Model gets confused about which one matters

# Good model (remove one):
Price = 100 + 0.2×(sq_ft)

import seaborn as sns

# Calculate correlations
corr_matrix = X.corr()

# Visualize
sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', center=0)
plt.title('Feature Correlation Matrix')
plt.show()

# Look for: values close to ±1 (high correlation) ❌
# Good: values close to 0 (low correlation) ✅

from statsmodels.stats.outliers_influence import variance_inflation_factor

# Calculate VIF for each feature
vif_data = pd.DataFrame()
vif_data["Feature"] = X.columns
vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(len(X.columns))]

print(vif_data)

# VIF < 5: Low multicollinearity ✅
# VIF 5-10: Moderate multicollinearity ⚠️
# VIF > 10: High multicollinearity ❌

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Now coefficients are directly comparable!

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Before scaling:
Price = 50 + 0.2×Size
# Interpretation: Each sq ft adds $200

# After scaling:
Price = 300 + 150×Size_scaled
# Interpretation: Each 1 std increase in size adds $150k

# Train model
model.fit(X_train, y_train)

# Evaluate on both sets
train_score = model.score(X_train, y_train)
test_score = model.score(X_test, y_test)

print(f"Training R²: {train_score:.3f}")
print(f"Test R²: {test_score:.3f}")

# Signs of overfitting:
# Training R² = 0.99 (excellent)
# Test R² = 0.60 (poor)
# Big gap = Overfitting! ❌

# Method 1: Box plot
plt.boxplot(y)
plt.title('Detect Outliers in Target')
plt.show()

# Method 2: Z-score
from scipy import stats
z_scores = np.abs(stats.zscore(y))
outliers = np.where(z_scores > 3)[0]
print(f"Outliers at indices: {outliers}")

# Method 3: IQR method
Q1 = y.quantile(0.25)
Q3 = y.quantile(0.75)
IQR = Q3 - Q1
outliers = (y < Q1 - 1.5*IQR) | (y > Q3 + 1.5*IQR)

from sklearn.preprocessing import PolynomialFeatures

# Original features: [Temperature]
# Polynomial features: [Temperature, Temperature²]

poly = PolynomialFeatures(degree=2)
X_poly = poly.fit_transform(X)

# Now model can learn:
# Sales = β₀ + β₁×Temp + β₂×Temp²
# Sales = 50 + 2×Temp + 0.1×Temp²

# Create interaction
X['TV_x_Online'] = X['TV_ads'] * X['Online_ads']

# Model:
Sales = β₀ + β₁×TV + β₂×Online + β₃×(TV × Online)

X['log_income'] = np.log(X['income'])

# Now more normally distributed:
# log($30k) = 10.3
# log($40k) = 10.6
# log($50k) = 10.8
# log($1M) = 13.8

# More evenly spaced!

from sklearn.linear_model import Ridge

# Try different alpha values
alphas = [0.01, 0.1, 1, 10, 100]

for alpha in alphas:
    ridge = Ridge(alpha=alpha)
    ridge.fit(X_train, y_train)
    
    print(f"Alpha = {alpha}")
    print(f"Coefficients: {ridge.coef_}")
    print(f"Test R²: {ridge.score(X_test, y_test):.3f}\n")

# Output:
# Alpha = 0.01: Coef = [0.20, 30.5, -1.2], R² = 0.75
# Alpha = 1:    Coef = [0.18, 25.0, -0.9], R² = 0.78 ← Better!
# Alpha = 100:  Coef = [0.05, 5.0, -0.1],  R² = 0.60 ← Too much!

from sklearn.linear_model import Lasso

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

print(f"Coefficients: {lasso.coef_}")
# Output: [0.15, 0, -0.8, 25.0, 0, 0, 18.5]
#              ↑         ↑  ↑
#         These features were eliminated!

# See which features were kept
feature_names = X.columns
important_features = feature_names[lasso.coef_ != 0]

print(f"Important features: {important_features}")
# Output: ['size', 'age', 'bedrooms', 'location_score']

from sklearn.linear_model import ElasticNet

elastic = ElasticNet(alpha=1, l1_ratio=0.5)
elastic.fit(X_train, y_train)

print(f"Coefficients: {elastic.coef_}")
print(f"Test R²: {elastic.score(X_test, y_test):.3f}")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from scipy import stats

print("=" * 70)
print("LINEAR REGRESSION ASSUMPTIONS CHECK")
print("=" * 70)

# ============================================
# STEP 1: CREATE SAMPLE DATA
# ============================================
print("\n📊 Step 1: Creating sample data")

np.random.seed(42)
n_samples = 100

# Features
size = np.random.uniform(1000, 4000, n_samples)
bedrooms = np.random.randint(1, 6, n_samples)
age = np.random.uniform(0, 50, n_samples)

# Target (with some noise)
price = 50 + 0.2*size + 30*bedrooms - 1*age + np.random.normal(0, 20, n_samples)

# Create DataFrame
df = pd.DataFrame({
    'size': size,
    'bedrooms': bedrooms,
    'age': age,
    'price': price
})

print(f"Dataset shape: {df.shape}")
print(f"\nFirst few rows:")
print(df.head())

# ============================================
# STEP 2: TRAIN MODEL
# ============================================
print("\n🤖 Step 2: Training model")

X = df[['size', 'bedrooms', 'age']]
y = df['price']

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

model = LinearRegression()
model.fit(X_train, y_train)

print("✅ Model trained!")
print(f"Coefficients: {model.coef_}")
print(f"Intercept: {model.intercept_:.2f}")

# ============================================
# STEP 3: CHECK ASSUMPTION 1 - LINEARITY
# ============================================
print("\n📈 Step 3: Checking Linearity")

fig, axes = plt.subplots(1, 3, figsize=(15, 4))

for i, col in enumerate(['size', 'bedrooms', 'age']):
    axes[i].scatter(X[col], y, alpha=0.5)
    axes[i].set_xlabel(col)
    axes[i].set_ylabel('price')
    axes[i].set_title(f'Price vs {col}')
    axes[i].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

print("✅ Check: Do the relationships look linear?")
print("   If you see curves, consider polynomial features!")

# ============================================
# STEP 4: CHECK ASSUMPTION 3 - HOMOSCEDASTICITY
# ============================================
print("\n📊 Step 4: Checking Homoscedasticity")

y_pred = model.predict(X)
residuals = y - y_pred

plt.figure(figsize=(10, 6))
plt.scatter(y_pred, residuals, alpha=0.5)
plt.axhline(y=0, color='r', linestyle='--', linewidth=2)
plt.xlabel('Predicted Values')
plt.ylabel('Residuals')
plt.title('Residual Plot - Check for Homoscedasticity')
plt.grid(True, alpha=0.3)
plt.show()

print("✅ Check: Is the spread constant across all predicted values?")
print("   Look for: Even spread (rectangle) ✅")
print("   Watch out for: Funnel shape (cone) ❌")

# ============================================
# STEP 5: CHECK ASSUMPTION 4 - NORMALITY
# ============================================
print("\n📊 Step 5: Checking Normality of Residuals")

fig, axes = plt.subplots(1, 2, figsize=(12, 4))

# Histogram
axes[0].hist(residuals, bins=30, edgecolor='black', alpha=0.7)
axes[0].set_xlabel('Residuals')
axes[0].set_ylabel('Frequency')
axes[0].set_title('Distribution of Residuals')
axes[0].grid(True, alpha=0.3)

# Q-Q Plot
stats.probplot(residuals, dist="norm", plot=axes[1])
axes[1].set_title('Q-Q Plot')
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

print("✅ Check: Do residuals follow a normal distribution?")
print("   Histogram should look like a bell curve")
print("   Q-Q plot points should be on the diagonal line")

# ============================================
# STEP 6: CHECK ASSUMPTION 5 - MULTICOLLINEARITY
# ============================================
print("\n📊 Step 6: Checking Multicollinearity")

# Correlation matrix
corr_matrix = X.corr()

plt.figure(figsize=(8, 6))
sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', center=0, 
            square=True, linewidths=1)
plt.title('Feature Correlation Matrix')
plt.show()

print("\nCorrelation Matrix:")
print(corr_matrix)

print("\n✅ Check: Are features highly correlated?")
print("   Values close to ±1 indicate high correlation ❌")
print("   Values close to 0 indicate low correlation ✅")

# VIF
from statsmodels.stats.outliers_influence import variance_inflation_factor

vif_data = pd.DataFrame()
vif_data["Feature"] = X.columns
vif_data["VIF"] = [variance_inflation_factor(X.values, i) 
                   for i in range(len(X.columns))]

print("\nVariance Inflation Factor (VIF):")
print(vif_data)
print("\nVIF Interpretation:")
print("  VIF < 5: Low multicollinearity ✅")
print("  VIF 5-10: Moderate multicollinearity ⚠️")
print("  VIF > 10: High multicollinearity ❌")

# ============================================
# STEP 7: MODEL EVALUATION
# ============================================
print("\n📊 Step 7: Model Evaluation")

train_score = model.score(X_train, y_train)
test_score = model.score(X_test, y_test)

print(f"Training R²: {train_score:.3f}")
print(f"Test R²: {test_score:.3f}")
print(f"Difference: {abs(train_score - test_score):.3f}")

if abs(train_score - test_score) > 0.1:
    print("⚠️  Large gap between train and test scores!")
    print("   This suggests overfitting.")
else:
    print("✅ Train and test scores are similar - good generalization!")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_squared_error

print("=" * 70)
print("SCALING AND REGULARIZATION EXAMPLE")
print("=" * 70)

# ============================================
# STEP 1: CREATE DATA WITH DIFFERENT SCALES
# ============================================
print("\n📊 Step 1: Creating data with different scales")

np.random.seed(42)
n_samples = 200

# Features on VERY different scales
size = np.random.uniform(1000, 4000, n_samples)        # 1000-4000
bedrooms = np.random.randint(1, 6, n_samples)          # 1-5
age = np.random.uniform(0, 50, n_samples)              # 0-50
income = np.random.uniform(30000, 200000, n_samples)   # 30k-200k

# Target
price = (50 + 0.2*size + 30*bedrooms - 1*age + 0.001*income 
         + np.random.normal(0, 20, n_samples))

df = pd.DataFrame({
    'size': size,
    'bedrooms': bedrooms,
    'age': age,
    'income': income,
    'price': price
})

print("Feature scales:")
print(df.describe())

# ============================================
# STEP 2: TRAIN WITHOUT SCALING
# ============================================
print("\n🤖 Step 2: Training WITHOUT scaling")

X = df[['size', 'bedrooms', 'age', 'income']]
y = df['price']

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

model_unscaled = LinearRegression()
model_unscaled.fit(X_train, y_train)

print("\nCoefficients (unscaled):")
for feature, coef in zip(X.columns, model_unscaled.coef_):
    print(f"  {feature:12s}: {coef:10.4f}")

print("\n⚠️  Hard to compare! Features are on different scales.")

# ============================================
# STEP 3: TRAIN WITH SCALING
# ============================================
print("\n🤖 Step 3: Training WITH scaling")

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

model_scaled = LinearRegression()
model_scaled.fit(X_train_scaled, y_train)

print("\nCoefficients (scaled):")
for feature, coef in zip(X.columns, model_scaled.coef_):
    print(f"  {feature:12s}: {coef:10.2f}")

print("\n✅ Now coefficients are directly comparable!")
print("   Larger absolute value = more important feature")

# Find most important feature
most_important_idx = np.argmax(np.abs(model_scaled.coef_))
most_important_feature = X.columns[most_important_idx]
print(f"\nMost important feature: {most_important_feature}")

# ============================================
# STEP 4: RIDGE REGRESSION
# ============================================
print("\n🔵 Step 4: Ridge Regression")

alphas = [0.01, 0.1, 1, 10, 100]
ridge_scores = []

print("\nTrying different alpha values:")
for alpha in alphas:
    ridge = Ridge(alpha=alpha)
    ridge.fit(X_train_scaled, y_train)
    
    train_score = ridge.score(X_train_scaled, y_train)
    test_score = ridge.score(X_test_scaled, y_test)
    ridge_scores.append(test_score)
    
    print(f"\nAlpha = {alpha:6.2f}")
    print(f"  Train R²: {train_score:.3f}")
    print(f"  Test R²:  {test_score:.3f}")
    print(f"  Coefficients: {ridge.coef_.round(2)}")

# Plot alpha vs performance
plt.figure(figsize=(10, 6))
plt.semilogx(alphas, ridge_scores, 'o-', linewidth=2, markersize=8)
plt.xlabel('Alpha (Regularization Strength)')
plt.ylabel('Test R² Score')
plt.title('Ridge Regression: Alpha vs Performance')
plt.grid(True, alpha=0.3)
plt.show()

best_alpha_idx = np.argmax(ridge_scores)
best_alpha = alphas[best_alpha_idx]
print(f"\n✅ Best alpha: {best_alpha} (Test R² = {ridge_scores[best_alpha_idx]:.3f})")

# ============================================
# STEP 5: LASSO REGRESSION
# ============================================
print("\n🔴 Step 5: Lasso Regression (Feature Selection)")

lasso = Lasso(alpha=1)
lasso.fit(X_train_scaled, y_train)

print("\nLasso Coefficients:")
for feature, coef in zip(X.columns, lasso.coef_):
    status = "✅ KEPT" if coef != 0 else "❌ ELIMINATED"
    print(f"  {feature:12s}: {coef:10.4f}  {status}")

# Count features
n_features_kept = np.sum(lasso.coef_ != 0)
print(f"\nFeatures kept: {n_features_kept}/{len(X.columns)}")

test_score = lasso.score(X_test_scaled, y_test)
print(f"Test R²: {test_score:.3f}")

# ============================================
# STEP 6: ELASTIC NET
# ============================================
print("\n🟣 Step 6: Elastic Net (Best of Both)")

elastic = ElasticNet(alpha=1, l1_ratio=0.5)
elastic.fit(X_train_scaled, y_train)

print("\nElastic Net Coefficients:")
for feature, coef in zip(X.columns, elastic.coef_):
    status = "✅ KEPT" if coef != 0 else "❌ ELIMINATED"
    print(f"  {feature:12s}: {coef:10.4f}  {status}")

test_score = elastic.score(X_test_scaled, y_test)
print(f"Test R²: {test_score:.3f}")

# ============================================
# STEP 7: COMPARE ALL METHODS
# ============================================
print("\n📊 Step 7: Comparing All Methods")

models = {
    'Linear (unscaled)': model_unscaled,
    'Linear (scaled)': model_scaled,
    'Ridge': Ridge(alpha=best_alpha).fit(X_train_scaled, y_train),
    'Lasso': lasso,
    'Elastic Net': elastic
}

results = []
for name, model in models.items():
    if 'unscaled' in name:
        score = model.score(X_test, y_test)
    else:
        score = model.score(X_test_scaled, y_test)
    results.append({'Model': name, 'Test R²': score})

results_df = pd.DataFrame(results)
print("\nModel Comparison:")
print(results_df.to_string(index=False))

# Visualize
plt.figure(figsize=(10, 6))
plt.barh(results_df['Model'], results_df['Test R²'])
plt.xlabel('Test R² Score')
plt.title('Model Comparison')
plt.xlim(0, 1)
plt.grid(True, alpha=0.3, axis='x')
plt.tight_layout()
plt.show()

print("\n✅ Analysis complete!")