skwrapper 0.1.0__tar.gz

skwrapper-0.1.0/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anuj Rajesh Tiwari
+
+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.

skwrapper-0.1.0/PKG-INFO

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: skwrapper
+Version: 0.1.0
+Summary: This package helps the Data Scientist to train there model on dataset with different models without copy pasting the code again and again, this package is a Sklearn wrapper which does performs the model training. this saves time of developer and it also helps with detail metrics and for quick scan which model best fits for dataset
+Author: Anuj Rajesh Tiwari
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+Requires-Dist: scikit-learn>=1.3
+Dynamic: license-file
+
+# **skwrapper**
+This package helps the Data Scientist to train there model on dataset with different models without copy pasting the code again and again, this package is a Sklearn wrapper which does performs the model training. this saves time of developer and it also helps with detail metrics and for quick scan which model best fits for dataset
+
+## Features
+- Supports regression and classifications models
+- Computes common regression and classificatons metrics.
+- Optional display of predicted values.
+- Easy-to-use unified interface for training and evaluation.
+
+---
+
+## Installation
+```bash```
+
+---
+
+## **Usage Example**
+```python
+## Import class from Library
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from skwrapper import sc, sr
+
+df = pd.read_csv("Social_Network_Ads.csv")
+
+selected_row = df.loc[:, 'Age': 'Purchased']
+
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+# first we have to define X and y where X is the variable or feature input and y is the output target basically
+x = selected_row[['Age', 'EstimatedSalary']]
+y = selected_row['Purchased']
+
+## Split the Data
+X_train, x_test, Y_train, y_test = train_test_split( x, y, train_size=0.8, random_state=48 )
+
+X_train.shape, x_test.shape
+
+
+# doing standardization
+scaler = StandardScaler()
+
+#fit the scaler to the train set, it will learn the parameter
+scaler.fit(X_train)  ## learn mean and std from the train dataset
+X_train_scaled = scaler.transform(X_train)  ## Apply sacling
+X_test_scaler = scaler.transform(x_test) ## Apply same scaling on X_test as well
+
+#convert the numpy 2D arry to pd dataframes with column names on it as numpy array dont have column name after scaling
+X_train_scaled_df = pd.DataFrame(X_train_scaled, columns=X_train.columns)  
+X_test_scaler_df = pd.DataFrame(X_test_scaler, columns=x_test.columns) 
+
+print(X_train_scaled_df.describe())
+print(X_train.describe())
+
+
+# Initialize class
+sc = sc() ## Supervised Classifications class
+sr = sr() ## Supervised Regression class
+
+# Train and evaluate Models
+|
+## Single Model Execution for sr(Supervised Classification Models)
+sc.perform(
+    case=["logistic"],
+    xy_train=[X_train_scaled_df, y_train],
+    xy_test=[X_test_scaler_df, y_test],
+
+    ## Optional Parameter
+    show_pred=True # If True, predicted_values will be printed. If False, only evaluation metrics will be displayed.
+)
+
+## Multiple Model Execution for sr(Supervised Regression Models)
+result = sc.perform(
+    case=[" logistic", "svc", "knc"],
+    xy_train=[X_train_scaled_df, y_train],
+    xy_test=[X_test_scaler_df, y_test],
+
+    ## Optional Parameter
+    show_pred=True # If True, predicted_values will be printed. If False, only evaluation metrics will be displayed.
+)
+
+#----------------and for Supervised Regression Models-------------------#
+## Single Model Execution:
+sr.perform(
+    case=["linearR"],
+    xy_train=[X_train, y_train],
+    xy_test=[X_test, y_test],
+
+    #Optional Parameter
+    show_pred=True # If True, predicted_values will be printed. If False, only evaluation metrics will be displayed.
+)
+
+## Multiple Model Execution:
+sr.perform(
+    case=["linearR", "svr", "knr"],
+    xy_train=[X_train, y_train],
+    xy_test=[X_test, y_test]
+)
+
+print(result) ## This will print all the metrics for all defiend models in **case**
+
+# Access specific model metrics or predection value
+print("MSE for Linear Regression:", results["linearR"]["mse"])
+print("predicted_value for SVR:", results["svr"]["predicted_value"])
+
+## You Can Plot the predicted Values
+sns.scatterplot(result['svr']['predicted_value'])
+plt.show()
+
+```
+---
+
+## **Supported Models**
+- **Wrapper class for multiple sklearn regression models.**:
+
+| Model | Description |
+|-------|-------------|
+| linearR | Linear Regression |
+| ridge  | Ridge Regression |
+| lasso  | Lasso Regression |
+| svr    | Support Vector Regression |
+| knr    | K-Nearest Neighbors Regressor |
+| gbr    | Gradient Boosting Regressor |
+| rfr    | Random Forest Regressor |
+| dtr    | Decision Tree Regressor |
+
+## **Metrics**
+- **metrics computed automatically**:
+
+```markdown
+- Mean Squared Error (MSE)
+- Mean Absolute Error (MAE)
+- Root Mean Squared Error (RMSE)
+- R² Score
+```
+
+---
+
+- **Wrapper class for multiple sklearn Classifications models.**:
+
+| Model | Description |
+|-------|-------------|
+| logistic | Logistic Regression Classifier |
+| svc      | Support Vector Classifier (SVC) |
+| rfc      | Random Forest Classifier |
+| gbc      | Gradient Boosting Classifier |
+| knc      | K-Nearest Neighbors Classifier |
+| dtc      | Decision Tree Classifier |
+
+## **Metrics**
+- **metrics computed automatically**:
+
+```markdown
+- accuracy
+- confusion_matrix
+- classification_report
+```
+---
+
+
+
+

skwrapper-0.1.0/README.md

@@ -0,0 +1,163 @@
+# **skwrapper**
+This package helps the Data Scientist to train there model on dataset with different models without copy pasting the code again and again, this package is a Sklearn wrapper which does performs the model training. this saves time of developer and it also helps with detail metrics and for quick scan which model best fits for dataset
+
+## Features
+- Supports regression and classifications models
+- Computes common regression and classificatons metrics.
+- Optional display of predicted values.
+- Easy-to-use unified interface for training and evaluation.
+
+---
+
+## Installation
+```bash```
+
+---
+
+## **Usage Example**
+```python
+## Import class from Library
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from skwrapper import sc, sr
+
+df = pd.read_csv("Social_Network_Ads.csv")
+
+selected_row = df.loc[:, 'Age': 'Purchased']
+
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+# first we have to define X and y where X is the variable or feature input and y is the output target basically
+x = selected_row[['Age', 'EstimatedSalary']]
+y = selected_row['Purchased']
+
+## Split the Data
+X_train, x_test, Y_train, y_test = train_test_split( x, y, train_size=0.8, random_state=48 )
+
+X_train.shape, x_test.shape
+
+
+# doing standardization
+scaler = StandardScaler()
+
+#fit the scaler to the train set, it will learn the parameter
+scaler.fit(X_train)  ## learn mean and std from the train dataset
+X_train_scaled = scaler.transform(X_train)  ## Apply sacling
+X_test_scaler = scaler.transform(x_test) ## Apply same scaling on X_test as well
+
+#convert the numpy 2D arry to pd dataframes with column names on it as numpy array dont have column name after scaling
+X_train_scaled_df = pd.DataFrame(X_train_scaled, columns=X_train.columns)  
+X_test_scaler_df = pd.DataFrame(X_test_scaler, columns=x_test.columns) 
+
+print(X_train_scaled_df.describe())
+print(X_train.describe())
+
+
+# Initialize class
+sc = sc() ## Supervised Classifications class
+sr = sr() ## Supervised Regression class
+
+# Train and evaluate Models
+|
+## Single Model Execution for sr(Supervised Classification Models)
+sc.perform(
+    case=["logistic"],
+    xy_train=[X_train_scaled_df, y_train],
+    xy_test=[X_test_scaler_df, y_test],
+
+    ## Optional Parameter
+    show_pred=True # If True, predicted_values will be printed. If False, only evaluation metrics will be displayed.
+)
+
+## Multiple Model Execution for sr(Supervised Regression Models)
+result = sc.perform(
+    case=[" logistic", "svc", "knc"],
+    xy_train=[X_train_scaled_df, y_train],
+    xy_test=[X_test_scaler_df, y_test],
+
+    ## Optional Parameter
+    show_pred=True # If True, predicted_values will be printed. If False, only evaluation metrics will be displayed.
+)
+
+#----------------and for Supervised Regression Models-------------------#
+## Single Model Execution:
+sr.perform(
+    case=["linearR"],
+    xy_train=[X_train, y_train],
+    xy_test=[X_test, y_test],
+
+    #Optional Parameter
+    show_pred=True # If True, predicted_values will be printed. If False, only evaluation metrics will be displayed.
+)
+
+## Multiple Model Execution:
+sr.perform(
+    case=["linearR", "svr", "knr"],
+    xy_train=[X_train, y_train],
+    xy_test=[X_test, y_test]
+)
+
+print(result) ## This will print all the metrics for all defiend models in **case**
+
+# Access specific model metrics or predection value
+print("MSE for Linear Regression:", results["linearR"]["mse"])
+print("predicted_value for SVR:", results["svr"]["predicted_value"])
+
+## You Can Plot the predicted Values
+sns.scatterplot(result['svr']['predicted_value'])
+plt.show()
+
+```
+---
+
+## **Supported Models**
+- **Wrapper class for multiple sklearn regression models.**:
+
+| Model | Description |
+|-------|-------------|
+| linearR | Linear Regression |
+| ridge  | Ridge Regression |
+| lasso  | Lasso Regression |
+| svr    | Support Vector Regression |
+| knr    | K-Nearest Neighbors Regressor |
+| gbr    | Gradient Boosting Regressor |
+| rfr    | Random Forest Regressor |
+| dtr    | Decision Tree Regressor |
+
+## **Metrics**
+- **metrics computed automatically**:
+
+```markdown
+- Mean Squared Error (MSE)
+- Mean Absolute Error (MAE)
+- Root Mean Squared Error (RMSE)
+- R² Score
+```
+
+---
+
+- **Wrapper class for multiple sklearn Classifications models.**:
+
+| Model | Description |
+|-------|-------------|
+| logistic | Logistic Regression Classifier |
+| svc      | Support Vector Classifier (SVC) |
+| rfc      | Random Forest Classifier |
+| gbc      | Gradient Boosting Classifier |
+| knc      | K-Nearest Neighbors Classifier |
+| dtc      | Decision Tree Classifier |
+
+## **Metrics**
+- **metrics computed automatically**:
+
+```markdown
+- accuracy
+- confusion_matrix
+- classification_report
+```
+---
+
+
+
+

skwrapper-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "skwrapper"
+version = "0.1.0"
+description = "This package helps the Data Scientist to train there model on dataset with different models without copy pasting the code again and again, this package is a Sklearn wrapper which does performs the model training. this saves time of developer and it also helps with detail metrics and for quick scan which model best fits for dataset"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.8"
+authors = [
+    { name = "Anuj Rajesh Tiwari" }
+]
+dependencies = [
+    "scikit-learn>=1.3"
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

skwrapper-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

skwrapper-0.1.0/src/skwrapper/Supervised/classificationModels.py

@@ -0,0 +1,264 @@
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.svm import SVC
+from sklearn.metrics  import accuracy_score, classification_report, confusion_matrix
+
+def logistic(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_test is None or xy_train is None:
+        raise ValueError("xy_train and xy_test is required to perform Logistic Regression")
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+
+    #Model Parameters
+    C: float = kwargs.get("C", 1.0)
+    solver: str = kwargs.get("solver", "lbfgs")
+    max_iter: int = kwargs.get("max_iter", 1000)
+    fit_intercept: bool = kwargs.get("fit_intercept", True)
+    class_weight = kwargs.get("class_weight", None)
+    random_state = kwargs.get("random_state", 42)
+    print("<------------------------Running LogisticRegression---------------------------------------->")
+
+    model = LogisticRegression( C=C, solver=solver, max_iter=max_iter, fit_intercept=fit_intercept,
+                            class_weight=class_weight,
+                            random_state=random_state )
+    model.fit(x_train, y_train)
+    y_pred = model.predict(x_test)
+
+    accuracy = accuracy_score(y_test, y_pred)
+    cm = confusion_matrix(y_test, y_pred)
+
+    metrics = {
+        "predicted_value": y_pred,
+        "accuracy": accuracy,
+        "confusion_matrix": cm
+    }
+
+    for key, v in metrics.items():
+        if key == "predicted_value" and show_pred != True:
+            continue
+        if( key == "predicted_value" ):
+            print(f"{key}:\n {v}")
+            print("-----------------metrics-----------------")        
+    print(f"accuracy score for LogisticRegression:  {accuracy :.4f}")           
+    print(f"Confusion_matrix:\n {cm}")
+    print(classification_report(y_test, y_pred))
+
+    return metrics
+
+###################################################################################################################################
+ 
+def randomForestClassifer(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_test is None or xy_train is None:
+        raise ValueError("xy_train and xy_test is required to perform RandomForestClassifer")
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+
+    ##Modal Parameters
+    n_estimators: int = kwargs.get("n_estimators", 100)
+    max_depth: int = kwargs.get("max_depth", None)
+    criterion: str = kwargs.get("criterion", "gini")
+    class_weight = kwargs.get("class_weight", None)
+    random_state = kwargs.get("random_state", 42)
+    n_jobs: int = kwargs.get("n_jobs", -1)
+
+    print("<-------------------------Running RandomForestClassifer------------------------------------->")
+    
+    model = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, criterion=criterion, 
+                                class_weight=class_weight, random_state=random_state, n_jobs=n_jobs)
+    model.fit(x_train, y_train)
+    y_pred = model.predict(x_test)
+    accuracy = accuracy_score(y_test, y_pred)
+    cm = confusion_matrix(y_test, y_pred)
+
+    metrics = {
+        "predicted_value": y_pred,
+        "accuracy": accuracy,
+        "confusion_matrix": cm
+    }
+
+    for key, v in metrics.items():
+        if key == "predicted_value" and show_pred != True:
+            print(f"{key}:\n {v}")
+            print("-----------------metrics-----------------")        
+    print(f"accuracy score for LogisticRegression:  {accuracy :.4f}")           
+    print(f"Confusion_matrix:\n {cm}")
+    print(classification_report(y_test, y_pred))
+
+    return metrics
+
+######################################################################################################################################
+
+def svc(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_test is None or xy_train is None:
+        raise ValueError("xy_train and xy_test is required to perform SupportVectorClassifer")
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+
+    #Model Parameters
+    kernel: str = kwargs.get("kernel", 'linear')
+    C: int = kwargs.get("C", 1.0)
+    random_state:int = kwargs.get("random_state", 0)
+    probability: bool = kwargs.get("probability", False) 
+
+    print("<-------------------------Running SupportVectorClassifer------------------------------------->")
+    
+    model = SVC( kernel=kernel, C=C, random_state=random_state, probability=probability )
+    model.fit(x_train, y_train)
+    y_pred = model.predict(x_test)
+    accuracy = accuracy_score(y_test, y_pred)
+    cm = confusion_matrix(y_test, y_pred)
+
+    metrics = {
+        "predicted_value": y_pred,
+        "accuracy": accuracy,
+        "confusion_matrix": cm
+    }
+
+    for key, v in metrics.items():
+        if key == "predicted_value" and show_pred != True:
+            print(f"{key}:\n {v}")
+            print("-----------------metrics-----------------")        
+    print(f"accuracy score for LogisticRegression:  {accuracy :.4f}")           
+    print(f"Confusion_matrix:\n {cm}")
+    print(classification_report(y_test, y_pred))
+
+    return metrics
+
+######################################################################################################################################
+
+def GBC(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_test is None or xy_train is None:
+        raise ValueError("xy_train and xy_test is required to perform GradientBoostingClassifier")
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+
+    #Model Parameters
+    n_estimators: int = kwargs.get("n_estimators", 100)
+    learning_rate: float = kwargs.get("learning_rate", 0.1)
+    max_depth:int = kwargs.get("max_depth", 3)
+    subsample: float = kwargs.get("subsample", 1.0)
+    min_samples_split = kwargs.get("min_samples_split", 2)
+    min_samples_leaf = kwargs.get("min_samples_leaf", 1)
+    random_state: int = kwargs.get("random_state", None)
+
+    print("<-------------------------Running GradientBoostingClassifier------------------------------------->")
+    
+    model = GradientBoostingClassifier(n_estimators= n_estimators, learning_rate= learning_rate, 
+                                       max_depth= max_depth, subsample= subsample, 
+                                       min_samples_split= min_samples_split, min_samples_leaf= min_samples_leaf, random_state= random_state )
+    model.fit(x_train, y_train)
+    y_pred = model.predict(x_test)
+    accuracy = accuracy_score(y_test, y_pred)
+    cm = confusion_matrix(y_test, y_pred)
+
+    metrics = {
+        "predicted_value": y_pred,
+        "accuracy": accuracy,
+        "confusion_matrix": cm
+    }
+
+    for key, v in metrics.items():
+        if key == "predicted_value" and show_pred != True:
+            print(f"{key}:\n {v}")
+            print("-----------------metrics-----------------")        
+    print(f"accuracy score for LogisticRegression:  {accuracy :.4f}")           
+    print(f"Confusion_matrix:\n {cm}")
+    print(classification_report(y_test, y_pred))
+
+    return metrics
+
+######################################################################################################################################
+
+def KNC(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_test is None or xy_train is None:
+        raise ValueError("xy_train and xy_test is required to perform KNeighborsClassifier")
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+
+    #Model Parameters
+    n_neighbors: int = kwargs.get("n_neighbors", 5)
+    weights : str = kwargs.get("weights", 'uniform')
+    algorithm :int = kwargs.get("algorithm", 'auto')
+    leaf_size: int = kwargs.get("leaf_size", 30)
+    p: int = kwargs.get("p", 2)
+    metric = kwargs.get("metric", 'minkowski')
+    n_jobs: int = kwargs.get("n_jobs", None)
+
+    print("<-------------------------Running KNeighborsClassifier------------------------------------->")
+    
+    model = KNeighborsClassifier( n_neighbors=n_neighbors, weights=weights, 
+                                 algorithm=algorithm, leaf_size=leaf_size, p=p, 
+                                 metric=metric, n_jobs=n_jobs )
+    model.fit(x_train, y_train)
+    y_pred = model.predict(x_test)
+    accuracy = accuracy_score(y_test, y_pred)
+    cm = confusion_matrix(y_test, y_pred)
+
+    metrics = {
+        "predicted_value": y_pred,
+        "accuracy": accuracy,
+        "confusion_matrix": cm
+    }
+
+    for key, v in metrics.items():
+        if key == "predicted_value" and show_pred != True:
+            print(f"{key}:\n {v}")
+            print("-----------------metrics-----------------")        
+    print(f"accuracy score for LogisticRegression:  {accuracy :.4f}")           
+    print(f"Confusion_matrix:\n {cm}")
+    print(classification_report(y_test, y_pred))
+
+    return metrics
+
+######################################################################################################################################
+
+def DTC(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_test is None or xy_train is None:
+        raise ValueError("xy_train and xy_test is required to perform KNeighborsClassifier")
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+
+    #Model Parameters
+    criterion:str = kwargs.get("criterion", "gini")
+    splitter: str = kwargs.get("splitter", "best")
+    max_depth = kwargs.get("max_depth", None)
+    min_samples_split = kwargs.get("min_samples_split", 2)
+    min_samples_leaf = kwargs.get("min_samples_leaf", 1)
+    max_features = kwargs.get("max_features", None)
+    random_state: int = kwargs.get("random_state", None)
+
+    print("<-------------------------Running DecisionTreeClassifier------------------------------------->")
+    
+    model = DecisionTreeClassifier(criterion=criterion, splitter=splitter, max_depth=max_depth,
+                                   min_samples_split= min_samples_split, min_samples_leaf= min_samples_leaf, max_features= max_features,
+                                    random_state=random_state )
+    model.fit(x_train, y_train)
+    y_pred = model.predict(x_test)
+    accuracy = accuracy_score(y_test, y_pred)
+    cm = confusion_matrix(y_test, y_pred)
+
+    metrics = {
+        "predicted_value": y_pred,
+        "accuracy": accuracy,
+        "confusion_matrix": cm
+    }
+
+    for key, v in metrics.items():
+        if key == "predicted_value" and show_pred != True:
+            print(f"{key}:\n {v}")
+            print("-----------------metrics-----------------")        
+    print(f"accuracy score for DecisionTreeClassifier:  {accuracy :.4f}")           
+    print(f"Confusion_matrix:\n {cm}")
+    print(classification_report(y_test, y_pred))
+
+    return metrics
+
+