mirror of
https://github.com/TheAlgorithms/Python.git
synced 2025-02-12 12:28:07 +00:00
130 lines
4.4 KiB
Python
130 lines
4.4 KiB
Python
import numpy as np
|
|
import pandas as pd
|
|
|
|
|
|
class RidgeRegression:
|
|
def __init__(
|
|
self, alpha: float = 0.001, lambda_: float = 0.1, iterations: int = 1000
|
|
) -> None:
|
|
"""
|
|
Ridge Regression Constructor
|
|
:param alpha: Learning rate for gradient descent
|
|
:param lambda_: Regularization parameter (L2 regularization)
|
|
:param iterations: Number of iterations for gradient descent
|
|
"""
|
|
self.alpha = alpha
|
|
self.lambda_ = lambda_
|
|
self.iterations = iterations
|
|
self.theta = None
|
|
|
|
def feature_scaling(
|
|
self, features: np.ndarray
|
|
) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
|
|
"""
|
|
Normalize features to have mean 0 and standard deviation 1.
|
|
|
|
:param features: Input features, shape (m, n)
|
|
:return: Tuple containing:
|
|
- Scaled features
|
|
- Mean of each feature
|
|
- Standard deviation of each feature
|
|
|
|
Example:
|
|
>>> rr = RidgeRegression()
|
|
>>> features = np.array([[1, 2], [2, 3], [4, 6]])
|
|
>>> scaled_features, mean, std = rr.feature_scaling(features)
|
|
>>> np.allclose(scaled_features.mean(axis=0), 0)
|
|
True
|
|
>>> np.allclose(scaled_features.std(axis=0), 1)
|
|
True
|
|
"""
|
|
mean = np.mean(features, axis=0)
|
|
std = np.std(features, axis=0)
|
|
|
|
# Avoid division by zero for constant features (std = 0)
|
|
std[std == 0] = 1 # Set std=1 for constant features to avoid NaN
|
|
|
|
scaled_features = (features - mean) / std
|
|
return scaled_features, mean, std
|
|
|
|
def fit(self, x: np.ndarray, y: np.ndarray) -> None:
|
|
"""
|
|
Fit the Ridge Regression model to the training data.
|
|
|
|
:param x: Input features, shape (m, n)
|
|
:param y: Target values, shape (m,)
|
|
"""
|
|
x_scaled, mean, std = self.feature_scaling(x) # Normalize features
|
|
m, n = x_scaled.shape
|
|
self.theta = np.zeros(n) # Initialize weights to zeros
|
|
|
|
for _ in range(self.iterations):
|
|
predictions = x_scaled.dot(self.theta)
|
|
error = predictions - y
|
|
|
|
# Compute gradient with L2 regularization
|
|
gradient = (x_scaled.T.dot(error) + self.lambda_ * self.theta) / m
|
|
self.theta -= self.alpha * gradient # Update weights
|
|
|
|
def predict(self, x: np.ndarray) -> np.ndarray:
|
|
"""
|
|
Predict values using the trained model.
|
|
|
|
:param x: Input features, shape (m, n)
|
|
:return: Predicted values, shape (m,)
|
|
"""
|
|
x_scaled, _, _ = self.feature_scaling(x) # Scale features using training data
|
|
return x_scaled.dot(self.theta)
|
|
|
|
def compute_cost(self, x: np.ndarray, y: np.ndarray) -> float:
|
|
"""
|
|
Compute the cost function with regularization.
|
|
|
|
:param x: Input features, shape (m, n)
|
|
:param y: Target values, shape (m,)
|
|
:return: Computed cost
|
|
"""
|
|
x_scaled, _, _ = self.feature_scaling(x) # Scale features using training data
|
|
m = len(y)
|
|
predictions = x_scaled.dot(self.theta)
|
|
cost = (1 / (2 * m)) * np.sum((predictions - y) ** 2) + (
|
|
self.lambda_ / (2 * m)
|
|
) * np.sum(self.theta**2)
|
|
return cost
|
|
|
|
def mean_absolute_error(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:
|
|
"""
|
|
Compute Mean Absolute Error (MAE) between true and predicted values.
|
|
|
|
:param y_true: Actual target values, shape (m,)
|
|
:param y_pred: Predicted target values, shape (m,)
|
|
:return: MAE
|
|
"""
|
|
return np.mean(np.abs(y_true - y_pred))
|
|
|
|
|
|
# Example usage
|
|
if __name__ == "__main__":
|
|
# Load dataset
|
|
data = pd.read_csv(
|
|
"https://raw.githubusercontent.com/yashLadha/The_Math_of_Intelligence/master/Week1/ADRvsRating.csv"
|
|
)
|
|
x = data[["Rating"]].to_numpy() # Feature: Rating
|
|
y = data["ADR"].to_numpy() # Target: ADR
|
|
y = (y - np.mean(y)) / np.std(y)
|
|
|
|
# Add bias term (intercept) to the feature matrix
|
|
x = np.c_[np.ones(X.shape[0]), x] # Add intercept term
|
|
|
|
# Initialize and train the Ridge Regression model
|
|
model = RidgeRegression(alpha=0.01, lambda_=0.1, iterations=1000)
|
|
model.fit(x, y)
|
|
|
|
# Predictions
|
|
predictions = model.predict(x)
|
|
|
|
# Results
|
|
print("Optimized Weights:", model.theta)
|
|
print("Cost:", model.compute_cost(x, y))
|
|
print("Mean Absolute Error:", model.mean_absolute_error(y, predictions))
|