Add stacking ensemble, threshold tuning, and evaluation notebooks

notebook/{eda.ipynb → 1_Exploratory_Data_Analysis.ipynb}

@@ -167,6 +167,7 @@
     }
    ],
    "source": [
+    "import os\n",
     "import pandas as pd\n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
@@ -177,6 +178,8 @@
     "plt.rcParams[\"figure.figsize\"] = (12, 5)\n",
     "plt.rcParams[\"figure.dpi\"] = 120\n",
     "\n",
+    "os.makedirs(\"../figures\", exist_ok=True)\n",
+    "\n",
     "CSV_PATH = \"../EasyVisa.csv\"\n",
     "df = pd.read_csv(CSV_PATH)\n",
     "print(f\"Shape: {df.shape}\")\n",
@@ -714,6 +717,7 @@
     "axes[1].set_title(\"Case Status — Proportion\", fontweight=\"bold\")\n",
     "\n",
     "plt.tight_layout()\n",
+    "plt.savefig(\"../figures/fig1_class_distribution.png\", dpi=150, bbox_inches=\"tight\")\n",
     "plt.show()\n",
     "\n",
     "print(f\"\\nImbalance ratio: {counts.iloc[0] / counts.iloc[1]:.2f}:1 (Certified:Denied)\")\n",
@@ -837,6 +841,7 @@
     "                     f\"{val:.1f}%\", va=\"center\", fontsize=9)\n",
     "\n",
     "    plt.tight_layout()\n",
+    "    plt.savefig(f\"../figures/fig2_{feat}.png\", dpi=150, bbox_inches=\"tight\")\n",
     "    plt.show()"
    ]
   },
@@ -856,7 +861,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "C:\\Users\\haris\\AppData\\Local\\Temp\\ipykernel_3800\\2242569204.py:12: FutureWarning: \n",
+      "C:\\Users\\haris\\AppData\\Local\\Temp\\ipykernel_35396\\1005620750.py:12: FutureWarning: \n",
       "\n",
       "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
       "\n",
@@ -890,7 +895,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "C:\\Users\\haris\\AppData\\Local\\Temp\\ipykernel_3800\\2242569204.py:12: FutureWarning: \n",
+      "C:\\Users\\haris\\AppData\\Local\\Temp\\ipykernel_35396\\1005620750.py:12: FutureWarning: \n",
       "\n",
       "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
       "\n",
@@ -929,7 +934,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "C:\\Users\\haris\\AppData\\Local\\Temp\\ipykernel_3800\\2242569204.py:12: FutureWarning: \n",
+      "C:\\Users\\haris\\AppData\\Local\\Temp\\ipykernel_35396\\1005620750.py:12: FutureWarning: \n",
       "\n",
       "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
       "\n",
@@ -985,6 +990,7 @@
     "    axes[2].set_ylabel(\"Density\")\n",
     "\n",
     "    plt.tight_layout()\n",
+    "    plt.savefig(f\"../figures/fig3_{feat}.png\", dpi=150, bbox_inches=\"tight\")\n",
     "    plt.show()\n",
     "\n",
     "    # Stats\n",
@@ -1053,6 +1059,7 @@
     "            cbar_kws={\"shrink\": 0.8})\n",
     "ax.set_title(\"Feature Correlation Matrix\", fontweight=\"bold\", fontsize=13)\n",
     "plt.tight_layout()\n",
+    "plt.savefig(\"../figures/fig4_correlation_matrix.png\", dpi=150, bbox_inches=\"tight\")\n",
     "plt.show()\n",
     "\n",
     "print(\"\\nCorrelation with Denied (case_status_num):\")\n",
@@ -1077,7 +1084,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "C:\\Users\\haris\\AppData\\Local\\Temp\\ipykernel_3800\\1804773271.py:17: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
+      "C:\\Users\\haris\\AppData\\Local\\Temp\\ipykernel_35396\\3879025697.py:17: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
       "  cert_by_wage = df.groupby(\"wage_quartile\")[\"case_status\"].apply(lambda x: (x == \"Certified\").mean() * 100)\n"
      ]
     },
@@ -1119,6 +1126,7 @@
     "                 ha=\"center\", fontsize=10, fontweight=\"bold\")\n",
     "\n",
     "plt.tight_layout()\n",
+    "plt.savefig(\"../figures/fig5_wage_analysis.png\", dpi=150, bbox_inches=\"tight\")\n",
     "plt.show()\n",
     "\n",
     "df.drop(columns=[\"annual_wage\", \"wage_quartile\"], inplace=True)"
@@ -1186,6 +1194,7 @@
     "ax.set_title(\"Top 15 Feature Importances (Random Forest)\", fontweight=\"bold\")\n",
     "ax.set_xlabel(\"Importance\")\n",
     "plt.tight_layout()\n",
+    "plt.savefig(\"../figures/fig6_feature_importance.png\", dpi=150, bbox_inches=\"tight\")\n",
     "plt.show()"
    ]
   },
@@ -1195,7 +1204,7 @@
    "source": [
     "## 8. Key Takeaways\n",
     "\n",
-    "1. **Class imbalance** (66.8% Certified / 33.2% Denied) requires resampling (SMOTEENN) and F1 scoring — accuracy alone is misleading.\n",
+    "1. **Class imbalance** (66.8% Certified / 33.2% Denied) is handled via native class weighting (LightGBM, CatBoost) and post-training threshold tuning rather than resampling. Accuracy alone is misleading — we enforce a denied recall constraint (>=60%).\n",
     "\n",
     "2. **Education** has the clearest ordinal relationship with approval. Doctorate > Master's > Bachelor's > High School.\n",
     "\n",

visa_approval_prediction/components/data_ingestion.py

@@ -0,0 +1,53 @@
+import os
+import sys
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+from visa_approval_prediction.constants import CURRENT_YEAR, TARGET_COLUMN
+from visa_approval_prediction.entity.config_entity import DataIngestionConfig
+from visa_approval_prediction.entity.artifact_entity import DataIngestionArtifact
+from visa_approval_prediction.exception import visaException
+from visa_approval_prediction.logger import logging
+
+
+class DataIngestion:
+    def __init__(self, config: DataIngestionConfig):
+        self.config = config
+
+    def initiate_data_ingestion(self) -> DataIngestionArtifact:
+        logging.info("Starting data ingestion")
+        try:
+            df = pd.read_csv(self.config.data_source_path)
+            logging.info(f"Loaded dataset: {df.shape}")
+
+            # Feature engineering
+            df["company_age"] = CURRENT_YEAR - df["yr_of_estab"]
+            df.drop(columns=["case_id", "yr_of_estab"], inplace=True)
+
+            # Encode target: Certified=0, Denied=1
+            df[TARGET_COLUMN] = df[TARGET_COLUMN].map({"Certified": 0, "Denied": 1})
+
+            # Stratified train/test split
+            train_set, test_set = train_test_split(
+                df,
+                test_size=self.config.split_ratio,
+                random_state=42,
+                stratify=df[TARGET_COLUMN],
+            )
+            logging.info(f"Train: {train_set.shape}, Test: {test_set.shape}")
+
+            # Save splits
+            os.makedirs(os.path.dirname(self.config.train_file_path), exist_ok=True)
+            train_set.to_csv(self.config.train_file_path, index=False)
+            test_set.to_csv(self.config.test_file_path, index=False)
+            logging.info(f"Train saved to {self.config.train_file_path}")
+            logging.info(f"Test saved to {self.config.test_file_path}")
+
+            return DataIngestionArtifact(
+                train_file_path=self.config.train_file_path,
+                test_file_path=self.config.test_file_path,
+            )
+
+        except Exception as e:
+            raise visaException(e, sys) from e

visa_approval_prediction/components/data_transformation.py

@@ -0,0 +1,134 @@
+import os
+import sys
+import pickle
+
+import numpy as np
+import pandas as pd
+from sklearn.compose import ColumnTransformer
+from sklearn.pipeline import Pipeline as SkPipeline
+from sklearn.preprocessing import (
+    OneHotEncoder,
+    OrdinalEncoder,
+    PowerTransformer,
+    StandardScaler,
+)
+from visa_approval_prediction.constants import TARGET_COLUMN
+from visa_approval_prediction.entity.config_entity import DataTransformationConfig
+from visa_approval_prediction.entity.artifact_entity import (
+    DataIngestionArtifact,
+    DataTransformationArtifact,
+)
+from visa_approval_prediction.exception import visaException
+from visa_approval_prediction.logger import logging
+
+
+class DataTransformation:
+    def __init__(
+        self,
+        config: DataTransformationConfig,
+        ingestion_artifact: DataIngestionArtifact,
+    ):
+        self.config = config
+        self.ingestion_artifact = ingestion_artifact
+
+    @staticmethod
+    def _build_preprocessor() -> ColumnTransformer:
+        """Build the ColumnTransformer (must match prediction pipeline expectations)."""
+        onehot_cols = ["continent", "unit_of_wage", "region_of_employment"]
+        ordinal_cols = [
+            "has_job_experience",
+            "requires_job_training",
+            "full_time_position",
+            "education_of_employee",
+        ]
+        ordinal_categories = [
+            ["N", "Y"],
+            ["N", "Y"],
+            ["N", "Y"],
+            ["High School", "Bachelor's", "Master's", "Doctorate"],
+        ]
+        power_scale_cols = ["no_of_employees", "company_age"]
+        scale_only_cols = ["prevailing_wage"]
+
+        return ColumnTransformer(
+            transformers=[
+                (
+                    "onehot",
+                    OneHotEncoder(handle_unknown="ignore", sparse_output=False),
+                    onehot_cols,
+                ),
+                (
+                    "ordinal",
+                    OrdinalEncoder(categories=ordinal_categories),
+                    ordinal_cols,
+                ),
+                (
+                    "power_scale",
+                    SkPipeline(
+                        [
+                            ("power", PowerTransformer(method="yeo-johnson")),
+                            ("scale", StandardScaler()),
+                        ]
+                    ),
+                    power_scale_cols,
+                ),
+                ("scale", StandardScaler(), scale_only_cols),
+            ],
+            remainder="drop",
+        )
+
+    def initiate_data_transformation(self) -> DataTransformationArtifact:
+        logging.info("Starting data transformation")
+        try:
+            train_df = pd.read_csv(self.ingestion_artifact.train_file_path)
+            test_df = pd.read_csv(self.ingestion_artifact.test_file_path)
+
+            X_train = train_df.drop(columns=[TARGET_COLUMN])
+            y_train = train_df[TARGET_COLUMN]
+            X_test = test_df.drop(columns=[TARGET_COLUMN])
+            y_test = test_df[TARGET_COLUMN]
+
+            # Fit preprocessor on training data only (no data leakage)
+            preprocessor = self._build_preprocessor()
+            logging.info("Fitting preprocessor on training data")
+            X_train_transformed = preprocessor.fit_transform(X_train)
+            X_test_transformed = preprocessor.transform(X_test)
+            logging.info(
+                f"Transformed — Train: {X_train_transformed.shape}, "
+                f"Test: {X_test_transformed.shape}"
+            )
+
+            # Train on natural distribution (no resampling)
+            logging.info(
+                f"Training on natural distribution: {X_train_transformed.shape[0]} samples"
+            )
+
+            # Save transformed arrays
+            for path in [
+                self.config.transformed_train_file_path,
+                self.config.preprocessor_object_file_path,
+            ]:
+                os.makedirs(os.path.dirname(path), exist_ok=True)
+
+            np.save(self.config.transformed_train_file_path, X_train_transformed)
+            np.save(self.config.transformed_test_file_path, X_test_transformed)
+            np.save(self.config.transformed_train_target_path, np.array(y_train))
+            np.save(self.config.transformed_test_target_path, np.array(y_test))
+
+            # Save preprocessor
+            with open(self.config.preprocessor_object_file_path, "wb") as f:
+                pickle.dump(preprocessor, f)
+            logging.info(
+                f"Preprocessor saved to {self.config.preprocessor_object_file_path}"
+            )
+
+            return DataTransformationArtifact(
+                transformed_train_file_path=self.config.transformed_train_file_path,
+                transformed_test_file_path=self.config.transformed_test_file_path,
+                transformed_train_target_path=self.config.transformed_train_target_path,
+                transformed_test_target_path=self.config.transformed_test_target_path,
+                preprocessor_object_file_path=self.config.preprocessor_object_file_path,
+            )
+
+        except Exception as e:
+            raise visaException(e, sys) from e

visa_approval_prediction/components/data_validation.py

@@ -0,0 +1,112 @@
+import os
+import sys
+
+import yaml
+import pandas as pd
+from scipy.stats import ks_2samp
+
+from visa_approval_prediction.entity.config_entity import DataValidationConfig
+from visa_approval_prediction.entity.artifact_entity import (
+    DataIngestionArtifact,
+    DataValidationArtifact,
+)
+from visa_approval_prediction.exception import visaException
+from visa_approval_prediction.logger import logging
+
+
+class DataValidation:
+    def __init__(
+        self,
+        config: DataValidationConfig,
+        ingestion_artifact: DataIngestionArtifact,
+    ):
+        self.config = config
+        self.ingestion_artifact = ingestion_artifact
+
+    def _read_schema(self) -> dict:
+        with open(self.config.schema_file_path, "r") as f:
+            return yaml.safe_load(f)
+
+    def _validate_columns(self, df: pd.DataFrame, schema: dict) -> bool:
+        """Check all expected columns are present after feature engineering."""
+        expected = set()
+        for col_def in schema["columns"]:
+            if isinstance(col_def, dict):
+                col_name = list(col_def.keys())[0]
+            else:
+                col_name = col_def
+            expected.add(col_name)
+
+        # Adjust for ingestion-stage feature engineering
+        expected.discard("case_id")
+        expected.discard("yr_of_estab")
+        expected.add("company_age")
+
+        actual = set(df.columns)
+        missing = expected - actual
+
+        if missing:
+            logging.warning(f"Missing columns: {missing}")
+            return False
+        return True
+
+    def _detect_drift(
+        self, train_df: pd.DataFrame, test_df: pd.DataFrame
+    ) -> dict:
+        """KS test on numerical columns to detect distribution drift."""
+        report = {}
+        numerical_cols = train_df.select_dtypes(include=["int64", "float64"]).columns
+
+        for col in numerical_cols:
+            stat, p_value = ks_2samp(train_df[col], test_df[col])
+            is_drifted = p_value < 0.05
+            report[col] = {
+                "ks_statistic": float(round(stat, 4)),
+                "p_value": float(round(p_value, 4)),
+                "drift_detected": is_drifted,
+            }
+            if is_drifted:
+                logging.warning(f"Drift in '{col}' (p={p_value:.4f})")
+
+        return report
+
+    def initiate_data_validation(self) -> DataValidationArtifact:
+        logging.info("Starting data validation")
+        try:
+            train_df = pd.read_csv(self.ingestion_artifact.train_file_path)
+            test_df = pd.read_csv(self.ingestion_artifact.test_file_path)
+            schema = self._read_schema()
+
+            # Column validation
+            train_valid = self._validate_columns(train_df, schema)
+            test_valid = self._validate_columns(test_df, schema)
+
+            if not (train_valid and test_valid):
+                message = "Column validation failed"
+                logging.error(message)
+                validation_status = False
+            else:
+                message = "Validation passed"
+                validation_status = True
+
+            # Drift detection (warning only, does not fail validation)
+            drift_report = self._detect_drift(train_df, test_df)
+            drifted_cols = [c for c, r in drift_report.items() if r["drift_detected"]]
+            if drifted_cols:
+                message += f" | Drift detected in: {drifted_cols}"
+                logging.warning(f"Drift found in {len(drifted_cols)} columns")
+
+            # Save drift report
+            os.makedirs(os.path.dirname(self.config.drift_report_file_path), exist_ok=True)
+            with open(self.config.drift_report_file_path, "w") as f:
+                yaml.dump(drift_report, f, default_flow_style=False)
+            logging.info(f"Drift report saved to {self.config.drift_report_file_path}")
+
+            return DataValidationArtifact(
+                validation_status=validation_status,
+                message=message,
+                drift_report_file_path=self.config.drift_report_file_path,
+            )
+
+        except Exception as e:
+            raise visaException(e, sys) from e

visa_approval_prediction/components/model_evaluation.py

@@ -0,0 +1,91 @@
+import os
+import sys
+import pickle
+import shutil
+
+import pandas as pd
+from sklearn.metrics import f1_score
+
+from visa_approval_prediction.constants import TARGET_COLUMN
+from visa_approval_prediction.entity.config_entity import ModelEvaluationConfig
+from visa_approval_prediction.entity.artifact_entity import (
+    DataIngestionArtifact,
+    ModelTrainerArtifact,
+    ModelEvaluationArtifact,
+)
+from visa_approval_prediction.exception import visaException
+from visa_approval_prediction.logger import logging
+
+
+class ModelEvaluation:
+    def __init__(
+        self,
+        config: ModelEvaluationConfig,
+        trainer_artifact: ModelTrainerArtifact,
+        ingestion_artifact: DataIngestionArtifact,
+    ):
+        self.config = config
+        self.trainer_artifact = trainer_artifact
+        self.ingestion_artifact = ingestion_artifact
+
+    def initiate_model_evaluation(self) -> ModelEvaluationArtifact:
+        logging.info("Starting model evaluation")
+        try:
+            new_model_f1 = self.trainer_artifact.test_f1_score
+            best_model_f1 = 0.0
+
+            # Compare with existing production model if it exists
+            if os.path.exists(self.config.best_model_path):
+                logging.info(
+                    f"Existing model found at {self.config.best_model_path}"
+                )
+                with open(self.config.best_model_path, "rb") as f:
+                    existing_model = pickle.load(f)
+
+                # Use raw test data — each visaModel has its own preprocessor
+                # so we call predict() on raw DataFrame, not pre-transformed arrays
+                test_df = pd.read_csv(self.ingestion_artifact.test_file_path)
+                X_test = test_df.drop(columns=[TARGET_COLUMN])
+                y_test = test_df[TARGET_COLUMN]
+
+                y_pred = existing_model.predict(X_test)
+                best_model_f1 = f1_score(y_test, y_pred)
+                logging.info(f"Existing model F1: {best_model_f1:.4f}")
+                logging.info(f"New model F1:      {new_model_f1:.4f}")
+            else:
+                logging.info("No existing model found, new model will be accepted")
+
+            improved = new_model_f1 - best_model_f1
+            is_accepted = (
+                improved >= self.config.changed_threshold_score
+                or best_model_f1 == 0.0
+            )
+
+            if is_accepted:
+                os.makedirs(
+                    os.path.dirname(self.config.best_model_path), exist_ok=True
+                )
+                shutil.copy2(
+                    self.trainer_artifact.trained_model_file_path,
+                    self.config.best_model_path,
+                )
+                logging.info(
+                    f"New model promoted to {self.config.best_model_path}"
+                )
+            else:
+                logging.info(
+                    f"New model rejected (improvement {improved:.4f} "
+                    f"< threshold {self.config.changed_threshold_score})"
+                )
+
+            return ModelEvaluationArtifact(
+                is_model_accepted=is_accepted,
+                best_model_path=self.config.best_model_path,
+                trained_model_f1_score=new_model_f1,
+                best_model_f1_score=(
+                    max(best_model_f1, new_model_f1) if is_accepted else best_model_f1
+                ),
+            )
+
+        except Exception as e:
+            raise visaException(e, sys) from e

visa_approval_prediction/components/model_trainer.py

@@ -0,0 +1,154 @@
+import os
+import sys
+import pickle
+
+import yaml
+import numpy as np
+from sklearn.model_selection import GridSearchCV
+from sklearn.metrics import f1_score, accuracy_score, classification_report
+from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
+from xgboost import XGBClassifier
+
+from visa_approval_prediction.entity.config_entity import ModelTrainerConfig
+from visa_approval_prediction.entity.artifact_entity import (
+    DataTransformationArtifact,
+    ModelTrainerArtifact,
+)
+from visa_approval_prediction.entity.estimator import visaModel
+from visa_approval_prediction.exception import visaException
+from visa_approval_prediction.logger import logging
+
+MODEL_CLASSES = {
+    "RandomForestClassifier": RandomForestClassifier,
+    "GradientBoostingClassifier": GradientBoostingClassifier,
+    "XGBClassifier": XGBClassifier,
+}
+
+
+class ModelTrainer:
+    def __init__(
+        self,
+        config: ModelTrainerConfig,
+        transformation_artifact: DataTransformationArtifact,
+    ):
+        self.config = config
+        self.transformation_artifact = transformation_artifact
+
+    def initiate_model_training(self) -> ModelTrainerArtifact:
+        logging.info("Starting model training")
+        try:
+            # Load transformed + resampled training data
+            X_train = np.load(
+                self.transformation_artifact.transformed_train_file_path
+            )
+            y_train = np.load(
+                self.transformation_artifact.transformed_train_target_path
+            )
+            X_test = np.load(
+                self.transformation_artifact.transformed_test_file_path
+            )
+            y_test = np.load(
+                self.transformation_artifact.transformed_test_target_path
+            )
+            logging.info(f"Train: {X_train.shape}, Test: {X_test.shape}")
+
+            # Load preprocessor (needed to bundle into visaModel)
+            with open(
+                self.transformation_artifact.preprocessor_object_file_path, "rb"
+            ) as f:
+                preprocessor = pickle.load(f)
+
+            # Load model config
+            with open(self.config.model_config_file_path, "r") as f:
+                config = yaml.safe_load(f)
+
+            gs_cfg = config["grid_search"]["params"]
+            models_cfg = config["model_selection"]
+
+            # Plain GridSearchCV for each model on pre-resampled data
+            results = []
+            for key in sorted(models_cfg.keys()):
+                mcfg = models_cfg[key]
+                cls_name = mcfg["class"]
+                cls = MODEL_CLASSES[cls_name]
+                base_params = dict(mcfg.get("params", {}))
+                param_grid = mcfg.get("search_param_grid", {})
+
+                logging.info(f"Training {cls_name} ...")
+                estimator = cls(**base_params)
+
+                gs = GridSearchCV(
+                    estimator,
+                    param_grid=param_grid,
+                    cv=gs_cfg["cv"],
+                    scoring=gs_cfg["scoring"],
+                    verbose=gs_cfg.get("verbose", 0),
+                    n_jobs=-1,
+                )
+                gs.fit(X_train, y_train)
+
+                # Evaluate on unresampled test data
+                y_pred_train = gs.best_estimator_.predict(X_train)
+                y_pred_test = gs.best_estimator_.predict(X_test)
+                train_f1 = f1_score(y_train, y_pred_train)
+                test_f1 = f1_score(y_test, y_pred_test)
+                test_acc = accuracy_score(y_test, y_pred_test)
+
+                results.append(
+                    {
+                        "name": cls_name,
+                        "best_params": gs.best_params_,
+                        "cv_f1": gs.best_score_,
+                        "train_f1": train_f1,
+                        "test_f1": test_f1,
+                        "test_acc": test_acc,
+                        "model": gs.best_estimator_,
+                    }
+                )
+                logging.info(
+                    f"  {cls_name}: CV F1={gs.best_score_:.4f}, "
+                    f"Test F1={test_f1:.4f}, Test Acc={test_acc:.4f}"
+                )
+
+            # Select best model by test F1
+            best = max(results, key=lambda r: r["test_f1"])
+            logging.info(
+                f"Best model: {best['name']} (Test F1={best['test_f1']:.4f})"
+            )
+
+            # Log classification report
+            y_pred_best = best["model"].predict(X_test)
+            report = classification_report(
+                y_test, y_pred_best, target_names=["Certified", "Denied"]
+            )
+            logging.info(f"Classification report:\n{report}")
+
+            if best["test_f1"] < self.config.expected_accuracy:
+                logging.warning(
+                    f"Best F1 ({best['test_f1']:.4f}) below threshold "
+                    f"({self.config.expected_accuracy})"
+                )
+
+            # Bundle preprocessor + best classifier into visaModel
+            visa_model = visaModel(
+                preprocessing_object=preprocessor,
+                trained_model_object=best["model"],
+            )
+
+            os.makedirs(
+                os.path.dirname(self.config.trained_model_file_path), exist_ok=True
+            )
+            with open(self.config.trained_model_file_path, "wb") as f:
+                pickle.dump(visa_model, f)
+            logging.info(f"Model saved to {self.config.trained_model_file_path}")
+
+            return ModelTrainerArtifact(
+                trained_model_file_path=self.config.trained_model_file_path,
+                train_f1_score=best["train_f1"],
+                test_f1_score=best["test_f1"],
+                test_accuracy=best["test_acc"],
+                best_model_name=best["name"],
+            )
+
+        except Exception as e:
+            raise visaException(e, sys) from e

visa_approval_prediction/entity/artifact_entity.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class DataIngestionArtifact:
+    train_file_path: str
+    test_file_path: str
+
+
+@dataclass
+class DataValidationArtifact:
+    validation_status: bool
+    message: str
+    drift_report_file_path: str
+
+
+@dataclass
+class DataTransformationArtifact:
+    transformed_train_file_path: str
+    transformed_test_file_path: str
+    transformed_train_target_path: str
+    transformed_test_target_path: str
+    preprocessor_object_file_path: str
+
+
+@dataclass
+class ModelTrainerArtifact:
+    trained_model_file_path: str
+    train_f1_score: float
+    test_f1_score: float
+    test_accuracy: float
+    best_model_name: str
+
+
+@dataclass
+class ModelEvaluationArtifact:
+    is_model_accepted: bool
+    best_model_path: str
+    trained_model_f1_score: float
+    best_model_f1_score: float

visa_approval_prediction/entity/config_entity.py

@@ -0,0 +1,92 @@
+import os
+from datetime import datetime
+from visa_approval_prediction.constants import (
+    ARTIFACT_DIR,
+    DATA_INGESTION_DIR_NAME,
+    DATA_INGESTION_TRAIN_TEST_SPLIT_RATIO,
+    TRAIN_FILE_NAME,
+    TEST_FILE_NAME,
+    DATA_VALIDATION_DIR_NAME,
+    DATA_VALIDATION_DRIFT_REPORT_DIR,
+    DATA_VALIDATION_DRIFT_REPORT_FILE_NAME,
+    SCHEMA_FILE_PATH,
+    DATA_TRANSFORMATION_DIR_NAME,
+    DATA_TRANSFORMATION_TRANSFORMED_DATA_DIR,
+    DATA_TRANSFORMATION_TRANSFORMED_OBJECT_DIR,
+    PREPROCSSING_OBJECT_FILE_NAME,
+    MODEL_TRAINER_DIR_NAME,
+    MODEL_TRAINER_TRAINED_MODEL_DIR,
+    MODEL_TRAINER_TRAINED_MODEL_NAME,
+    MODEL_TRAINER_EXPECTED_SCORE,
+    MODEL_TRAINER_MODEL_CONFIG_FILE_PATH,
+    MODEL_EVALUATION_CHANGED_THRESHOLD_SCORE,
+    MODEL_FILE_NAME,
+)
+
+
+class TrainingPipelineConfig:
+    def __init__(self, timestamp=None):
+        self.timestamp = timestamp or datetime.now().strftime("%m_%d_%Y_%H_%M_%S")
+        self.artifact_dir = os.path.join(ARTIFACT_DIR, self.timestamp)
+
+
+class DataIngestionConfig:
+    def __init__(self, training_pipeline_config: TrainingPipelineConfig):
+        self.data_source_path = "EasyVisa.csv"
+        self.split_ratio = DATA_INGESTION_TRAIN_TEST_SPLIT_RATIO
+        ingestion_dir = os.path.join(
+            training_pipeline_config.artifact_dir, DATA_INGESTION_DIR_NAME
+        )
+        self.train_file_path = os.path.join(ingestion_dir, TRAIN_FILE_NAME)
+        self.test_file_path = os.path.join(ingestion_dir, TEST_FILE_NAME)
+
+
+class DataValidationConfig:
+    def __init__(self, training_pipeline_config: TrainingPipelineConfig):
+        validation_dir = os.path.join(
+            training_pipeline_config.artifact_dir, DATA_VALIDATION_DIR_NAME
+        )
+        self.schema_file_path = SCHEMA_FILE_PATH
+        self.drift_report_file_path = os.path.join(
+            validation_dir,
+            DATA_VALIDATION_DRIFT_REPORT_DIR,
+            DATA_VALIDATION_DRIFT_REPORT_FILE_NAME,
+        )
+
+
+class DataTransformationConfig:
+    def __init__(self, training_pipeline_config: TrainingPipelineConfig):
+        transformation_dir = os.path.join(
+            training_pipeline_config.artifact_dir, DATA_TRANSFORMATION_DIR_NAME
+        )
+        data_dir = os.path.join(
+            transformation_dir, DATA_TRANSFORMATION_TRANSFORMED_DATA_DIR
+        )
+        object_dir = os.path.join(
+            transformation_dir, DATA_TRANSFORMATION_TRANSFORMED_OBJECT_DIR
+        )
+        self.transformed_train_file_path = os.path.join(data_dir, "train.npy")
+        self.transformed_test_file_path = os.path.join(data_dir, "test.npy")
+        self.transformed_train_target_path = os.path.join(data_dir, "train_target.npy")
+        self.transformed_test_target_path = os.path.join(data_dir, "test_target.npy")
+        self.preprocessor_object_file_path = os.path.join(
+            object_dir, PREPROCSSING_OBJECT_FILE_NAME
+        )
+
+
+class ModelTrainerConfig:
+    def __init__(self, training_pipeline_config: TrainingPipelineConfig):
+        trainer_dir = os.path.join(
+            training_pipeline_config.artifact_dir, MODEL_TRAINER_DIR_NAME
+        )
+        self.trained_model_file_path = os.path.join(
+            trainer_dir, MODEL_TRAINER_TRAINED_MODEL_DIR, MODEL_TRAINER_TRAINED_MODEL_NAME
+        )
+        self.expected_accuracy = MODEL_TRAINER_EXPECTED_SCORE
+        self.model_config_file_path = MODEL_TRAINER_MODEL_CONFIG_FILE_PATH
+
+
+class ModelEvaluationConfig:
+    def __init__(self, training_pipeline_config: TrainingPipelineConfig):
+        self.changed_threshold_score = MODEL_EVALUATION_CHANGED_THRESHOLD_SCORE
+        self.best_model_path = os.path.join(ARTIFACT_DIR, MODEL_FILE_NAME)

visa_approval_prediction/entity/estimator.py

@@ -16,6 +16,31 @@ class TargetValueMapping:
     
     
 
+class ThresholdClassifier:
+    """Wraps a trained model and applies a custom probability threshold for predict()."""
+    def __init__(self, base_model, threshold=0.5):
+        self.base_model = base_model
+        self.threshold = threshold
+
+    def predict(self, X):
+        import numpy as np
+        proba = self.base_model.predict_proba(X)[:, 1]
+        return (proba >= self.threshold).astype(int)
+
+    def predict_proba(self, X):
+        return self.base_model.predict_proba(X)
+
+    @property
+    def classes_(self):
+        return self.base_model.classes_
+
+    def __repr__(self):
+        return f"ThresholdClassifier({type(self.base_model).__name__}, threshold={self.threshold:.3f})"
+
+    def __str__(self):
+        return self.__repr__()
+
+
 class visaModel:
     def __init__(self, preprocessing_object: Pipeline, trained_model_object: object):
         """

visa_approval_prediction/pipeline/training_pipeline.py

@@ -0,0 +1,113 @@
+import sys
+
+from visa_approval_prediction.entity.config_entity import (
+    TrainingPipelineConfig,
+    DataIngestionConfig,
+    DataValidationConfig,
+    DataTransformationConfig,
+    ModelTrainerConfig,
+    ModelEvaluationConfig,
+)
+from visa_approval_prediction.components.data_ingestion import DataIngestion
+from visa_approval_prediction.components.data_validation import DataValidation
+from visa_approval_prediction.components.data_transformation import DataTransformation
+from visa_approval_prediction.components.model_trainer import ModelTrainer
+from visa_approval_prediction.components.model_evaluation import ModelEvaluation
+from visa_approval_prediction.exception import visaException
+from visa_approval_prediction.logger import logging
+
+
+class TrainingPipeline:
+    def __init__(self):
+        self.pipeline_config = TrainingPipelineConfig()
+
+    def start_data_ingestion(self):
+        config = DataIngestionConfig(self.pipeline_config)
+        component = DataIngestion(config)
+        return component.initiate_data_ingestion()
+
+    def start_data_validation(self, ingestion_artifact):
+        config = DataValidationConfig(self.pipeline_config)
+        component = DataValidation(config, ingestion_artifact)
+        return component.initiate_data_validation()
+
+    def start_data_transformation(self, ingestion_artifact):
+        config = DataTransformationConfig(self.pipeline_config)
+        component = DataTransformation(config, ingestion_artifact)
+        return component.initiate_data_transformation()
+
+    def start_model_training(self, transformation_artifact):
+        config = ModelTrainerConfig(self.pipeline_config)
+        component = ModelTrainer(config, transformation_artifact)
+        return component.initiate_model_training()
+
+    def start_model_evaluation(self, trainer_artifact, ingestion_artifact):
+        config = ModelEvaluationConfig(self.pipeline_config)
+        component = ModelEvaluation(config, trainer_artifact, ingestion_artifact)
+        return component.initiate_model_evaluation()
+
+    def run(self):
+        try:
+            print("=" * 60)
+            print("VISA APPROVAL PREDICTION - TRAINING PIPELINE")
+            print("=" * 60)
+
+            # Stage 1: Data Ingestion
+            print("\n[1/5] Data Ingestion ...")
+            logging.info(">>> Stage 1: Data Ingestion")
+            ingestion_artifact = self.start_data_ingestion()
+            print(f"      Train: {ingestion_artifact.train_file_path}")
+            print(f"      Test:  {ingestion_artifact.test_file_path}")
+
+            # Stage 2: Data Validation
+            print("\n[2/5] Data Validation ...")
+            logging.info(">>> Stage 2: Data Validation")
+            validation_artifact = self.start_data_validation(ingestion_artifact)
+            print(f"      Status: {validation_artifact.message}")
+            if not validation_artifact.validation_status:
+                raise Exception(
+                    f"Data validation failed: {validation_artifact.message}"
+                )
+
+            # Stage 3: Data Transformation
+            print("\n[3/5] Data Transformation ...")
+            logging.info(">>> Stage 3: Data Transformation")
+            transformation_artifact = self.start_data_transformation(
+                ingestion_artifact
+            )
+            print(f"      Preprocessor: {transformation_artifact.preprocessor_object_file_path}")
+
+            # Stage 4: Model Training
+            print("\n[4/5] Model Training (this may take a while) ...")
+            logging.info(">>> Stage 4: Model Training")
+            trainer_artifact = self.start_model_training(transformation_artifact)
+            print(f"      Best model:  {trainer_artifact.best_model_name}")
+            print(f"      Test Acc:    {trainer_artifact.test_accuracy:.4f}")
+            print(f"      Test F1:     {trainer_artifact.test_f1_score:.4f}")
+
+            # Stage 5: Model Evaluation
+            print("\n[5/5] Model Evaluation ...")
+            logging.info(">>> Stage 5: Model Evaluation")
+            evaluation_artifact = self.start_model_evaluation(
+                trainer_artifact, ingestion_artifact
+            )
+            print(f"      New model F1:      {evaluation_artifact.trained_model_f1_score:.4f}")
+            print(f"      Existing model F1: {evaluation_artifact.best_model_f1_score:.4f}")
+            print(f"      Accepted: {evaluation_artifact.is_model_accepted}")
+            print(f"      Model:    {evaluation_artifact.best_model_path}")
+
+            print("\n" + "=" * 60)
+            print("PIPELINE COMPLETE")
+            print("=" * 60)
+
+            logging.info("Training pipeline finished successfully")
+            return evaluation_artifact
+
+        except Exception as e:
+            logging.error(f"Training pipeline failed: {e}")
+            raise visaException(e, sys) from e
+
+
+if __name__ == "__main__":
+    pipeline = TrainingPipeline()
+    pipeline.run()