Correlation & Regression

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_squared_error

sqft = np.array([1400, 1600, 1700, 1875, 1100, 1550, 2350, 2450, 1425, 1700])
price = np.array([245000, 312000, 279000, 308000, 199000, 219000, 405000, 324000, 319000, 255000])

# Reshape for sklearn
X = sqft.reshape(-1, 1)
y = price

# Fit model
model = LinearRegression()
model.fit(X, y)

# Make predictions
y_pred = model.predict(X)

# Evaluate
r2 = r2_score(y, y_pred)
rmse = np.sqrt(mean_squared_error(y, y_pred))

print(f"Equation: Price = ${model.coef_[0]:.2f} × sqft + ${model.intercept_:,.0f}")
print(f"R² Score: {r2:.4f}")
print(f"RMSE: ${rmse:,.0f}")

# Predict for 2000 sqft
new_price = model.predict([[2000]])[0]
print(f"\nPredicted price for 2000 sqft: ${new_price:,.0f}")

# Assessment
print(f"\nModel Assessment:")
print(f"- R² = {r2:.2%} variance explained (moderate fit)")
print(f"- RMSE = ${rmse:,.0f} average error")
print(f"- Use cautiously - other factors affect price!")

from sklearn.linear_model import LinearRegression
import numpy as np

advertising = np.array([100, 200, 300, 400, 500, 600, 700, 800])
sales = np.array([10, 22, 28, 38, 45, 55, 60, 68])

# Reshape for sklearn
X = advertising.reshape(-1, 1)
y = sales

# Fit model
model = LinearRegression()
model.fit(X, y)

print(f"Equation: sales = {model.coef_[0]:.4f} × advertising + {model.intercept_:.4f}")
# sales = 0.0829 × advertising + 2.50

# Predict for $900
prediction = model.predict([[900]])[0]
print(f"Predicted sales for $900: {prediction:.1f} units")  # ~77.1 units

from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
import numpy as np

y_true = np.array([100, 150, 200, 250, 300])
y_pred = np.array([110, 145, 195, 260, 290])

r2 = r2_score(y_true, y_pred)
rmse = np.sqrt(mean_squared_error(y_true, y_pred))
mae = mean_absolute_error(y_true, y_pred)

print(f"R-squared: {r2:.4f}")  # 0.9875 (excellent!)
print(f"RMSE: {rmse:.4f}")     # 8.94
print(f"MAE: {mae:.4f}")       # 8.00

# Assessment: Very good model!
# - R² of 0.99 means 99% of variance explained
# - RMSE/MAE of ~8-9 units on values ranging 100-300 is small
# - Errors are roughly 4% of the mean value

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_squared_error
import numpy as np

# Create dataset
np.random.seed(42)
X = np.random.rand(100, 1) * 10  # 100 samples, values 0-10
y = 3 * X.flatten() + 5 + np.random.randn(100) * 2  # y = 3x + 5 + noise

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
print(f"Train: {len(X_train)}, Test: {len(X_test)}")

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

# Evaluate on test set (NOT train set!)
y_pred = model.predict(X_test)
r2 = r2_score(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))

print(f"Test R²: {r2:.4f}")
print(f"Test RMSE: {rmse:.4f}")
print(f"True equation: y = 3x + 5")
print(f"Learned: y = {model.coef_[0]:.2f}x + {model.intercept_:.2f}")

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
import numpy as np

def simple_regression_pipeline(X, y, test_size=0.2, random_state=42):
    """
    Complete simple regression pipeline.
    Returns model and comprehensive metrics.
    """
    # Ensure X is 2D
    if len(X.shape) == 1:
        X = X.reshape(-1, 1)
    
    # Split data
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=test_size, random_state=random_state
    )
    
    # Train model
    model = LinearRegression()
    model.fit(X_train, y_train)
    
    # Predictions
    y_train_pred = model.predict(X_train)
    y_test_pred = model.predict(X_test)
    
    # Metrics
    results = {
        'model': model,
        'slope': model.coef_[0],
        'intercept': model.intercept_,
        'train_r2': r2_score(y_train, y_train_pred),
        'test_r2': r2_score(y_test, y_test_pred),
        'train_rmse': np.sqrt(mean_squared_error(y_train, y_train_pred)),
        'test_rmse': np.sqrt(mean_squared_error(y_test, y_test_pred)),
        'train_mae': mean_absolute_error(y_train, y_train_pred),
        'test_mae': mean_absolute_error(y_test, y_test_pred),
        'n_train': len(X_train),
        'n_test': len(X_test)
    }
    
    return results

# Test
X = np.random.rand(100) * 10
y = 2.5 * X + 10 + np.random.randn(100) * 3

results = simple_regression_pipeline(X, y)
print(f"Equation: y = {results['slope']:.2f}x + {results['intercept']:.2f}")
print(f"Train R²: {results['train_r2']:.4f}, Test R²: {results['test_r2']:.4f}")
print(f"Test RMSE: {results['test_rmse']:.4f}")

import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression

data = {
    'horsepower': [130, 165, 150, 150, 140, 198, 220, 215, 225, 190],
    'weight': [3504, 3693, 3436, 3433, 3449, 4341, 4354, 4312, 4425, 3850],
    'cylinders': [8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
    'mpg': [18, 15, 18, 16, 17, 14, 14, 14, 12, 16]
}
df = pd.DataFrame(data)

X = df[['horsepower', 'weight', 'cylinders']]
y = df['mpg']

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

print("Coefficients:")
for name, coef in zip(X.columns, model.coef_):
    print(f"  {name}: {coef:.6f}")
print(f"  Intercept: {model.intercept_:.2f}")

print("\nInterpretation:")
print(f"  - Each additional HP → {model.coef_[0]:.3f} MPG change")
print(f"  - Each additional lb → {model.coef_[1]:.4f} MPG change")

# Predict for new car
new_car = [[175, 3800, 6]]
pred_mpg = model.predict(new_car)[0]
print(f"\nPredicted MPG for 175HP/3800lb/6cyl: {pred_mpg:.1f}")

import pandas as pd
from sklearn.linear_model import LinearRegression

data = {
    'horsepower': [130, 165, 150, 150, 140, 198, 220, 215],
    'weight': [3504, 3693, 3436, 3433, 3449, 4341, 4354, 4312],
    'mpg': [18, 15, 18, 16, 17, 14, 14, 14]
}
df = pd.DataFrame(data)

X = df[['horsepower', 'weight']]
y = df['mpg']

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

print(f"Intercept: {model.intercept_:.4f}")
print(f"Horsepower coef: {model.coef_[0]:.6f}")
print(f"Weight coef: {model.coef_[1]:.6f}")

# Interpretation: Both negative - more HP and weight = lower MPG
# Weight has stronger effect (larger absolute standardized coef)

import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler

df = pd.DataFrame({
    'hours_studied': [2, 3, 4, 5, 6, 7, 8, 9, 10],
    'sleep_hours': [5, 6, 7, 6, 8, 7, 6, 8, 7],
    'caffeine_mg': [100, 150, 200, 250, 100, 150, 300, 200, 250],
    'exam_score': [65, 70, 75, 78, 85, 82, 88, 92, 95]
})

X = df[['hours_studied', 'sleep_hours', 'caffeine_mg']]
y = df['exam_score']

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

# Fit on standardized data
model = LinearRegression()
model.fit(X_scaled, y)

# Compare standardized coefficients
print("Standardized Coefficients (Feature Importance):")
for feature, coef in zip(X.columns, model.coef_):
    print(f"  {feature}: {coef:+.4f}")

# hours_studied has largest coefficient - most important!

import numpy as np
from scipy import stats
import matplotlib.pyplot as plt

y_actual = np.array([45, 52, 58, 63, 70, 75, 82, 88, 95, 100])
y_pred = np.array([50, 52, 56, 62, 68, 76, 80, 86, 94, 96])

# Calculate residuals
residuals = y_actual - y_pred

print("Residual Statistics:")
print(f"  Mean: {residuals.mean():.2f} (should be ~0)")
print(f"  Std Dev: {residuals.std():.2f}")
print(f"  Min: {residuals.min()}, Max: {residuals.max()}")

# Shapiro-Wilk test for normality
stat, p_value = stats.shapiro(residuals)
print(f"\nShapiro-Wilk Test:")
print(f"  Statistic: {stat:.4f}")
print(f"  P-value: {p_value:.4f}")
print(f"  {'Normal' if p_value > 0.05 else 'NOT Normal'} distribution")

# Look for patterns
print(f"\nResiduals: {residuals}")
print("\nDiagnosis:")
print("- Early residuals are negative (model overpredicts)")
print("- Later residuals are positive (model underpredicts)")
print("- This pattern suggests non-linear relationship!")
print("- Consider polynomial regression or transformation")

import numpy as np
from scipy import stats
from sklearn.linear_model import LinearRegression

# Create sample data
np.random.seed(42)
X = np.random.rand(50, 1) * 10
y = 2 * X.flatten() + 3 + np.random.randn(50) * 2

# Fit model
model = LinearRegression()
model.fit(X, y)

# Get residuals
residuals = y - model.predict(X)

# Shapiro-Wilk test
stat, p_value = stats.shapiro(residuals)
print(f"Shapiro-Wilk statistic: {stat:.4f}")
print(f"P-value: {p_value:.4f}")

if p_value > 0.05:
    print("Result: Residuals are normally distributed (fail to reject H0)")
else:
    print("Result: Residuals are NOT normally distributed (reject H0)")

import pandas as pd
from statsmodels.stats.outliers_influence import variance_inflation_factor

df = pd.DataFrame({
    'x1': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'x2': [1.1, 2.0, 3.1, 4.0, 5.1, 6.0, 7.1, 8.0, 9.1, 10.0],
    'x3': [5, 3, 6, 2, 8, 4, 7, 1, 9, 5]
})

# Calculate VIF for each feature
vif_data = pd.DataFrame()
vif_data['Feature'] = df.columns
vif_data['VIF'] = [variance_inflation_factor(df.values, i) 
                   for i in range(df.shape[1])]

print(vif_data)
# x1 and x2 will have HIGH VIF (>10) due to near-perfect correlation
# x3 will have low VIF (~1)

# Solution: Remove x1 OR x2 (they're nearly identical)
print("\nRecommendation: Remove x1 or x2 - they carry same info")