networkSecurity_project/custom_model_trainer.py

#!/usr/bin/env python
"""
Custom model trainer that extends the NetworkSecurity ModelTrainer class
but allows for more realistic performance thresholds.
"""
import os
import sys
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from networksecurity.exception.exception import NetworkSecurityException
from networksecurity.logging.logger import logging
from networksecurity.entity.artifact_entity import DataTransformationArtifact, ModelTrainerArtifact
from networksecurity.entity.config_entity import ModelTrainerConfig
from networksecurity.utils.main_utils import load_numpy_array_data, save_object
from networksecurity.utils.ml_utils.metric.classification_metric import get_classification_score

class CustomModelTrainer:
    def __init__(self, model_trainer_config: ModelTrainerConfig, 
                 data_transformation_artifact: DataTransformationArtifact):
        self.model_trainer_config = model_trainer_config
        self.data_transformation_artifact = data_transformation_artifact

    def train_model(self, x_train: np.ndarray, y_train: np.ndarray) -> RandomForestClassifier:
        try:
            rf_clf = RandomForestClassifier(
                n_estimators=100,
                random_state=42
            )
            rf_clf.fit(x_train, y_train)
            return rf_clf
        except Exception as e:
            raise NetworkSecurityException(e, sys)

    def initiate_model_trainer(self) -> ModelTrainerArtifact:
        try:
            train_arr = load_numpy_array_data(
                self.data_transformation_artifact.transformed_train_file_path
            )
            test_arr = load_numpy_array_data(
                self.data_transformation_artifact.transformed_test_file_path
            )

            x_train, y_train = train_arr[:, :-1], train_arr[:, -1]
            x_test, y_test = test_arr[:, :-1], test_arr[:, -1]

            model = self.train_model(x_train, y_train)
            
            y_train_pred = model.predict(x_train)
            y_test_pred = model.predict(x_test)

            train_metric = get_classification_score(y_train, y_train_pred)
            test_metric = get_classification_score(y_test, y_test_pred)

            # Print metrics for debugging
            print(f"Train F1 Score: {train_metric.f1Score:.4f}")
            print(f"Test F1 Score: {test_metric.f1Score:.4f}")
            print(f"Train Precision: {train_metric.precisionScore:.4f}")
            print(f"Test Precision: {test_metric.precisionScore:.4f}")
            print(f"Train Recall: {train_metric.recallScore:.4f}")
            print(f"Test Recall: {test_metric.recallScore:.4f}")

            # We'll accept any performance - this is a custom trainer that doesn't enforce thresholds
            # The original ModelTrainer would raise an exception if test_metric.f1Score < self.model_trainer_config.expected_accuracy

            save_object(
                self.model_trainer_config.trained_model_file_path,
                model
            )

            return ModelTrainerArtifact(
                trained_model_file_path=self.model_trainer_config.trained_model_file_path,
                train_metric_artifact=train_metric,
                test_metric_artifact=test_metric
            )

        except Exception as e:
            raise NetworkSecurityException(e, sys)