JustDataML 0.0.26__tar.gz

JustDataML-0.0.26/JDML/JDML.py

@@ -0,0 +1,153 @@
+#python3
+
+import os
+import sys
+import pandas as pd
+import argparse
+
+
+
+from .source.Exception import CustomException
+from .source.Pipeline import Train_Pipeline
+from .source.Pipeline.Predict_Pipeline import PredictPipeline,CustomData
+from .source.Logger import logging
+from .source.Configuration import DataProcessor
+
+
+class Just_Data_ML:
+
+    """
+    Just_Data_ML is a class to train and predict our Values 
+    """
+
+    def __init__(self,args):
+        self.args = args
+        #self.data_processor = DataProcessor(os.path.join("Data", "Data_Config.csv"))
+        self.data_processor = DataProcessor(args.Config)
+        self.data_processor.load_config()
+        self.data_processor.read_data()
+        self.Data_df = self.data_processor.Data_df
+        self.Features_Cols = self.data_processor.Features_Cols
+        self.Target_Col = self.data_processor.Target_Col
+        self.Models = self.data_processor.Models
+        self.HyperParamter_Yes_or_No = self.data_processor.HyperParamter_Yes_or_No
+        self.Problem_Objective = self.data_processor.Problem_Objective
+        self.Normalization_tech = self.data_processor.scaler
+        
+    def Data_Train(self):
+
+        """
+        Here we are calling Train_pipeline and Training our models and saving it to the files we can use for Prediction.
+        """
+
+        try:
+            os.makedirs("Output",exist_ok=True)
+            train_ourconfig_model = Train_Pipeline.TrainingPipeline(self.Features_Cols, self.Data_df, self.Target_Col, self.Models, self.HyperParamter_Yes_or_No, self.Problem_Objective,self.Normalization_tech)
+            train_ourconfig_model.Train_Model()    
+
+        except Exception as e:
+            raise CustomException(e,sys)
+        
+
+    def Predict_test(self):
+
+        """
+        Here we are Doing prediction base on our trianed model using in pervious function and importing Predict_pipeline
+        it will take Dataframe and as input (you can use csv file and pass it to the function)
+        """
+
+        try:
+            predict_val = PredictPipeline(self.Problem_Objective)
+            data = pd.read_csv(self.args.Predict)
+            input_features = data.columns
+
+            custom_data = CustomData(self.Features_Cols,**dict.fromkeys(input_features))
+            
+            for feature in input_features:
+                custom_data.__dict__[feature] = data[feature]
+
+            data_frame = custom_data.get_data_as_data_frame()
+
+            final_pred = predict_val.predict(data_frame)
+            data["Target_Out"] = final_pred
+            if self.args.Output:
+                out_path = os.path.join('Output',f'{self.args.Output}.csv')
+                print(f"Predicted file is saved in {out_path}")
+                logging.info(f"Predicted file is saved in {out_path}")
+            else:
+                out_path = os.path.join('Output','Target_outFile.csv')
+                print(f"Predicted file is saved in {out_path} : Note --Output was not given")
+                logging.info(f"Predicted file is saved in {out_path} : Note --Output was not given")
+            data.to_csv(out_path,index=False)
+            logging.info("Your Model Has Given Prediction Congratulations !!! Your Prediction Files ready in Output Folder")
+        except Exception as e:
+            raise CustomException(e,sys)
+        
+
+
+
+def MLtool():
+    parser = argparse.ArgumentParser(
+        prog="JDML",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description="""\
+            Tool : JustData_ML (JDML)
+            Author: Jaideepsinh Dabhi
+            emailID: jaideep.dabhi7603@gmail.com
+            Usage : JDML.py -C <Data_Config.csv>-T -P <test.csv> -O <Output Folder>
+                                         
+            * This Tool is Design to Train Machine Learning models and give prediction to help non coder or non tech students to do ML.
+            * This Tool will Train models with various paramters and give output.
+                        
+                *****************\n
+                ARUGMENTS  
+                -C, --Config    [Compulsory] You need to provide a configuration file to obtain all the necessary arguments for ML models to operate.
+                            Make Sure you give Proper Argument mentioned in the Document.
+                -T, --Train     [Optional]  If you give this function it will start training your model based on your data_config file.
+                            Make Sure you have Data in "Data" Folder.
+                -P, --Predict   [Optional]  If you give this function it will do prediction based on your trained model.
+                            Make  Sure you don't delete or modify artifact folder to get better results.
+                -O, --Output    [Please give with --Predict ]Name of Output csv file (if not given it will store data in Target_outFile csv file)
+                            It will store you input test file to output folder with 'Target_Out' Col containing Predictions based on your model.
+                                
+                        """,
+        epilog=" Contact jaideep.dabhi7603@gmail.com for any help or suggestion."
+    )
+
+    parser.add_argument('-C', '--Config', type = str, help=" Give a Config file to Application to get details about your task ")
+    parser.add_argument('-T', '--Train', action="store_true", default=False, help=" Give a Train argument to Train Data and create a Model")
+    parser.add_argument('-P', '--Predict', type=str, help=" Give a Test Data to Predict the Values from the Model")
+    parser.add_argument('-O', '--Output', type=str, help=" Give a Output name to Predicted Data Frame from Test Data")
+
+    args, _ = parser.parse_known_args()
+
+    if not any(vars(args).values()):  # Check if no arguments were provided
+        parser.print_usage()
+    else:
+        jdml_instance = Just_Data_ML(args)
+
+        if args.Train and not args.Predict:
+            jdml_instance.Data_Train()
+            print("Training of Data is Done please Do prediction using model in artifact folder")
+
+
+        elif args.Train and args.Predict:
+            jdml_instance.Data_Train()            
+            jdml_instance.Predict_test()
+            print("Training and Prediction Done for given Data")
+
+        elif args.Predict and not args.Train:
+            jdml_instance.Predict_test()
+            print("Model as predicted Values Based on Periously Trained Data in artifact folder")
+            
+        elif args.Output and not args.Predict:
+
+            print("NO INPUT DATA PLEASE PROVIDE INPUT DATA (-P or --Predict Argument) to Predict Data")
+
+        else:
+            print("Some Problem with Arguments")
+            parser.print_help()
+
+            
+if __name__ == "__main__":
+    MLtool()

JustDataML-0.0.26/JDML/__init__.py

@@ -0,0 +1 @@
+#Python

JustDataML-0.0.26/JDML/source/Configuration.py

@@ -0,0 +1,64 @@
+import pandas as pd 
+import os
+import sys
+
+from ..source.Utils import ReadConfig , regressor_models, classfication_models,Normalization_method
+from ..source.Exception import CustomException
+
+
+
+
+class DataProcessor:
+    def __init__(self, config_file):
+        self.config_file = config_file
+
+    def load_config(self):
+        self.DataConfig = ReadConfig(self.config_file)
+
+    def read_data(self):
+        try:
+            self.Data_df = pd.read_csv(os.path.join("Data", self.DataConfig['Data_Name'][0]))
+            self.Features_Cols = self.DataConfig["Features_Cols"]
+            self.Target_Col = self.DataConfig["Target_Col"]
+            self.Normalization_tech = self.DataConfig["Normalization_tech"][0]
+            self.Model_to_include = self.DataConfig["Model_to_include"]
+            self.Problem_Objective = self.DataConfig["Problem_Objective"][0]
+            if self.Problem_Objective == "Regression":
+                if self.Model_to_include[0] == "ALL":
+                    self.Models = regressor_models
+                else:
+                    self.Models = {key: value for key, value in regressor_models.items() if key in self.Model_to_include}
+            elif self.Problem_Objective == "Classification":
+                if self.Model_to_include[0] == "ALL":
+                    self.Models = classfication_models
+                else:
+                    self.Models = {key: value for key, value in classfication_models.items() if key in self.Model_to_include}
+            else:
+                print(f"Problem obj is '{self.Problem_Objective}' this is not properly define please add Proper problem objective i.e 'Regression' or 'Classification'")
+
+            if self.Normalization_tech in Normalization_method:
+                self.scaler = Normalization_method[self.Normalization_tech]
+            else:
+                print(f"{self.Normalization_tech} is not a valid normalization method.")
+
+
+            self.HyperParamter_Yes_or_No = self.DataConfig["HyperParamter_Yes_or_No"][0]
+        except Exception as e:
+            raise CustomException(e,sys)
+
+
+
+#Example usage:
+# ConfigFile = os.path.join("Data","Data_Config.csv")
+# data_processor = DataProcessor(ConfigFile)
+# data_processor.load_config()
+# data_processor.read_data()
+# Data_df = data_processor.Data_df
+# Features_Cols = data_processor.Features_Cols
+# Target_Col = data_processor.Target_Col
+# Normalization_tech = data_processor.Normalization_tech
+# Problem_Objective = data_processor.Problem_Objective
+# Models = data_processor.Models
+# HyperParamter_Yes_or_No = data_processor.HyperParamter_Yes_or_No
+
+

JustDataML-0.0.26/JDML/source/Exception.py

@@ -0,0 +1,21 @@
+import sys
+
+
+
+
+def error_message_detail(error,error_details:sys):
+    _,_,exc_tb = error_details.exc_info()
+    file_name = exc_tb.tb_frame.f_code.co_filename
+    error_message = "Error Occured in Python Script Name : [{0}] \n , Line Number [{1}] \n  error message [{2}] ".format(
+     file_name,exc_tb.tb_lineno,str(error))
+    return error_message
+
+
+class CustomException(Exception):
+    def __init__(self,error_message,error_details:sys):
+        super().__init__(error_message)
+        self.error_message=error_message_detail(error_message,error_details=error_details)
+    
+
+    def __str__(self):
+        return self.error_message

JustDataML-0.0.26/JDML/source/Logger.py

@@ -0,0 +1,16 @@
+import logging
+import os
+from datetime import datetime
+
+LOG_FILE =f"{datetime.now().strftime('%d_%m_%Y_%H_%M_%S')}.log"
+logs_path = os.path.join(os.getcwd(),"logs",f"{datetime.now().strftime('%d_%m_%Y')}-logs")
+os.makedirs(logs_path,exist_ok=True)
+
+LOG_FILE_PATH = os.path.join(logs_path,LOG_FILE)
+
+logging.basicConfig(
+    filename=LOG_FILE_PATH,
+    format="[ %(asctime)s ] - %(filename)s - %(lineno)d %(name)s - %(levelname)s - %(message)s",
+    level=logging.INFO
+    
+)