From 2293d37599c9bcc7c1e3769ead589bd3aa09da99 Mon Sep 17 00:00:00 2001
From: Harmanaya Sharma <harmanyasharma@gmail.com>
Date: Tue, 22 Oct 2024 23:19:28 +0530
Subject: [PATCH 01/16] Fix issue #12108: Added Ridge Regression to Machine
 Learning

---
 machine_learning/ridge_regression.py | 108 +++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 machine_learning/ridge_regression.py

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
new file mode 100644
index 000000000000..d4d3162e50ed
--- /dev/null
+++ b/machine_learning/ridge_regression.py
@@ -0,0 +1,108 @@
+import numpy as np
+import pandas as pd
+
+
+class RidgeRegression:
+    def __init__(self, alpha=0.001, lambda_=0.1, iterations=1000):
+        """
+        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, X):
+        """
+        Normalize features to have mean 0 and standard deviation 1
+        :param X: Input features, shape (m, n)
+        :return: Scaled features, mean, and std for each feature
+        """
+        mean = np.mean(X, axis=0)
+        std = np.std(X, axis=0)
+
+        # Avoid division by zero for constant features (std = 0)
+        std[std == 0] = 1  # Set std=1 for constant features to avoid NaN
+
+        X_scaled = (X - mean) / std
+        return X_scaled, mean, std
+
+    def fit(self, X, y):
+        """
+        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 i 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):
+        """
+        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, y):
+        """
+        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, y_pred):
+        """
+        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
+    df = pd.read_csv(
+        "https://raw.githubusercontent.com/yashLadha/The_Math_of_Intelligence/master/Week1/ADRvsRating.csv"
+    )
+    X = df[["Rating"]].values  # Feature: Rating
+    y = df["ADR"].values  # 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))

From e9ef03eadbca254bd5557899d1655f13954335dd Mon Sep 17 00:00:00 2001
From: Harmanaya Sharma <harmanyasharma@gmail.com>
Date: Tue, 22 Oct 2024 23:49:07 +0530
Subject: [PATCH 02/16] Added type hints and minor case improvements

---
 machine_learning/ridge_regression.py | 51 ++++++++++++++++++----------
 1 file changed, 34 insertions(+), 17 deletions(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index d4d3162e50ed..65fb82318e09 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -3,7 +3,7 @@
 
 
 class RidgeRegression:
-    def __init__(self, alpha=0.001, lambda_=0.1, iterations=1000):
+    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
@@ -15,24 +15,38 @@ def __init__(self, alpha=0.001, lambda_=0.1, iterations=1000):
         self.iterations = iterations
         self.theta = None
 
-    def feature_scaling(self, X):
+    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 X: Input features, shape (m, n)
-        :return: Scaled features, mean, and std for each feature
+        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(X, axis=0)
-        std = np.std(X, axis=0)
+        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
 
-        X_scaled = (X - mean) / std
-        return X_scaled, mean, std
+        scaled_features = (features - mean) / std
+        return scaled_features, mean, std
 
-    def fit(self, X, y):
+    def fit(self, X: np.ndarray, y: np.ndarray) -> None:
         """
-        Fit the Ridge Regression model to the training data
+        Fit the Ridge Regression model to the training data.
+
         :param X: Input features, shape (m, n)
         :param y: Target values, shape (m,)
         """
@@ -48,18 +62,20 @@ def fit(self, X, y):
             gradient = (X_scaled.T.dot(error) + self.lambda_ * self.theta) / m
             self.theta -= self.alpha * gradient  # Update weights
 
-    def predict(self, X):
+    def predict(self, X: np.ndarray) -> np.ndarray:
         """
-        Predict values using the trained model
+        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, y):
+    def compute_cost(self, X: np.ndarray, y: np.ndarray) -> float:
         """
-        Compute the cost function with regularization
+        Compute the cost function with regularization.
+
         :param X: Input features, shape (m, n)
         :param y: Target values, shape (m,)
         :return: Computed cost
@@ -72,9 +88,10 @@ def compute_cost(self, X, y):
         ) * np.sum(self.theta**2)
         return cost
 
-    def mean_absolute_error(self, y_true, y_pred):
+    def mean_absolute_error(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:
         """
-        Compute Mean Absolute Error (MAE) between true and predicted values
+        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

From 861618ef11210d6dd4bdcba8671a20214b86801d Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 22 Oct 2024 18:19:50 +0000
Subject: [PATCH 03/16] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 machine_learning/ridge_regression.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index 65fb82318e09..1d7e0c694c4f 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -3,7 +3,9 @@
 
 
 class RidgeRegression:
-    def __init__(self, alpha: float = 0.001, lambda_: float = 0.1, iterations: int = 1000) -> None:
+    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
@@ -15,7 +17,9 @@ def __init__(self, alpha: float = 0.001, lambda_: float = 0.1, iterations: int =
         self.iterations = iterations
         self.theta = None
 
-    def feature_scaling(self, features: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def feature_scaling(
+        self, features: np.ndarray
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Normalize features to have mean 0 and standard deviation 1.
 

From 2dc60f475b7147b4fb54f2e534ac492f96a359f3 Mon Sep 17 00:00:00 2001
From: Harmanaya Sharma <harmanyasharma@gmail.com>
Date: Tue, 22 Oct 2024 23:58:50 +0530
Subject: [PATCH 04/16] Resolved ruff checks

---
 machine_learning/ridge_regression.py | 44 ++++++++++++++--------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index 1d7e0c694c4f..cc60d2218c14 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -47,46 +47,46 @@ def feature_scaling(
         scaled_features = (features - mean) / std
         return scaled_features, mean, std
 
-    def fit(self, X: np.ndarray, y: np.ndarray) -> None:
+    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 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
+        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 i in range(self.iterations):
-            predictions = X_scaled.dot(self.theta)
+        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
+            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:
+    def predict(self, x: np.ndarray) -> np.ndarray:
         """
         Predict values using the trained model.
 
-        :param X: Input features, shape (m, n)
+        :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)
+        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:
+    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 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
+        x_scaled, _, _ = self.feature_scaling(x)  # Scale features using training data
         m = len(y)
-        predictions = X_scaled.dot(self.theta)
+        predictions = x_scaled.dot(self.theta)
         cost = (1 / (2 * m)) * np.sum((predictions - y) ** 2) + (
             self.lambda_ / (2 * m)
         ) * np.sum(self.theta**2)
@@ -106,24 +106,24 @@ def mean_absolute_error(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:
 # Example usage
 if __name__ == "__main__":
     # Load dataset
-    df = pd.read_csv(
+    data = pd.read_csv(
         "https://raw.githubusercontent.com/yashLadha/The_Math_of_Intelligence/master/Week1/ADRvsRating.csv"
     )
-    X = df[["Rating"]].values  # Feature: Rating
-    y = df["ADR"].values  # Target: ADR
+    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
+    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)
+    model.fit(x, y)
 
     # Predictions
-    predictions = model.predict(X)
+    predictions = model.predict(x)
 
     # Results
     print("Optimized Weights:", model.theta)
-    print("Cost:", model.compute_cost(X, y))
+    print("Cost:", model.compute_cost(x, y))
     print("Mean Absolute Error:", model.mean_absolute_error(y, predictions))

From 61945d03c674ebca5f98ccb9c16fb384620f2b47 Mon Sep 17 00:00:00 2001
From: Harmanaya Sharma <harmanyasharma@gmail.com>
Date: Wed, 23 Oct 2024 00:08:52 +0530
Subject: [PATCH 05/16] Added doctests

---
 machine_learning/ridge_regression.py | 76 ++++++++++++++++++++--------
 1 file changed, 55 insertions(+), 21 deletions(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index cc60d2218c14..02a48f360b2c 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -47,47 +47,73 @@ def feature_scaling(
         scaled_features = (features - mean) / std
         return scaled_features, mean, std
 
-    def fit(self, x: np.ndarray, y: np.ndarray) -> None:
+    def fit(self, features: np.ndarray, target: 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,)
+        :param features: Input features, shape (m, n)
+        :param target: Target values, shape (m,)
+
+        Example:
+        >>> rr = RidgeRegression(alpha=0.01, lambda_=0.1, iterations=10)
+        >>> features = np.array([[1, 2], [2, 3], [4, 6]])
+        >>> target = np.array([1, 2, 3])
+        >>> rr.fit(features, target)
+        >>> rr.theta is not None
+        True
         """
-        x_scaled, mean, std = self.feature_scaling(x)  # Normalize features
-        m, n = x_scaled.shape
+        features_scaled, mean, std = self.feature_scaling(features)  # Normalize features
+        m, n = features_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
+        for i in range(self.iterations):
+            predictions = features_scaled.dot(self.theta)
+            error = predictions - target
 
             # Compute gradient with L2 regularization
-            gradient = (x_scaled.T.dot(error) + self.lambda_ * self.theta) / m
+            gradient = (features_scaled.T.dot(error) + self.lambda_ * self.theta) / m
             self.theta -= self.alpha * gradient  # Update weights
 
-    def predict(self, x: np.ndarray) -> np.ndarray:
+    def predict(self, features: np.ndarray) -> np.ndarray:
         """
         Predict values using the trained model.
 
-        :param x: Input features, shape (m, n)
+        :param features: 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:
+        Example:
+        >>> rr = RidgeRegression(alpha=0.01, lambda_=0.1, iterations=10)
+        >>> features = np.array([[1, 2], [2, 3], [4, 6]])
+        >>> target = np.array([1, 2, 3])
+        >>> rr.fit(features, target)
+        >>> predictions = rr.predict(features)
+        >>> predictions.shape == target.shape
+        True
+        """
+        features_scaled, _, _ = self.feature_scaling(features)  # Scale features using training data
+        return features_scaled.dot(self.theta)
+    
+    def compute_cost(self, features: np.ndarray, target: np.ndarray) -> float:
         """
         Compute the cost function with regularization.
 
-        :param x: Input features, shape (m, n)
-        :param y: Target values, shape (m,)
+        :param features: Input features, shape (m, n)
+        :param target: Target values, shape (m,)
         :return: Computed cost
+
+        Example:
+        >>> rr = RidgeRegression(alpha=0.01, lambda_=0.1, iterations=10)
+        >>> features = np.array([[1, 2], [2, 3], [4, 6]])
+        >>> target = np.array([1, 2, 3])
+        >>> rr.fit(features, target)
+        >>> cost = rr.compute_cost(features, target)
+        >>> isinstance(cost, float)
+        True
         """
-        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) + (
+        features_scaled, _, _ = self.feature_scaling(features)  # Scale features using training data
+        m = len(target)
+        predictions = features_scaled.dot(self.theta)
+        cost = (1 / (2 * m)) * np.sum((predictions - target) ** 2) + (
             self.lambda_ / (2 * m)
         ) * np.sum(self.theta**2)
         return cost
@@ -99,6 +125,14 @@ def mean_absolute_error(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:
         :param y_true: Actual target values, shape (m,)
         :param y_pred: Predicted target values, shape (m,)
         :return: MAE
+
+        Example:
+        >>> rr = RidgeRegression(alpha=0.01, lambda_=0.1, iterations=10)
+        >>> y_true = np.array([1, 2, 3])
+        >>> y_pred = np.array([1.1, 2.1, 2.9])
+        >>> mae = rr.mean_absolute_error(y_true, y_pred)
+        >>> isinstance(mae, float)
+        True
         """
         return np.mean(np.abs(y_true - y_pred))
 

From a2d07af8c1f005a60c31ff002c05a48d81d13ddf Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 22 Oct 2024 18:39:20 +0000
Subject: [PATCH 06/16] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 machine_learning/ridge_regression.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index 02a48f360b2c..0cd32caeb19b 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -62,7 +62,9 @@ def fit(self, features: np.ndarray, target: np.ndarray) -> None:
         >>> rr.theta is not None
         True
         """
-        features_scaled, mean, std = self.feature_scaling(features)  # Normalize features
+        features_scaled, mean, std = self.feature_scaling(
+            features
+        )  # Normalize features
         m, n = features_scaled.shape
         self.theta = np.zeros(n)  # Initialize weights to zeros
 
@@ -90,9 +92,11 @@ def predict(self, features: np.ndarray) -> np.ndarray:
         >>> predictions.shape == target.shape
         True
         """
-        features_scaled, _, _ = self.feature_scaling(features)  # Scale features using training data
+        features_scaled, _, _ = self.feature_scaling(
+            features
+        )  # Scale features using training data
         return features_scaled.dot(self.theta)
-    
+
     def compute_cost(self, features: np.ndarray, target: np.ndarray) -> float:
         """
         Compute the cost function with regularization.
@@ -110,7 +114,9 @@ def compute_cost(self, features: np.ndarray, target: np.ndarray) -> float:
         >>> isinstance(cost, float)
         True
         """
-        features_scaled, _, _ = self.feature_scaling(features)  # Scale features using training data
+        features_scaled, _, _ = self.feature_scaling(
+            features
+        )  # Scale features using training data
         m = len(target)
         predictions = features_scaled.dot(self.theta)
         cost = (1 / (2 * m)) * np.sum((predictions - target) ** 2) + (

From 8f1f091aa4db5a1ca8f8e2dfd0a7f6caf5d56b11 Mon Sep 17 00:00:00 2001
From: Harmanaya Sharma <harmanyasharma@gmail.com>
Date: Wed, 23 Oct 2024 00:14:37 +0530
Subject: [PATCH 07/16] Resolved ruff checks

---
 machine_learning/ridge_regression.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index 0cd32caeb19b..1206d41b52d0 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -68,7 +68,7 @@ def fit(self, features: np.ndarray, target: np.ndarray) -> None:
         m, n = features_scaled.shape
         self.theta = np.zeros(n)  # Initialize weights to zeros
 
-        for i in range(self.iterations):
+        for _ in range(self.iterations):
             predictions = features_scaled.dot(self.theta)
             error = predictions - target
 
@@ -149,21 +149,21 @@ def mean_absolute_error(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:
     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)
+    data_x = data[["Rating"]].to_numpy()  # Feature: Rating
+    data_y = data["ADR"].to_numpy()  # Target: ADR
+    data_y = (data_y - np.mean(data_y)) / np.std(data_y)
 
     # Add bias term (intercept) to the feature matrix
-    x = np.c_[np.ones(X.shape[0]), x]  # Add intercept term
+    data_x = np.c_[np.ones(data_x.shape[0]), data_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)
+    model.fit(data_x, data_y)
 
     # Predictions
-    predictions = model.predict(x)
+    predictions = model.predict(data_x)
 
     # Results
     print("Optimized Weights:", model.theta)
-    print("Cost:", model.compute_cost(x, y))
-    print("Mean Absolute Error:", model.mean_absolute_error(y, predictions))
+    print("Cost:", model.compute_cost(data_x, data_y))
+    print("Mean Absolute Error:", model.mean_absolute_error(data_y, predictions))

From 5bf9b854b466525fe0f1aae60422c903715ef61d Mon Sep 17 00:00:00 2001
From: Harmanaya Sharma <harmanyasharma@gmail.com>
Date: Wed, 23 Oct 2024 00:20:29 +0530
Subject: [PATCH 08/16] Resolved mypy checks

---
 machine_learning/ridge_regression.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index 1206d41b52d0..ad34600b389e 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -1,5 +1,6 @@
 import numpy as np
 import pandas as pd
+from typing import Optional, Tuple
 
 
 class RidgeRegression:
@@ -15,7 +16,7 @@ def __init__(
         self.alpha = alpha
         self.lambda_ = lambda_
         self.iterations = iterations
-        self.theta = None
+        self.theta: Optional[np.ndarray] = None  # Initialize as None, later will be ndarray
 
     def feature_scaling(
         self, features: np.ndarray
@@ -92,6 +93,9 @@ def predict(self, features: np.ndarray) -> np.ndarray:
         >>> predictions.shape == target.shape
         True
         """
+        if self.theta is None:
+            raise ValueError("Model is not trained yet. Call the `fit` method first.")
+        
         features_scaled, _, _ = self.feature_scaling(
             features
         )  # Scale features using training data
@@ -114,6 +118,9 @@ def compute_cost(self, features: np.ndarray, target: np.ndarray) -> float:
         >>> isinstance(cost, float)
         True
         """
+        if self.theta is None:
+            raise ValueError("Model is not trained yet. Call the `fit` method first.")
+        
         features_scaled, _, _ = self.feature_scaling(
             features
         )  # Scale features using training data

From 85020a76c28127b7aa4f0e923a0f3dcd284df915 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 22 Oct 2024 18:51:19 +0000
Subject: [PATCH 09/16] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 machine_learning/ridge_regression.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index ad34600b389e..20324e9877c2 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -16,7 +16,9 @@ def __init__(
         self.alpha = alpha
         self.lambda_ = lambda_
         self.iterations = iterations
-        self.theta: Optional[np.ndarray] = None  # Initialize as None, later will be ndarray
+        self.theta: Optional[np.ndarray] = (
+            None  # Initialize as None, later will be ndarray
+        )
 
     def feature_scaling(
         self, features: np.ndarray
@@ -95,7 +97,7 @@ def predict(self, features: np.ndarray) -> np.ndarray:
         """
         if self.theta is None:
             raise ValueError("Model is not trained yet. Call the `fit` method first.")
-        
+
         features_scaled, _, _ = self.feature_scaling(
             features
         )  # Scale features using training data
@@ -120,7 +122,7 @@ def compute_cost(self, features: np.ndarray, target: np.ndarray) -> float:
         """
         if self.theta is None:
             raise ValueError("Model is not trained yet. Call the `fit` method first.")
-        
+
         features_scaled, _, _ = self.feature_scaling(
             features
         )  # Scale features using training data

From 52345d90138fb5f598d30db43bab0d2080268b98 Mon Sep 17 00:00:00 2001
From: Harmanaya Sharma <harmanyasharma@gmail.com>
Date: Wed, 23 Oct 2024 00:28:46 +0530
Subject: [PATCH 10/16] Resolved ruff checks

---
 machine_learning/ridge_regression.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index 20324e9877c2..32c76a90c2f2 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -1,7 +1,5 @@
 import numpy as np
 import pandas as pd
-from typing import Optional, Tuple
-
 
 class RidgeRegression:
     def __init__(
@@ -16,9 +14,7 @@ def __init__(
         self.alpha = alpha
         self.lambda_ = lambda_
         self.iterations = iterations
-        self.theta: Optional[np.ndarray] = (
-            None  # Initialize as None, later will be ndarray
-        )
+        self.theta: np.ndarray | None = None  # Initialize as None, later will be ndarray
 
     def feature_scaling(
         self, features: np.ndarray

From 4204bf6d280bf45b476cebe56726a8b0f2b76fa1 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 22 Oct 2024 18:59:33 +0000
Subject: [PATCH 11/16] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 machine_learning/ridge_regression.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index 32c76a90c2f2..3976cf8a70bb 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -1,6 +1,7 @@
 import numpy as np
 import pandas as pd
 
+
 class RidgeRegression:
     def __init__(
         self, alpha: float = 0.001, lambda_: float = 0.1, iterations: int = 1000
@@ -14,7 +15,9 @@ def __init__(
         self.alpha = alpha
         self.lambda_ = lambda_
         self.iterations = iterations
-        self.theta: np.ndarray | None = None  # Initialize as None, later will be ndarray
+        self.theta: np.ndarray | None = (
+            None  # Initialize as None, later will be ndarray
+        )
 
     def feature_scaling(
         self, features: np.ndarray

From aadb03658832d15062c789c47e96802be93bf3b4 Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@users.noreply.github.com>
Date: Mon, 14 Sep 2026 05:10:19 +0000
Subject: [PATCH 12/16] updating DIRECTORY.md

---
 DIRECTORY.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 311a7c7c9de8..2655cb60e3b7 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -712,14 +712,18 @@
   * [Loss Functions](machine_learning/loss_functions.py)
   * Lstm
     * [Lstm Prediction](machine_learning/lstm/lstm_prediction.py)
+  * [Mean Shift](machine_learning/mean_shift.py)
   * [Mfcc](machine_learning/mfcc.py)
   * [Mini Batch Gradient Descent](machine_learning/mini_batch_gradient_descent.py)
   * [Multilayer Perceptron Classifier](machine_learning/multilayer_perceptron_classifier.py)
+  * [Naive Bayes Text Classification](machine_learning/naive_bayes_text_classification.py)
   * [Polynomial Regression](machine_learning/polynomial_regression.py)
   * [Principle Component Analysis](machine_learning/principle_component_analysis.py)
   * [Q Learning](machine_learning/q_learning.py)
   * [Random Forest Classifier](machine_learning/random_forest_classifier.py)
   * [Random Forest Regressor](machine_learning/random_forest_regressor.py)
+  * [Ridge Regression](machine_learning/ridge_regression.py)
+  * [Rmsprop](machine_learning/rmsprop.py)
   * [Scoring Functions](machine_learning/scoring_functions.py)
   * [Self Organizing Map](machine_learning/self_organizing_map.py)
   * [Sequential Minimum Optimization](machine_learning/sequential_minimum_optimization.py)
@@ -736,6 +740,7 @@
   * [Arc Length](maths/arc_length.py)
   * [Area](maths/area.py)
   * [Area Under Curve](maths/area_under_curve.py)
+  * [Autocorrelation](maths/autocorrelation.py)
   * [Average Absolute Deviation](maths/average_absolute_deviation.py)
   * [Average Mean](maths/average_mean.py)
   * [Average Median](maths/average_median.py)
@@ -781,6 +786,7 @@
   * [Fibonacci](maths/fibonacci.py)
   * [Find Max](maths/find_max.py)
   * [Find Min](maths/find_min.py)
+  * [First Fundamental Form](maths/first_fundamental_form.py)
   * [Floor](maths/floor.py)
   * [Gamma](maths/gamma.py)
   * [Gaussian](maths/gaussian.py)
@@ -843,6 +849,7 @@
     * [Square Root](maths/numerical_analysis/square_root.py)
     * [Weierstrass Method](maths/numerical_analysis/weierstrass_method.py)
   * [Odd Sieve](maths/odd_sieve.py)
+  * [Padovan Sequence](maths/padovan_sequence.py)
   * [Pell Number](maths/pell_number.py)
   * [Perfect Cube](maths/perfect_cube.py)
   * [Perfect Number](maths/perfect_number.py)
@@ -872,6 +879,8 @@
   * [Reverse Factorial Recursive](maths/reverse_factorial_recursive.py)
   * [Segmented Sieve](maths/segmented_sieve.py)
   * Series
+    * [Alternate Harmonic Series](maths/series/alternate_harmonic_series.py)
+    * [Alternating Harmonic Series](maths/series/alternating_harmonic_series.py)
     * [Arithmetic](maths/series/arithmetic.py)
     * [Geometric](maths/series/geometric.py)
     * [Geometric Series](maths/series/geometric_series.py)
@@ -911,6 +920,7 @@
     * [Polygonal Numbers](maths/special_numbers/polygonal_numbers.py)
     * [Pronic Number](maths/special_numbers/pronic_number.py)
     * [Proth Number](maths/special_numbers/proth_number.py)
+    * [Spy Number](maths/special_numbers/spy_number.py)
     * [Triangular Numbers](maths/special_numbers/triangular_numbers.py)
     * [Trimorphic Number](maths/special_numbers/trimorphic_number.py)
     * [Ugly Numbers](maths/special_numbers/ugly_numbers.py)

From 1db256e32222f55a0713864ce1d275b66c5f6379 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 15 Sep 2026 18:03:19 +0200
Subject: [PATCH 13/16] Comments should not force line wrapping

---
 machine_learning/ridge_regression.py | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index 3976cf8a70bb..91ae2a345a4b 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -15,9 +15,7 @@ def __init__(
         self.alpha = alpha
         self.lambda_ = lambda_
         self.iterations = iterations
-        self.theta: np.ndarray | None = (
-            None  # Initialize as None, later will be ndarray
-        )
+        self.theta: np.ndarray | None = None
 
     def feature_scaling(
         self, features: np.ndarray
@@ -64,9 +62,8 @@ def fit(self, features: np.ndarray, target: np.ndarray) -> None:
         >>> rr.theta is not None
         True
         """
-        features_scaled, mean, std = self.feature_scaling(
-            features
-        )  # Normalize features
+        # Normalize features
+        features_scaled, _mean, _std = self.feature_scaling(features)
         m, n = features_scaled.shape
         self.theta = np.zeros(n)  # Initialize weights to zeros
 
@@ -97,9 +94,8 @@ def predict(self, features: np.ndarray) -> np.ndarray:
         if self.theta is None:
             raise ValueError("Model is not trained yet. Call the `fit` method first.")
 
-        features_scaled, _, _ = self.feature_scaling(
-            features
-        )  # Scale features using training data
+        # Scale features using training data
+        features_scaled, _mean, _std= self.feature_scaling(features)  
         return features_scaled.dot(self.theta)
 
     def compute_cost(self, features: np.ndarray, target: np.ndarray) -> float:

From f123b6aeb28474ee2bde74ab557aa144deb7efdf Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@users.noreply.github.com>
Date: Tue, 15 Sep 2026 16:05:00 +0000
Subject: [PATCH 14/16] updating DIRECTORY.md

---
 DIRECTORY.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 48cc865cc705..06406719dc43 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -62,6 +62,7 @@
   * [Generate Parentheses Iterative](backtracking/generate_parentheses_iterative.py)
   * [Hamiltonian Cycle](backtracking/hamiltonian_cycle.py)
   * [Knight Tour](backtracking/knight_tour.py)
+  * [M Coloring Problem](backtracking/m_coloring_problem.py)
   * [Match Word Pattern](backtracking/match_word_pattern.py)
   * [Minimax](backtracking/minimax.py)
   * [N Queens](backtracking/n_queens.py)
@@ -108,6 +109,9 @@
 
 ## [Blockchain](blockchain)
   * [Diophantine Equation](blockchain/diophantine_equation.py)
+  * [Merkle Tree](blockchain/merkle_tree.py)
+  * [Simple Blockchain](blockchain/simple_blockchain.py)
+  * [Simple Proof Of Work](blockchain/simple_proof_of_work.py)
 
 ## [Boolean Algebra](boolean_algebra)
   * [And Gate](boolean_algebra/and_gate.py)
@@ -166,6 +170,7 @@
   * [Porta Cipher](ciphers/porta_cipher.py)
   * [Rabin Miller](ciphers/rabin_miller.py)
   * [Rail Fence Cipher](ciphers/rail_fence_cipher.py)
+  * [Rc4](ciphers/rc4.py)
   * [Rot13](ciphers/rot13.py)
   * [Rsa Cipher](ciphers/rsa_cipher.py)
   * [Rsa Factorization](ciphers/rsa_factorization.py)
@@ -180,6 +185,7 @@
   * [Vernam Cipher](ciphers/vernam_cipher.py)
   * [Vigenere Cipher](ciphers/vigenere_cipher.py)
   * [Xor Cipher](ciphers/xor_cipher.py)
+  * [Xtea](ciphers/xtea.py)
 
 ## [Computer Vision](computer_vision)
   * [Cnn Classification](computer_vision/cnn_classification.py)
@@ -198,6 +204,9 @@
 ## [Conversions](conversions)
   * [Astronomical Length Scale Conversion](conversions/astronomical_length_scale_conversion.py)
   * [Binary To Decimal](conversions/binary_to_decimal.py)
+  * [Binary To Excess3](conversions/binary_to_excess3.py)
+  * [Binary To Gray](conversions/binary_to_gray.py)
+  * [Binary To Gray Code](conversions/binary_to_gray_code.py)
   * [Binary To Hexadecimal](conversions/binary_to_hexadecimal.py)
   * [Binary To Octal](conversions/binary_to_octal.py)
   * [Convert Number To Words](conversions/convert_number_to_words.py)
@@ -205,6 +214,7 @@
   * [Decimal To Binary](conversions/decimal_to_binary.py)
   * [Decimal To Hexadecimal](conversions/decimal_to_hexadecimal.py)
   * [Decimal To Octal](conversions/decimal_to_octal.py)
+  * [Endianness](conversions/endianness.py)
   * [Energy Conversions](conversions/energy_conversions.py)
   * [Excel Title To Column](conversions/excel_title_to_column.py)
   * [Hex To Bin](conversions/hex_to_bin.py)
@@ -540,6 +550,7 @@
 ## [Geodesy](geodesy)
   * [Haversine Distance](geodesy/haversine_distance.py)
   * [Lamberts Ellipsoidal Distance](geodesy/lamberts_ellipsoidal_distance.py)
+  * [Radar Target Calculation](geodesy/radar_target_calculation.py)
 
 ## [Geometry](geometry)
   * [Geometry](geometry/geometry.py)
@@ -689,6 +700,7 @@
   * [Astar](machine_learning/astar.py)
   * [Automatic Differentiation](machine_learning/automatic_differentiation.py)
   * [Data Transformations](machine_learning/data_transformations.py)
+  * [Dbscan](machine_learning/dbscan.py)
   * [Decision Tree](machine_learning/decision_tree.py)
   * [Dimensionality Reduction](machine_learning/dimensionality_reduction.py)
   * [Federated Averaging](machine_learning/federated_averaging.py)

From 7db4bf84fd035362aa4a2e3237c153053a3c9b50 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 15 Sep 2026 18:19:15 +0200
Subject: [PATCH 15/16] Fix feature scaling variable assignment in predictions

---
 machine_learning/ridge_regression.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index 91ae2a345a4b..1994fa72ed24 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -95,7 +95,7 @@ def predict(self, features: np.ndarray) -> np.ndarray:
             raise ValueError("Model is not trained yet. Call the `fit` method first.")
 
         # Scale features using training data
-        features_scaled, _mean, _std= self.feature_scaling(features)  
+        features_scaled, _mean, _std= self.feature_scaling(features)
         return features_scaled.dot(self.theta)
 
     def compute_cost(self, features: np.ndarray, target: np.ndarray) -> float:
@@ -118,9 +118,8 @@ def compute_cost(self, features: np.ndarray, target: np.ndarray) -> float:
         if self.theta is None:
             raise ValueError("Model is not trained yet. Call the `fit` method first.")
 
-        features_scaled, _, _ = self.feature_scaling(
-            features
-        )  # Scale features using training data
+        # Scale features using training data
+        features_scaled, _mean, _std = self.feature_scaling(features)
         m = len(target)
         predictions = features_scaled.dot(self.theta)
         cost = (1 / (2 * m)) * np.sum((predictions - target) ** 2) + (

From 50eb8a077232d0609b05ea58bedfac77923d3b44 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 15 Sep 2026 16:19:30 +0000
Subject: [PATCH 16/16] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 machine_learning/ridge_regression.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/machine_learning/ridge_regression.py b/machine_learning/ridge_regression.py
index 1994fa72ed24..2fe2e995f6a4 100644
--- a/machine_learning/ridge_regression.py
+++ b/machine_learning/ridge_regression.py
@@ -95,7 +95,7 @@ def predict(self, features: np.ndarray) -> np.ndarray:
             raise ValueError("Model is not trained yet. Call the `fit` method first.")
 
         # Scale features using training data
-        features_scaled, _mean, _std= self.feature_scaling(features)
+        features_scaled, _mean, _std = self.feature_scaling(features)
         return features_scaled.dot(self.theta)
 
     def compute_cost(self, features: np.ndarray, target: np.ndarray) -> float: