Master Linear Regression

import numpy as np

def mean_squared_error(y_true, y_pred):
    """Calculate Mean Squared Error"""
    return np.mean((y_true - y_pred) ** 2)

# Example: actual vs predicted house prices (in thousands)
actual = np.array([200, 250, 300, 350, 400])
predicted = np.array([210, 240, 310, 340, 390])

mse = mean_squared_error(actual, predicted)  # 120.0
print(f"MSE: ${mse}k squared")  # Lower is better!

import numpy as np

def gradient_descent(x, y, learning_rate=0.01, epochs=1000):
    m, b = 0, 0  # Initialize slope and intercept to zero
    n = len(x)   # Number of data points

    for epoch in range(epochs):
        # Make predictions using current m and b
        y_pred = m * x + b

        # Calculate gradients (direction of steepest increase in error)
        dm = -(2/n) * np.sum(x * (y - y_pred))  # Gradient for slope
        db = -(2/n) * np.sum(y - y_pred)        # Gradient for intercept

        # Update parameters by moving against the gradient
        m = m - learning_rate * dm
        b = b - learning_rate * db
        
        # Print progress every 100 epochs
        if epoch % 100 == 0:
            mse = np.mean((y - y_pred) ** 2)
            print(f"Epoch {epoch}: MSE = {mse:.2f}")

    return m, b

# Test with sample data
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 5, 4, 5])
m, b = gradient_descent(x, y)  # m ≈ 0.6, b ≈ 2.2

print(f"Final equation: y = {m:.2f}x + {b:.2f}")

import numpy as np

# Sample data
X = np.array([[1, 1], [1, 2], [1, 3], [1, 4], [1, 5]])  # First column is 1s
y = np.array([2, 4, 5, 4, 5])

# Apply normal equation: theta = (X^T X)^-1 X^T y
X_transpose = X.T
theta = np.linalg.inv(X_transpose.dot(X)).dot(X_transpose).dot(y)

print(f"Optimal parameters: {theta}")
# [1.2 0.6] - intercept and slope

# Make predictions
X_test = np.array([[1, 6], [1, 7]])  # Include 1s for intercept
predictions = X_test.dot(theta)
print(f"Predictions: {predictions}")  # [4.8 5.4]

import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# Data: years of experience and salary (in thousands)
experience = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).reshape(-1, 1)
salary = np.array([40, 45, 50, 55, 65, 70, 75, 80, 85, 90])

# Create and train the model
model = LinearRegression()
model.fit(experience, salary)

# Get parameters
slope = model.coef_[0]  # 5.45
intercept = model.intercept_  # 36.97

print(f"Salary = {slope:.2f} × Experience + {intercept:.2f}")
# Output: Salary = 5.45 × Experience + 36.97

# Make prediction for 12 years experience
prediction = model.predict([[12]])  # ~102.42k
print(f"Predicted salary for 12 years: ${prediction[0]:.2f}k")

import matplotlib.pyplot as plt

# Plot data points
plt.scatter(experience, salary, color='blue', label='Actual Data')

# Plot regression line
plt.plot(experience, model.predict(experience), 
         color='red', linewidth=2, label='Best Fit Line')

plt.xlabel('Years of Experience')
plt.ylabel('Salary ($1000s)')
plt.title('Salary vs Experience')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()
# Shows how well the line fits through the data points

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

# Generate sample data
np.random.seed(42)  # For reproducibility
X = np.random.rand(100, 1) * 10
y = 2.5 * X.squeeze() + 5 + np.random.randn(100) * 2

# Split data: 80% training, 20% testing
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

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

# Evaluate
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)  # ~4.2
r2 = r2_score(y_test, y_pred)  # ~0.92

print(f"MSE: {mse:.2f}")
print(f"R²: {r2:.2f}")
print(f"Model: y = {model.coef_[0]:.2f}x + {model.intercept_:.2f}")

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

# House data: size, bedrooms, age, location_score, price
data = pd.DataFrame({
    'size': [1500, 1800, 2400, 2000, 2200],
    'bedrooms': [3, 3, 4, 3, 4],
    'age': [10, 5, 2, 8, 3],
    'location': [7, 8, 9, 6, 8],
    'price': [300, 350, 450, 380, 420]
})

# Separate features and target
X = data[['size', 'bedrooms', 'age', 'location']]
y = data['price']

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

# Print coefficients
print("Feature Importance:")
for feature, coef in zip(X.columns, model.coef_):
    print(f"{feature:12s}: {coef:7.2f}")
print(f"Intercept: {model.intercept_:.2f}")

# Predict for new house: 2100 sqft, 3 bed, 5 years old, location 8
new_house = [[2100, 3, 5, 8]]
predicted_price = model.predict(new_house)  # ~405k
print(f"\nPredicted price: ${predicted_price[0]:.0f}k")

from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
import numpy as np

# Data with different scales
X = np.array([
    [2000, 3, 10],  # size, bedrooms, age
    [1500, 2, 5],
    [2500, 4, 2],
    [1800, 3, 8]
])
y = np.array([400, 300, 500, 350])

# Scale features (mean=0, std=1)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Train model on scaled data
model = LinearRegression()
model.fit(X_scaled, y)

# Predict for new house
new_house = [[2100, 3, 6]]
new_house_scaled = scaler.transform(new_house)
prediction = model.predict(new_house_scaled)  # ~380k

print(f"Predicted price: ${prediction[0]:.0f}k")

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression

# Non-linear data (productivity vs hours of sleep)
X = np.array([4, 5, 6, 7, 8, 9, 10]).reshape(-1, 1)
y = np.array([60, 70, 85, 95, 90, 75, 60])  # Inverted U-shape

# Create polynomial features (degree 2)
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)

print("Original features:", X[0])      # [4]
print("Polynomial features:", X_poly[0])  # [4, 16] (x, x²)

# Train model on polynomial features
model = LinearRegression()
model.fit(X_poly, y)

# Predict
X_test = np.array([[7.5]])
X_test_poly = poly.transform(X_test)
prediction = model.predict(X_test_poly)
print(f"Predicted productivity at 7.5 hrs sleep: {prediction[0]:.1f}")

# Visualize
X_range = np.linspace(4, 10, 100).reshape(-1, 1)
X_range_poly = poly.transform(X_range)
y_pred = model.predict(X_range_poly)

plt.scatter(X, y, color='blue', label='Actual data')
plt.plot(X_range, y_pred, color='red', label='Polynomial fit (degree 2)')
plt.xlabel('Hours of Sleep')
plt.ylabel('Productivity Score')
plt.legend()
plt.title('Polynomial Regression: Productivity vs Sleep')
plt.show()

from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline
import numpy as np

# Try different polynomial degrees
X = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).reshape(-1, 1)
y = np.array([2, 4, 5, 7, 8, 9, 10, 11, 11, 12])

for degree in range(1, 6):
    # Create pipeline: polynomial features + linear regression
    model = make_pipeline(
        PolynomialFeatures(degree=degree),
        LinearRegression()
    )
    
    # Cross-validation scores
    scores = cross_val_score(model, X, y, cv=5, 
                            scoring='r2')
    print(f"Degree {degree}: R² = {scores.mean():.3f} (+/- {scores.std():.3f})")

# Choose degree with highest average R² without overfitting
# Output might show:
# Degree 1: R² = 0.920 (+/- 0.050)
# Degree 2: R² = 0.945 (+/- 0.030)  <- Best balance
# Degree 3: R² = 0.935 (+/- 0.055)  <- Starting to overfit
# Degree 4: R² = 0.880 (+/- 0.120)  <- Overfitting

import pandas as pd
import numpy as np

# Create sample data
data = pd.DataFrame({
    'size': [1500, 1800, 2400, 2000, 2200],
    'rooms': [5, 6, 8, 7, 8],  # Highly correlated with size
    'age': [10, 5, 2, 8, 3]
})

# Calculate correlation matrix
correlation_matrix = data.corr()
print(correlation_matrix)

# If correlation > 0.8, consider removing one feature
print("\nHigh correlations detected:")
for i in range(len(correlation_matrix.columns)):
    for j in range(i+1, len(correlation_matrix.columns)):
        if abs(correlation_matrix.iloc[i, j]) > 0.8:
            col1 = correlation_matrix.columns[i]
            col2 = correlation_matrix.columns[j]
            print(f"{col1} & {col2}: {correlation_matrix.iloc[i, j]:.2f}")

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

# 1. Load and explore data
data = pd.DataFrame({
    'square_feet': [1400, 1600, 1700, 1875, 1100, 1550, 2350, 2450, 1425, 1700],
    'bedrooms': [3, 3, 2, 4, 2, 3, 4, 5, 3, 3],
    'age_years': [10, 8, 15, 5, 20, 12, 3, 2, 18, 9],
    'price': [245, 312, 279, 308, 199, 219, 405, 324, 319, 255]
})

print("Dataset shape:", data.shape)
print("\nFirst few rows:")
print(data.head())

# 2. Prepare features and target
X = data[['square_feet', 'bedrooms', 'age_years']]
y = data['price']

# 3. Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 4. Scale features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 5. Train model
model = LinearRegression()
model.fit(X_train_scaled, y_train)

# 6. Make predictions
y_train_pred = model.predict(X_train_scaled)
y_test_pred = model.predict(X_test_scaled)

# 7. Evaluate
print("\nModel Performance:")
print(f"Train R²: {r2_score(y_train, y_train_pred):.4f}")
print(f"Test R²: {r2_score(y_test, y_test_pred):.4f}")
print(f"Test MSE: {mean_squared_error(y_test, y_test_pred):.2f}")
print(f"Test MAE: {mean_absolute_error(y_test, y_test_pred):.2f}")

# 8. Feature importance
print("\nFeature Coefficients:")
for feature, coef in zip(X.columns, model.coef_):
    print(f"{feature}: {coef:.2f}")

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

# True and predicted values
y_true = np.array([100, 150, 200, 250, 300])
y_pred = np.array([110, 140, 190, 260, 290])

# Calculate all metrics
mse = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)  # Or use mean_squared_error(y_true, y_pred, squared=False)
mae = mean_absolute_error(y_true, y_pred)
r2 = r2_score(y_true, y_pred)

print(f"MSE:  {mse:.2f}  (units squared)")
print(f"RMSE: {rmse:.2f} (same units as target)")
print(f"MAE:  {mae:.2f}  (same units as target)")
print(f"R²:   {r2:.4f} (0 to 1, dimensionless)")

# Example output:
# MSE:  200.00  (units squared)
# RMSE: 14.14   (same units as target)
# MAE:  10.00   (same units as target)
# R²:   0.9840  (0 to 1, dimensionless)

import numpy as np
import matplotlib.pyplot as plt

# Calculate residuals (prediction errors)
residuals = y_test - y_test_pred

# 1. Residual plot (should show random scatter)
plt.figure(figsize=(12, 4))

plt.subplot(1, 3, 1)
plt.scatter(y_test_pred, residuals, alpha=0.6)
plt.axhline(y=0, color='r', linestyle='--')
plt.xlabel('Predicted Values')
plt.ylabel('Residuals')
plt.title('Residual Plot')

# 2. Histogram (should be roughly normal/bell-shaped)
plt.subplot(1, 3, 2)
plt.hist(residuals, bins=10, edgecolor='black')
plt.xlabel('Residuals')
plt.ylabel('Frequency')
plt.title('Residual Distribution')

# 3. Q-Q plot (points should follow diagonal line)
plt.subplot(1, 3, 3)
from scipy import stats
stats.probplot(residuals, dist="norm", plot=plt)
plt.title('Q-Q Plot')

plt.tight_layout()
plt.show()

# Statistical test for normality
_, p_value = stats.shapiro(residuals)
print(f"Shapiro test p-value: {p_value:.4f}")
print("Normal!" if p_value > 0.05 else "Not normal - check assumptions")

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LinearRegression
import numpy as np

# Create model
model = LinearRegression()

# Perform 5-fold cross-validation
cv_scores = cross_val_score(
    model, X_train_scaled, y_train, 
    cv=5, scoring='r2'
)

print("Cross-Validation R² Scores:", cv_scores)
print(f"Mean R²: {cv_scores.mean():.4f}")
print(f"Std Dev: {cv_scores.std():.4f}")

# Also check MSE
cv_mse = -cross_val_score(
    model, X_train_scaled, y_train,
    cv=5, scoring='neg_mean_squared_error'
)

print(f"\nMean MSE: {cv_mse.mean():.2f}")

import joblib

# Save model and scaler
joblib.dump(model, 'house_price_model.pkl')
joblib.dump(scaler, 'feature_scaler.pkl')

print("Model saved successfully!")

# Load model later for predictions
loaded_model = joblib.load('house_price_model.pkl')
loaded_scaler = joblib.load('feature_scaler.pkl')

# Make prediction with loaded model
new_house = [[2000, 3, 10]]  # sqft, beds, age
new_house_scaled = loaded_scaler.transform(new_house)
prediction = loaded_model.predict(new_house_scaled)

print(f"Predicted price: ${prediction[0]:.0f}k")