Model Trainer part completed

Author: GoJo-Rika

final_model/model.pkl

@@ -0,0 +1,157 @@
+import sys
+from pathlib import Path
+
+from sklearn.ensemble import (
+    AdaBoostClassifier,
+    GradientBoostingClassifier,
+    RandomForestClassifier,
+)
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+
+from network_security.entity.artifact_entity import (
+    DataTransformationArtifact,
+    ModelTrainerArtifact,
+)
+from network_security.entity.config_entity import ModelTrainerConfig
+from network_security.exception.exception import NetworkSecurityException
+from network_security.logging.logger import logging
+from network_security.utils.main_utils.utils import (
+    load_numpy_array_data,
+    load_object,
+    save_object,
+)
+from network_security.utils.ml_utils.evaluation.evaluation import evaluate_models
+from network_security.utils.ml_utils.metric.classification_metric import (
+    get_classification_score,
+)
+from network_security.utils.ml_utils.model.estimator import NetworkModel
+
+
+class ModelTrainer:
+    def __init__(
+        self,
+        model_trainer_config: ModelTrainerConfig,
+        data_transformation_artifact: DataTransformationArtifact,
+    ) -> None:
+        try:
+            self.model_trainer_config = model_trainer_config
+            self.data_transformation_artifact = data_transformation_artifact
+        except Exception as e:
+            raise NetworkSecurityException(e, sys)
+
+    def train_model(
+        self,
+        X_train: object,
+        y_train: object,
+        X_test: object,
+        y_test: object,
+    ) -> ModelTrainerArtifact:
+        models = {
+            "Random Forest": RandomForestClassifier(verbose=1),
+            "Decision Tree": DecisionTreeClassifier(),
+            "Gradient Boosting": GradientBoostingClassifier(verbose=1),
+            "Logistic Regression": LogisticRegression(verbose=1),
+            "AdaBoost": AdaBoostClassifier(),
+        }
+        params = {
+            "Decision Tree": {
+                "criterion": ["gini", "entropy", "log_loss"],
+                "splitter": ["best", "random"],
+                "max_features": ["sqrt", "log2"],
+            },
+            "Random Forest": {
+                "criterion": ["gini", "entropy", "log_loss"],
+                "max_features": ["sqrt", "log2", None],
+                "n_estimators": [8, 16, 32, 128, 256],
+            },
+            "Gradient Boosting": {
+                "loss": ["log_loss", "exponential"],
+                "learning_rate": [0.1, 0.01, 0.05, 0.001],
+                "subsample": [0.6, 0.7, 0.75, 0.85, 0.9],
+                "criterion": ["squared_error", "friedman_mse"],
+                "max_features": ["auto", "sqrt", "log2"],
+                "n_estimators": [8, 16, 32, 64, 128, 256],
+            },
+            "Logistic Regression": {},
+            "AdaBoost": {
+                "learning_rate": [0.1, 0.01, 0.001],
+                "n_estimators": [8, 16, 32, 64, 128, 256],
+            },
+        }
+        model_report: dict = evaluate_models(
+            X_train=X_train,
+            y_train=y_train,
+            X_test=X_test,
+            y_test=y_test,
+            models=models,
+            param=params,
+        )
+
+        ## To get best model score from dict
+        best_model_score = max(sorted(model_report.values()))
+
+        ## To get best model name from dict
+        best_model_name = list(model_report.keys())[
+            list(model_report.values()).index(best_model_score)
+        ]
+        best_model = models[best_model_name]
+        y_train_pred = best_model.predict(X_train)
+
+        classification_train_metric = get_classification_score(
+            y_true=y_train,
+            y_pred=y_train_pred,
+        )
+
+        y_test_pred = best_model.predict(X_test)
+        classification_test_metric = get_classification_score(
+            y_true=y_test,
+            y_pred=y_test_pred,
+        )
+
+        preprocessor = load_object(
+            file_path=self.data_transformation_artifact.transformed_object_file_path,
+        )
+        model_dir_path = Path(self.model_trainer_config.trained_model_file_path).parent
+        model_dir_path.mkdir(parents=True, exist_ok=True)
+
+        network_model = NetworkModel(preprocessor=preprocessor, model=best_model)
+        save_object(self.model_trainer_config.trained_model_file_path, obj=NetworkModel)
+
+        ## Model pusher
+        save_object("final_model/model.pkl", best_model)
+
+        ## Model Trainer Artifact
+        model_trainer_artifact = ModelTrainerArtifact(
+            trained_model_file_path=self.model_trainer_config.trained_model_file_path,
+            train_metric_artifact=classification_train_metric,
+            test_metric_artifact=classification_test_metric,
+        )
+        logging.info(f"Model trainer artifact: {model_trainer_artifact}")
+        return model_trainer_artifact
+
+    def initiate_model_trainer(self) -> ModelTrainerArtifact:
+        try:
+            train_file_path = (
+                self.data_transformation_artifact.transformed_train_file_path
+            )
+            test_file_path = (
+                self.data_transformation_artifact.transformed_test_file_path
+            )
+
+            # Loading training array and testing array
+            train_arr = load_numpy_array_data(train_file_path)
+            test_arr = load_numpy_array_data(test_file_path)
+
+            x_train, y_train, x_test, y_test = (
+                train_arr[:, :-1],
+                train_arr[:, -1],
+                test_arr[:, :-1],
+                test_arr[:, -1],
+            )
+
+            model_trainer_artifact = self.train_model(x_train, y_train, x_test, y_test)
+            return model_trainer_artifact
+
+        except Exception as e:
+            raise NetworkSecurityException(e, sys)

final_model/preprocessor.pkl

@@ -55,3 +55,14 @@
 DATA_TRANSFORMATION_TRAIN_FILE_PATH: str = "train.npy"
 
 DATA_TRANSFORMATION_TEST_FILE_PATH: str = "test.npy"
+
+
+"""
+Model Trainer ralated constant start with MODE TRAINER VAR NAME
+"""
+
+MODEL_TRAINER_DIR_NAME: str = "model_trainer"
+MODEL_TRAINER_TRAINED_MODEL_DIR: str = "trained_model"
+MODEL_TRAINER_TRAINED_MODEL_NAME: str = "model.pkl"
+MODEL_TRAINER_EXPECTED_SCORE: float = 0.6
+MODEL_TRAINER_OVER_FIITING_UNDER_FITTING_THRESHOLD: float = 0.05

network_security/components/model_trainer.py

@@ -22,3 +22,17 @@ class DataTransformationArtifact:
     transformed_object_file_path: str
     transformed_train_file_path: str
     transformed_test_file_path: str
+
+
+@dataclass
+class ClassificationMetricArtifact:
+    f1_score: float
+    precision_score: float
+    recall_score: float
+
+
+@dataclass
+class ModelTrainerArtifact:
+    trained_model_file_path: str
+    train_metric_artifact: ClassificationMetricArtifact
+    test_metric_artifact: ClassificationMetricArtifact

network_security/constant/training_pipeline/__init__.py

@@ -99,3 +99,20 @@ def __init__(self, training_pipeline_config: TrainingPipelineConfig) -> None:
             / training_pipeline.DATA_TRANSFORMATION_TRANSFORMED_OBJECT_DIR
             / training_pipeline.PREPROCESSING_OBJECT_FILE_NAME
         )
+
+
+class ModelTrainerConfig:
+    def __init__(self, training_pipeline_config: TrainingPipelineConfig) -> None:
+        self.model_trainer_dir: Path = (
+            Path(training_pipeline_config.artifact_dir)
+            / training_pipeline.MODEL_TRAINER_DIR_NAME
+        )
+        self.trained_model_file_path: Path = (
+            self.model_trainer_dir
+            / training_pipeline.MODEL_TRAINER_TRAINED_MODEL_DIR
+            / training_pipeline.MODEL_FILE_NAME
+        )
+        self.expected_accuracy: float = training_pipeline.MODEL_TRAINER_EXPECTED_SCORE
+        self.overfitting_underfitting_threshold = (
+            training_pipeline.MODEL_TRAINER_OVER_FIITING_UNDER_FITTING_THRESHOLD
+        )

network_security/entity/artifact_entity.py

@@ -1,6 +1,3 @@
-import os
-
-# import dill
 import pickle
 import sys
 from pathlib import Path
@@ -31,16 +28,16 @@ def write_yaml_file(file_path: str, content: object, replace: bool = False) -> N
         raise NetworkSecurityException(e, sys)
 
 
-def save_numpy_array_data(file_path: str, array: np.array):
+def save_numpy_array_data(file_path: str, array: np.array) -> None:
     """
     Save numpy array data to file
     file_path: str location of file to save
-    array: np.array data to save
+    array: np.array data to save.
     """
     try:
-        dir_path = os.path.dirname(file_path)
-        os.makedirs(dir_path, exist_ok=True)
-        with open(file_path, "wb") as file_obj:
+        dir_path = Path(file_path).parent
+        dir_path.mkdir(parents=True, exist_ok=True)
+        with Path(file_path).open("wb") as file_obj:
             np.save(file_obj, array)
     except Exception as e:
         raise NetworkSecurityException(e, sys) from e
@@ -49,9 +46,34 @@ def save_numpy_array_data(file_path: str, array: np.array):
 def save_object(file_path: str, obj: object) -> None:
     try:
         logging.info("Entered the save_object method of MainUtils class")
-        os.makedirs(os.path.dirname(file_path), exist_ok=True)
-        with open(file_path, "wb") as file_obj:
+        Path(file_path).parent.mkdir(parents=True, exist_ok=True)
+        with Path(file_path).open("wb") as file_obj:
             pickle.dump(obj, file_obj)
         logging.info("Exited the save_object method of MainUtils class")
     except Exception as e:
         raise NetworkSecurityException(e, sys) from e
+
+
+def load_object(file_path: str) -> object:
+    try:
+        if not Path(file_path).exists():
+            raise Exception(f"The file: {file_path} is not exists")
+        with Path(file_path).open("rb") as file_obj:
+            print(file_obj)
+            return pickle.load(file_obj)
+    except Exception as e:
+        raise NetworkSecurityException(e, sys) from e
+
+
+def load_numpy_array_data(file_path: str) -> np.array:
+    """
+    Load numpy array data from file
+    file_path: str location of file to load
+    return: np.array data loaded.
+    """
+    try:
+        with Path(file_path).open("rb") as file_obj:
+            return np.load(file_obj)
+    except Exception as e:
+        raise NetworkSecurityException(e, sys) from e
+

network_security/entity/config_entity.py

@@ -0,0 +1,38 @@
+import sys
+
+from sklearn.metrics import r2_score
+from sklearn.model_selection import GridSearchCV
+
+from network_security.exception.exception import NetworkSecurityException
+
+
+def evaluate_models(X_train: object, y_train: object, X_test: object, y_test: object, models: dict, param: dict) -> dict:
+    try:
+        report = {}
+
+        for i in range(len(list(models))):
+            model = list(models.values())[i]
+            para = param[list(models.keys())[i]]
+
+            gs = GridSearchCV(model, para, cv=3)
+            gs.fit(X_train, y_train)
+
+            model.set_params(**gs.best_params_)
+            model.fit(X_train, y_train)
+
+            # model.fit(X_train, y_train)  # Train model
+
+            y_train_pred = model.predict(X_train)
+
+            y_test_pred = model.predict(X_test)
+
+            train_model_score = r2_score(y_train, y_train_pred)
+
+            test_model_score = r2_score(y_test, y_test_pred)
+
+            report[list(models.keys())[i]] = test_model_score
+
+        return report
+
+    except Exception as e:
+        raise NetworkSecurityException(e, sys)