Rename vars for clarity

Author: tianyizheng02

machine_learning/local_weighted_learning/local_weighted_learning.py

@@ -2,13 +2,11 @@
 import numpy as np
 
 
-def weighted_matrix(
-    point: np.ndarray, training_data_x: np.ndarray, bandwidth: float
-) -> np.ndarray:
+def weight_matrix(point: np.ndarray, x_train: np.ndarray, tau: float) -> np.ndarray:
     """
     Calculate the weight for every point in the data set.
     point --> the x value at which we want to make predictions
-    >>> weighted_matrix(
+    >>> weight_matrix(
     ...     np.array([1., 1.]),
     ...     np.array([[16.99, 10.34], [21.01,23.68], [24.59,25.69]]),
     ...     0.6
@@ -17,21 +15,18 @@ def weighted_matrix(
            [0.00000000e+000, 0.00000000e+000, 0.00000000e+000],
            [0.00000000e+000, 0.00000000e+000, 0.00000000e+000]])
     """
-    m, _ = np.shape(training_data_x)  # m is the number of training samples
+    m, _ = np.shape(x_train)  # m is the number of training samples
     weights = np.eye(m)  # Initializing weights as identity matrix
 
     # calculating weights for all training examples [x(i)'s]
     for j in range(m):
-        diff = point - training_data_x[j]
-        weights[j, j] = np.exp(diff @ diff.T / (-2.0 * bandwidth**2))
+        diff = point - x_train[j]
+        weights[j, j] = np.exp(diff @ diff.T / (-2.0 * tau**2))
     return weights
 
 
 def local_weight(
-    point: np.ndarray,
-    training_data_x: np.ndarray,
-    training_data_y: np.ndarray,
-    bandwidth: float,
+    point: np.ndarray, x_train: np.ndarray, y_train: np.ndarray, tau: float
 ) -> np.ndarray:
     """
     Calculate the local weights using the weight_matrix function on training data.
@@ -45,16 +40,16 @@ def local_weight(
     array([[0.00873174],
            [0.08272556]])
     """
-    weight = weighted_matrix(point, training_data_x, bandwidth)
-    w = np.linalg.inv(training_data_x.T @ (weight @ training_data_x)) @ (
-        training_data_x.T @ weight @ training_data_y.T
+    weight_mat = weight_matrix(point, x_train, tau)
+    weight = np.linalg.inv(x_train.T @ weight_mat @ x_train) @ (
+        x_train.T @ weight_mat @ y_train.T
     )
 
-    return w
+    return weight
 
 
 def local_weight_regression(
-    training_data_x: np.ndarray, training_data_y: np.ndarray, bandwidth: float
+    x_train: np.ndarray, y_train: np.ndarray, tau: float
 ) -> np.ndarray:
     """
     Calculate predictions for each data point on axis
@@ -65,43 +60,39 @@ def local_weight_regression(
     ... )
     array([1.07173261, 1.65970737, 3.50160179])
     """
-    m, _ = np.shape(training_data_x)
-    ypred = np.zeros(m)
+    m, _ = np.shape(x_train)
+    y_pred = np.zeros(m)
 
-    for i, item in enumerate(training_data_x):
-        ypred[i] = item @ local_weight(
-            item, training_data_x, training_data_y, bandwidth
-        )
+    for i, item in enumerate(x_train):
+        y_pred[i] = item @ local_weight(item, x_train, y_train, tau)
 
-    return ypred
+    return y_pred
 
 
 def load_data(
-    dataset_name: str, cola_name: str, colb_name: str
+    dataset_name: str, x_name: str, y_name: str
 ) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
     """
     Load data from seaborn and split it into x and y points
     """
     import seaborn as sns
 
     data = sns.load_dataset(dataset_name)
-    col_a = np.array(data[cola_name])  # total_bill
-    col_b = np.array(data[colb_name])  # tip
+    x_data = np.array(data[x_name])  # total_bill
+    y_data = np.array(data[y_name])  # tip
 
-    mcol_a = col_a.copy()
-    mcol_b = col_b.copy()
+    mcol_a = x_data.copy()
+    mcol_b = y_data.copy()
 
     one = np.ones(np.shape(mcol_b)[0], dtype=int)
 
     # pairing elements of one and mcol_a
-    training_data_x = np.column_stack((one, mcol_a))
+    x_train = np.column_stack((one, mcol_a))
 
-    return training_data_x, mcol_b, col_a, col_b
+    return x_train, mcol_b, x_data, y_data
 
 
-def get_preds(
-    training_data_x: np.ndarray, mcol_b: np.ndarray, tau: float
-) -> np.ndarray:
+def get_preds(x_train: np.ndarray, y_train: np.ndarray, tau: float) -> np.ndarray:
     """
     Get predictions with minimum error for each training data
     >>> get_preds(
@@ -111,33 +102,32 @@ def get_preds(
     ... )
     array([1.07173261, 1.65970737, 3.50160179])
     """
-    ypred = local_weight_regression(training_data_x, mcol_b, tau)
-    return ypred
+    y_pred = local_weight_regression(x_train, y_train, tau)
+    return y_pred
 
 
 def plot_preds(
-    training_data_x: np.ndarray,
+    x_train: np.ndarray,
     predictions: np.ndarray,
-    col_x: np.ndarray,
-    col_y: np.ndarray,
-    cola_name: str,
-    colb_name: str,
+    x_data: np.ndarray,
+    y_data: np.ndarray,
+    x_name: str,
+    y_name: str,
 ) -> plt.plot:
     """
     Plot predictions and display the graph
     """
-    xsort = training_data_x.copy()
-    xsort.sort(axis=0)
-    plt.scatter(col_x, col_y, color="blue")
+    x_train_sorted = np.sort(x_train, axis=0)
+    plt.scatter(x_data, y_data, color="blue")
     plt.plot(
-        xsort[:, 1],
-        predictions[training_data_x[:, 1].argsort(0)],
+        x_train_sorted[:, 1],
+        predictions[x_train[:, 1].argsort(0)],
         color="yellow",
         linewidth=5,
     )
     plt.title("Local Weighted Regression")
-    plt.xlabel(cola_name)
-    plt.ylabel(colb_name)
+    plt.xlabel(x_name)
+    plt.ylabel(y_name)
     plt.show()
 
 
@@ -146,6 +136,6 @@ def plot_preds(
 
     doctest.testmod()
 
-    training_data_x, mcol_b, col_a, col_b = load_data("tips", "total_bill", "tip")
+    training_data_x, mcol_b, total_bill, tip = load_data("tips", "total_bill", "tip")
     predictions = get_preds(training_data_x, mcol_b, 0.5)
-    plot_preds(training_data_x, predictions, col_a, col_b, "total_bill", "tip")
+    plot_preds(training_data_x, predictions, total_bill, tip, "total_bill", "tip")