skwrapper 0.1.0__py3-none-any.whl

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
+
+

skwrapper/Supervised/regressionModels.py

@@ -0,0 +1,363 @@
+from sklearn.linear_model import LinearRegression, Lasso, Ridge
+from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
+from sklearn.neighbors import KNeighborsRegressor
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.svm import SVR
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score, root_mean_squared_error
+
+def linerR(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_train is None or xy_test is None:
+        raise ValueError("xy_train & xy_test is needed")
+    if len(xy_train) != 2 or len(xy_test) != 2:
+        raise ValueError("xy_train and xy_test require 2 items x_train, y_train, x_test, y_test")
+    
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+    ## Model Parameters
+    fit_intercept=kwargs.get("fit_intercept", True)
+    copy_X= kwargs.get("copy_x", True)
+    positive= kwargs.get("positive",False)
+
+    print("<------------------------Running LinearRegression---------------------------------------->")
+
+    model = LinearRegression(fit_intercept=fit_intercept, copy_X=copy_X, positive=positive)
+    model.fit(x_train, y_train)
+
+    pred = model.predict(x_test)
+
+    metrics = {
+    "predicted_value": pred,
+    "mse" : mean_squared_error(y_test, pred),
+    "mae" : mean_absolute_error(y_test, pred),
+    "rmse" : root_mean_squared_error(y_test, pred),
+    "r2" : r2_score(y_test, pred),
+    }
+    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-----------------")
+        else:
+            print(f"{key.upper()}: {v:.3f}")
+    
+    return metrics
+
+###################################################################################################################################
+
+def RFR(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_train is None or xy_test is None:
+        raise ValueError("xy_train & xy_test is needed")
+    if len(xy_train) != 2 or len(xy_test) != 2:
+        raise ValueError("xy_train and xy_test require 2 items x_train, y_train, x_test, y_test")
+    
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+    ## Model Parameters
+    n_estimators = kwargs.get("n_esti", 100)
+    max_depth = kwargs.get("max_d", None)
+    min_samples_split = kwargs.get("min_samples_split", 2)
+    min_samples_leaf = kwargs.get("min_samples_leaf", 1)
+    random_state = kwargs.get("random_state", None)
+
+    print("<------------------------Running RandomForestRegressor---------------------------------------->")
+
+    model = RandomForestRegressor(n_estimators= n_estimators, max_depth= max_depth, 
+                                  min_samples_split= min_samples_split, min_samples_leaf= min_samples_leaf, 
+                                  random_state= random_state )
+    model.fit(x_train, y_train)
+
+    pred = model.predict(x_test)
+
+    metrics = {
+    "predicted_value": pred,
+    "mse" : mean_squared_error(y_test, pred),
+    "mae" : mean_absolute_error(y_test, pred),
+    "rmse" : root_mean_squared_error(y_test, pred),
+    "r2" : r2_score(y_test, pred),
+    }
+    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-----------------")
+        else:
+            print(f"{key.upper()}: {v:.3f}")
+    
+    return metrics
+
+###################################################################################################################################
+
+def GBR(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_train is None or xy_test is None:
+        raise ValueError("xy_train & xy_test is needed")
+    if len(xy_train) != 2 or len(xy_test) != 2:
+        raise ValueError("xy_train and xy_test require 2 items x_train, y_train, x_test, y_test")
+    
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+    ## Model Parameters
+    n_estimators: int = kwargs.get("n_esti", 100)
+    learning_rate: float = kwargs.get("l_r", 0.1)
+    max_depth:int = kwargs.get("max_d", 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)
+    loss = kwargs.get("loss", "squared_error")
+    random_state: int = kwargs.get("random_state", None)
+
+    print("<------------------------Running GradientBoostingRegressor---------------------------------------->")
+
+    model = GradientBoostingRegressor(n_estimators= n_estimators, max_depth= max_depth, 
+                                  min_samples_split= min_samples_split, min_samples_leaf= min_samples_leaf, 
+                                  random_state=random_state, subsample=subsample, learning_rate=learning_rate, loss=loss)
+    model.fit(x_train, y_train)
+
+    pred = model.predict(x_test)
+
+    metrics = {
+    "predicted_value": pred,
+    "mse" : mean_squared_error(y_test, pred),
+    "mae" : mean_absolute_error(y_test, pred),
+    "rmse" : root_mean_squared_error(y_test, pred),
+    "r2" : r2_score(y_test, pred),
+    }
+    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-----------------")
+        else:
+            print(f"{key.upper()}: {v:.3f}")
+    
+    return metrics
+
+###################################################################################################################################
+
+def KNR(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_train is None or xy_test is None:
+        raise ValueError("xy_train & xy_test is needed")
+    if len(xy_train) != 2 or len(xy_test) != 2:
+        raise ValueError("xy_train and xy_test require 2 items x_train, y_train, x_test, y_test")
+    
+    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 KNeighborsRegressor---------------------------------------->")
+
+    model = KNeighborsRegressor( 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)
+
+    pred = model.predict(x_test)
+
+    metrics = {
+    "predicted_value": pred,
+    "mse" : mean_squared_error(y_test, pred),
+    "mae" : mean_absolute_error(y_test, pred),
+    "rmse" : root_mean_squared_error(y_test, pred),
+    "r2" : r2_score(y_test, pred),
+    }
+    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-----------------")
+        else:
+            print(f"{key.upper()}: {v:.3f}")
+    
+    return metrics
+
+###################################################################################################################################
+
+def svr(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_train is None or xy_test is None:
+        raise ValueError("xy_train & xy_test is needed")
+    if len(xy_train) != 2 or len(xy_test) != 2:
+        raise ValueError("xy_train and xy_test require 2 items x_train, y_train, x_test, y_test")
+    
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+    ## Model Parameters
+    kernel: str = kwargs.get("kernel", "rbf")
+    C: float = kwargs.get("C", 1.0)
+    epsilon: float = kwargs.get("epsilon", 0.1)
+    gamma = kwargs.get("gamma", "scale")
+
+    print("<------------------------Running SupportVectorRegression.---------------------------------------->")
+
+    model = SVR( kernel=kernel, C=C, epsilon=epsilon, gamma=gamma, )
+    model.fit(x_train, y_train)
+
+    pred = model.predict(x_test)
+
+    metrics = {
+    "predicted_value": pred,
+    "mse" : mean_squared_error(y_test, pred),
+    "mae" : mean_absolute_error(y_test, pred),
+    "rmse" : root_mean_squared_error(y_test, pred),
+    "r2" : r2_score(y_test, pred),
+    }
+    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-----------------")
+        else:
+            print(f"{key.upper()}: {v:.3f}")
+    
+    return metrics
+
+###################################################################################################################################
+
+def lasso(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_train is None or xy_test is None:
+        raise ValueError("xy_train & xy_test is needed")
+    if len(xy_train) != 2 or len(xy_test) != 2:
+        raise ValueError("xy_train and xy_test require 2 items x_train, y_train, x_test, y_test")
+    
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+    ## Model Parameters
+    alpha: float = kwargs.get("alpha", 1.0)
+    fit_intercept: bool = kwargs.get("fit_intercept", True)
+    max_iter: int = kwargs.get("max_iter", 1000)
+
+
+    print("<------------------------Running Lasso Regression.---------------------------------------->")
+
+    model = Lasso( max_iter=max_iter, fit_intercept=fit_intercept, alpha=alpha )
+    model.fit(x_train, y_train)
+
+    pred = model.predict(x_test)
+
+    metrics = {
+    "predicted_value": pred,
+    "mse" : mean_squared_error(y_test, pred),
+    "mae" : mean_absolute_error(y_test, pred),
+    "rmse" : root_mean_squared_error(y_test, pred),
+    "r2" : r2_score(y_test, pred),
+    }
+    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-----------------")
+        else:
+            print(f"{key.upper()}: {v:.3f}")
+    
+    return metrics
+
+###################################################################################################################################
+
+def ridge(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_train is None or xy_test is None:
+        raise ValueError("xy_train & xy_test is needed")
+    if len(xy_train) != 2 or len(xy_test) != 2:
+        raise ValueError("xy_train and xy_test require 2 items x_train, y_train, x_test, y_test")
+    
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+    ## Model Parameters
+    alpha: float = kwargs.get("alpha", 1.0)
+    fit_intercept: bool = kwargs.get("fit_intercept", True)
+    solver: str = kwargs.get("solver", "auto")
+
+
+    print("<------------------------Running Ridge Regression.---------------------------------------->")
+
+    model = Ridge( solver=solver, fit_intercept=fit_intercept, alpha=alpha )
+    model.fit(x_train, y_train)
+
+    pred = model.predict(x_test)
+
+    metrics = {
+    "predicted_value": pred,
+    "mse" : mean_squared_error(y_test, pred),
+    "mae" : mean_absolute_error(y_test, pred),
+    "rmse" : root_mean_squared_error(y_test, pred),
+    "r2" : r2_score(y_test, pred),
+    }
+    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-----------------")
+        else:
+            print(f"{key.upper()}: {v:.3f}")
+    
+    return metrics
+
+###################################################################################################################################
+
+def DTR(xy_train, xy_test, show_pred:bool, **kwargs):
+    if xy_train is None or xy_test is None:
+        raise ValueError("xy_train & xy_test is needed")
+    if len(xy_train) != 2 or len(xy_test) != 2:
+        raise ValueError("xy_train and xy_test require 2 items x_train, y_train, x_test, y_test")
+    
+    x_train, y_train = xy_train
+    x_test, y_test = xy_test
+
+    ## Model Parameters
+    criterion = kwargs.get("criterion", "squared_error")
+    splitter = 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 = kwargs.get("random_state", None)
+
+
+    print("<------------------------Running DecisionTreeRegressor.---------------------------------------->")
+
+    model = DecisionTreeRegressor( 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)
+
+    pred = model.predict(x_test)
+
+    metrics = {        
+    "predicted_value": pred,
+    "mse" : mean_squared_error(y_test, pred),
+    "mae" : mean_absolute_error(y_test, pred),
+    "rmse" : root_mean_squared_error(y_test, pred),
+    "r2" : r2_score(y_test, pred),
+    }
+    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-----------------")
+        else:
+            print(f"{key.upper()}: {v:.3f}")
+    
+    return metrics
+
+###################################################################################################################################
+

skwrapper/__init__.py

@@ -0,0 +1,4 @@
+from .core import supervised_classification as sc, supervised_regression as sr
+
+__all__ = ["sc", "sr"]
+

skwrapper/core.py

@@ -0,0 +1,236 @@
+from .Supervised.classificationModels import logistic, svc, randomForestClassifer, GBC, KNC, DTC
+from .Supervised.regressionModels import linerR, RFR, GBR, svr, KNR, lasso, ridge, DTR
+
+import logging
+logger = logging.getLogger(__name__)
+
+class supervised_classification:
+    """
+    Wrapper class for multiple sklearn classification models.
+    See module docstring for usage examples.
+
+    Supported Models
+    ----------------
+    "logistic": Logistic Classification,
+    "svc": Support Vector Classification,
+    "rfc": Random-Forest Classifer,
+    "gbc": Gradient-Boosting Classifer,
+    "knc": K-Nearest Neighbors Classifer,
+    "dtc": Decision Tree Classifer
+    """
+
+    def __init__(self):
+        self.operations = {
+            "logistic": logistic,
+            "svc": svc,
+            "rfc": randomForestClassifer,
+            "gbc": GBC,
+            "knc": KNC,
+            "dtc": DTC
+        }
+    
+    def perform(self, case=None, xy_train = None, xy_test=None, show_pred:bool = False, **kwargs ):
+        """
+Classification Utilities
+=========================
+
+This module provides tools to execute and evaluate multiple classification models.
+It supports models such as Logistic Regression, Support Vector Classifier (SVC),
+Random Forest Classifier (RFC), K-Nearest Classifier (KNC), and others. The module
+computes standard classification metrics and can optionally display predicted values.
+
+To check supported models:
+    >>> help(sc)
+
+Classes
+-------
+sc
+    Main class to run classification models. Use the `perform` method to execute selected models.
+
+Methods
+-------
+sc.perform(case, xy_train, xy_test, show_pred=False, **kwargs)
+    Run selected classification models and return predictions along with evaluation metrics.
+
+Parameters
+----------
+case : list
+    List of model names to execute, e.g., ["logistic", "svc", "rfc"].
+
+    To check supported models:
+    >>> help(sc)
+
+xy_train : list
+    Training dataset in the format [X_train, y_train].
+
+xy_test : list
+    Testing dataset in the format [X_test, y_test].
+
+show_pred : bool, default=False
+    If True, predicted values will be printed.
+    If False, only evaluation metrics will be displayed.
+
+**kwargs : dict
+    Model-specific parameters passed to the underlying classification functions.
+
+Returns
+-------
+dict
+    Dictionary containing results for each executed model:
+    - predicted_value
+    - accuracy
+    - confusion_matrix
+
+Examples
+--------
+Single Model Execution:
+>>> sc_instance.perform(
+...     case=["logistic"],
+...     xy_train=[X_train, y_train],
+...     xy_test=[X_test, y_test],
+...     show_pred=True
+... )
+
+Multiple Model Execution:
+>>> sc_instance.perform(
+...     case=["logistic", "svc", "knc"],
+...     xy_train=[X_train, y_train],
+...     xy_test=[X_test, y_test]
+... )
+"""
+        
+        if case is None or xy_train is None or xy_test is None :
+            raise ValueError("case, xy_tarin and xy_test is required")
+        if len(xy_train) != 2 or len(xy_test) != 2:
+            raise ValueError("xy_train and xy_test must contain exactly 2 items")
+        
+        result = {}
+        for operation in case:
+            if operation in self.operations:
+                try:
+                    result[operation] = self.operations[operation](xy_train, xy_test, show_pred, **kwargs)
+                except (ValueError, IndexError) as e:
+                    logger.error("Operation '%s' failed: %s", operation, e)
+                else:
+                    raise ValueError(f"Model '{operation }' is not supported.")
+        return result
+
+
+class supervised_regression:
+    """
+    Wrapper class for multiple sklearn regression models.
+    See module docstring for usage examples.
+
+    Supported Models
+    ----------------
+    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
+    """
+    def __init__(self):
+        # Each key is a model name, and the value is the corresponding function.
+        self.operationss = {
+            "linearR": linerR,
+            "rfr": RFR,
+            "gbr": GBR,
+            "svr": svr,
+            "knr": KNR,
+            "lasso": lasso,
+            "ridge": ridge,
+            "dtr": DTR
+        }
+    
+    def perform(self, case=None, xy_train=None, xy_test=None, show_pred:bool =False, **kwargs):
+        """
+Regression Utilities Module
+===========================
+
+This module provides tools to train and evaluate multiple regression models.
+It supports linear regression, support vector regression, k-nearest neighbors regression,
+and other models, with automatic computation of common regression metrics.
+
+Classes
+-------
+sr
+    Main class to run regression models. Use the `perform` method to execute selected models.
+
+Methods
+-------
+sr.perform(case, xy_train, xy_test, show_pred=False, **kwargs)
+    Runs the selected regression models and returns predictions
+    along with evaluation metrics.
+
+Parameters
+----------
+case : list
+    List of model names to execute.
+    Example: ["linearR", "svr"].
+
+    To check supported models:
+    >>> help(sr)
+
+xy_train : list
+    Training dataset in the format [X_train, y_train].
+
+xy_test : list
+    Testing dataset in the format [X_test, y_test].
+
+show_pred : bool, default=False
+    If True, predicted values will be printed.
+    If False, only evaluation metrics will be printed.
+
+**kwargs : dict
+    Model-specific parameters that will be passed to the
+    underlying regression model.
+
+Returns
+-------
+dict
+    Dictionary containing results for each executed model:
+    - predicted_value
+    - mse
+    - mae
+    - rmse
+    - r2
+
+Examples
+--------
+Single Model Execution
+>>> sr_instance.perform(
+...     case=["linearR"],
+...     xy_train=[X_train, y_train],
+...     xy_test=[X_test, y_test],
+...     show_pred=True
+... )
+
+Multiple Model Execution
+>>> sr_instance.perform(
+...     case=["linearR", "svr", "knr"],
+...     xy_train=[X_train, y_train],
+...     xy_test=[X_test, y_test]
+... )
+"""
+        
+        if case is None or xy_train is None or xy_test is None :
+            raise ValueError("case, xy_train, and xy_test are required")
+        if len(xy_train) != 2 or len(xy_test) != 2:
+            raise ValueError("xy_train and xy_test must contain exactly 2 items")
+        result = {}
+        for operation in case:
+            if operation in self.operationss:
+                try:
+                    result[operation] = self.operationss[operation](xy_train, xy_test, show_pred, **kwargs)
+                except (ValueError, IndexError) as e:
+                    logger.error("Operation '%s' failed: %s", operation, e)
+            else:
+                raise ValueError(f"Model '{operation }' is not supported.")
+        return result
+
+
+
+

skwrapper-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+skwrapper/__init__.py,sha256=8Q6ZimekxULZN6fGse29hNXXfUvASaq7nVHP73s6Lpg,108
+skwrapper/core.py,sha256=HCPVm6c3bdW3YqQgNHJLxW6HMOlUPwiGdzbJt2AMpBs,7120
+skwrapper/Supervised/classificationModels.py,sha256=Nerahd2qyH2L8A6eAPaXB7xefKYDgbwuHQFruNtYMaQ,10947
+skwrapper/Supervised/regressionModels.py,sha256=KJCjWbjQLFA-SXwpJd0CatY0CObq5bl0NZLc8DHdBCA,14278
+skwrapper-0.1.0.dist-info/licenses/LICENCE.txt,sha256=Y5d-uZ3T8fXs2sAmlkI0twS423qMdIEExcY9-PoQeG8,1096
+tests/test_basic.py,sha256=_Q1U0ezyFUQBJ5yP4zM-tRjT9IwjbutTi4jFNtQYvME,2367
+skwrapper-0.1.0.dist-info/METADATA,sha256=2eZ0Q7KGFnlLjnJSIoeCmGU3GmfCVXO5sHCyjolMYC8,5486
+skwrapper-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+skwrapper-0.1.0.dist-info/top_level.txt,sha256=d_zPYcMdQmcehsnJczoZ1ohT7_690DU9DUrkqKs8V10,16
+skwrapper-0.1.0.dist-info/RECORD,,

skwrapper-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

skwrapper-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+skwrapper
+tests

tests/test_basic.py

@@ -0,0 +1,73 @@
+import pandas as pd
+from skwrapper import sc, sr
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+import kagglehub
+
+# path = kagglehub.dataset_download("raipiyush558/social-network-ad")
+# print(path)
+
+import os
+os.listdir('C:/Users/91989/.cache/kagglehub/datasets/raipiyush558/social-network-ad/versions/1')
+
+
+df = pd.read_csv("C:/Users/91989/.cache/kagglehub/datasets/raipiyush558/social-network-ad/versions/1/Social_Network_Ads.csv")
+# print(df.head(5))
+# print(df.tail(5))
+
+maxSal = df["EstimatedSalary"].max()
+minSal = df['EstimatedSalary'].min()
+
+print(f"max = {maxSal}, min = {minSal}")
+
+selected_row = df.loc[:, 'Age': 'Purchased']
+
+# print(selected_row)
+
+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']]
+# print(x) just to see the outcome
+y = selected_row['Purchased']
+# print(y)
+
+## 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
+
+# scaler.mean_
+
+X_train_scaled_df = pd.DataFrame(X_train_scaled, columns=X_train.columns)  #convert the numpy 2D arry to pd dataframes with column names on it as numpy array dont have column name after scaling
+X_test_scaler_df = pd.DataFrame(X_test_scaler, columns=x_test.columns)     #convert the numpy 2D arry to pd dataframes with column names on it as numpy array dont have column name after scaling
+print(X_train_scaled_df.describe())
+print(X_train.describe())
+
+sc = sc()
+sr = sr()
+
+# print(help(sr))
+
+# print(help(sr.perform))
+result = sr.perform(case=["linearR", "svr"], 
+                    xy_train=[X_train_scaled_df, Y_train], 
+                    xy_test=[X_test_scaler_df, y_test]
+                    )
+
+sns.scatterplot(result['svr']['predicted_value'])
+# print(result['linearR']["mse"])
+
+plt.show()
+
+# print(df)