Repository: TheAlgorithms/Python

Issue:
[PYTEST WARNING] Machine learning local weighted learning
### Feature description

@venkateshtantravahi Please could you resolve this warning
```
machine_learning/local_weighted_learning/local_weighted_learning.py: 87 warnings
  /opt/hostedtoolcache/Python/3.10.7/x64/lib/python3.10/site-packages/numpy/matrixlib/defmatrix.py:69: PendingDeprecationWarning: the matrix subclass is not the recommended way to represent matrices or deal with linear algebra (see https://docs.scipy.org/doc/numpy/user/numpy-for-matlab-users.html). Please adjust your code to use regular ndarray.
    return matrix(data, dtype=dtype, copy=False)
```

origin: #7211


Discussion:
> ### Feature description
> @venkateshtantravahi Please could you resolve this warning
> 
> ```
> machine_learning/local_weighted_learning/local_weighted_learning.py: 87 warnings
>   /opt/hostedtoolcache/Python/3.10.7/x64/lib/python3.10/site-packages/numpy/matrixlib/defmatrix.py:69: PendingDeprecationWarning: the matrix subclass is not the recommended way to represent matrices or deal with linear algebra (see https://docs.scipy.org/doc/numpy/user/numpy-for-matlab-users.html). Please adjust your code to use regular ndarray.
>     return matrix(data, dtype=dtype, copy=False)
> ```
> 
> origin: #7211

Can you assign me to this issue ?


Resolving patch:
diff --git a/machine_learning/local_weighted_learning/local_weighted_learning.py b/machine_learning/local_weighted_learning/local_weighted_learning.py
--- a/machine_learning/local_weighted_learning/local_weighted_learning.py
+++ b/machine_learning/local_weighted_learning/local_weighted_learning.py
@@ -1,76 +1,86 @@
-# 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
 
@@ -78,23 +88,25 @@ def load_data(dataset_name: str, cola_name: str, colb_name: str) -> np.mat:
     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)
@@ -102,15 +114,15 @@ def get_preds(training_data_x: np.mat, mcol_b: np.mat, tau: float) -> np.ndarray
 
 
 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")


Test patch: