minimatrix 0.1.1__tar.gz

minimatrix-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Suchibrata Patra
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

minimatrix-0.1.1/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: minimatrix
+Version: 0.1.1
+Summary: For academic and educational use under St. Xavier's College only.
+Author: Suchibrata Patra
+Author-email: SXC_Student_developer_Community <suchibratapatra2003@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Suchibrata Patra
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Keywords: machine-learning,classification,regression,data-science,automated-ml
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3.0,>=1.23
+Requires-Dist: pandas>=1.5
+Requires-Dist: scikit-learn>=1.2
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: seaborn>=0.12
+Requires-Dist: plotly>=5.0
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-python
+
+SXC is a Python library designed for academic and educational use, providing intuitive access to machine learning algorithms, nonparametric smoothing techniques, and classical statistical learning workflows. Inspired by Scikit-Learn’s clean API principles, SXC ensures that users can perform data analysis with consistent, modular, and user-friendly interfaces.
+
+
+---
+
+## Features
+
+### Supervised Learning
+- Decision Tree Classifier & Regressor
+- Random Forest Classifier & Regressor
+- K-Nearest Neighbors Classification & Regression
+- Naive Bayes Classifier
+- Support Vector Machines (Classification & Regression)
+- Bagging for both Regression and Classification
+
+### Nonparametric Regression & Smoothing
+Located under `sxc.mdts.adv_reg`:
+- Bin Smoother
+- KNN Smoother
+- Kernel Weighted Regression
+- LOWESS (Locally Weighted Regression)
+- LWR (Local Weighted Regression variants)
+
+### Clustering
+- K-Means clustering
+
+### Utility
+- Indexing helper for dataset preprocessing
+
+---
+
+## Installation
+
+```bash
+pip install sxc
+``` 
+This will install all core dependencies required to run the machine learning modules inside SXC.
+
+##  Quick Start
+```py
+from sxc.mdts.decision_tree_classifier import DecisionTreeClassifier
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+
+# Load toy dataset
+X, y = load_iris(return_X_y=True)
+
+# Train-test split
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=42
+)
+
+# Initialize the model
+model = DecisionTreeClassifier()
+
+# Fit and predict
+model.fit(X_train, y_train)
+preds = model.predict(X_test)
+```
+
+All algorithms included are intended for educational demonstrations and experiments. SXC facilitates rapid learning of:
+
+Machine learning theory
+Practical model building
+Nonparametric regression foundations
+For academic citation or publication:
+
+## Patra, S. (2025).
+SXC: Statistical & Explainable Computing (Version 0.1.x).
+Python package available at PyPI.
+
+# Contributing
+Contributions are welcomed. Kindly create pull requests via GitHub or report issues to help improve stability, documentation, and performance.
+
+## License
+Licensed under the MIT License. Free to view, modify, and learn from.
+
+## Acknowledgement
+Developed with passion for the community of statisticians, data scientists, and research enthusiasts at St. Xavier’s College.
+
+Keep experimenting. Keep learning. Keep computing elegantly.

minimatrix-0.1.1/README.md

@@ -0,0 +1,82 @@
+SXC is a Python library designed for academic and educational use, providing intuitive access to machine learning algorithms, nonparametric smoothing techniques, and classical statistical learning workflows. Inspired by Scikit-Learn’s clean API principles, SXC ensures that users can perform data analysis with consistent, modular, and user-friendly interfaces.
+
+
+---
+
+## Features
+
+### Supervised Learning
+- Decision Tree Classifier & Regressor
+- Random Forest Classifier & Regressor
+- K-Nearest Neighbors Classification & Regression
+- Naive Bayes Classifier
+- Support Vector Machines (Classification & Regression)
+- Bagging for both Regression and Classification
+
+### Nonparametric Regression & Smoothing
+Located under `sxc.mdts.adv_reg`:
+- Bin Smoother
+- KNN Smoother
+- Kernel Weighted Regression
+- LOWESS (Locally Weighted Regression)
+- LWR (Local Weighted Regression variants)
+
+### Clustering
+- K-Means clustering
+
+### Utility
+- Indexing helper for dataset preprocessing
+
+---
+
+## Installation
+
+```bash
+pip install sxc
+``` 
+This will install all core dependencies required to run the machine learning modules inside SXC.
+
+##  Quick Start
+```py
+from sxc.mdts.decision_tree_classifier import DecisionTreeClassifier
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+
+# Load toy dataset
+X, y = load_iris(return_X_y=True)
+
+# Train-test split
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=42
+)
+
+# Initialize the model
+model = DecisionTreeClassifier()
+
+# Fit and predict
+model.fit(X_train, y_train)
+preds = model.predict(X_test)
+```
+
+All algorithms included are intended for educational demonstrations and experiments. SXC facilitates rapid learning of:
+
+Machine learning theory
+Practical model building
+Nonparametric regression foundations
+For academic citation or publication:
+
+## Patra, S. (2025).
+SXC: Statistical & Explainable Computing (Version 0.1.x).
+Python package available at PyPI.
+
+# Contributing
+Contributions are welcomed. Kindly create pull requests via GitHub or report issues to help improve stability, documentation, and performance.
+
+## License
+Licensed under the MIT License. Free to view, modify, and learn from.
+
+## Acknowledgement
+Developed with passion for the community of statisticians, data scientists, and research enthusiasts at St. Xavier’s College.
+
+Keep experimenting. Keep learning. Keep computing elegantly.

minimatrix-0.1.1/minimatrix/__init__.py

@@ -0,0 +1,3 @@
+from . import mdts
+
+__all__ = ["mdts"]

minimatrix-0.1.1/minimatrix/mdts/__init__.py

@@ -0,0 +1,60 @@
+# Machine Learning Folder
+from .machine_learning import indexing
+from .machine_learning import bagging_classifier
+from .machine_learning import bagging_regressor
+from .machine_learning import decision_tree_classifier
+from .machine_learning import decision_tree_regressor
+from .machine_learning import indexing
+from .machine_learning import kmeans_clustering
+from .machine_learning import knn_classifier
+from .machine_learning import knn_regressor
+from .machine_learning import naive_bayes
+from .machine_learning import random_forest_classifier
+from .machine_learning import random_forest_regressor
+from .machine_learning import support_vector_classifier
+from .machine_learning import support_vector_regressor
+
+# From Advanced Regression Folder
+from .adv_reg import bin_smoother
+from .adv_reg import knn_smoother
+from .adv_reg import kernel_smoother
+from .adv_reg import lowess
+from .adv_reg import lwr
+
+# Fom Optimization Folder
+from .optimization import newton_method
+from .optimization import golden_section
+from .optimization import fibonacci_method
+from .optimization import conjugate_gradient_without_direction
+from .optimization import conjugate_gradient_with_direction
+from .optimization import steepest_descent
+from .optimization import quassi_newton
+from .optimization import quassi_newton_documentation
+__all__ = [
+    "indexing",
+    "BaggingClassifier",
+    "BaggingRegressor",
+    "DecisionTreeClassifier",
+    "DecisionTreeRegressor",
+    "KMeansClustering",
+    "KNNClassifier",
+    "KNNRegressor",
+    "NaiveBayesClassifier",
+    "RandomForestClassifier",
+    "RandomForestRegressor",
+    "SVC",
+    "SVR",
+    "bin_smoother",
+    "knn_smoother",
+    "kernel_smoother",
+    "lowess",
+    "lwr",
+    "newton_method",
+    "golden_section",
+    "fibonacci_method",
+    "conjugate_gradient_without_direction",
+    "conjugate_gradient_with_direction",
+    "steepest_descent",
+    "quassi_newton",
+    "quassi_newton_documentation"
+]

minimatrix-0.1.1/minimatrix/mdts/adv_reg/__init__.py

@@ -0,0 +1,13 @@
+from .bin_smoother import bin_smoother
+from .knn_smoother import knn_smoother
+from .kernel_smoother import kernel_smoother
+from .lowess import lowess
+from .lwr import lwr
+
+__all__ = [
+    "bin_smoother",
+    "knn_smoother",
+    "kernel_smoother",
+    "lowess",
+    "lwr"
+]

minimatrix-0.1.1/minimatrix/mdts/adv_reg/bin_smoother.py

@@ -0,0 +1,128 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+
+def bin_smoother(train, test, target="target", regression=None, bin=5):
+    """
+    Perform bin smoothing estimation for a univariate nonparametric regression model.
+
+    The method divides the range of the covariate variable into a specified number of
+    equal-width bins using only the training set. It then estimates a stepwise regression
+    curve by computing the mean of the regression function values within each bin.
+
+    Parameters
+    ----------
+    train : pandas.DataFrame
+        Training dataset containing the covariate in the first column and the response
+        specified by the target parameter.
+    test : pandas.DataFrame
+        Test dataset with similar structure as train.
+    target : str, optional
+        Name of the response variable column. Default is "target".
+    regression : callable, optional
+        A function that represents the true regression function f(x). It must accept
+        a NumPy array of x values and return predicted y values of equal length.
+    bin : int, optional
+        Number of equal-width bins for bin smoothing. Default is 5.
+        
+    Example
+    -------
+    >>> from sxc import mdts
+    >>> import numpy as np
+    >>> import pandas as pd
+    >>>
+    >>> np.random.seed(1234)
+    >>> def reg(x):
+    ...     return 5*np.sin(x) + 23*(np.cos(x)**2)
+    >>>
+    >>> x = np.random.uniform(5, 15, 100)
+    >>> y = reg(x) + np.random.normal(0, 5, 100)
+    >>> data = pd.DataFrame({"feature": x, "target": y})
+    >>> train = data.iloc[:80]
+    >>> test = data.iloc[80:]
+    >>>
+    >>> mdts.bin_smoother(train, test, target="target", regression=reg, bin=10)
+    """
+    # Function body continues here...
+
+    X_train = train.iloc[:, 0].values
+    y_train = train[target].values
+
+    X_test = test.iloc[:, 0].values
+    y_test = test[target].values
+
+    # Create bins using training data
+    bins = np.linspace(X_train.min(), X_train.max(), bin + 1)
+    bin_indices = np.digitize(X_train, bins) - 1
+
+    # Compute mean predicted value in each bin
+    bin_means = []
+    for i in range(bin):
+        in_bin = bin_indices == i
+        if np.any(in_bin):
+            bin_means.append(np.mean(regression(X_train[in_bin])))
+        else:
+            bin_means.append(0)
+
+    bin_means = np.array(bin_means)
+
+    # Step smoother prediction helper
+    def step_predict(x_values):
+        preds = np.zeros_like(x_values, float)
+        idx = np.digitize(x_values, bins) - 1
+        for i in range(bin):
+            preds[idx == i] = bin_means[i]
+        return preds
+
+    # Compute errors
+    train_pred = step_predict(X_train)
+    test_pred = step_predict(X_test)
+
+    train_mse = np.mean((y_train - train_pred)**2)
+    test_mse = np.mean((y_test - test_pred)**2)
+
+    # Plotting
+    plt.figure(figsize=(10, 6))
+    
+    # Scatter
+    plt.scatter(X_train, y_train, label="Train", alpha=0.7)
+    plt.scatter(X_test, y_test, label="Test", marker='s')
+
+    # True function curve
+    x_curve = np.linspace(X_train.min(), X_train.max(), 400)
+    plt.plot(x_curve, regression(x_curve), label="True function", color='blue')
+
+    # Step horizontal segments
+    for i in range(bin):
+        plt.hlines(bin_means[i], bins[i], bins[i+1], colors='red', linewidth=2)
+
+    # Vertical dotted bin edges
+    for b in bins:
+        plt.axvline(x=b, linestyle='dotted', color='gray')
+
+    plt.title(f'k = {bin}')
+    
+    # Legend at top right corner
+    plt.legend(loc='upper right')
+
+    plt.grid(True)
+    plt.show()
+
+    print(f"Train MSE: {train_mse:.4f}")
+    print(f"Test  MSE: {test_mse:.4f}")
+
+    bin_summary = pd.DataFrame({
+    "Bin": [f"{i+1}" for i in range(bin)],
+    "Range Start": [round(bins[i], 3) for i in range(bin)],
+    "Range End": [round(bins[i+1], 3) for i in range(bin)],
+    "Mean Estimate": [round(bin_means[i], 3) for i in range(bin)]
+    })
+    print("Summary Table:")
+    print(bin_summary.to_string(index=False))
+
+    # return {
+    #     "train_mse": train_mse,
+    #     "test_mse": test_mse,
+    #     "bin_means": bin_means,
+    #     "bin_edges": bins
+    # }

minimatrix-0.1.1/minimatrix/mdts/adv_reg/kernel_smoother.py

@@ -0,0 +1,233 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error
+from scipy.stats import norm
+
+# Kernel Regression Function
+def kernel_smoother(train, test, target="target",
+                    kernel=["gaussian", "uniform", "triangular", "epanechnikov"],
+                    n_repeats=50):
+    """
+Kernel Smoother: Documentation
+---------------------------------------------------------------------------
+Parameters
+---------------------------------------------------------------------------
+train : pandas.DataFrame
+    Training dataset with columns:
+        • "feature" (predictor)
+        • "target"  (response)
+
+test : pandas.DataFrame
+    Testing dataset with the same structure as train.
+
+target : str, default = "target"
+    Target column name.
+
+kernel : list of str
+    Names of kernels to apply. Supported options:
+        • "gaussian"
+        • "uniform"
+        • "epanechnikov"
+        • "triangular"
+        • "biweight"
+        • "triweight"
+        • "tricube"
+
+n_repeats : int, default = 50
+    Number of repeated evaluations for stable error estimates.
+---------------------------------------------------------------------------
+R Equivalent Example (Kernel Smoothing with Train/Test Errors)
+---------------------------------------------------------------------------
+rm(list=ls())
+set.seed(1234)
+reg = function(x) 5 * sin(x) + 23 * (cos(x))^2
+n = 100 ; x = runif(n, 5, 15)
+y = reg(x) + rnorm(n, 0, 5)
+train_idx = sample(1:n, size = 0.8 * n)
+X_train = x[train_idx] ; Y_train = y[train_idx]
+X_test = x[-train_idx] ; Y_test = y[-train_idx]
+
+# Kernels
+gaussian = function(u) exp(-0.5 * u^2) / sqrt(2*pi)
+kernels = list( gaussian = gaussian )
+bandwidths = c(0.1, 0.25, 0.5, 1, 2)
+n_repeats = 50
+results = data.frame()
+
+# Kernel smoothing evaluation
+for (kname in names(kernels)) {
+  cat("Processing Kernel:", toupper(kname)")
+  K = kernels[[kname]]
+  for (h in bandwidths) {
+    train_err = c()
+    test_err = c()
+    
+    for (r in 1:n_repeats) {
+      n_train = length(X_train)
+      L = matrix(0, n_train, n_train)
+      for (i in 1:n_train) {
+        u = (X_train[i] - X_train) / h
+        w = K(u)
+        L[i, ] = w / sum(w)
+      }
+      
+      Y_pred_train = L %*% Y_train
+      train_mse = mean((Y_pred_train - Y_train)^2)
+      
+      Y_pred_test = numeric(length(X_test))
+      for (i in 1:length(X_test)) {
+        u = (X_test[i] - X_train) / h
+        w = K(u)
+        Y_pred_test[i] = sum(w * Y_train) / sum(w)
+      }
+      test_mse = mean((Y_pred_test - Y_test)^2)
+      
+      train_err = c(train_err, train_mse)
+      test_err = c(test_err, test_mse)
+    }
+    
+    results = rbind(results, data.frame(
+      Kernel = kname,
+      h = h,
+      Avg_Train_MSE = mean(train_err),
+      Avg_Test_MSE = mean(test_err)
+    ))
+  }
+}
+
+print(results)
+
+for (kname in names(kernels)) {
+  df = subset(results, Kernel == kname)
+  best_h = df$h[which.min(df$Avg_Test_MSE)]
+  K = kernels[[kname]]
+  cat("Best bandwidth for", kname, "=", best_h)
+  
+  x_grid = seq(min(X_train), max(X_train), length.out = 200)
+  y_smooth = numeric(length(x_grid))
+  
+  for (i in 1:length(x_grid)) {
+    u = (x_grid[i] - X_train) / best_h
+    w = K(u)
+    y_smooth[i] = sum(w * Y_train) / sum(w)
+  }
+  
+  plot(X_train, Y_train, col="blue", pch=16,
+       main=paste(kname, "Kernel Regression Fit"),
+       xlab="X", ylab="Y")
+  points(X_test, Y_test, col="orange", pch=16)
+  lines(x_grid, y_smooth, col="red", lwd=2)
+  legend("topleft", legend=c("Train","Test","Fit"),
+         col=c("blue","orange","red"), pch=c(16,16,NA), lty=c(NA,NA,1))
+}
+
+---------------------------------------------------------------------------
+Returns
+---------------------------------------------------------------------------
+pandas.DataFrame
+    Summary of training/testing MSE for each kernel-bandwidth combination.
+"""
+    X_train = train["feature"].values
+    y_train = train[target].values
+    X_test = test["feature"].values
+    y_test = test[target].values
+
+    # Bandwidth values (h or σ)
+    bandwidths = [0.1, 0.25, 0.5, 1, 2]
+    def gaussian_kernel(u): return (1/np.sqrt(2*np.pi)) * np.exp(-u**2 / 2)
+    def uniform_kernel(u): return np.where(np.abs(u) <= 1, 1/2, 0)
+    def epanechnikov_kernel(u): return np.where(np.abs(u) <= 1, 3/4 * (1 - u**2), 0)
+    def triangular_kernel(u): return np.where(np.abs(u) < 1, (35/32) * (1 - u**2)**3, 0)
+    def biweight_kernel(u): return np.where(np.abs(u) <= 1, 15/16 * (1 - u**2)**2, 0)
+    def triweight_kernel(u): return np.where(np.abs(u) <= 1, 35/32 * (1 - u**2)**3, 0)
+    def tricube_kernel(u): return np.where(np.abs(u) <= 1, 70/81 * (1 - np.abs(u)**3)**3, 0)
+
+
+    kernels = {
+    "gaussian": gaussian_kernel,
+    "uniform": uniform_kernel,
+    "epanechnikov": epanechnikov_kernel,
+    "triangular": triangular_kernel,
+    "biweight": biweight_kernel,
+    "triweight": triweight_kernel,
+    "tricube": tricube_kernel
+    }
+    results = []
+
+    # Compute Regression for Each Kernel
+    for k_name in kernel:
+        K = kernels[k_name]
+        print(f"\nProcessing Kernel: {k_name.upper()}")
+
+        for h in bandwidths:
+            train_errors = []
+            test_errors = []
+
+            for _ in range(n_repeats):
+                # Predict on train and test
+                def kernel_regression(x_query, X, Y, h):
+                    weights = K((x_query - X[:, None]) / h)
+                    numer = np.dot(weights.T, Y)
+                    denom = np.sum(weights, axis=0)
+                    denom = np.where(denom == 0, 1e-8, denom) 
+                    return numer / denom
+
+                y_pred_train = kernel_regression(X_train, X_train, y_train, h)
+                y_pred_test = kernel_regression(X_test, X_train, y_train, h)
+
+                train_mse = mean_squared_error(y_train, y_pred_train)
+                test_mse = mean_squared_error(y_test, y_pred_test)
+
+                train_errors.append(train_mse)
+                test_errors.append(test_mse)
+
+            avg_train_err = np.mean(train_errors)
+            avg_test_err = np.mean(test_errors)
+            results.append({
+                "Kernel": k_name,
+                "h": h,
+                "Avg Train error": avg_train_err,
+                "Avg Test error": avg_test_err
+            })
+
+    Res_df = pd.DataFrame(results)
+
+    # Plot Average Train/Test MSE vs h
+    for k_name in kernel:
+        df_k = Res_df[Res_df["Kernel"] == k_name]
+        plt.figure(figsize=(8, 5))
+        plt.plot(df_k["h"], df_k["Avg Train error"], label="Avg Train error", marker="o")
+        plt.plot(df_k["h"], df_k["Avg Test error"], label="Avg Test error", marker="s")
+        plt.xlabel("Bandwidth (h)", fontsize=14)
+        plt.ylabel("Average MSE", fontsize=14)
+        plt.title(f"{k_name.capitalize()} Kernel: Train vs Test Error", fontsize=16)
+        plt.legend()
+        plt.grid(True)
+        plt.show()
+
+        # Plot Scatter + Smoothed Line
+        plt.figure(figsize=(8, 5))
+        plt.scatter(X_train, y_train, color="blue", alpha=0.6, label="Train Data")
+        plt.scatter(X_test, y_test, color="orange", alpha=0.6, label="Test Data")
+
+        x_grid = np.linspace(min(X_train), max(X_train), 200)
+        y_smooth = []
+
+        best_h = df_k.loc[df_k["Avg Test error"].idxmin(), "h"]
+        for xq in x_grid:
+            weights = K((xq - X_train) / best_h)
+            y_hat = np.sum(weights * y_train) / np.sum(weights)
+            y_smooth.append(y_hat)
+
+        plt.plot(x_grid, y_smooth, color="blue", linewidth=1,
+                 label=f"Smoothed ({k_name}, h={best_h})")
+        plt.xlabel("Feature", fontsize=14)
+        plt.ylabel("Target", fontsize=14)
+        plt.title(f"{k_name.capitalize()} Kernel Regression Fit", fontsize=16)
+        plt.legend()
+        plt.grid(True)
+        plt.show()
+
+    return Res_df