How to Build a Student Dropout Prediction Model with Machine Learning: Step-by-Step Project

pip install scikit-learn pandas numpy matplotlib seaborn shap xgboost fastapi pydantic uvicorn

student-dropout-prediction/
├── data/
│   └── student_dropout_uci.csv          # UCI Student Dropout dataset
├── models/
│   └── xgb_dropout.pkl                  # trained XGBoost model
├── notebooks/
│   ├── 01_eda.ipynb
│   ├── 02_feature_selection.ipynb
│   ├── 03_benchmarking.ipynb
│   ├── 04_shap_interpretability.ipynb
│   └── 05_deploy.ipynb
├── src/
│   ├── preprocessing.py
│   └── model.py
├── api/
│   └── main.py                          # FastAPI endpoint
└── requirements.txt

import pandas as pd

df = pd.read_csv("data/student_dropout_uci.csv", sep=";")

# Keep only Dropout and Graduate — remove Enrolled (unknown outcome)
df = df[df["Target"].isin(["Dropout", "Graduate"])].copy()

# Encode target: 1 = Dropout, 0 = Graduate
df["dropout"] = (df["Target"] == "Dropout").astype(int)
df.drop("Target", axis=1, inplace=True)

print(df.shape)
print(df["dropout"].value_counts(normalize=True))

"student dropout prediction model"
AND "machine learning"
AND "feature importance"
AND "early intervention"

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

df = pd.read_csv("data/student_dropout_uci.csv", sep=";")
df = df[df["Target"].isin(["Dropout", "Graduate"])].copy()
df["dropout"] = (df["Target"] == "Dropout").astype(int)
df.drop("Target", axis=1, inplace=True)

print(df.head())
print(df.info())
print(df["dropout"].value_counts(normalize=True))

# Feature correlation with the target variable
corr_target = df.corr()["dropout"].sort_values(ascending=False)
print(corr_target.head(10))

# Visualize class imbalance
df["dropout"].value_counts().plot.bar()
plt.title("Target variable distribution")
plt.xticks([0, 1], ["Graduate (0)", "Dropout (1)"], rotation=0)
plt.ylabel("Number of students")
plt.tight_layout()
plt.show()

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X = df.drop("dropout", axis=1)
y = df["dropout"]

# Split: 80% train, 10% val, 10% test
X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.2, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42)

# Normalize: mean 0, variance 1
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_val_scaled   = scaler.transform(X_val)
X_test_scaled  = scaler.transform(X_test)

print(f"Train: {X_train_scaled.shape}")
print(f"Val:   {X_val_scaled.shape}")
print(f"Test:  {X_test_scaled.shape}")

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, roc_auc_score

baseline_model = LogisticRegression(max_iter=1000, random_state=42)
baseline_model.fit(X_train_scaled, y_train)

y_pred  = baseline_model.predict(X_test_scaled)
y_proba = baseline_model.predict_proba(X_test_scaled)[:, 1]

print(classification_report(y_test, y_pred))
print(f"AUC: {roc_auc_score(y_test, y_proba):.4f}")

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from xgboost import XGBClassifier
from sklearn.model_selection import cross_val_score
import numpy as np
import pandas as pd

models = {
    "Logistic Regression": LogisticRegression(max_iter=1000, random_state=42),
    "Random Forest":       RandomForestClassifier(random_state=42),
    "Gradient Boosting":   GradientBoostingClassifier(random_state=42),
    "XGBoost":             XGBClassifier(random_state=42, eval_metric="logloss"),
    "SVM":                 SVC(probability=True, random_state=42),
}

results = {}
for name, model in models.items():
    auc_scores = cross_val_score(model, X_train_scaled, y_train,
                                 scoring="roc_auc", cv=5)
    rec_scores = cross_val_score(model, X_train_scaled, y_train,
                                 scoring="recall", cv=5)
    results[name] = {
        "AUC":    auc_scores.mean(),
        "Recall": rec_scores.mean()
    }
    print(f"{name}: AUC={auc_scores.mean():.4f} | Recall={rec_scores.mean():.4f}")

df_results = pd.DataFrame(results).T
print(df_results.sort_values("AUC", ascending=False))

from sklearn.model_selection import GridSearchCV
from xgboost import XGBClassifier

param_grid = {
    "n_estimators":     [100, 200, 300],
    "max_depth":        [3, 5, 7],
    "learning_rate":    [0.05, 0.1, 0.2],
    "subsample":        [0.8, 1.0],
    "colsample_bytree": [0.8, 1.0],
}

grid_search = GridSearchCV(
    XGBClassifier(random_state=42, eval_metric="logloss"),
    param_grid,
    cv=5,
    scoring="roc_auc",
    n_jobs=-1,
    verbose=1
)

grid_search.fit(X_train_scaled, y_train)

print(f"Best parameters: {grid_search.best_params_}")
print(f"Best CV AUC: {grid_search.best_score_:.4f}")

import pickle

# Train the final model on all training data
xgb_final = XGBClassifier(**grid_search.best_params_, random_state=42, eval_metric="logloss")
xgb_final.fit(X_train_scaled, y_train)

# Save model and scaler
with open("models/xgb_dropout.pkl", "wb") as f:
    pickle.dump(xgb_final, f)

with open("models/scaler_dropout.pkl", "wb") as f:
    pickle.dump(scaler, f)

print("Model and scaler saved successfully.")

from sklearn.metrics import (classification_report, roc_auc_score,
                             ConfusionMatrixDisplay)
import matplotlib.pyplot as plt

best_model = grid_search.best_estimator_

y_pred  = best_model.predict(X_test_scaled)
y_proba = best_model.predict_proba(X_test_scaled)[:, 1]

print(classification_report(y_test, y_pred))
print(f"AUC: {roc_auc_score(y_test, y_proba):.4f}")

# Confusion matrix
fig, ax = plt.subplots(figsize=(6, 5))
ConfusionMatrixDisplay.from_predictions(
    y_test, y_pred,
    display_labels=["Graduate", "Dropout"],
    ax=ax, colorbar=False
)
plt.title("Confusion matrix — tuned XGBoost")
plt.tight_layout()
plt.show()

import shap

explainer    = shap.Explainer(best_model, X_train_scaled)
shap_values  = explainer(X_test_scaled)

# Global feature importance — which variables drive dropout overall
shap.summary_plot(shap_values, X_test_scaled,
                  feature_names=X.columns.tolist())

# Individual explanation — why this specific student is flagged
shap.waterfall_plot(shap_values[0])

from fastapi import FastAPI
from pydantic import BaseModel
import pickle
import numpy as np

# Load model and scaler on startup
with open("models/xgb_dropout.pkl", "rb") as f:
    model = pickle.load(f)

with open("models/scaler_dropout.pkl", "rb") as f:
    scaler = pickle.load(f)

app = FastAPI(title="API — Student Dropout Early Warning System")

class Student(BaseModel):
    units_approved_sem1: float
    units_approved_sem2: float
    avg_grade_sem1: float
    avg_grade_sem2: float
    debtor: int           # 0 = No, 1 = Yes
    scholarship: int      # 0 = No, 1 = Yes
    tuition_up_to_date: int  # 0 = No, 1 = Yes
    # ... remaining variables

@app.post("/predict")
def predict(student: Student):
    data = np.array([[
        student.units_approved_sem1,
        student.units_approved_sem2,
        student.avg_grade_sem1,
        student.avg_grade_sem2,
        student.debtor,
        student.scholarship,
        student.tuition_up_to_date,
    ]])
    data_scaled   = scaler.transform(data)
    probability   = model.predict_proba(data_scaled)[0][1]
    risk_level    = "High" if probability >= 0.6 else "Medium" if probability >= 0.4 else "Low"
    return {
        "dropout_probability": round(float(probability), 4),
        "risk_level": risk_level,
        "recommended_action": "Immediate intervention" if risk_level == "High" else "Monitor"
    }

# Run: uvicorn api.main:app --reload