ML Basics: Build Your First Pipeline

Your Task

Create a Python file called ml_pipeline.py that implements a complete machine learning pipeline. Your code must load datasets, train multiple models, evaluate their performance, and generate visualizations comparing results.

You will work with TWO datasets. Create these CSV files or generate synthetic data:

Implement the following 13 functions in your ml_pipeline.py file. Each function should follow the exact signature provided:

def load_dataset(filepath: str) -> pd.DataFrame:
    """
    Load and clean a CSV dataset.
    
    Args:
        filepath: Path to the CSV file
        
    Returns:
        Cleaned pandas DataFrame with no missing values
    """
    pass

def split_features_target(df: pd.DataFrame, target_col: str) -> tuple:
    """
    Split DataFrame into features and target.
    
    Args:
        df: Input DataFrame
        target_col: Name of the target column
        
    Returns:
        Tuple of (X, y) where X is features DataFrame and y is target Series
    """
    pass

def create_train_test_split(X, y, test_size=0.2, random_state=42) -> tuple:
    """
    Create train/test split of the data.
    
    Args:
        X: Features
        y: Target
        test_size: Proportion of data for testing (default 0.2)
        random_state: Random seed for reproducibility
        
    Returns:
        Tuple of (X_train, X_test, y_train, y_test)
    """
    pass

def scale_features(X_train, X_test) -> tuple:
    """
    Standardize features using StandardScaler.
    
    Args:
        X_train: Training features
        X_test: Test features
        
    Returns:
        Tuple of (X_train_scaled, X_test_scaled, scaler)
    """
    pass

def train_knn_classifier(X_train, y_train, n_neighbors=5):
    """
    Train a KNN classifier.
    
    Args:
        X_train: Training features
        y_train: Training labels
        n_neighbors: Number of neighbors (default 5)
        
    Returns:
        Trained KNeighborsClassifier model
    """
    pass

def train_decision_tree_classifier(X_train, y_train, max_depth=5, random_state=42):
    """
    Train a Decision Tree classifier.
    
    Args:
        X_train: Training features
        y_train: Training labels
        max_depth: Maximum tree depth (default 5)
        random_state: Random seed for reproducibility
        
    Returns:
        Trained DecisionTreeClassifier model
    """
    pass

def train_linear_regression(X_train, y_train):
    """
    Train a Linear Regression model.
    
    Args:
        X_train: Training features
        y_train: Training target values
        
    Returns:
        Trained LinearRegression model
    """
    pass

def evaluate_classifier(model, X_test, y_test) -> dict:
    """
    Evaluate a classification model.
    
    Args:
        model: Trained classifier
        X_test: Test features
        y_test: True labels
        
    Returns:
        Dictionary with 'accuracy', 'precision', 'recall', 'f1' scores
    """
    pass

def evaluate_regressor(model, X_test, y_test) -> dict:
    """
    Evaluate a regression model.
    
    Args:
        model: Trained regressor
        X_test: Test features
        y_test: True target values
        
    Returns:
        Dictionary with 'mse', 'rmse', 'mae', 'r2' scores
    """
    pass

def compare_classifiers(X_train, X_test, y_train, y_test) -> dict:
    """
    Train and compare KNN and Decision Tree classifiers.
    
    Args:
        X_train, X_test: Train and test features
        y_train, y_test: Train and test labels
        
    Returns:
        Dictionary with model names as keys and evaluation dicts as values
        Example: {'KNN': {'accuracy': 0.85, ...}, 'DecisionTree': {...}}
    """
    pass

def plot_confusion_matrix(model, X_test, y_test, save_path: str) -> None:
    """
    Plot and save confusion matrix.
    
    Args:
        model: Trained classifier
        X_test: Test features
        y_test: True labels
        save_path: File path to save the plot
    """
    pass

def plot_regression_results(model, X_test, y_test, save_path: str) -> None:
    """
    Plot actual vs predicted values for regression.
    
    Args:
        model: Trained regressor
        X_test: Test features
        y_test: True target values
        save_path: File path to save the plot
    """
    pass

def main():
    """
    Execute the complete ML pipeline:
    1. Load and prepare both datasets
    2. Train classification models (KNN, Decision Tree)
    3. Train regression model (Linear Regression)
    4. Evaluate all models
    5. Generate visualizations
    6. Print summary report
    """
    pass

if __name__ == "__main__":
    main()

Create a public GitHub repository with the exact name shown below:

Required Files

ai-ml-basics-assignment/
├── ml_pipeline.py          # Main implementation file with ALL 13 functions
├── data/
│   ├── customer_churn.csv  # Classification dataset
│   └── house_prices.csv    # Regression dataset
├── outputs/
│   ├── confusion_matrix.png
│   └── regression_plot.png
├── requirements.txt        # Dependencies
└── README.md               # REQUIRED - see contents below