Data Ingestion

The data ingestion process involves reading the raw dataset, performing initial processing, and splitting it into training and testing sets.

Data Ingestion Workflow

Implementation Details:

• Located in src/components/data_ingestion.py
• Reads the dataset from notebooks/dataset/stud.csv
• Splits the data into training (80%) and testing (20%) sets using train_test_split with random_state=42
• Saves the processed datasets as CSV files in the artifacts directory:
  • artifacts/data.csv - Full dataset
  • artifacts/train.csv - Training split
  • artifacts/test.csv - Testing split

# Key implementation details
def initiate_data_ingestion(self):
    # Read dataset
    df = pd.read_csv('notebooks/dataset/stud.csv')
    
    # Create directories
    os.makedirs(os.path.dirname(self.ingestion_config.train_data_path), exist_ok=True)
    
    # Split dataset
    train_set, test_set = train_test_split(df, test_size=0.2, random_state=42)
    
    # Save datasets
    train_set.to_csv(self.ingestion_config.train_data_path, index=False, header=True)
    test_set.to_csv(self.ingestion_config.test_data_path, index=False, header=True)
    
    return self.ingestion_config.train_data_path, self.ingestion_config.test_data_path
                

Data validation ensures the quality and integrity of the dataset before proceeding to model training.

Validation Checks

• Checking for missing values
• Validating data types
• Ensuring appropriate value ranges
• Checking for duplicates
• Verifying the schema consistency

Data Transformation

The data transformation process converts raw data into a format suitable for model training, including handling categorical features and scaling numerical values.

Data Transformation Workflow

Implementation

The DataTransformation class in src/components/data_transformation.py performs the following:

1. Identifying numerical and categorical features
2. Creating preprocessing pipelines for both feature types
3. Applying One-Hot Encoding for categorical features
4. Applying StandardScaler for numerical features
5. Combining transformations using ColumnTransformer
6. Saving the preprocessor for later use in prediction

# Key implementation details
def get_data_transformer_object(self):
    # Define numerical and categorical features
    numerical_columns = ["writing_score", "reading_score"]
    categorical_columns = [
        "gender",
        "race_ethnicity",
        "parental_level_of_education",
        "lunch",
        "test_preparation_course",
    ]
    
    # Create preprocessing pipelines
    num_pipeline = Pipeline(
        steps=[
            ("scaler", StandardScaler())
        ]
    )
    
    cat_pipeline = Pipeline(
        steps=[
            ("one_hot_encoder", OneHotEncoder()),
            ("scaler", StandardScaler(with_mean=False))
        ]
    )
    
    # Combine pipelines using ColumnTransformer
    preprocessor = ColumnTransformer(
        [
            ("num_pipeline", num_pipeline, numerical_columns),
            ("cat_pipeline", cat_pipeline, categorical_columns)
        ]
    )
    
    return preprocessor

def initiate_data_transformation(self, train_path, test_path):
    # Load train and test data
    train_df = pd.read_csv(train_path)
    test_df = pd.read_csv(test_path)
    
    # Get preprocessor object
    preprocessing_obj = self.get_data_transformer_object()
    
    # Define target column
    target_column_name = "math_score"
    
    # Split into features and target
    input_feature_train_df = train_df.drop(columns=[target_column_name], axis=1)
    target_feature_train_df = train_df[target_column_name]
    
    input_feature_test_df = test_df.drop(columns=[target_column_name], axis=1)
    target_feature_test_df = test_df[target_column_name]
    
    # Apply transformations
    input_feature_train_arr = preprocessing_obj.fit_transform(input_feature_train_df)
    input_feature_test_arr = preprocessing_obj.transform(input_feature_test_df)
    
    # Convert to arrays for modeling
    train_arr = np.c_[input_feature_train_arr, np.array(target_feature_train_df)]
    test_arr = np.c_[input_feature_test_arr, np.array(target_feature_test_df)]
    
    # Save preprocessor object
    save_object(
        file_path=self.data_transformation_config.preprocessor_obj_file_path,
        obj=preprocessing_obj
    )
    
    return train_arr, test_arr, self.data_transformation_config.preprocessor_obj_file_path
                

Model Training & Hyperparameter Tuning

The model training process involves evaluating multiple regression algorithms and selecting the best performing model through hyperparameter tuning.

Model Selection Strategy

The project employs a comprehensive approach to model selection, evaluating seven different regression algorithms with rigorous hyperparameter tuning to find the optimal predictor for student math scores.

Candidate Models

Training Process

The model training process is implemented in src/components/model_trainer.py. The key steps include:

1. Splitting preprocessed data into features (X) and target (y) for both training and testing sets
2. Initializing multiple regression models with default parameters
3. Training each model on the training data
4. Evaluating model performance on both training and testing sets
5. Selecting the best model based on R² score on the test set
6. Saving the best model as artifacts/model.pkl

Implementation

The ModelTrainer class in src/components/model_trainer.py handles model training and selection:

# Key implementation details
def initiate_model_trainer(self, train_array, test_array):
    try:
        # Split arrays into features and target
        X_train, y_train, X_test, y_test = (
            train_array[:,:-1],
            train_array[:,-1],
            test_array[:,:-1],
            test_array[:,-1]
        )
        
        # Define models to evaluate
        models = {
            "Random Forest": RandomForestRegressor(),
            "Decision Tree": DecisionTreeRegressor(),
            "Gradient Boosting": GradientBoostingRegressor(),
            "Linear Regression": LinearRegression(),
            "XGBRegressor": XGBRegressor(),
            "CatBoosting Regressor": CatBoostRegressor(verbose=False),
            "AdaBoost Regressor": AdaBoostRegressor(),
        }
        
        # Define hyperparameter grids
        params = {
            "Decision Tree": {
                'criterion': ['squared_error', 'friedman_mse', 'absolute_error', 'poisson'],
                'splitter': ['best', 'random'],
                'max_features': ['sqrt', 'log2'],
            },
            "Random Forest": {
                'n_estimators': [8, 16, 32, 64, 128, 256],
                'criterion': ['squared_error', 'absolute_error'],
                'max_features': ['sqrt', 'log2'],
            },
            "Gradient Boosting": {
                'learning_rate': [.1, .01, .05, .001],
                'subsample': [0.6, 0.7, 0.75, 0.8, 0.85, 0.9],
                'n_estimators': [8, 16, 32, 64, 128, 256]
            },
            "Linear Regression": {},
            "XGBRegressor": {
                'learning_rate': [.1, .01, .05, .001],
                'n_estimators': [8, 16, 32, 64, 128, 256]
            },
            "CatBoosting Regressor": {
                'depth': [6, 8, 10],
                'learning_rate': [0.01, 0.05, 0.1],
                'iterations': [30, 50, 100]
            },
            "AdaBoost Regressor": {
                'learning_rate': [.1, .01, 0.5, .001],
                'n_estimators': [8, 16, 32, 64, 128, 256]
            }
        }
        
        # Evaluate models
        model_report = evaluate_models(
            X_train=X_train, 
            y_train=y_train, 
            X_test=X_test, 
            y_test=y_test, 
            models=models, 
            param=params
        )
        
        # Get the best model
        best_model_score = max(sorted(model_report.values()))
        best_model_name = list(model_report.keys())[
            list(model_report.values()).index(best_model_score)
        ]
        best_model = models[best_model_name]
        
        # Save the best model
        save_object(
            file_path=self.model_trainer_config.trained_model_file_path,
            obj=best_model
        )
        
        return best_model_name, best_model_score
    except Exception as e:
        raise CustomException(e, sys)
                

Hyperparameter Tuning

The project uses GridSearchCV to find the optimal hyperparameters for each model:

Model Training Results

After evaluation, the models showed the following performance (R² Score):

Best Model Selection

After evaluating all models with their optimal hyperparameters, the best performing model is selected based on the R² score on the test set. This model is then saved for deployment in the prediction pipeline.

# Find best model
best_model_score = max(sorted(model_report.values()))
best_model_name = list(model_report.keys())[list(model_report.values()).index(best_model_score)]
best_model = models[best_model_name]

if best_model_score < 0.6:
    raise CustomException("No best model found")

logging.info(f"Best found model on both training and testing dataset: {best_model_name}")

save_object(
    file_path=self.model_trainer_config.trained_model_file_path,
    obj=best_model
)
            

import logging
import os
from datetime import datetime

LOG_FILE = f"{datetime.now().strftime('%m_%d_%Y_%H_%M_%S')}.log"
logs_path = os.path.join(os.getcwd(), "logs", LOG_FILE)
os.makedirs(logs_path, exist_ok=True)

LOG_FILE_PATH = os.path.join(logs_path, LOG_FILE)

logging.basicConfig(
    filename=LOG_FILE_PATH,
    format="[ %(asctime)s ] %(lineno)d %(name)s - %(levelname)s - %(message)s",
    level=logging.INFO,
)
            

def save_object(file_path, obj):
    try:
        dir_path = os.path.dirname(file_path)
        os.makedirs(dir_path, exist_ok=True)

        with open(file_path, "wb") as file_obj:
            dill.dump(obj, file_obj)

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

# Key implementation details from app.py
from flask import Flask, request, render_template
import numpy as np
import pandas as pd

from sklearn.preprocessing import StandardScaler
from src.pipeline.predict_pipeline import CustomData, PredictPipeline

application = Flask(__name__)
app = application

@app.route('/')
def index():
    return render_template('index.html') 

@app.route('/predictdata', methods=['GET', 'POST'])
def predict_datapoint():
    if request.method == 'GET':
        return render_template('home.html')
    else:
        data = CustomData(
            gender=request.form.get('gender'),
            race_ethnicity=request.form.get('ethnicity'),
            parental_level_of_education=request.form.get('parental_level_of_education'),
            lunch=request.form.get('lunch'),
            test_preparation_course=request.form.get('test_preparation_course'),
            reading_score=float(request.form.get('writing_score')),
            writing_score=float(request.form.get('reading_score'))
        )
        pred_df = data.get_data_as_data_frame()
        
        predict_pipeline = PredictPipeline()
        results = predict_pipeline.predict(pred_df)
        
        return render_template('home.html', results=results[0])

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=80)
                

FROM python:3.9-slim
WORKDIR /app
COPY . /app
RUN apt update -y
RUN apt-get update && pip install -r requirements.txt
CMD ["python3", "app.py"]
                

venv
.git
__pycache__
*.log
                

CI/CD Pipeline

The project implements a CI/CD pipeline using GitHub Actions to automate the build and deployment process.

GitHub Actions Workflow

The CI/CD pipeline is defined in .github/workflows/main_studentperformancecheck.yml and includes the following steps:

Workflow Trigger:

• Automatically triggered on push to the main branch
• Can also be manually triggered using workflow_dispatch

Build Job:

1. Checkout repository code
2. Set up Docker Buildx for multi-platform builds
3. Log in to Azure Container Registry using secrets
4. Build Docker image from Dockerfile
5. Push the image to Azure Container Registry with a tag based on the commit SHA

Deploy Job:

1. Run after the build job completes
2. Deploy to Azure Web App using the azure/webapps-deploy action
3. Configure the deployment with app name, slot, and authentication details
4. Specify the Docker image to deploy from Azure Container Registry

name: Build and deploy container app to Azure Web App - studentperformancecheck

on:
  push:
    branches:
      - main
  workflow_dispatch:

jobs:
  build:
    runs-on: 'ubuntu-latest'
    steps:
    - uses: actions/checkout@v2
    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v2
    - name: Log in to registry
      uses: docker/login-action@v2
      with:
        registry: https://testdockerafroz.azurecr.io/
        username: ${{ secrets.AzureAppService_ContainerUsername_f24c206db1e145f79bfb160d64f62f1d }}
        password: ${{ secrets.AzureAppService_ContainerPassword_2f191264d14048f9979084413f811090 }}
    - name: Build and push container image to registry
      uses: docker/build-push-action@v3
      with:
        push: true
        tags: testdockerafroz.azurecr.io/${{ secrets.AzureAppService_ContainerUsername_f24c206db1e145f79bfb160d64f62f1d }}/studentperformance1:${{ github.sha }}
        file: ./Dockerfile

  deploy:
    runs-on: ubuntu-latest
    needs: build
    environment:
      name: 'production'
      url: ${{ steps.deploy-to-webapp.outputs.webapp-url }}
    steps:
    - name: Deploy to Azure Web App
      id: deploy-to-webapp
      uses: azure/webapps-deploy@v2
      with:
        app-name: 'studentperformancecheck'
        slot-name: 'production'
        publish-profile: ${{ secrets.AzureAppService_PublishProfile_a291bb02fa174668a5f7d1ca7a8cc164 }}
        images: 'testdockerafroz.azurecr.io/${{ secrets.AzureAppService_ContainerUsername_f24c206db1e145f79bfb160d64f62f1d }}/studentperformance1:${{ github.sha }}'
                

Cloud Deployment (Azure)

The application is deployed on Azure using Azure Web App and Azure Container Registry.

Azure Services Used

Azure Container Registry (ACR)

Hosts Docker images built by the CI/CD pipeline, providing version control and secure storage for container images.

Azure Web App

Hosts the containerized application, providing a fully managed platform for running the prediction service with automatic scaling and high availability.

Azure Deployed webpage

Hosted the containerized application, providing a fully managed platform for running the prediction service with automatic scaling and high availability.

Deployment Architecture

The deployment architecture follows these steps:

1. Docker image is built and pushed to Azure Container Registry
2. Azure Web App pulls the Docker image from the registry
3. Web App runs the container and exposes the application
4. The application is accessible via the URL provided by Azure Web App

Azure Deployment Workflow

GitHub Repository

GitHub Actions

Docker Image

Azure Container Registry

Azure Web App

Production Deployment

Security Considerations:

• Secrets and credentials stored securely in GitHub repository secrets
• Azure publish profile used for secure deployment
• Container registry authentication required for accessing images

Conclusion

The Student Success Predictor project successfully demonstrates an end-to-end machine learning pipeline, from exploratory data analysis to model deployment in production.

Key Achievements

• Comprehensive EDA revealing factors affecting student performance
• Modular implementation of data processing and model training components
• Evaluation of multiple regression models with hyperparameter tuning
• Achieving 88% accuracy (R² Score) with Ridge Regression
• Web application development with Flask for user-friendly predictions
• Containerization with Docker for reproducibility
• Automated CI/CD pipeline using GitHub Actions
• Cloud deployment on Azure for scalability and accessibility

Key Insights

The project provided several valuable insights:

• Student performance is strongly influenced by socioeconomic factors (as indicated by lunch type)
• Test preparation courses significantly improve performance across all subjects
• There are gender differences in performance, with females generally performing better overall but males slightly better in mathematics
• Linear models (Ridge and Linear Regression) outperformed more complex models for this prediction task
• Reading and writing scores are strong predictors of math scores

Future Improvements

• Collecting more data to improve model generalization
• Implementing more advanced feature engineering techniques
• Exploring deeper neural network architectures
• Adding monitoring and feedback mechanisms
• Implementing A/B testing for model improvements

Skills Showcased

Data Science

• Exploratory Data Analysis
• Data Preprocessing
• Feature Engineering
• Machine Learning Modeling
• Model Evaluation & Validation
• Hyperparameter Tuning

Software Engineering

• Object-Oriented Programming
• Modular Code Design
• Python Development
• Web Application Development
• API Development
• Error Handling & Logging

DevOps & MLOps

• Containerization with Docker
• CI/CD Pipeline Implementation
• Cloud Deployment
• Version Control with Git
• Artifact Management
• Model Deployment

Tools & Technologies

• Python (Pandas, NumPy, Scikit-learn)
• Machine Learning Libraries (XGBoost, CatBoost)
• Flask Web Framework
• Docker
• GitHub Actions
• Azure Cloud Services

GitHub & Contact Details

Project Repository

github.com/MOHD-AFROZ-ALI/eduml-studentsuccesspredictor

Contact Information

• Email: afrozali3001.aa@gmail.com
• Phone: +91 9959786710
• LinkedIn: linkedin.com/in/mohd-afroz-ali