Add main pipelines and rename stages

src/mlpipeline/pipeline/__init__.py

@@ -0,0 +1,4 @@
+from mlpipeline.pipeline.training_pipeline import TrainingPipeline
+from mlpipeline.pipeline.prediction_pipeline import PredictionPipeline
+
+__all__ = ["TrainingPipeline", "PredictionPipeline"]

src/mlpipeline/pipeline/prediction_pipeline.py

@@ -0,0 +1,78 @@
+import pandas as pd
+from pathlib import Path
+from autogluon.tabular import TabularPredictor
+from mlpipeline.logging.logger import get_logger
+from mlpipeline.exception import MLPipelineException
+import sys
+
+logger = get_logger(__name__)
+
+
+class PredictionPipeline:
+    def __init__(self, model_path: str = "models/production/model"):
+        self.model_path = Path(model_path)
+        self.model = None
+    
+    def load_model(self):
+        try:
+            if not self.model_path.exists():
+                raise FileNotFoundError(f"Model not found at {self.model_path}")
+            
+            logger.info(f"Loading model from {self.model_path}")
+            self.model = TabularPredictor.load(str(self.model_path))
+            logger.info("Model loaded successfully")
+            
+        except Exception as e:
+            raise MLPipelineException(f"Failed to load model: {str(e)}", sys)
+    
+    def predict(self, input_data: pd.DataFrame) -> dict:
+        try:
+            if self.model is None:
+                self.load_model()
+            
+            logger.info("Making predictions")
+            predictions = self.model.predict(input_data)
+            binary_predictions = (predictions > 0).astype(int)
+            
+            try:
+                probabilities = self.model.predict_proba(input_data)
+                proba_list = probabilities.values.tolist() if hasattr(probabilities, 'values') else probabilities
+            except:
+                proba_list = None
+            
+            result = {
+                "predictions": binary_predictions.tolist(),
+                "probabilities": proba_list,
+                "num_samples": len(input_data)
+            }
+            
+            logger.info(f"Predictions completed for {len(input_data)} samples")
+            return result
+            
+        except Exception as e:
+            raise MLPipelineException(f"Prediction failed: {str(e)}", sys)
+    
+    def predict_single(self, input_dict: dict) -> dict:
+        try:
+            df = pd.DataFrame([input_dict])
+            result = self.predict(df)
+            
+            return {
+                "prediction": result["predictions"][0],
+                "probability": result["probabilities"][0] if result["probabilities"] else None
+            }
+            
+        except Exception as e:
+            raise MLPipelineException(f"Single prediction failed: {str(e)}", sys)
+
+
+if __name__ == "__main__":
+    pipeline = PredictionPipeline()
+    test_data = pd.read_csv("artifacts/feature_engineering/test_features.csv")
+    
+    if "Heart Disease" in test_data.columns:
+        test_data = test_data.drop(columns=["Heart Disease"])
+    
+    results = pipeline.predict(test_data.head(10))
+    logger.info(f"Predictions: {results['predictions']}")
+    logger.info(f"Number of samples: {results['num_samples']}")

src/mlpipeline/pipeline/training_pipeline.py

@@ -0,0 +1,126 @@
+from mlpipeline.logging.logger import get_logger
+from mlpipeline.exception import MLPipelineException
+from mlpipeline.config.configuration import ConfigurationManager
+from mlpipeline.components.data_ingestion import DataIngestion
+from mlpipeline.components.data_validation import DataValidation
+from mlpipeline.components.data_transformation import DataTransformation
+from mlpipeline.components.feature_engineering import FeatureEngineering
+from mlpipeline.components.automl_trainer import AutoMLTrainer
+from mlpipeline.components.model_evaluation import ModelEvaluation
+from mlpipeline.components.model_pusher import ModelPusher
+import sys
+
+logger = get_logger(__name__)
+
+
+class TrainingPipeline:
+    def __init__(self):
+        self.config_manager = ConfigurationManager()
+    
+    def run_data_ingestion(self):
+        try:
+            logger.info("Stage 1: Data Ingestion started")
+            config = self.config_manager.get_data_ingestion_config()
+            data_ingestion = DataIngestion(config)
+            artifact = data_ingestion.download_data()
+            logger.info(f"Stage 1: Data Ingestion completed - {artifact}")
+            return artifact
+        except Exception as e:
+            raise MLPipelineException(str(e), sys)
+    
+    def run_data_validation(self):
+        try:
+            logger.info("Stage 2: Data Validation started")
+            config = self.config_manager.get_data_validation_config()
+            data_validation = DataValidation(config)
+            artifact = data_validation.validate_schema()
+            logger.info(f"Stage 2: Data Validation completed - {artifact}")
+            return artifact
+        except Exception as e:
+            raise MLPipelineException(str(e), sys)
+    
+    def run_data_transformation(self):
+        try:
+            logger.info("Stage 3: Data Transformation started")
+            config = self.config_manager.get_data_transformation_config()
+            data_transformation = DataTransformation(config)
+            artifact = data_transformation.transform()
+            logger.info(f"Stage 3: Data Transformation completed - {artifact}")
+            return artifact
+        except Exception as e:
+            raise MLPipelineException(str(e), sys)
+    
+    def run_feature_engineering(self):
+        try:
+            logger.info("Stage 4: Feature Engineering started")
+            config = self.config_manager.get_feature_engineering_config()
+            feature_engineering = FeatureEngineering(config)
+            artifact = feature_engineering.engineer_features()
+            logger.info(f"Stage 4: Feature Engineering completed - {artifact}")
+            return artifact
+        except Exception as e:
+            raise MLPipelineException(str(e), sys)
+    
+    def run_model_training(self):
+        try:
+            logger.info("Stage 5: Model Training started")
+            config = self.config_manager.get_model_trainer_config()
+            model_trainer = AutoMLTrainer(config)
+            artifact = model_trainer.train()
+            logger.info(f"Stage 5: Model Training completed - {artifact}")
+            return artifact
+        except Exception as e:
+            raise MLPipelineException(str(e), sys)
+    
+    def run_model_evaluation(self):
+        try:
+            logger.info("Stage 6: Model Evaluation started")
+            config = self.config_manager.get_model_evaluation_config()
+            model_evaluation = ModelEvaluation(config)
+            artifact = model_evaluation.evaluate()
+            logger.info(f"Stage 6: Model Evaluation completed - {artifact}")
+            return artifact
+        except Exception as e:
+            raise MLPipelineException(str(e), sys)
+    
+    def run_model_pusher(self):
+        try:
+            logger.info("Stage 7: Model Pusher started")
+            config = self.config_manager.get_model_pusher_config()
+            model_pusher = ModelPusher(config)
+            artifact = model_pusher.push_model()
+            logger.info(f"Stage 7: Model Pusher completed - {artifact}")
+            return artifact
+        except Exception as e:
+            raise MLPipelineException(str(e), sys)
+    
+    def run_pipeline(self):
+        try:
+            logger.info("=" * 50)
+            logger.info("Training Pipeline Started")
+            logger.info("=" * 50)
+            
+            self.run_data_ingestion()
+            self.run_data_validation()
+            self.run_data_transformation()
+            self.run_feature_engineering()
+            self.run_model_training()
+            eval_artifact = self.run_model_evaluation()
+            push_artifact = self.run_model_pusher()
+            
+            logger.info("=" * 50)
+            logger.info("Training Pipeline Completed Successfully")
+            logger.info(f"Model Accuracy: {eval_artifact.evaluation_metrics.get('accuracy', 'N/A')}")
+            logger.info(f"Model Location: {push_artifact.pushed_model_path}")
+            logger.info("=" * 50)
+            
+            return push_artifact
+            
+        except Exception as e:
+            logger.error(f"Training Pipeline Failed: {str(e)}")
+            raise MLPipelineException(str(e), sys)
+
+
+if __name__ == "__main__":
+    pipeline = TrainingPipeline()
+    pipeline.run_pipeline()