Final Project — Student Performance Predictor

The Project Brief

Imagine a school wants a rough early-warning tool: given a few easy-to-collect numbers about a student, can we flag who's at risk of failing an upcoming exam before it happens? We'll build exactly that — a binary classifier that predicts pass or fail from three numeric features.

As with Lesson 13's retail dataset, student_performance.csv here is a plausible, illustrative synthetic dataset built to teach the workflow end to end — not a real published study. The pandas and scikit-learn methods are 100% real and correct; the specific numbers are stand-ins for whatever CSV a real project would hand you.

Load the Data and Take a First Look

Same opening move as every EDA in this course: read the file, then look before touching anything.

import pandas as pd

df = pd.read_csv("student_performance.csv")

print(df.shape)
# (2000, 4)

print(df.head())

Row 2 is already missing its attendance_pct — worth remembering for the next step. Next, the dtypes pandas inferred:

print(df.dtypes)
# study_hours_per_week    float64
# attendance_pct          float64
# past_exam_avg           float64
# passed                    int64
# dtype: object

Check for Missing Values and Describe the Stats

Two quick pandas calls before any modeling happens: .isnull().sum() to find gaps, and .describe() to get a feel for each column's range and center — the same habit from Lesson 13's EDA project.

print(df.isnull().sum())
# study_hours_per_week     0
# attendance_pct          34
# past_exam_avg             0
# passed                    0
# dtype: int64

print(df.describe().round(2))

34 missing values in attendance_pct is under 2% of 2,000 rows — small enough to fill rather than drop, exactly the same call made in Lesson 13.

# Fill the small number of missing attendance values with the column median
df["attendance_pct"] = df["attendance_pct"].fillna(df["attendance_pct"].median())

assert df.isnull().sum().sum() == 0, "Still missing values!"

A Correlation Heatmap

Before training anything, it's worth asking — in plain statistics terms from Section 4 — which raw features actually move together with passed. DataFrame.corr() computes the pairwise Pearson correlation between every numeric column, from -1 (perfectly opposite) through 0 (no linear relationship) to +1 (perfectly together).

corr = df.corr().round(2)
print(corr)

# A real project would typically visualize this with Seaborn (Section 3):
# import seaborn as sns
# sns.heatmap(corr, annot=True, cmap="Blues")

Splitting Into Features and a Train/Test Set

Same rule from Lesson 24 onward: never evaluate a model on the same rows it was trained on. Separate X (the three feature columns) from y (the passed label), then hold out 20% of the rows for testing only.

from sklearn.model_selection import train_test_split

feature_cols = ["study_hours_per_week", "attendance_pct", "past_exam_avg"]
X = df[feature_cols]
y = df["passed"]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print(f"Train: {X_train.shape}, Test: {X_test.shape}")
# Train: (1600, 3), Test: (400, 3)

Training a RandomForestClassifier

This is a classification problem — passed is 0 or 1, not a continuous number — so it calls for a classifier, not a regressor. We'll use RandomForestClassifier from Lesson 26: an ensemble of decision trees that tends to handle non-linear relationships between features well and, as a bonus, ships with a built-in feature importance score for Section 8.

from sklearn.ensemble import RandomForestClassifier

clf = RandomForestClassifier(
    n_estimators=200,
    max_depth=6,
    random_state=42
)
clf.fit(X_train, y_train)

Evaluating the Model Properly

A single accuracy number can hide a lot — exactly the lesson from Lesson 27. Since passed isn't perfectly balanced (59/41), classification_report and a confusion matrix tell a much fuller story than .score() alone.

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

y_pred = clf.predict(X_test)

print(f"Accuracy: {accuracy_score(y_test, y_pred):.2f}")
print(classification_report(y_test, y_pred, target_names=["Fail", "Pass"]))
print(confusion_matrix(y_test, y_pred))

Interpreting Feature Importance

A trained RandomForestClassifier exposes .feature_importances_ — one number per feature, summing to 1.0, measuring roughly how much each feature contributed to the forest's decisions across all its trees.

importances = pd.Series(clf.feature_importances_, index=feature_cols)
print(importances.sort_values(ascending=False).round(2))

# past_exam_avg            0.47
# study_hours_per_week     0.31
# attendance_pct           0.22
# dtype: float64

The Complete Script, Start to Finish

Every step from this lesson, combined into one runnable pipeline against a CSV shaped like student_performance.csv.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

# 1. Load and take a first look
df = pd.read_csv("student_performance.csv")
print("Shape:", df.shape)
print(df.head())
print(df.dtypes)

# 2. Check for missing values, describe, then clean
print(df.isnull().sum())
print(df.describe().round(2))
df["attendance_pct"] = df["attendance_pct"].fillna(df["attendance_pct"].median())
assert df.isnull().sum().sum() == 0

# 3. Correlation heatmap (printed here; visualize with sns.heatmap in a notebook)
print(df.corr().round(2))

# 4. Split into features/target, then train/test
feature_cols = ["study_hours_per_week", "attendance_pct", "past_exam_avg"]
X = df[feature_cols]
y = df["passed"]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 5. Train the model
clf = RandomForestClassifier(n_estimators=200, max_depth=6, random_state=42)
clf.fit(X_train, y_train)

# 6. Evaluate
y_pred = clf.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, y_pred):.2f}")
print(classification_report(y_test, y_pred, target_names=["Fail", "Pass"]))
print(confusion_matrix(y_test, y_pred))

# 7. Interpret feature importance
importances = pd.Series(clf.feature_importances_, index=feature_cols)
print(importances.sort_values(ascending=False).round(2))

Writing Up Findings

A trained model isn't the deliverable by itself — the point is turning it into a few statements someone at the school could actually act on. Treat these as an example of the kind of takeaway a real project like this would produce, not as claims about any real student population.

That's the full pipeline — and the full course core curriculum. Every earlier lesson fed into this one: pandas cleaning, correlation from Section 4's statistics, the classifier itself, and the exact same evaluation tools from Lesson 27. Section 6 next turns this project into something you can actually show off.