Example: Predicting Exam Pass/Fail Based on Hours Studied

This is the worked example the rest of the chapter builds on: predicting whether a student passes (1) or fails (0) from the hours they studied. Ten students switch cleanly from Fail to Pass between 5 and 6 hours, and logistic regression turns that pattern into a probability of passing.

The example has one feature, Hours_Studied (1 to 10), and one binary label, Passed: the five students who studied 1 to 5 hours failed and the five who studied 6 to 10 hours passed. Because the answer is a category, a straight line is the wrong tool; logistic regression passes a straight-line score through the sigmoid function to get a probability between 0 and 1, then applies a 0.5 threshold. This lesson walks the whole example end to end in plain Python: inspect the data, hold out a test set, train the model, check it on unseen students and predict for a student who studied 4.5 hours. It then explains what the result does and does not mean, ready for the step-by-step lessons that follow.

Example: Predicting Exam Pass/Fail Based on Hours Studied

This is the example that the rest of the chapter, from visualising the data to drawing the logistic curve, keeps coming back to. A teacher wants to know: given how many hours a student studied, will they pass the exam? The answer is one of two categories, Pass (1) or Fail (0), so this is binary classification, the job logistic regression was built for.

The data. In the chapter's code (Step 2) the dataset is a small table with two columns: Hours_Studied, the feature, and Passed, the label.

• Hours_Studied: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
• Passed: 0, 0, 0, 0, 0, 1, 1, 1, 1, 1

A quick look in plain Python:

# The chapter's dataset: hours studied and whether the student passed (1) or not (0)
hours_studied = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
passed = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]
for h, p in zip(hours_studied, passed):
    print(str(h).rjust(2), "hours |", "*" * h, "| passed" if p == 1 else "| failed")
fails = [h for h, p in zip(hours_studied, passed) if p == 0]
passes = [h for h, p in zip(hours_studied, passed) if p == 1]
print("Pass rate:", sum(passed) / len(passed))
print("Most hours among those who failed:", max(fails))
print("Fewest hours among those who passed:", min(passes))

Two facts stand out. The classes are balanced (a pass rate of 0.5), and they are perfectly separated: everyone who studied 5 hours or less failed, and everyone who studied 6 hours or more passed. So the decision boundary, where predictions should switch from Fail to Pass, lies somewhere between 5 and 6 hours.

Why not a straight line? If you fit ordinary linear regression to the 0s and 1s, the line predicts −0.33 at 0 hours and 1.18 at 10 hours. Neither can be a probability. Logistic regression keeps the straight-line score z = w × hours + b but passes it through the sigmoid function, σ(z) = 1 / (1 + e^(−z)), which squeezes any number into the range 0 to 1. The result is read as the probability of passing, and a threshold of 0.5 turns it into a class.

The plan. The next lessons take these steps one at a time with pandas, scikit-learn and matplotlib:

1. Visualise the data (7.5).
2. Split it into a training set and a test set, then train the model (7.6). There, train_test_split(X, y, test_size=0.2, random_state=42) holds back 2 of the 10 students: the ones who studied 9 hours and 2 hours.
3. Make predictions, including one for a new student who studied 4.5 hours (7.7).
4. Evaluate with accuracy and a confusion matrix (7.8).
5. Draw the logistic curve (7.9).

The whole example in plain Python. Here is the same pipeline without libraries. Training starts with w = 0 and b = 0, where every probability is 0.5. In each of 5,000 rounds the code compares each training student's predicted probability with their true 0 or 1, and nudges w and b a little in the direction that shrinks the errors. This nudging is called gradient descent.

import math

def sigmoid(z):
    return 1 / (1 + math.exp(-z))

# Hold out the 2-hour and 9-hour students as a small test set
train_x = [1, 3, 4, 5, 6, 7, 8, 10]
train_y = [0, 0, 0, 0, 1, 1, 1, 1]
test_x = [9, 2]
test_y = [1, 0]
# Train: start at w = 0 and b = 0, then nudge them 5000 times
w, b = 0.0, 0.0
learning_rate = 0.1
for step in range(5000):
    grad_w = 0.0
    grad_b = 0.0
    for x, y in zip(train_x, train_y):
        error = sigmoid(w * x + b) - y
        grad_w += error * x
        grad_b += error
    w -= learning_rate * grad_w / len(train_x)
    b -= learning_rate * grad_b / len(train_x)
print("Learned w =", round(w, 3), "and b =", round(b, 3))
print("Probability is 0.5 at", round(-b / w, 2), "hours")
# Evaluate on the two held-out students
predictions = [1 if sigmoid(w * x + b) >= 0.5 else 0 for x in test_x]
print("Test predictions:", predictions, "| actual:", test_y)
correct = sum(1 for p, y in zip(predictions, test_y) if p == y)
print("Test accuracy:", correct / len(test_y))
# Predict for a new student
p = sigmoid(w * 4.5 + b)
print("4.5 hours -> probability of passing", round(p, 3), "->", "Pass" if p >= 0.5 else "Fail")

The results. Training gives w ≈ 2.108 and b ≈ −11.442, so the probability crosses 0.5 at about 5.43 hours, between the last fail and the first pass. Both held-out students are classified correctly (the 9-hour student as Pass, the 2-hour student as Fail), a test accuracy of 1.0. The new student who studied 4.5 hours gets a probability of passing of about 0.124, so the prediction is Fail.

What it means.

• The model has turned "students who studied 6 or more hours passed" into a smooth rule. Below about 5.4 hours it predicts Fail and above it Pass, and the probability shows how sure it is: 0.124 at 4.5 hours is a fairly confident Fail, while 5 hours (about 0.29) is much closer to the line.
• A test accuracy of 1.0 on two students proves very little. Ten tidy students contain no surprises, such as someone who studied 7 hours and still failed. Real data is messier, and the model's confidence would drop.
• Because the two classes are perfectly separated, training longer keeps making the curve steeper. scikit-learn's LogisticRegression adds a small penalty by default that stops the weights growing, so its exact probabilities differ from ours. Its 0.5 point still lies between 5 and 6 hours, and it makes the same Pass and Fail predictions here.
• The model shows an association, not a cause. Hours studied is only one of many things that affect a result.