Refactor local_weighted_learning.py to use np.array (TheAlgorithm…

…s#8069) * updating DIRECTORY.md * Format local_weighted_learning.py doctests for clarity * Refactor local_weighted_learning.py to use np.array instead of np.mat The np.matrix class is planned to be eventually depreciated in favor of np.array, and current use of the class raises warnings in pytest * Update local_weighted_learning.py documentation Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>

DIRECTORY.md

@@ -123,6 +123,7 @@
  * [Huffman](compression/huffman.py)
  * [Lempel Ziv](compression/lempel_ziv.py)
  * [Lempel Ziv Decompress](compression/lempel_ziv_decompress.py)
+ * [Lz77](compression/lz77.py)
  * [Peak Signal To Noise Ratio](compression/peak_signal_to_noise_ratio.py)
  * [Run Length Encoding](compression/run_length_encoding.py)
 
@@ -1162,7 +1163,7 @@
  * [Get Amazon Product Data](web_programming/get_amazon_product_data.py)
  * [Get Imdb Top 250 Movies Csv](web_programming/get_imdb_top_250_movies_csv.py)
  * [Get Imdbtop](web_programming/get_imdbtop.py)
- * [Get Top Billioners](web_programming/get_top_billioners.py)
+ * [Get Top Billionaires](web_programming/get_top_billionaires.py)
  * [Get Top Hn Posts](web_programming/get_top_hn_posts.py)
  * [Get User Tweets](web_programming/get_user_tweets.py)
  * [Giphy](web_programming/giphy.py)

machine_learning/local_weighted_learning/local_weighted_learning.py

@@ -1,116 +1,128 @@
-# Required imports to run this file
 import matplotlib.pyplot as plt
 import numpy as np
 
 
-# weighted matrix
-def weighted_matrix(point: np.mat, training_data_x: np.mat, bandwidth: float) -> np.mat:
+def weighted_matrix(
+ point: np.array, training_data_x: np.array, bandwidth: float
+) -> np.array:
  """
- Calculate the weight for every point in the
- data set. It takes training_point , query_point, and tau
- Here Tau is not a fixed value it can be varied depends on output.
- tau --> bandwidth
- xmat -->Training data
- point --> the x where we want to make predictions
- >>> weighted_matrix(np.array([1., 1.]),np.mat([[16.99, 10.34], [21.01,23.68],
- ... [24.59,25.69]]), 0.6)
- matrix([[1.43807972e-207, 0.00000000e+000, 0.00000000e+000],
- [0.00000000e+000, 0.00000000e+000, 0.00000000e+000],
- [0.00000000e+000, 0.00000000e+000, 0.00000000e+000]])
+ Calculate the weight for every point in the data set.
+ point --> the x value at which we want to make predictions
+ >>> weighted_matrix(
+ ... np.array([1., 1.]),
+ ... np.array([[16.99, 10.34], [21.01,23.68], [24.59,25.69]]),
+ ... 0.6
+ ... )
+ array([[1.43807972e-207, 0.00000000e+000, 0.00000000e+000],
+ [0.00000000e+000, 0.00000000e+000, 0.00000000e+000],
+ [0.00000000e+000, 0.00000000e+000, 0.00000000e+000]])
  """
- # m is the number of training samples
- m, n = np.shape(training_data_x)
- # Initializing weights as identity matrix
- weights = np.mat(np.eye(m))
+ m, _ = np.shape(training_data_x) # 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))
+ weights[j, j] = np.exp(diff @ diff.T / (-2.0 * bandwidth**2))
  return weights
 
 
 def local_weight(
- point: np.mat, training_data_x: np.mat, training_data_y: np.mat, bandwidth: float
-) -> np.mat:
+ point: np.array,
+ training_data_x: np.array,
+ training_data_y: np.array,
+ bandwidth: float,
+) -> np.array:
  """
  Calculate the local weights using the weight_matrix function on training data.
  Return the weighted matrix.
- >>> local_weight(np.array([1., 1.]),np.mat([[16.99, 10.34], [21.01,23.68],
- ... [24.59,25.69]]),np.mat([[1.01, 1.66, 3.5]]), 0.6)
- matrix([[0.00873174],
- [0.08272556]])
+ >>> local_weight(
+ ... np.array([1., 1.]),
+ ... np.array([[16.99, 10.34], [21.01,23.68], [24.59,25.69]]),
+ ... np.array([[1.01, 1.66, 3.5]]),
+ ... 0.6
+ ... )
+ array([[0.00873174],
+ [0.08272556]])
  """
  weight = weighted_matrix(point, training_data_x, bandwidth)
- w = (training_data_x.T * (weight * training_data_x)).I * (
- training_data_x.T * weight * training_data_y.T
+ w = np.linalg.inv(training_data_x.T @ (weight @ training_data_x)) @ (
+ training_data_x.T @ weight @ training_data_y.T
  )
 
  return w
 
 
 def local_weight_regression(
- training_data_x: np.mat, training_data_y: np.mat, bandwidth: float
-) -> np.mat:
+ training_data_x: np.array, training_data_y: np.array, bandwidth: float
+) -> np.array:
  """
- Calculate predictions for each data point on axis.
- >>> local_weight_regression(np.mat([[16.99, 10.34], [21.01,23.68],
- ... [24.59,25.69]]),np.mat([[1.01, 1.66, 3.5]]), 0.6)
+ Calculate predictions for each data point on axis
+ >>> local_weight_regression(
+ ... np.array([[16.99, 10.34], [21.01, 23.68], [24.59, 25.69]]),
+ ... np.array([[1.01, 1.66, 3.5]]),
+ ... 0.6
+ ... )
  array([1.07173261, 1.65970737, 3.50160179])
  """
- m, n = np.shape(training_data_x)
+ m, _ = np.shape(training_data_x)
  ypred = np.zeros(m)
 
  for i, item in enumerate(training_data_x):
- ypred[i] = item * local_weight(
+ ypred[i] = item @ local_weight(
  item, training_data_x, training_data_y, bandwidth
  )
 
  return ypred
 
 
-def load_data(dataset_name: str, cola_name: str, colb_name: str) -> np.mat:
+def load_data(
+ dataset_name: str, cola_name: str, colb_name: str
+) -> tuple[np.array, np.array, np.array, np.array]:
  """
- Function used for loading data from the seaborn splitting into x and y points
+ 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
 
- mcol_a = np.mat(col_a)
- mcol_b = np.mat(col_b)
+ mcol_a = col_a.copy()
+ mcol_b = col_b.copy()
 
- m = np.shape(mcol_b)[1]
- one = np.ones((1, m), dtype=int)
+ one = np.ones(np.shape(mcol_b)[0], dtype=int)
 
- # horizontal stacking
- training_data_x = np.hstack((one.T, mcol_a.T))
+ # pairing elements of one and mcol_a
+ training_data_x = np.column_stack((one, mcol_a))
 
  return training_data_x, mcol_b, col_a, col_b
 
 
-def get_preds(training_data_x: np.mat, mcol_b: np.mat, tau: float) -> np.ndarray:
+def get_preds(training_data_x: np.array, mcol_b: np.array, tau: float) -> np.array:
  """
  Get predictions with minimum error for each training data
- >>> get_preds(np.mat([[16.99, 10.34], [21.01,23.68],
- ... [24.59,25.69]]),np.mat([[1.01, 1.66, 3.5]]), 0.6)
+ >>> get_preds(
+ ... np.array([[16.99, 10.34], [21.01, 23.68], [24.59, 25.69]]),
+ ... np.array([[1.01, 1.66, 3.5]]),
+ ... 0.6
+ ... )
  array([1.07173261, 1.65970737, 3.50160179])
  """
  ypred = local_weight_regression(training_data_x, mcol_b, tau)
  return ypred
 
 
 def plot_preds(
- training_data_x: np.mat,
- predictions: np.ndarray,
- col_x: np.ndarray,
- col_y: np.ndarray,
+ training_data_x: np.array,
+ predictions: np.array,
+ col_x: np.array,
+ col_y: np.array,
  cola_name: str,
  colb_name: str,
 ) -> plt.plot:
  """
- This function used to plot predictions and display the graph
+ Plot predictions and display the graph
  """
  xsort = training_data_x.copy()
  xsort.sort(axis=0)
@@ -128,6 +140,10 @@ def plot_preds(
 
 
 if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
  training_data_x, mcol_b, col_a, col_b = 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")