Mean Squared Error (MSE)

graph TD
    A[Mean Squared Error] --> B[Error Calculation]
    A --> C[Squaring Operation]
    A --> D[Average]
    A --> E[Properties]

    B --> B1[Actual - Predicted]
    B --> B2[Residuals]

    C --> C1[Squared Differences]
    C --> C2[Amplifies Large Errors]

    D --> D1[Mean of Squared Errors]
    D --> D2[Single Value Metric]

    E --> E1[Always Non-Negative]
    E --> E2[Lower is Better]
    E --> E3[Same Units as Target²]

    style A fill:#f9f,stroke:#333
    style B fill:#cfc,stroke:#333
    style C fill:#fcc,stroke:#333

import numpy as np
from sklearn.metrics import mean_squared_error
from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression

# Generate synthetic regression data
X, y = make_regression(n_samples=1000, n_features=5, noise=10, random_state=42)

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

# Make predictions
y_pred = model.predict(X)

# Calculate MSE
mse = mean_squared_error(y, y_pred)
print(f"Mean Squared Error: {mse:.4f}")

# Manual calculation
mse_manual = np.mean((y - y_pred) ** 2)
print(f"Manual MSE: {mse_manual:.4f}")

from sklearn.model_selection import cross_val_score

# Cross-validated MSE
mse_scores = cross_val_score(
    model, X, y,
    cv=5,
    scoring='neg_mean_squared_error'
)

# Convert to positive MSE
mse_scores = -mse_scores

print(f"Cross-validated MSE scores: {mse_scores}")
print(f"Mean MSE: {np.mean(mse_scores):.4f} ± {np.std(mse_scores):.4f}")

def weighted_mse(y_true, y_pred, weights):
    """Calculate weighted MSE"""
    squared_errors = (y_true - y_pred) ** 2
    return np.sum(weights * squared_errors) / np.sum(weights)

# Example with weights
weights = np.random.rand(len(y))
wmse = weighted_mse(y, y_pred, weights)
print(f"Weighted MSE: {wmse:.4f}")

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestRegressor

# Example: Optimizing hyperparameters to minimize MSE
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20],
    'min_samples_split': [2, 5, 10]
}

model = RandomForestRegressor(random_state=42)
grid_search = GridSearchCV(
    model,
    param_grid,
    cv=5,
    scoring='neg_mean_squared_error',
    n_jobs=-1
)

grid_search.fit(X, y)

# Best parameters and MSE
print(f"Best parameters: {grid_search.best_params_}")
best_mse = -grid_search.best_score_
print(f"Best MSE: {best_mse:.4f}")

def analyze_errors(y_true, y_pred):
    """Comprehensive error analysis"""
    errors = y_true - y_pred
    squared_errors = errors ** 2
    abs_errors = np.abs(errors)

    # Basic statistics
    stats = {
        'mse': np.mean(squared_errors),
        'rmse': np.sqrt(np.mean(squared_errors)),
        'mae': np.mean(abs_errors),
        'max_error': np.max(abs_errors),
        'min_error': np.min(abs_errors),
        'error_std': np.std(errors),
        'error_skew': np.mean((errors - np.mean(errors))**3) / np.std(errors)**3,
        'error_kurtosis': np.mean((errors - np.mean(errors))**4) / np.std(errors)**4
    }

    # Error distribution
    plt.figure(figsize=(12, 5))

    plt.subplot(1, 2, 1)
    plt.hist(errors, bins=30, alpha=0.7, color='skyblue')
    plt.axvline(0, color='red', linestyle='--')
    plt.title('Error Distribution')
    plt.xlabel('Prediction Error')
    plt.ylabel('Frequency')

    plt.subplot(1, 2, 2)
    plt.scatter(y_pred, errors, alpha=0.5)
    plt.axhline(0, color='red', linestyle='--')
    plt.title('Errors vs Predictions')
    plt.xlabel('Predicted Values')
    plt.ylabel('Prediction Error')

    plt.tight_layout()
    plt.show()

    return stats

# Example usage
error_stats = analyze_errors(y, y_pred)
print("Error Statistics:")
for key, value in error_stats.items():
    print(f"{key}: {value:.4f}")