ML-Classify 0.1.0__tar.gz

ml_classify-0.1.0/ML_Classify/EDA.py

@@ -0,0 +1,159 @@
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import math
+import seaborn as sns
+from sklearn.preprocessing import LabelEncoder
+
+class EDA:
+    def __init__(self,X,y,numcol,catcol):
+        self.X = X
+        self.Y = y
+        self.numcol = numcol
+        self.catcol = catcol
+        self.num_col_name=[]
+        self.cat_col_name=[]
+        self.numericaldf=pd.DataFrame()
+        self.categoricaldf=pd.DataFrame()   
+        self.__validate_and_assign_columns()     
+        print(self.numcol,self.catcol,self.num_col_name)
+        
+        # self.simulation_result_n={}
+        # self.simulation_result_one={}
+        # self.data_sim_one={}
+        # self.data_sim_n={}
+        # self.validate_and_assign_columns()
+        
+        
+    def __validate_and_assign_columns(self):
+        for idx, col in enumerate(self.X.columns):
+            if self.catcol[idx]==0:
+                self.num_col_name.append(col)
+            else:
+                self.X[col] = self.X[col].astype('category')
+                self.cat_col_name.append(col)
+
+        self.numericaldf=self.X[self.num_col_name]
+        self.categoricaldf=self.X[self.cat_col_name]
+        
+        
+    
+    def PlotGraphs(self):
+        self.__bar_ylabel()
+        self.__categorical_counts()
+        self.__numerical_box_plot()
+        self.__corr_matrix()
+        self.__kde_plot()
+    
+    def __bar_ylabel(self):
+        counts = self.Y.value_counts().sort_index()
+        plt.bar(counts.index, counts.values, edgecolor='black')
+        plt.title("Output Label Frequency")
+        
+    def __categorical_counts(self):
+        if(len(self.cat_col_name)==0):
+            return "Na"
+        total_plots = len(self.cat_col_name) 
+        cols = 3
+        rows = math.ceil(total_plots / cols)
+
+        fig_width = cols * 6
+        fig_height = rows * 6
+        fig,axes= plt.subplots(nrows=rows,
+            ncols=cols,
+            figsize=(fig_width, fig_height))
+
+        row,col=0,0
+        for colm in self.categoricaldf.columns:
+            counts = self.X[colm].value_counts().sort_index()
+            axes[row,col].bar(counts.index, counts.values, edgecolor='black')
+            axes[row,col].set_title(colm)
+            # axes.
+            # axes[row,col].set_ylabel()
+            col=col+1
+            if(col==3):
+                row+=1
+            col=(col)%cols
+            
+        fig.suptitle("Categorical Counts", y=1)
+        plt.tight_layout(w_pad=2)
+        # plt.set_title("Categorical Counts")
+        plt.show()
+    
+    def __numerical_box_plot(self):
+        total_plots = len(self.num_col_name) 
+        cols = 3
+        rows = math.ceil(total_plots / cols)
+
+        fig_width = cols * 6
+        fig_height = rows * 6
+        fig,axes= plt.subplots(nrows=rows,
+            ncols=cols,
+            figsize=(fig_width, fig_height))
+
+        row,col=0,0
+        for colm in self.numericaldf.columns:
+            sns.boxplot(ax=axes[row,col],x=self.Y,y=self.X[colm])
+            axes[row,col].set_title(colm)
+
+            # axes.
+            # axes[row,col].set_ylabel()
+            col=col+1
+            if(col==3):
+                row+=1
+            col=(col)%cols
+            
+        fig.suptitle("Distribution of Label with Respect to Numerical Features", y=1)
+        plt.tight_layout(w_pad=2)
+        # plt.set_title("Categorical Counts")
+        plt.show()
+    
+    def __corr_matrix(self):
+        corrmatrix=self.numericaldf.corr(numeric_only=True)
+        plt.figure(figsize=(14, 10))  
+        sns.heatmap(corrmatrix, annot=True, cmap="coolwarm", fmt=".2f", linewidths=0.1)
+        plt.show()
+    
+    def __kde_plot(self):
+        
+        Lable_Enc=LabelEncoder()
+        y_encoded = Lable_Enc.fit_transform(self.Y)
+        total_plots = len(self.num_col_name) 
+        cols = 3
+        rows = math.ceil(total_plots / cols)
+
+        fig_width = cols * 6
+        fig_height = rows * 6
+
+        fig, axes = plt.subplots(
+            nrows=rows,
+            ncols=cols,
+            figsize=(fig_width, fig_height),
+            # constrained_layout=True
+        )
+        row,col=0,0
+        classes=np.unique(y_encoded)
+        colors = sns.color_palette("Set1", n_colors=len(classes))
+
+        for i in self.numericaldf.columns:
+            for j, color in zip(classes, colors):
+                sns.kdeplot(
+                self.X.loc[y_encoded == j, i],
+                color=color,
+                label=f'{Lable_Enc.inverse_transform([j])[0]} class',
+                ax=axes[row,col],
+                fill=True
+                )
+
+            axes[row, col].legend()
+            col=col+1
+            if(col==3):
+                row+=1
+            col=(col)%cols
+
+        plt.tight_layout(w_pad=2)
+        plt.show()
+
+
+

ml_classify-0.1.0/ML_Classify/Model.py

@@ -0,0 +1,832 @@
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from sklearn.pipeline import Pipeline,make_pipeline
+from sklearn.compose import ColumnTransformer
+from sklearn.impute import SimpleImputer
+from sklearn.model_selection import train_test_split
+from imblearn.over_sampling import SMOTENC
+from imblearn.under_sampling import RandomUnderSampler
+from sklearn.datasets import load_breast_cancer
+from imblearn.over_sampling import SMOTEN
+
+
+from sklearn.preprocessing import LabelEncoder
+from sklearn.preprocessing import label_binarize
+from sklearn.multiclass import OneVsRestClassifier, OneVsOneClassifier, OutputCodeClassifier
+
+from sklearn.model_selection import GridSearchCV
+from sklearn.model_selection import StratifiedKFold, cross_val_score
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.svm import SVC
+import random
+
+from .EDA import EDA
+from sklearn.metrics import (
+    accuracy_score,
+    recall_score,
+    precision_score,
+    f1_score,
+    roc_auc_score,
+    confusion_matrix
+)
+from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
+# from abc import ABC, abstractclassmethod
+
+class PyClassify():
+    def __init__(self,X,y,numcol,catcol):
+        self.X = X
+        self.y = y
+        self.numcol = numcol
+        self.catcol = catcol
+        self.simulation_result_n={}
+        self.simulation_result_one={}
+        self.data_sim_one={}
+        self.data_sim_n={}
+        self.validate_and_assign_columns()
+    
+    def validate_and_assign_columns(self):
+        numeric_cols=[]
+        cat_cols=[]
+        for Num,Cat,Col in zip(self.numcol,self.catcol,self.X.columns.tolist()):
+            if(Num==1 and Cat==1):
+                raise Exception("Column could not be both cat and num.")
+
+            if(Num==1):
+                numeric_cols.append(Col)
+            elif(Cat==1):
+                cat_cols.append(Col)
+            else:
+                raise Exception("A column has to be cat/numeric.")
+        self.numcol=numeric_cols
+        self.catcol=cat_cols
+    
+       
+    def preprocess(self, EncodeCat=False,EncodeLabel=False,seed=42,sampling=2):
+        
+        '''
+        other logic would be apply one hot and std scaler the in last apply smote
+        then it would have 1 final pipline 
+        
+        '''
+
+        '''
+        Docstring for preprocess
+        
+        :param EncodeCat: by default false
+        :param EncodeLabel: by default false
+        :param seed: 
+        :param sampling: 0 for no sampling, 1 for undersampling, 2 for oversampling
+        '''
+        
+        # label encoding
+        if EncodeLabel:
+            self.label_encoder = LabelEncoder()
+            y_encoded = self.label_encoder.fit_transform(self.y)
+        else:
+            y_encoded = self.y
+        
+        X_train,X_test,y_train,y_test=train_test_split(self.X,y_encoded,random_state=seed,test_size=0.3, stratify=y_encoded)
+
+        
+        # standardization
+        numeric_pipeline = Pipeline(steps=[
+            ("imputer", SimpleImputer(strategy="mean")),
+            ("scaler", StandardScaler())
+        ])
+        # numeric_processor = make_pipeline(
+        #     SimpleImputer(strategy="mean"),
+        #     StandardScaler()
+        #     )
+        
+        scale_transformer = ColumnTransformer(
+            transformers=[
+            ("num", numeric_pipeline, self.numcol)
+            ],
+            remainder="passthrough"   # keep categorical untouched
+            )
+        
+        X_train_scaled = scale_transformer.fit_transform(X_train)
+        X_test_scaled  = scale_transformer.transform(X_test)
+        
+        # smotenc
+        original_cols = list(self.X.columns)
+        remainder_cols = [col for col in original_cols if col not in self.numcol]
+
+        cat_indices = [
+            len(self.numcol) + remainder_cols.index(cat_col)
+            for cat_col in self.catcol
+        ]
+
+        if sampling==0:
+            
+            X_train_res,y_train_res=X_train_scaled,y_train
+            
+        elif sampling==1:
+
+            rus = RandomUnderSampler(sampling_strategy='majority')
+            X_train_res, y_train_res = rus.fit_resample(X_train_scaled, y_train)
+            
+        elif sampling==2:
+            if (1 in self.numcol):
+                
+                smote = SMOTENC(
+                    categorical_features=cat_indices
+                    )
+                X_train_res, y_train_res = smote.fit_resample(
+                    X_train_scaled, y_train)
+            else:
+                smote = SMOTEN(random_state=42)
+
+                X_train_res, y_train_res = smote.fit_resample(
+                    X_train_scaled, y_train
+                )
+        else:
+            raise ValueError("invalid sampling input")
+        
+        
+        print('After Sampling train_X: {}'.format(X_train_res.shape))
+        print('After Sampling train_y: {} \n'.format(y_train_res.shape))
+
+        
+        # numeric_processor=Pipeline(
+        #     steps=[("imputation_mean",SimpleImputer(missing_values=np.nan,strategy="mean")),
+        #            ("scaler",StandardScaler())]
+        # )
+
+        
+        
+        
+        # one hot 
+        cat_processor=make_pipeline(
+            OneHotEncoder(handle_unknown="ignore")            
+        )
+        cat_transformer = cat_processor if EncodeCat else "passthrough"
+        
+        Cat_transformation= ColumnTransformer([
+            ('cat', cat_transformer, cat_indices)],
+            remainder='passthrough')
+        
+        x_train_final = Cat_transformation.fit_transform(X_train_res)
+        x_test_final  = Cat_transformation.transform(X_test_scaled)
+        
+        return x_train_final,x_test_final,y_train_res,y_test
+    
+    
+
+
+
+class Binclassification:
+    def __init__(self,X,y,numcol,catcol):
+        self.X = X
+        self.y = y
+        self.numcol_onehot=numcol
+        self.catcol_onehot=catcol
+        self.numcol = numcol
+        self.catcol = catcol
+        self.simulation_result_n={}
+        self.simulation_result_one={}
+        self.data_sim_one={}
+        self.data_sim_n={}
+        self.validate_and_assign_columns()
+        
+        
+    def validate_and_assign_columns(self):
+        numeric_cols=[]
+        cat_cols=[]
+        for Num,Cat,Col in zip(self.numcol,self.catcol,self.X.columns.tolist()):
+            if(Num==1 and Cat==1):
+                raise Exception("Column could not be both cat and num.")
+
+            if(Num==1):
+                numeric_cols.append(Col)
+            elif(Cat==1):
+                cat_cols.append(Col)
+            else:
+                raise Exception("A column has to be cat/numeric.")
+        self.numcol=numeric_cols
+        self.catcol=cat_cols
+    
+    def EDA(self):
+        EDAobject= EDA(X=self.X,y=self.y, numcol=self.numcol_onehot,catcol=self.catcol_onehot )
+        EDAobject.PlotGraphs()
+    
+    
+    def preprocess(self, EncodeCat=False,EncodeLabel=False,seed=42,sampling=2):
+        
+        '''
+        other logic would be apply one hot and std scaler the in last apply smote
+        then it would have 1 final pipline 
+        
+        '''
+
+        '''
+        Docstring for preprocess
+        
+        :param EncodeCat: by default false
+        :param EncodeLabel: by default false
+        :param seed: 
+        :param sampling: 0 for no sampling, 1 for undersampling, 2 for oversampling
+        '''
+        
+        # label encoding
+        if EncodeLabel:
+            self.label_encoder = LabelEncoder()
+            y_encoded = self.label_encoder.fit_transform(self.y)
+        else:
+            y_encoded = self.y
+        
+        X_train,X_test,y_train,y_test=train_test_split(self.X,y_encoded,random_state=seed,test_size=0.3, stratify=y_encoded)
+
+        
+        # standardization
+        numeric_pipeline = Pipeline(steps=[
+            ("imputer", SimpleImputer(strategy="mean")),
+            ("scaler", StandardScaler())
+        ])
+        # numeric_processor = make_pipeline(
+        #     SimpleImputer(strategy="mean"),
+        #     StandardScaler()
+        #     )
+        
+        scale_transformer = ColumnTransformer(
+            transformers=[
+            ("num", numeric_pipeline, self.numcol)
+            ],
+            remainder="passthrough"   # keep categorical untouched
+            )
+        
+        X_train_scaled = scale_transformer.fit_transform(X_train)
+        X_test_scaled  = scale_transformer.transform(X_test)
+        
+        # smotenc
+        original_cols = list(self.X.columns)
+        remainder_cols = [col for col in original_cols if col not in self.numcol]
+
+        cat_indices = [
+            len(self.numcol) + remainder_cols.index(cat_col)
+            for cat_col in self.catcol
+        ]
+
+        if sampling==0:
+            
+            X_train_res,y_train_res=X_train_scaled,y_train
+            
+        elif sampling==1:
+
+            rus = RandomUnderSampler(sampling_strategy='majority')
+            X_train_res, y_train_res = rus.fit_resample(X_train_scaled, y_train)
+            
+        elif sampling==2:
+            if (1 in self.numcol):
+                
+                smote = SMOTENC(
+                    categorical_features=cat_indices
+                    )
+                X_train_res, y_train_res = smote.fit_resample(
+                    X_train_scaled, y_train)
+            else:
+                smote = SMOTEN(random_state=42)
+
+                X_train_res, y_train_res = smote.fit_resample(
+                    X_train_scaled, y_train
+                )
+        else:
+            raise ValueError("invalid sampling input")
+        
+        
+        print('After Sampling train_X: {}'.format(X_train_res.shape))
+        print('After Sampling train_y: {} \n'.format(y_train_res.shape))
+
+        
+        # numeric_processor=Pipeline(
+        #     steps=[("imputation_mean",SimpleImputer(missing_values=np.nan,strategy="mean")),
+        #            ("scaler",StandardScaler())]
+        # )
+
+        
+        
+        
+        # one hot 
+        cat_processor=make_pipeline(
+            OneHotEncoder(handle_unknown="ignore")            
+        )
+        cat_transformer = cat_processor if EncodeCat else "passthrough"
+        
+        Cat_transformation= ColumnTransformer([
+            ('cat', cat_transformer, cat_indices)],
+            remainder='passthrough')
+        
+        x_train_final = Cat_transformation.fit_transform(X_train_res)
+        x_test_final  = Cat_transformation.transform(X_test_scaled)
+        
+        return x_train_final,x_test_final,y_train_res,y_test
+    
+    
+    
+    def _run_simulation(self, EncodeCat, EncodeLabel, seed, sampling):
+            X_train, X_test, y_train, y_test = self.preprocess(EncodeCat,EncodeLabel,seed,sampling)
+            
+            results = {}
+
+            models = {
+                "LogisticRegression": (
+                    LogisticRegression(max_iter=5000),
+                    {
+                        'C': np.logspace(-4, 4, 20),
+                        "penalty": ["l1", "l2"],
+                        "solver": ["liblinear"]
+                    }
+                ),
+                "SVC": (
+                    SVC(probability=True,max_iter=1000),
+                    {
+                        'C': [0.1, 1, 10],
+                        'gamma': [0.01, 0.1, 1],
+                        'kernel': ['linear',"rbf"]
+                    }
+                ),
+                "DecisionTree": (
+                    DecisionTreeClassifier(),
+                    {
+                        'max_depth': range(1, 15),
+                        'min_samples_leaf': range(1, 20, 2),
+                        'min_samples_split': range(2, 20, 2),
+                        'criterion': ["entropy", "gini"]
+                    }
+                ),
+                "RandomForest": (
+                    RandomForestClassifier(),
+                    {
+                        'n_estimators': [100, 200, 300],
+                        'max_depth': [None, 5, 10, 20],
+                        'min_samples_split': [2, 5, 10],
+                        'min_samples_leaf': [1, 2, 4]
+                    }
+                ),
+                "AdaBoost": (
+                    AdaBoostClassifier(),
+                    {
+                        'n_estimators': [50, 100, 200],
+                        'learning_rate': [0.01, 0.1, 1]
+                    }
+                ),
+            }
+            
+
+            for name, (model, params) in models.items():
+                print("inside the loop 1")
+
+                grid = GridSearchCV(
+                    estimator=model,
+                    param_grid=params,
+                    cv=StratifiedKFold(10),
+                    scoring='accuracy',
+                    n_jobs=-1,
+                    verbose=True
+                )
+
+                grid.fit(X_train, y_train)
+
+                best_model = grid.best_estimator_
+
+                y_pred = best_model.predict(X_test)
+
+                if hasattr(best_model, "predict_proba"):
+                    y_prob = best_model.predict_proba(X_test)[:, 1]
+                else:
+                    y_prob = best_model.decision_function(X_test)
+
+                acc = accuracy_score(y_test, y_pred)
+                sensitivity = recall_score(y_test, y_pred)
+                precision = precision_score(y_test, y_pred)
+                f1 = f1_score(y_test, y_pred)
+                auc = roc_auc_score(y_test, y_prob)
+
+                tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel()
+                specificity = tn / (tn + fp)
+
+                results[name] = {
+                    "best_estimator": grid.best_estimator_,
+                    "best_score": grid.best_score_,
+                    "best_params": grid.best_params_,
+                    "test_result": {
+                        "Accuracy": acc,
+                        "Sensitivity": sensitivity,
+                        "Specificity": specificity,
+                        "Precision": precision,
+                        "F1-score": f1,
+                        "AUC": auc
+                    }
+                }
+                
+            data = {
+            "X_train":X_train,
+            "X_test":X_test,
+            "y_train":y_train,
+            "y_test":y_test
+            }
+
+            return data, results
+
+
+    def simulate_one(self, EncodeCat=False, EncodeLabel=False, seed=42, sampling=2):
+
+        data, results = self._run_simulation(
+            EncodeCat, EncodeLabel, seed, sampling
+        )
+
+        self.data_sim_one[f"seed {seed}"] = data
+        self.simulation_result_one[f"seed {seed}"] = results
+
+        # return results
+        
+            
+
+
+    
+    def simulate_ntimes(self, n=5, EncodeCat=False, EncodeLabel=False, sampling=2):
+
+        seeds = random.sample(range(1, 101), n)
+
+        for seed in seeds:
+
+            data, results = self._run_simulation(
+                EncodeCat, EncodeLabel, seed, sampling
+            )
+
+            self.data_sim_n[f"seed {seed}"] = data
+            self.simulation_result_n[f"seed {seed}"] = results
+
+        # return self.simulation_result_n
+
+    # def preprocess(self, EncodeCat=False,EncodeLabel=False,seed=42,sampling=2):
+
+    #     '''
+    #     Docstring for preprocess
+        
+    #     :param EncodeCat: by default false
+    #     :param EncodeLabel: by default false
+    #     :param seed: 
+    #     :param sampling: 0 for no sampling, 1 for undersampling, 2 for oversampling
+    #     '''
+        
+        
+        
+    #     X_train,X_test,y_train,y_test=train_test_split(self.X,self.y,random_state=seed,test_size=0.3, stratify=self.y)
+        
+    #     numeric_pipeline = Pipeline(steps=[
+    #         ("imputer", SimpleImputer(strategy="mean")),
+    #         ("scaler", StandardScaler())
+    #     ])
+    #     # numeric_processor = make_pipeline(
+    #     #     SimpleImputer(strategy="mean"),
+    #     #     StandardScaler()
+    #     #     )
+    #     scale_transformer = ColumnTransformer(
+    #         transformers=[
+    #         ("num", numeric_pipeline, self.numcol)
+    #         ],
+    #         remainder="passthrough"   # keep categorical untouched
+    #         )
+        
+    #     X_train_scaled = scale_transformer.fit_transform(X_train)
+    #     X_test_scaled  = scale_transformer.transform(X_test)
+
+    #     if sampling==0:
+            
+    #         X_train_res,y_train_res=X_train,y_train
+            
+    #     if sampling==1:
+            
+    #         rus = RandomUnderSampler(sampling_strategy='majority')
+    #         X_train_res, y_train_res = rus.fit_resample(X_train_scaled, y_train)
+            
+    #     elif sampling==2:
+    #         cat_indices = self.X.columns.get_indexer(self.catcol)
+    #         smote = SMOTENC(
+    #             categorical_features=cat_indices
+    #             )
+    #         X_train_res, y_train_res = smote.fit_resample(
+    #             X_train_scaled, y_train)
+            
+    #     else:
+    #         raise "invalid sampling input"
+        
+        
+    #     print('After Sampling train_X: {}'.format(X_train_res.shape))
+    #     print('After Sampling train_y: {} \n'.format(y_train_res.shape))
+
+        
+    #     # numeric_processor=Pipeline(
+    #     #     steps=[("imputation_mean",SimpleImputer(missing_values=np.nan,strategy="mean")),
+    #     #            ("scaler",StandardScaler())]
+    #     # )
+
+        
+
+    #     cat_processor=make_pipeline(
+    #         OneHotEncoder(handle_unknown="ignore")            
+    #     )
+    #     cat_transformer = cat_processor if EncodeCat else "passthrough"
+        
+    #     Cat_transformation= ColumnTransformer([
+    #         ("num",numeric_pipeline,self.numcol)
+    #         ('cat', cat_transformer, self.catcol)])
+        
+    #     x_train_final = Cat_transformation.fit_transform(X_train_res)
+    #     x_test_final  = Cat_transformation.transform(X_test_scaled)
+    #     return x_train_final,x_test_final,y_train_res,y_test
+    
+from sklearn.multiclass import OneVsRestClassifier, OneVsOneClassifier
+from sklearn.metrics import classification_report
+from sklearn.preprocessing import label_binarize
+from sklearn.multiclass import OneVsRestClassifier, OneVsOneClassifier, OutputCodeClassifier
+from sklearn.svm import SVC
+
+class MulticlassClassification:
+    def __init__(self,X,y,numcol,catcol):
+        self.X = X
+        self.y = y
+        self.numcol_onehot=numcol
+        self.catcol_onehot=catcol
+        self.numcol = numcol
+        self.catcol = catcol
+        self.simulation_result_n={}
+        self.simulation_result_one={}
+        self.data_sim_one={}
+        self.data_sim_n={}
+        self.validate_and_assign_columns()
+        
+
+    def validate_and_assign_columns(self):
+        numeric_cols = []
+        cat_cols = []
+
+        for Num, Cat, Col in zip(self.numcol, self.catcol, self.X.columns.tolist()):
+            if Num == 1 and Cat == 1:
+                raise Exception("Column cannot be both categorical and numeric")
+
+            if Num == 1:
+                numeric_cols.append(Col)
+            elif Cat == 1:
+                cat_cols.append(Col)
+            else:
+                raise Exception("Column must be either numeric or categorical")
+
+        self.numcol = numeric_cols
+        self.catcol = cat_cols
+    
+    def preprocess(self, EncodeCat=False,EncodeLabel=False,seed=42,sampling=2):
+        
+        '''
+        other logic would be apply one hot and std scaler the in last apply smote
+        then it would have 1 final pipline 
+        
+        '''
+
+        '''
+        Docstring for preprocess
+        
+        :param EncodeCat: by default false
+        :param EncodeLabel: by default false
+        :param seed: 
+        :param sampling: 0 for no sampling, 1 for undersampling, 2 for oversampling
+        '''
+        
+        # label encoding
+        if EncodeLabel:
+            self.label_encoder = LabelEncoder()
+            y_encoded = self.label_encoder.fit_transform(self.y)
+        else:
+            y_encoded = self.y
+        
+        X_train,X_test,y_train,y_test=train_test_split(self.X,y_encoded,random_state=seed,test_size=0.3, stratify=y_encoded)
+
+        
+        # standardization
+        numeric_pipeline = Pipeline(steps=[
+            ("imputer", SimpleImputer(strategy="mean")),
+            ("scaler", StandardScaler())
+        ])
+        # numeric_processor = make_pipeline(
+        #     SimpleImputer(strategy="mean"),
+        #     StandardScaler()
+        #     )
+        
+        scale_transformer = ColumnTransformer(
+            transformers=[
+            ("num", numeric_pipeline, self.numcol)
+            ],
+            remainder="passthrough"   # keep categorical untouched
+            )
+        
+        X_train_scaled = scale_transformer.fit_transform(X_train)
+        X_test_scaled  = scale_transformer.transform(X_test)
+        
+        # smotenc
+        original_cols = list(self.X.columns)
+        remainder_cols = [col for col in original_cols if col not in self.numcol]
+
+        cat_indices = [
+            len(self.numcol) + remainder_cols.index(cat_col)
+            for cat_col in self.catcol
+        ]
+
+        if sampling==0:
+            
+            X_train_res,y_train_res=X_train_scaled,y_train
+            
+        elif sampling==1:
+
+            rus = RandomUnderSampler(sampling_strategy='majority')
+            X_train_res, y_train_res = rus.fit_resample(X_train_scaled, y_train)
+            
+        elif sampling==2:
+            if (1 in self.numcol):
+                
+                smote = SMOTENC(
+                    categorical_features=cat_indices
+                    )
+                X_train_res, y_train_res = smote.fit_resample(
+                    X_train_scaled, y_train)
+            else:
+                smote = SMOTEN(random_state=42)
+
+                X_train_res, y_train_res = smote.fit_resample(
+                    X_train_scaled, y_train
+                )
+        else:
+            raise ValueError("invalid sampling input")
+        
+        
+        print('After Sampling train_X: {}'.format(X_train_res.shape))
+        print('After Sampling train_y: {} \n'.format(y_train_res.shape))
+
+        
+        # numeric_processor=Pipeline(
+        #     steps=[("imputation_mean",SimpleImputer(missing_values=np.nan,strategy="mean")),
+        #            ("scaler",StandardScaler())]
+        # )
+
+        
+        
+        
+        # one hot 
+        cat_processor=make_pipeline(
+            OneHotEncoder(handle_unknown="ignore")            
+        )
+        cat_transformer = cat_processor if EncodeCat else "passthrough"
+        
+        Cat_transformation= ColumnTransformer([
+            ('cat', cat_transformer, cat_indices)],
+            remainder='passthrough')
+        
+        x_train_final = Cat_transformation.fit_transform(X_train_res)
+        x_test_final  = Cat_transformation.transform(X_test_scaled)
+        
+        return x_train_final,x_test_final,y_train_res,y_test
+    
+    
+    def EDA(self):
+        EDAobject= EDA(X=self.X,y=self.y, numcol=self.numcol_onehot,catcol=self.catcol_onehot )
+        EDAobject.PlotGraphs()
+    
+    def _run_simulation(self, EncodeCat, EncodeLabel, seed, sampling):
+        
+        X_train, X_test, y_train, y_test = self.preprocess(
+            EncodeCat, EncodeLabel, seed, sampling
+        )
+
+        results = {}
+        models={
+            "LogisticRegression_OvR": (
+                OneVsRestClassifier(LogisticRegression(max_iter=5000)),
+                {
+                    "estimator__C": np.logspace(-4, 4, 10)
+                }
+            ),
+
+            "SVC_OvR": (
+                OneVsRestClassifier(SVC(probability=True)),
+                {
+                    "estimator__C": [0.1, 1, 10],
+                    "estimator__gamma": [0.01, 0.1],
+                    "estimator__kernel": ["linear", "rbf"]
+                }
+            ),
+
+            "SVC_OvO": (
+                OneVsOneClassifier(SVC(probability=True)),
+                {
+                    "estimator__C": [0.1, 1, 10],
+                    "estimator__gamma": [0.01, 0.1],
+                    "estimator__kernel": ["linear", "rbf"]
+                }
+            ),
+
+            "SVC_ECOC": (
+                OutputCodeClassifier(SVC(probability=True)),
+                {
+                    "estimator__C": [0.1, 1, 10],
+                    "estimator__gamma": [0.01, 0.1],
+                    "estimator__kernel": ["linear", "rbf"],
+                    "code_size": [1.5, 2]
+                }
+            ),
+
+        }
+
+        for name, (model, params) in models.items():
+            print(f"Training {name}...")
+
+            grid = GridSearchCV(
+                estimator=model,
+                param_grid=params,
+                cv=StratifiedKFold(10),
+                scoring='accuracy',
+                n_jobs=-1,
+                verbose=1
+            )
+
+            grid.fit(X_train, y_train)
+            best_model = grid.best_estimator_
+
+            y_pred = best_model.predict(X_test)
+            # if hasattr(best_model, "predict_proba"):
+            #     y_prob = best_model.predict_proba(X_test)
+
+            # elif hasattr(best_model, "decision_function"):
+            #     y_prob = best_model.decision_function(X_test)
+
+            # else:
+            #     y_prob = best_model.predict(X_test)
+
+
+            acc = accuracy_score(y_test, y_pred)
+            recall = recall_score(y_test, y_pred, average="macro")
+            precision = precision_score(y_test, y_pred, average="macro")
+            f1 = f1_score(y_test, y_pred, average="macro")
+
+            classes = np.unique(y_train)
+            # y_test_bin = label_binarize(y_test, classes=classes)
+
+            # auc = roc_auc_score(
+            #     y_test_bin,
+            #     y_prob,
+            #     multi_class="ovr",
+            #     average="macro"
+            # )
+
+            cm = confusion_matrix(y_test, y_pred)
+
+            results[name] = {
+                "best_estimator": best_model,
+                "best_score": grid.best_score_,
+                "best_params": grid.best_params_,
+                "test_result": {
+                    "Accuracy": acc,
+                    "Recall (Macro)": recall,
+                    "Precision (Macro)": precision,
+                    "F1-score (Macro)": f1,
+                    # "AUC (OvR Macro)": auc,
+                    "ConfusionMatrix": cm
+                }
+            }
+
+        data = {
+            "X_train": X_train,
+            "X_test": X_test,
+            "y_train": y_train,
+            "y_test": y_test
+        }
+
+        return data, results
+    
+    def simulate_one(self, EncodeCat=True, EncodeLabel=True, seed=42, sampling=2):
+
+        data, results = self._run_simulation(
+                EncodeCat, EncodeLabel, seed, sampling
+        )
+
+        self.data_sim_one[f"seed {seed}"] = data
+        self.simulation_result_one[f"seed {seed}"] = results
+
+            
+            
+
+
+    
+    def simulate_ntimes(self, n=5, EncodeCat=True, EncodeLabel=True, sampling=2):
+
+        seeds = random.sample(range(1, 101), n)
+
+        for seed in seeds:
+
+            data, results = self._run_simulation(
+                EncodeCat, EncodeLabel, seed, sampling
+            )
+
+            self.data_sim_n[f"seed {seed}"] = data
+            self.simulation_result_n[f"seed {seed}"] = results

ml_classify-0.1.0/ML_Classify/__init__.py

@@ -0,0 +1,2 @@
+from .Model import PyClassify, Binclassification, MulticlassClassification  
+from .EDA import EDA

ml_classify-0.1.0/ML_Classify.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: ML_Classify
+Version: 0.1.0
+Summary: My Python package ml classify lib
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: imbalanced-learn
+Requires-Dist: imblearn
+Requires-Dist: matplotlib
+Requires-Dist: seaborn
+
+# My Package
+
+My Python package containing machine learning models and EDA utilities.
+
+## Installation
+
+```bash
+pip install ML_Classify

ml_classify-0.1.0/ML_Classify.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+ML_Classify/EDA.py
+ML_Classify/Model.py
+ML_Classify/__init__.py
+ML_Classify.egg-info/PKG-INFO
+ML_Classify.egg-info/SOURCES.txt
+ML_Classify.egg-info/dependency_links.txt
+ML_Classify.egg-info/requires.txt
+ML_Classify.egg-info/top_level.txt

ml_classify-0.1.0/ML_Classify.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ml_classify-0.1.0/ML_Classify.egg-info/requires.txt

@@ -0,0 +1,7 @@
+numpy
+pandas
+scikit-learn
+imbalanced-learn
+imblearn
+matplotlib
+seaborn

ml_classify-0.1.0/ML_Classify.egg-info/top_level.txt

@@ -0,0 +1 @@
+ML_Classify

ml_classify-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: ML_Classify
+Version: 0.1.0
+Summary: My Python package ml classify lib
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: imbalanced-learn
+Requires-Dist: imblearn
+Requires-Dist: matplotlib
+Requires-Dist: seaborn
+
+# My Package
+
+My Python package containing machine learning models and EDA utilities.
+
+## Installation
+
+```bash
+pip install ML_Classify

ml_classify-0.1.0/README.md

@@ -0,0 +1,8 @@
+# My Package
+
+My Python package containing machine learning models and EDA utilities.
+
+## Installation
+
+```bash
+pip install ML_Classify

ml_classify-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ML_Classify"
+version = "0.1.0"
+description = "My Python package ml classify lib"
+readme = "README.md"
+requires-python = ">=3.9"
+
+dependencies = [
+    "numpy",
+    "pandas",
+    "scikit-learn",
+    "imbalanced-learn",
+    "imblearn",
+    "matplotlib",
+    "seaborn",
+]

ml_classify-0.1.0/setup.cfg

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