pulseflow-mlops 0.1.0__tar.gz

pulseflow_mlops-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anil Prasad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pulseflow_mlops-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: pulseflow-mlops
+Version: 0.1.0
+Summary: Production-grade open source MLOps pipeline for enterprise data engineering and predictive modeling
+Author-email: Anil Prasad <anil@ambharii.com>
+License: MIT
+Project-URL: Homepage, https://github.com/anilatambharii/PulseFlow
+Project-URL: Documentation, https://github.com/anilatambharii/PulseFlow/blob/main/README.md
+Keywords: mlops,machine-learning,fastapi,airflow,mlflow,etl
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Enterprise MLOps Pipeline
+
+This repository provides a production-ready MLOps template for building and deploying machine learning pipelines in enterprise environments.
+
+## Architecture Overview
+
+Components included:
+- ETL Pipeline: Data ingestion and preprocessing.
+- Training Pipeline: Model training with MLflow tracking.
+- Deployment Service: FastAPI microservice for real-time inference.
+- Airflow Orchestration: Workflow automation for end-to-end pipelines.
+- Dockerized Stack: Easily deployable with Docker Compose.
+
+## Run Locally
+
+### Prerequisites
+- Python 3.10+
+- Docker & Docker Compose
+
+### 1. Install dependencies
+python -m venv .venv
+source .venv/bin/activate # or .venv\Scripts\activate on Windows
+pip install -r requirements.txt
+
+
+### 2. Run the pipeline manually
+
+python etl/data_ingestion.py
+python etl/data_preprocessing.py
+python training/train_model.py
+uvicorn deployment.app.main:app --reload
+
+
+### 3. Start MLflow and Airflow (optional)
+
+mlflow ui &
+airflow db init && airflow webserver -p 8080 & airflow scheduler &
+
+
+### 4. Run full stack with Docker
+docker-compose up --build

pulseflow_mlops-0.1.0/README.md

@@ -0,0 +1,41 @@
+# Enterprise MLOps Pipeline
+
+This repository provides a production-ready MLOps template for building and deploying machine learning pipelines in enterprise environments.
+
+## Architecture Overview
+
+Components included:
+- ETL Pipeline: Data ingestion and preprocessing.
+- Training Pipeline: Model training with MLflow tracking.
+- Deployment Service: FastAPI microservice for real-time inference.
+- Airflow Orchestration: Workflow automation for end-to-end pipelines.
+- Dockerized Stack: Easily deployable with Docker Compose.
+
+## Run Locally
+
+### Prerequisites
+- Python 3.10+
+- Docker & Docker Compose
+
+### 1. Install dependencies
+python -m venv .venv
+source .venv/bin/activate # or .venv\Scripts\activate on Windows
+pip install -r requirements.txt
+
+
+### 2. Run the pipeline manually
+
+python etl/data_ingestion.py
+python etl/data_preprocessing.py
+python training/train_model.py
+uvicorn deployment.app.main:app --reload
+
+
+### 3. Start MLflow and Airflow (optional)
+
+mlflow ui &
+airflow db init && airflow webserver -p 8080 & airflow scheduler &
+
+
+### 4. Run full stack with Docker
+docker-compose up --build

pulseflow_mlops-0.1.0/airflow/dags/mlops_workflow_dag.py

@@ -0,0 +1,56 @@
+from airflow import DAG
+from airflow.operators.python import PythonOperator
+from datetime import datetime, timedelta
+import subprocess
+
+
+def run_etl():
+    subprocess.run(['python', 'etl/data_ingestion.py'], check=True)
+    subprocess.run(['python', 'etl/data_preprocessing.py'], check=True)
+
+
+def run_training():
+    subprocess.run(['python', 'training/train_model.py'], check=True)
+
+
+def run_deployment():
+    subprocess.run(['uvicorn', 'deployment.app.main:app', '--host', '0.0.0.0', '--port', '8000'], check=True)
+
+
+default_args = {
+    'owner': 'airflow',
+    'depends_on_past': False,
+    'email_on_failure': False,
+    'email_on_retry': False,
+    'retries': 1,
+    'retry_delay': timedelta(minutes=2),
+}
+
+dag = DAG(
+    'mlops_pipeline_dag',
+    default_args=default_args,
+    description='End-to-end Enterprise MLOps workflow',
+    schedule_interval='@daily',
+    start_date=datetime(2025, 1, 1),
+    catchup=False,
+)
+
+etl_task = PythonOperator(
+    task_id='run_etl',
+    python_callable=run_etl,
+    dag=dag,
+)
+
+train_task = PythonOperator(
+    task_id='run_training',
+    python_callable=run_training,
+    dag=dag,
+)
+
+deploy_task = PythonOperator(
+    task_id='run_deployment',
+    python_callable=run_deployment,
+    dag=dag,
+)
+
+etl_task >> train_task >> deploy_task

pulseflow_mlops-0.1.0/deployment/app/main.py

@@ -0,0 +1,170 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import pandas as pd
+from typing import List, Dict
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from app.model_loader import ModelLoader
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Enterprise MLOps Prediction API",
+    description="Production-grade ML model serving with FastAPI",
+    version="1.0.0"
+)
+
+# Initialize model loader
+model_loader = ModelLoader(model_path="models/saved_model.pkl")
+
+
+class PredictionInput(BaseModel):
+    """Schema for single prediction request"""
+    features: Dict[str, float]
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "features": {
+                    "feature1": 50.0,
+                    "feature2": 75.0
+                }
+            }
+        }
+
+
+class BatchPredictionInput(BaseModel):
+    """Schema for batch prediction request"""
+    data: List[Dict[str, float]]
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "data": [
+                    {"feature1": 50.0, "feature2": 75.0},
+                    {"feature1": 30.0, "feature2": 45.0}
+                ]
+            }
+        }
+
+
+class PredictionResponse(BaseModel):
+    """Schema for prediction response"""
+    prediction: float
+    model_version: str
+
+
+class BatchPredictionResponse(BaseModel):
+    """Schema for batch prediction response"""
+    predictions: List[float]
+    model_version: str
+    count: int
+
+
+@app.get("/")
+def root():
+    """Health check endpoint"""
+    return {
+        "status": "online",
+        "service": "Enterprise MLOps Prediction API",
+        "version": "1.0.0"
+    }
+
+
+@app.get("/health")
+def health_check():
+    """Detailed health check"""
+    model_status = "loaded" if model_loader.model is not None else "not_loaded"
+    return {
+        "status": "healthy",
+        "model_status": model_status,
+        "model_path": model_loader.model_path
+    }
+
+
+@app.post("/predict", response_model=PredictionResponse)
+def predict(input_data: PredictionInput):
+    """
+    Single prediction endpoint
+    
+    Args:
+        input_data: Dictionary of feature names and values
+        
+    Returns:
+        Prediction result and model version
+    """
+    try:
+        # Convert input to DataFrame
+        df = pd.DataFrame([input_data.features])
+        
+        # Make prediction
+        prediction = model_loader.predict(df)
+        
+        return PredictionResponse(
+            prediction=float(prediction[0]),
+            model_version=model_loader.get_model_version()
+        )
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Prediction error: {str(e)}")
+
+
+@app.post("/predict/batch", response_model=BatchPredictionResponse)
+def predict_batch(input_data: BatchPredictionInput):
+    """
+    Batch prediction endpoint
+    
+    Args:
+        input_data: List of feature dictionaries
+        
+    Returns:
+        List of predictions and model version
+    """
+    try:
+        # Convert input to DataFrame
+        df = pd.DataFrame(input_data.data)
+        
+        # Make predictions
+        predictions = model_loader.predict(df)
+        
+        return BatchPredictionResponse(
+            predictions=[float(p) for p in predictions],
+            model_version=model_loader.get_model_version(),
+            count=len(predictions)
+        )
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Batch prediction error: {str(e)}")
+
+
+@app.get("/model/info")
+def model_info():
+    """Get model metadata and information"""
+    return {
+        "model_path": model_loader.model_path,
+        "model_version": model_loader.get_model_version(),
+        "model_type": str(type(model_loader.model).__name__) if model_loader.model else None,
+        "status": "loaded" if model_loader.model else "not_loaded"
+    }
+
+
+@app.post("/model/reload")
+def reload_model():
+    """Reload the model from disk"""
+    try:
+        model_loader.load_model()
+        return {
+            "status": "success",
+            "message": "Model reloaded successfully",
+            "model_version": model_loader.get_model_version()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Model reload error: {str(e)}")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

pulseflow_mlops-0.1.0/deployment/app/model_loader.py

@@ -0,0 +1,79 @@
+import os
+import joblib
+from datetime import datetime
+from typing import Any
+import numpy as np
+import pandas as pd
+
+
+class ModelLoader:
+    """
+    Model loader and manager for ML model serving
+    """
+    
+    def __init__(self, model_path: str = "models/saved_model.pkl"):
+        """
+        Initialize model loader
+        
+        Args:
+            model_path: Path to the saved model file
+        """
+        self.model_path = model_path
+        self.model = None
+        self.loaded_at = None
+        
+        # Load model on initialization
+        self.load_model()
+    
+    def load_model(self):
+        """Load the model from disk"""
+        if not os.path.exists(self.model_path):
+            raise FileNotFoundError(f"Model file not found at {self.model_path}")
+        
+        print(f"Loading model from {self.model_path}...")
+        self.model = joblib.load(self.model_path)
+        self.loaded_at = datetime.now()
+        print(f"Model loaded successfully at {self.loaded_at}")
+    
+    def predict(self, features: pd.DataFrame) -> np.ndarray:
+        """
+        Make predictions using the loaded model
+        
+        Args:
+            features: DataFrame with feature columns
+            
+        Returns:
+            Array of predictions
+        """
+        if self.model is None:
+            raise ValueError("Model not loaded. Call load_model() first.")
+        
+        predictions = self.model.predict(features)
+        return predictions
+    
+    def get_model_version(self) -> str:
+        """
+        Get model version based on file modification time
+        
+        Returns:
+            Model version string
+        """
+        if not os.path.exists(self.model_path):
+            return "unknown"
+        
+        mod_time = os.path.getmtime(self.model_path)
+        return datetime.fromtimestamp(mod_time).strftime("%Y%m%d_%H%M%S")
+    
+    def get_model_info(self) -> dict:
+        """
+        Get detailed model information
+        
+        Returns:
+            Dictionary with model metadata
+        """
+        return {
+            "model_path": self.model_path,
+            "model_type": str(type(self.model).__name__) if self.model else None,
+            "loaded_at": self.loaded_at.isoformat() if self.loaded_at else None,
+            "version": self.get_model_version()
+        }

pulseflow_mlops-0.1.0/etl/data_ingestion.py

@@ -0,0 +1,36 @@
+import os
+import pandas as pd
+
+def load_data(source_path: str, output_path: str):
+    if not os.path.exists(source_path):
+        raise FileNotFoundError(f"Source data not found at {source_path}")
+
+    print(f"Loading data from {source_path}...")
+    df = pd.read_csv(source_path)
+    print(f"Loaded {len(df)} records.")
+
+    # Basic cleaning: drop duplicates and NaNs
+    df = df.drop_duplicates().dropna()
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    df.to_parquet(output_path, index=False)
+
+    print(f"Data saved to {output_path}")
+    return df
+
+if __name__ == "__main__":
+    INPUT_FILE = 'data/sample.csv'
+    OUTPUT_FILE = 'data/intermediate.parquet'
+    os.makedirs('data', exist_ok=True)
+
+    # Generate synthetic data if sample.csv doesn't exist
+    if not os.path.exists(INPUT_FILE):
+        print("sample.csv not found — generating mock dataset...")
+        sample_df = pd.DataFrame({
+            'feature1': range(100),
+            'feature2': [x * 1.5 for x in range(100)],
+            'target': [x * 3 + 5 for x in range(100)]
+        })
+        sample_df.to_csv(INPUT_FILE, index=False)
+
+    load_data(INPUT_FILE, OUTPUT_FILE)

pulseflow_mlops-0.1.0/etl/data_preprocessing.py

@@ -0,0 +1,31 @@
+import os
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
+
+def preprocess_data(input_path: str, output_path: str):
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"Input parquet file not found at {input_path}")
+
+    print(f"Preprocessing data from {input_path}...")
+    df = pd.read_parquet(input_path)
+
+    # Identify numeric columns
+    num_cols = df.select_dtypes(include='number').columns.tolist()
+
+    if 'target' in num_cols:
+        num_cols.remove('target')
+
+    print(f"Scaling columns: {num_cols}")
+    scaler = StandardScaler()
+    df[num_cols] = scaler.fit_transform(df[num_cols])
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    df.to_parquet(output_path, index=False)
+    print(f"Preprocessed data saved to {output_path}")
+    return df
+
+if __name__ == "__main__":
+    INPUT_FILE = 'data/intermediate.parquet'
+    OUTPUT_FILE = 'data/processed.parquet'
+
+    preprocess_data(INPUT_FILE, OUTPUT_FILE)

pulseflow_mlops-0.1.0/models/generate_model.py

@@ -0,0 +1,71 @@
+import os
+import pandas as pd
+import numpy as np
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import train_test_split
+import joblib
+
+def generate_sample_data():
+    """Generate synthetic sample data"""
+    np.random.seed(42)
+    n_samples = 1000
+    
+    data = {
+        'feature1': np.random.randn(n_samples) * 10 + 50,
+        'feature2': np.random.randn(n_samples) * 15 + 75,
+        'target': None
+    }
+    
+    # Create target as a function of features with some noise
+    data['target'] = (
+        data['feature1'] * 2.5 + 
+        data['feature2'] * 1.8 + 
+        np.random.randn(n_samples) * 5
+    )
+    
+    return pd.DataFrame(data)
+
+def train_and_save_model(output_path='models/saved_model.pkl'):
+    """Train a simple model and save it"""
+    
+    print("Generating sample dataset...")
+    df = generate_sample_data()
+    
+    X = df[['feature1', 'feature2']]
+    y = df['target']
+    
+    print(f"Dataset shape: {X.shape}")
+    
+    # Split data
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+    
+    print("Training Random Forest model...")
+    model = RandomForestRegressor(
+        n_estimators=100,
+        max_depth=10,
+        min_samples_split=5,
+        random_state=42
+    )
+    
+    model.fit(X_train, y_train)
+    
+    # Evaluate
+    train_score = model.score(X_train, y_train)
+    test_score = model.score(X_test, y_test)
+    
+    print(f"Train R² Score: {train_score:.4f}")
+    print(f"Test R² Score: {test_score:.4f}")
+    
+    # Save model
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    joblib.dump(model, output_path)
+    
+    print(f"\nModel saved to: {output_path}")
+    print(f"Model file size: {os.path.getsize(output_path) / 1024:.2f} KB")
+    
+    return model
+
+if __name__ == "__main__":
+    train_and_save_model()

pulseflow_mlops-0.1.0/pulseflow_mlops.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: pulseflow-mlops
+Version: 0.1.0
+Summary: Production-grade open source MLOps pipeline for enterprise data engineering and predictive modeling
+Author-email: Anil Prasad <anil@ambharii.com>
+License: MIT
+Project-URL: Homepage, https://github.com/anilatambharii/PulseFlow
+Project-URL: Documentation, https://github.com/anilatambharii/PulseFlow/blob/main/README.md
+Keywords: mlops,machine-learning,fastapi,airflow,mlflow,etl
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Enterprise MLOps Pipeline
+
+This repository provides a production-ready MLOps template for building and deploying machine learning pipelines in enterprise environments.
+
+## Architecture Overview
+
+Components included:
+- ETL Pipeline: Data ingestion and preprocessing.
+- Training Pipeline: Model training with MLflow tracking.
+- Deployment Service: FastAPI microservice for real-time inference.
+- Airflow Orchestration: Workflow automation for end-to-end pipelines.
+- Dockerized Stack: Easily deployable with Docker Compose.
+
+## Run Locally
+
+### Prerequisites
+- Python 3.10+
+- Docker & Docker Compose
+
+### 1. Install dependencies
+python -m venv .venv
+source .venv/bin/activate # or .venv\Scripts\activate on Windows
+pip install -r requirements.txt
+
+
+### 2. Run the pipeline manually
+
+python etl/data_ingestion.py
+python etl/data_preprocessing.py
+python training/train_model.py
+uvicorn deployment.app.main:app --reload
+
+
+### 3. Start MLflow and Airflow (optional)
+
+mlflow ui &
+airflow db init && airflow webserver -p 8080 & airflow scheduler &
+
+
+### 4. Run full stack with Docker
+docker-compose up --build

pulseflow_mlops-0.1.0/pulseflow_mlops.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+airflow/dags/mlops_workflow_dag.py
+deployment/app/__init__.py
+deployment/app/main.py
+deployment/app/model_loader.py
+etl/__init__.py
+etl/data_ingestion.py
+etl/data_preprocessing.py
+models/generate_model.py
+pulseflow_mlops.egg-info/PKG-INFO
+pulseflow_mlops.egg-info/SOURCES.txt
+pulseflow_mlops.egg-info/dependency_links.txt
+pulseflow_mlops.egg-info/top_level.txt
+training/__init__.py
+training/evaluate_model.py
+training/train_model.py

pulseflow_mlops-0.1.0/pulseflow_mlops.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pulseflow_mlops-0.1.0/pulseflow_mlops.egg-info/top_level.txt

@@ -0,0 +1,5 @@
+airflow
+deployment
+etl
+models
+training

pulseflow_mlops-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools==73", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pulseflow-mlops"
+version = "0.1.0"
+description = "Production-grade open source MLOps pipeline for enterprise data engineering and predictive modeling"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [{name = "Anil Prasad", email = "anil@ambharii.com"}]
+keywords = ["mlops", "machine-learning", "fastapi", "airflow", "mlflow", "etl"]
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://github.com/anilatambharii/PulseFlow"
+Documentation = "https://github.com/anilatambharii/PulseFlow/blob/main/README.md"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["etl*", "training*", "deployment*", "models*", "airflow*"]

pulseflow_mlops-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pulseflow_mlops-0.1.0/training/evaluate_model.py

@@ -0,0 +1,65 @@
+import os
+import pandas as pd
+import joblib
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+import json
+
+def evaluate_model(model_path: str, data_path: str, output_metrics_path: str = 'models/metrics.json'):
+    """
+    Evaluate a trained model and save metrics
+    """
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(f"Model not found at {model_path}")
+
+    if not os.path.exists(data_path):
+        raise FileNotFoundError(f"Data not found at {data_path}")
+
+    print(f"Loading model from {model_path}...")
+    model = joblib.load(model_path)
+
+    print(f"Loading evaluation data from {data_path}...")
+    df = pd.read_parquet(data_path)
+
+    if 'target' not in df.columns:
+        raise ValueError("Target column 'target' not found in dataset")
+
+    X = df.drop('target', axis=1)
+    y = df['target']
+
+    print(f"Evaluating model on {len(X)} samples...")
+    y_pred = model.predict(X)
+
+    # Calculate metrics
+    mse = mean_squared_error(y, y_pred)
+    mae = mean_absolute_error(y, y_pred)
+    r2 = r2_score(y, y_pred)
+    rmse = mse ** 0.5
+
+    metrics = {
+        'mse': float(mse),
+        'mae': float(mae),
+        'rmse': float(rmse),
+        'r2_score': float(r2)
+    }
+
+    print("\nEvaluation Results:")
+    print(f"  MSE: {mse:.4f}")
+    print(f"  MAE: {mae:.4f}")
+    print(f"  RMSE: {rmse:.4f}")
+    print(f"  R2 Score: {r2:.4f}")
+
+    # Save metrics to JSON
+    os.makedirs(os.path.dirname(output_metrics_path), exist_ok=True)
+    with open(output_metrics_path, 'w') as f:
+        json.dump(metrics, f, indent=4)
+
+    print(f"\nMetrics saved to {output_metrics_path}")
+
+    return metrics
+
+if __name__ == "__main__":
+    MODEL_PATH = 'models/saved_model.pkl'
+    DATA_PATH = 'data/processed.parquet'
+    METRICS_OUTPUT_PATH = 'models/metrics.json'
+
+    evaluate_model(MODEL_PATH, DATA_PATH, METRICS_OUTPUT_PATH)

pulseflow_mlops-0.1.0/training/train_model.py

@@ -0,0 +1,92 @@
+import os
+import pandas as pd
+import mlflow
+import mlflow.sklearn
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+import joblib
+
+# MLflow tracking configuration
+MLFLOW_TRACKING_URI = os.getenv('MLFLOW_TRACKING_URI', 'http://localhost:5000')
+mlflow.set_tracking_uri(MLFLOW_TRACKING_URI)
+mlflow.set_experiment("enterprise_mlops_training")
+
+def train_model(data_path: str, model_output_path: str):
+    """
+    Train a Random Forest model with MLflow tracking
+    """
+    if not os.path.exists(data_path):
+        raise FileNotFoundError(f"Processed data not found at {data_path}")
+
+    print(f"Loading processed data from {data_path}...")
+    df = pd.read_parquet(data_path)
+
+    # Separate features and target
+    if 'target' not in df.columns:
+        raise ValueError("Target column 'target' not found in dataset")
+
+    X = df.drop('target', axis=1)
+    y = df['target']
+
+    print(f"Dataset shape: {X.shape}")
+
+    # Train-test split
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+
+    print(f"Training set: {X_train.shape}, Test set: {X_test.shape}")
+
+    # Start MLflow run
+    with mlflow.start_run(run_name="random_forest_training"):
+        # Model parameters
+        params = {
+            'n_estimators': 100,
+            'max_depth': 10,
+            'min_samples_split': 5,
+            'random_state': 42
+        }
+
+        print("Training Random Forest model...")
+        model = RandomForestRegressor(**params)
+        model.fit(X_train, y_train)
+
+        # Predictions
+        y_pred = model.predict(X_test)
+
+        # Metrics
+        mse = mean_squared_error(y_test, y_pred)
+        mae = mean_absolute_error(y_test, y_pred)
+        r2 = r2_score(y_test, y_pred)
+
+        print(f"Model Performance:")
+        print(f"  MSE: {mse:.4f}")
+        print(f"  MAE: {mae:.4f}")
+        print(f"  R2 Score: {r2:.4f}")
+
+        # Log parameters and metrics to MLflow
+        mlflow.log_params(params)
+        mlflow.log_metric("mse", mse)
+        mlflow.log_metric("mae", mae)
+        mlflow.log_metric("r2_score", r2)
+
+        # Log model to MLflow
+        mlflow.sklearn.log_model(
+            model,
+            artifact_path="model",
+            registered_model_name="enterprise_mlops_rf_model"
+        )
+
+        # Save model locally
+        os.makedirs(os.path.dirname(model_output_path), exist_ok=True)
+        joblib.dump(model, model_output_path)
+        print(f"Model saved to {model_output_path}")
+
+        return model, mse, mae, r2
+
+if __name__ == "__main__":
+    DATA_PATH = 'data/processed.parquet'
+    MODEL_OUTPUT_PATH = 'models/saved_model.pkl'
+
+    train_model(DATA_PATH, MODEL_OUTPUT_PATH)