JustDataML 0.0.26__py3-none-any.whl

JDML/source/Pipeline/Train_Pipeline.py

@@ -0,0 +1,49 @@
+
+import sys
+
+
+from ...source.Logger import logging
+from ...source.Exception import CustomException
+
+
+from ...source.components.Data_ingestion import DataIngestion
+from ...source.components.Data_Transformation import Data_Transformation
+from ...source.components.Model_Trainer import ModelTrainer
+
+
+
+class TrainingPipeline:
+
+    """
+    This is a Training Pipeline to Train the Given Model and 
+    Combining all the Fuctions of this tool and do help us to get the best model for prediction
+    
+    """
+
+    def __init__(self, features_cols, data_df, target_col, models, hyperparameter_yes_or_no, problem_objective,normalization_tech):
+        self.Features_Cols = features_cols
+        self.Data_df = data_df
+        self.Target_Col = target_col
+        self.Models = models
+        self.HyperParamter_Yes_or_No = hyperparameter_yes_or_no
+        self.Problem_Objective = problem_objective
+        self.Normalization_tech = normalization_tech
+    def Train_Model(self):
+        try:
+            obj = DataIngestion()
+            train_data,test_data = obj.initate_data_ingestion(self.Data_df)
+            logging.info("Data Splitting is Successful")
+
+            data_transformation =  Data_Transformation(self.Features_Cols,self.Data_df,self.Target_Col,self.Problem_Objective,self.Normalization_tech)
+            train_arr,test_arr,_ = data_transformation.initiate_data_tranformation(train_path=train_data,test_path=test_data)
+            logging.info("Data Transformation Done Successfully")
+
+            model_trainer = ModelTrainer(self.Models, self.HyperParamter_Yes_or_No, self.Problem_Objective)
+            logging.info("Data Training is Successful")
+            logging.info("Model exported  Successfully")
+            print("Best Model Score is : ",model_trainer.initiate_model_trainer(train_array=train_arr,test_array=test_arr))
+           
+
+        except Exception as e:
+            raise CustomException(e,sys)
+        

JDML/source/Utils.py

@@ -0,0 +1,356 @@
+import os
+import sys
+import csv
+import json
+import pickle
+import pandas as pd
+
+from ..source.Exception import CustomException
+#from source.Configuration import Problem_Objective
+
+
+from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score, explained_variance_score, median_absolute_error
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix
+
+from sklearn.model_selection import GridSearchCV
+from sklearn.preprocessing import StandardScaler,MinMaxScaler,RobustScaler,MaxAbsScaler 
+
+from sklearn.ensemble import (
+    AdaBoostRegressor,AdaBoostClassifier,
+    GradientBoostingRegressor,GradientBoostingClassifier,
+    RandomForestRegressor,RandomForestClassifier
+)
+from sklearn.linear_model import LinearRegression, LogisticRegression, Ridge, RidgeClassifier, Lasso, ElasticNet
+from sklearn.neighbors import KNeighborsRegressor, KNeighborsClassifier
+from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier
+from sklearn.svm import SVC, SVR
+from sklearn.naive_bayes import GaussianNB
+from xgboost import XGBRegressor, XGBClassifier
+#from catboost import CatBoostRegressor, CatBoostClassifier
+
+
+regressor_models = {
+                "Random Forest": RandomForestRegressor(n_jobs=-1),
+                "Decision Tree": DecisionTreeRegressor(),
+                "Gradient Boosting": GradientBoostingRegressor(),
+                "Linear Regression": LinearRegression(n_jobs=-1),
+                "XGBRegressor": XGBRegressor(n_jobs=-1),
+                "Support Vector Reg" : SVR(),
+                "Linear Ridge" : Ridge(),
+                "Linear Lasso" : Lasso(),
+                "ElasticNet" : ElasticNet(),
+                #"CatBoosting Regressor": CatBoostRegressor(verbose=False),
+                "AdaBoost Regressor": AdaBoostRegressor(),
+                "KNeighborsRegressor": KNeighborsRegressor(n_jobs=-1)
+            }
+
+
+classfication_models = {
+    "Logistic Regression": LogisticRegression(multi_class='ovr',n_jobs=-1),
+    "Ridge Classifcaiton": RidgeClassifier(),
+    "GaussianNB": GaussianNB(),
+    "KNeighborsClassifier": KNeighborsClassifier(n_jobs=-1),
+    "Decision Tree Classifier":DecisionTreeClassifier(),
+    "Random Forest Classifier": RandomForestClassifier(n_jobs=-1),
+    "Support Vector Classifier": SVC(),
+    "AdaBoost Classifier": AdaBoostClassifier(),
+    "Gradient Boosting Classifier": GradientBoostingClassifier(),
+    "XGBClassifier": XGBClassifier(n_jobs=-1)
+            }
+
+
+
+parameters_regressor= {
+                "Decision Tree": {
+                    'criterion':['squared_error', 'friedman_mse', 'absolute_error', 'poisson'],
+                    # 'splitter':['best','random'],
+                    # 'max_features':['sqrt','log2'],
+                },
+                "Random Forest":{
+                    # 'criterion':['squared_error', 'friedman_mse', 'absolute_error', 'poisson'],
+                 
+                    # 'max_features':['sqrt','log2',None],
+                    'n_estimators': [8,16,32,64,128,256]
+                },
+                "Gradient Boosting":{
+                    # 'loss':['squared_error', 'huber', 'absolute_error', 'quantile'],
+                    'learning_rate':[.1,.01,.05,.001],
+                    'subsample':[0.6,0.7,0.75,0.8,0.85,0.9],
+                    # 'criterion':['squared_error', 'friedman_mse'],
+                    # 'max_features':['auto','sqrt','log2'],
+                    'n_estimators': [8,16,32,64,128,256]
+                },
+                "Linear Regression":{},
+                "XGBRegressor":{
+                    'learning_rate':[.1,.01,.05,.001],
+                    'n_estimators': [8,16,32,64,128,256]
+                },
+                "Support Vector Reg":{
+                    'C':[0.1,1,10],
+                    'kernel': ['linear', 'rbf', 'poly']
+                },
+                "Linear Ridge":{
+                    'alpha': [0.1, 1, 10]
+                },
+                "Linear Lasso":{
+                    'alpha': [0.1, 1, 10]
+                },
+                "ElasticNet":{
+                    'alpha': [0.1, 1, 10],
+                    'l1_ratio': [0.1, 0.5, 0.9]
+                },
+
+                #"CatBoosting Regressor":{
+                #    'depth': [6,8,10],
+                #    'learning_rate': [0.01, 0.05, 0.1],
+                #    'iterations': [30, 50, 100]
+                #},
+                "AdaBoost Regressor":{
+                    'learning_rate':[.1,.01,0.5,.001],
+                    # 'loss':['linear','square','exponential'],
+                    'n_estimators': [8,16,32,64,128,256]
+                },
+
+                "KNeighborsRegressor": {
+                    'n_neighbors': [3, 5, 7, 9, 11],
+                    'weights': ['uniform', 'distance'],
+                    #'algorithm': ['auto', 'ball_tree', 'kd_tree', 'brute'],
+                    #'leaf_size': [10, 20, 30, 40, 50],
+                    'p': [1, 2],
+                    'metric': ['minkowski']
+                }
+
+            }
+
+
+parameters_classifier = {
+                "Logistic Regression": {
+                    'C': [0.001, 0.01, 0.1, 1, 10, 100],
+                },
+
+                "Ridge Classifcaiton": {
+                    'alpha': [0.1, 1, 10]
+                },
+
+                "GaussianNB": {},
+
+                "KNeighborsClassifier": {
+                    'n_neighbors': [3, 5, 7],
+                    #'weights': ['uniform', 'distance'],
+                    'algorithm': ['auto', 'ball_tree', 'kd_tree', 'brute']
+                },
+
+                "Decision Tree Classifier":{
+                    'max_depth': [None, 10, 20, 30],
+                    #'min_samples_split': [2, 5, 10],
+                    #'min_samples_leaf': [1, 2, 4]
+                },
+
+                "Random Forest Classifier":{
+                    'n_estimators': [100, 200, 300],
+                    #'max_features': ['auto', 'sqrt', 'log2'],
+                    'max_depth': [None, 10, 20, 30],
+                    #'min_samples_split': [2, 5, 10],
+                    #'min_samples_leaf': [1, 2, 4],
+                    #'bootstrap': [True, False]
+                },
+
+                "Support Vector Classifier":{
+                    'C': [0.1, 1, 10],
+                    'kernel': ['linear', 'poly', 'rbf', 'sigmoid'],
+                    'gamma': ['scale', 'auto']
+                },
+
+                "AdaBoost Classifier":{
+                    'n_estimators': [50, 100, 200],
+                    'learning_rate': [0.01, 0.1, 1.0]
+                },
+
+                "Gradient Boosting Classifier": {
+                    'n_estimators': [50, 100, 200],
+                    #'learning_rate': [0.01, 0.1, 1.0],
+                    'max_depth': [3, 5, 7]
+                },
+
+                "XGBClassifier": {
+                    'n_estimators': [50, 100, 200],
+                    #'learning_rate': [0.01, 0.1, 1.0],
+                    'max_depth': [3, 5, 7],
+                    'gamma': [0, 0.1, 0.2],
+                    #'subsample': [0.8, 1.0],
+                    #'colsample_bytree': [0.8, 1.0]
+                }
+            }
+
+
+
+Normalization_method = {
+    "StandardScaler":StandardScaler(),
+    "MinMaxScaler":MinMaxScaler(),
+    "RobustScaler":RobustScaler(),
+    "MaxAbsScaler":MaxAbsScaler()
+
+}
+
+
+
+def save_object(file_path,obj):
+    try:
+        dir_path = os.path.dirname(file_path)
+        os.makedirs(dir_path,exist_ok=True)
+
+        with open(file_path,"wb") as file_obj:
+            pickle.dump(obj,file_obj)
+        #logging.info(f"{file_obj} is saved")
+
+    except Exception as e:
+        raise CustomException(e,sys)
+    
+
+def evaluate_model(X_train,y_train,X_test,y_test,models,param,prob):
+    try:
+        
+        report = {}
+        report_df = pd.DataFrame()
+        model_summary = pd.DataFrame()
+        for model_name, model in models.items():
+            #model = list(models.values())[i]
+            #print(model_name)
+            if prob == "Regression":
+                para = parameters_regressor[model_name]
+            elif prob == "Classification":
+                para = parameters_classifier[model_name]
+            #print(para)
+            else:
+                print("Problem Objective is not Properly Defined")
+            if param == "Yes":
+                gs = GridSearchCV(model,para,cv=3,n_jobs=-1)
+                gs.fit(X_train,y_train)
+                result_out = gs.cv_results_
+                result_out_df = pd.DataFrame(result_out)
+                result_out_df["Model"] = model_name
+                report_df = pd.concat([report_df, result_out_df]) 
+                report_df.to_csv(os.path.join("Output","Hyperparameter_stats.csv"), index=False)
+                model.set_params(**gs.best_params_)
+                model.fit(X_train,y_train)
+            else:
+                model.fit(X_train, y_train)
+
+            y_train_pred = model.predict(X_train)
+            y_test_pred = model.predict(X_test)
+
+            #train_model_score = r2_score(y_train,y_train_pred)
+
+            # For Evaluation of our Model for reg we will use R-sq value and for clf we will use accuracy. for testing
+
+            if prob == 'Regression':
+                
+                mae_train = mean_absolute_error(y_train, y_train_pred)
+                mse_train = mean_squared_error(y_train, y_train_pred)
+                #rmse_train = mean_squared_error(y_train, y_train_pred, squared=False)
+                r2_train = r2_score(y_train, y_train_pred)
+                explained_var_train = explained_variance_score(y_train, y_train_pred)
+                med_abs_error_train = median_absolute_error(y_train, y_train_pred)
+
+                mae_test = mean_absolute_error(y_test, y_test_pred)
+                mse_test = mean_squared_error(y_test, y_test_pred)
+                #rmse_test = mean_squared_error(y_test, y_test_pred)
+                r2_test = r2_score(y_test, y_test_pred)
+                explained_var_test = explained_variance_score(y_test, y_test_pred)
+                med_abs_error_test = median_absolute_error(y_test, y_test_pred)
+                test_model_score = r2_test
+            # Construct DataFrame for metrics
+                model_metrics = pd.DataFrame({
+                'Model': [model_name],
+                'MAE_train': [mae_train],
+                'MSE_train': [mse_train],
+                #'RMSE_train': [rmse_train],
+                'R2_train': [r2_train],
+                'Explained_Var_train': [explained_var_train],
+                'Med_Abs_Error_train': [med_abs_error_train],
+                'MAE_test': [mae_test],
+                'MSE_test': [mse_test],
+                #'RMSE_test': [rmse_test],
+                'R2_test': [r2_test],
+                'Explained_Var_test': [explained_var_test],
+                'Med_Abs_Error_test': [med_abs_error_test]
+                })
+
+
+            elif prob == 'Classification':
+                # Compute classification metrics
+                accuracy_train = accuracy_score(y_train, y_train_pred)
+                precision_train = precision_score(y_train, y_train_pred, average='weighted')
+                recall_train = recall_score(y_train, y_train_pred, average='weighted')
+                f1_train = f1_score(y_train, y_train_pred, average='weighted')
+
+                accuracy_test = accuracy_score(y_test, y_test_pred)
+                precision_test = precision_score(y_test, y_test_pred, average='weighted')
+                recall_test = recall_score(y_test, y_test_pred, average='weighted')
+                f1_test = f1_score(y_test, y_test_pred, average='weighted')
+                test_model_score = accuracy_test
+
+                # Confusion Matrix
+                conf_matrix = confusion_matrix(y_test, y_test_pred)
+
+
+                model_metrics = pd.DataFrame({
+                'Model': [model_name],
+                'Accuracy_train': [accuracy_train],
+                'Precision_train': [precision_train],
+                'Recall_train': [recall_train],
+                'F1_train': [f1_train],
+                'Accuracy_test': [accuracy_test],
+                'Precision_test': [precision_test],
+                'Recall_test': [recall_test],
+                'F1_test': [f1_test]
+            })
+
+
+            else:
+                print("Wrong Problem Objective")
+            
+            model_summary = pd.concat([model_summary, model_metrics])
+            model_summary.to_csv(os.path.join("Output","Model_Summary.csv"),index=False)
+            report[model_name] = test_model_score
+            print(f" Model : {model_name} ,  Test Scores : {test_model_score}")
+            
+            # print(report)
+        return report
+
+    except Exception as e:
+        raise CustomException(e,sys)
+    
+
+def load_object(file_path):
+    try:
+        with open(file_path,"rb") as file_obj:
+            return pickle.load(file_obj)
+    except Exception as e:
+        raise CustomException(e,sys)
+
+
+def ReadConfig(file_path):
+    try:
+        if not os.path.exists(file_path):
+            os.makedirs("Data",exist_ok=True)
+            raise FileNotFoundError("Data_Config.csv file not found. Please make sure it exists in the 'Data' folder.")
+        output_json = "".join([file_path.split(".")[0],".json"])
+        Config_Dict = {}
+        with open(file_path, 'r') as file:
+            reader = csv.reader(file)
+            for row in reader:
+                key = row[0]
+                values = [value for value in row[1:] if value]  # Exclude empty values
+                Config_Dict[key] = values
+        with open(output_json,'w') as json_file:
+            json.dump(Config_Dict,json_file,indent=4)
+
+        return Config_Dict
+    except Exception as e:
+        raise CustomException(e,sys)
+    
+
+
+
+

JDML/source/components/Data_Transformation.py

@@ -0,0 +1,161 @@
+from dataclasses import dataclass
+import sys
+import os
+import numpy as np 
+import pandas as pd
+from sklearn.compose import ColumnTransformer
+from sklearn.impute import SimpleImputer
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import OneHotEncoder , LabelEncoder
+
+from ...source.Exception import CustomException
+from ...source.Logger import logging
+from ...source.Utils import save_object
+
+
+
+@dataclass
+class Data_transformationConfig:
+
+    """
+    A DataClass Config for Data Tranformation it will save locations to save preprocessor pkl file
+    """
+
+    preprocessor_obj_file_path = os.path.join('artifact','prerocessor.pkl')
+    #DataConfig = ReadConfig("Data_Config.csv")
+
+class Data_Transformation:
+
+    """
+    This is a very Import Step in our Program to do Data Tranformation 
+    """
+
+#    def __init__(self):
+#        self.Data_transformationConfig=Data_transformationConfig()
+
+    def __init__(self, features_cols, data_df, target_col, problem_objective,normalization_tech):
+        self.Features_Cols = features_cols
+        self.Data_df = data_df
+        self.Target_Col = target_col
+        self.Problem_Objective = problem_objective
+        self.Data_transformationConfig=Data_transformationConfig()
+        self.Normalization_tech = normalization_tech
+
+
+
+    def get_data_transformer_object(self):
+        '''
+        This Function is Handling Data Tranformation 
+        Here it will Identify Categorical Columns and Numerical Columns and do some processing like
+        Imputing the missing values if there are any (Using Simple Imputer)
+        Standard Scaling for Numberical Cols and OneHot Encoding for Categorical Cols
+        If the Problem is Classification Problem then Target Col (Dependent Col) will be label encoded.
+
+        '''
+        try:
+
+            #All_Features = self.Data_transformationConfig.DataConfig["Features_Cols"]
+            All_Features = self.Features_Cols
+            numerical_columns = self.Data_df[All_Features].select_dtypes(exclude="object").columns   #To get Num Features
+            categorical_columns = self.Data_df[All_Features].select_dtypes(include="object").columns #To get Cat Features
+            num_pipeline = Pipeline(
+                steps=[
+                    ("imputer",SimpleImputer(strategy="median")),
+                    ("scaler",self.Normalization_tech)
+                ]
+            )
+            cat_pipeline = Pipeline(
+                steps=[
+                    ('imputer',SimpleImputer(strategy="most_frequent")),
+                    ("one hot encoder",OneHotEncoder())
+                ]
+            )
+            logging.info("Numerical and Categorical Columns Processed (Scaling and OneHotEncoding Done)")
+            logging.info(f"for Numerical Columns we will do scaling with {self.Normalization_tech} )")
+            logging.info(f"Categorical columns: {list(categorical_columns)}")
+            logging.info(f"Numerical columns: {list(numerical_columns)}")
+
+            preprocessor = ColumnTransformer(
+                [
+                    ("Num_pipeline",num_pipeline,numerical_columns),
+                    ("Cat_pipeline",cat_pipeline,categorical_columns)
+                ]
+            )
+
+            return preprocessor
+        
+        
+        except Exception as e:
+            raise CustomException(e,sys)
+        
+
+    def initiate_data_tranformation(self,train_path,test_path):
+
+        """
+        Here we will do the Data Tranformation using above Pipeline tools. 
+        Reading DataFrames (train test both)... Spliting it into Features and Targets... and
+         doing Preprocessing before goining into model.
+        """
+
+        try:
+            train_df = pd.read_csv(train_path)
+            test_df = pd.read_csv(test_path)
+            
+            logging.info("The Train and Test Data Imported Sucessfully")
+
+            logging.info('Obtaining Preprocessor object')
+            preprocessor_obj = self.get_data_transformer_object()
+
+            target_column_name = self.Target_Col[0]
+            logging.info(f"Target Col is : {target_column_name}")            
+            input_feature_train_df=train_df.drop(columns=[target_column_name],axis=1)
+            target_feature_train_df=train_df[target_column_name]
+            input_feature_test_df=test_df.drop(columns=[target_column_name],axis=1)
+            target_feature_test_df=test_df[target_column_name]
+            logging.info(
+                f"Applying preprocessing object on training dataframe and testing dataframe."
+            )
+            input_feature_train_arr=preprocessor_obj.fit_transform(input_feature_train_df)
+            input_feature_test_arr=preprocessor_obj.transform(input_feature_test_df)
+
+            # Do Label Encoding for Target Variable (for Classification Only)
+            if self.Problem_Objective=='Classification':
+                try:
+                    logging.info("Here Problem Objective is  Classification so we have done label encoding for target Variable")
+                    label_encoder = LabelEncoder()
+                    target_feature_train_df_encoded = label_encoder.fit_transform(target_feature_train_df)
+                    target_feature_test_df_encoded = label_encoder.transform(target_feature_test_df)
+                    train_arr = np.c_[
+                        input_feature_train_arr, np.array(target_feature_train_df_encoded)
+                            ]  
+                    test_arr = np.c_[input_feature_test_arr, np.array(target_feature_test_df_encoded)]
+                    label_obj_file_path = os.path.join('artifact','Targetlabel.pkl')
+                    save_object(label_obj_file_path,label_encoder)
+                    logging.info("Here Targetlabel.pkl object is saved to artifact folder")
+                except Exception as e:
+                    logging.ERROR(e)
+                    raise CustomException(e,sys)
+            else:
+                train_arr = np.c_[
+                    input_feature_train_arr, np.array(target_feature_train_df)
+                ]
+                test_arr = np.c_[input_feature_test_arr, np.array(target_feature_test_df)]
+            
+            logging.info(f"Saved preprocessing object.")
+
+            save_object(
+
+                file_path=self.Data_transformationConfig.preprocessor_obj_file_path,
+                obj=preprocessor_obj
+
+            )
+
+            return(
+                train_arr,
+                test_arr,
+                self.Data_transformationConfig.preprocessor_obj_file_path
+            )
+
+        except Exception as e:
+            raise CustomException(e,sys)
+        

JDML/source/components/Data_ingestion.py

@@ -0,0 +1,60 @@
+import os
+import sys
+
+from ...source.Exception import CustomException
+from ...source.Logger import logging
+
+
+
+from sklearn.model_selection import train_test_split
+from dataclasses import dataclass
+
+
+@dataclass
+class DataIngestionConfig:
+    """
+    This Class is to save file locations to artifact folder it will save train , test and raw data into it
+    """
+
+    train_data_path: str = os.path.join('artifact','train.csv')
+    test_data_path: str = os.path.join('artifact','test.csv')
+    raw_data_path: str = os.path.join('artifact','data.csv')
+
+class DataIngestion:
+    """
+    Here we are starting with Data Ingestion and will read dataset making dir structures doing train test splits
+
+    """
+
+    def __init__(self):
+        self.ingestion_config =DataIngestionConfig()
+
+    def initate_data_ingestion(self,df):
+
+        """
+        To Initate Data Ingestion use this Function.
+        """
+
+        logging.info("Entering the Data Ingestion Method or Components")
+
+        try:
+            
+            #df = Data_df
+            logging.info("Read the Data Set as Pandas Dataframe")
+            os.makedirs(os.path.dirname(self.ingestion_config.train_data_path),exist_ok=True)
+
+            df.to_csv(self.ingestion_config.raw_data_path,index=False, header=True)
+            logging.info("Train Test Split will Start, Raw Data Exported")
+            train_set, test_set = train_test_split(df,test_size=0.2,random_state=14)
+
+            train_set.to_csv(self.ingestion_config.train_data_path,index=False, header=True)
+            test_set.to_csv(self.ingestion_config.test_data_path,index=False, header=True) 
+
+            logging.info("Train Test Split is Done , Data in Artifact Folder")
+            return(
+                self.ingestion_config.train_data_path,
+                self.ingestion_config.test_data_path,     
+            )
+
+        except Exception as e:
+            raise CustomException(e,sys)