Lab 8, Modeling at Summit Gear: Specify, Fit, Interpret

Exercise 1, Fit OLS for days_to_pay and interpret the coefficients 25 pts

What to do here: specify an OLS model for days_to_pay, have the AI fit it, and read the coefficient table in collections terms.

The question: how long does a customer take to pay, and what drives it?

Specify. The target is days_to_pay. For this first fit, use this predictor set (you will revise it in Exercise 2):

credit_limit, avg_balance, annual_spend, prior_late_count, days_since_last_order, orders_per_year, discount_rate, avg_order_value, noise_a, noise_b.

This is the "kitchen sink" model, every numeric predictor in the table. Fitting it first, on purpose, sets up the problem you solve in Exercise 2.

Let AI write the fit. Ask the tutor for the statsmodels OLS that regresses days_to_pay on those predictors and prints the coefficient table plus R² and adjusted R². Run it. Save the output in the cell.

Validate. Confirm the model fit on all 2,200 rows and used the predictors you named. Read off the R² and adjusted R².

Interpret (this is the graded part). Write a short paragraph that answers:

• Read two coefficients in collections terms, in the form "holding the other predictors fixed, a one-unit increase in X changes predicted days_to_pay by b days." Pick prior_late_count and one other.
• State what the R² says about how much of the in-sample variation in payment timing the model explains, in plain words. (These are illustrative in-sample numbers, not a claim about new customers.)
• Name one coefficient whose sign or size looks wrong or unstable and say you will come back to it. (You will: it is the collinearity problem.)

Write the helper. Fill in predicted_days:

def predicted_days(coefs, row):
    """TODO: one sentence, what does this return?"""
    return None

coefs is a dict of predictor name to coefficient (including the key const for the intercept). row is a dict of predictor name to value. Return the predicted days_to_pay for that customer: the intercept plus the sum of each coefficient times its value. This is "score one customer from a fitted model", the same arithmetic the AI's .predict() does, written once by hand so you know what it is doing.

Exercise 2, Feature selection: spot and drop a collinear predictor 25 pts

What to do here: use a correlation matrix to find predictors that move together, drop the redundant ones, and re-fit a cleaner OLS.

The problem you set up in Exercise 1. Look at the kitchen-sink coefficient table. Three predictors, credit_limit, avg_balance, annual_spend, describe the same thing (a customer's account size) in three units. When predictors move together like that, the model cannot tell their effects apart, so their individual coefficients become unstable: inflated standard errors, and sometimes a sign that makes no business sense. This is multicollinearity, and diagnosing it is the most important judgment in this lab.

Diagnose with a correlation matrix. Ask the AI for a correlation matrix of the numeric predictors (the full set, or just the suspects). Read the off-diagonal cells: a cell close to 1.0 (or -1.0) between two different predictors is the warning sign that they move together. You will see credit_limit, avg_balance, and annual_spend all correlate above 0.96 with each other, three measures of one underlying thing, account size. The noise_a and noise_b columns correlate with nothing; they are not collinear, they are just useless, which is a different problem you also fix.

Write the helper. Fill in flag_collinear_pairs. It takes the correlation matrix itself, the same one you just built:

def flag_collinear_pairs(corr, threshold=0.9):
    """TODO: one sentence, what does this return?"""
    return None

What it takes: corr is the correlation DataFrame from df[predictors].corr(), a square table of pairwise correlations. What it returns: a list of (col_a, col_b, r) triples. Walk the upper triangle only (each pair once, skip the diagonal), and for every pair whose absolute correlation clears the bar (abs(r) >= threshold), append (col_a, col_b, r), where col_a and col_b are the two column names and r is their correlation. Use abs(...) so a strong negative correlation is caught too. That specific shape, a list of name-name-value triples, is what the auto-check and the final_check testing function expect, so return exactly that.

Decide and re-fit. Reduce the collinear cluster to one representative predictor and drop the noise columns. Ask the AI to re-fit the OLS on your reduced set and print the new coefficient table, R², and adjusted R².

Justify (this is the graded part). Write a short paragraph that answers:

• Which predictors were collinear, and what in the correlation matrix told you (name the hot cells)?
• Which one did you keep, and why one is enough.
• What happened to adjusted R² when you dropped the redundant and noise columns, and why dropping them was the right call even though plain R² barely moved. (More predictors is not a better model. Adjusted R² is the number that stops rewarding clutter.)

Exercise 3, Fit logistic for defaulted, read odds and probabilities, pick a cutoff 25 pts

What to do here: fit a logistic model for defaulted, read the odds ratios and predicted probabilities in collections terms, and look at one cutoff.

The question changes shape. "Will this receivable go bad" is a yes/no, not a dollar amount, so OLS is the wrong tool, a linear model would predict probabilities below 0 and above 1. Logistic regression is built for a 0/1 outcome: it runs a linear score through a sigmoid that squashes any number into a probability between 0 and 1.

A short on-ramp (read this before you fit). Nothing before this week defined a probability or odds, so:

• A probability is a number from 0 to 1: the chance the outcome is 1.
• Odds are p / (1 - p). A probability of 0.2 is odds of 0.25, or "1 to 4."
• A logistic coefficient is read on the log-odds scale (the probability, odds, log-odds chain from lecture), which is awkward to read raw, so we report exp(coef), the odds ratio: the multiplier on the odds of default per one-unit rise in that predictor, holding the others fixed. An odds ratio above 1 raises the odds of default; below 1 lowers them.

Specify. The target is defaulted. Choose a sensible predictor set, the clean payment-behavior predictors are the natural ones (prior_late_count, days_since_last_order, discount_rate, orders_per_year). Name your set and say in one line why each belongs and is known at decision time.

Let AI write the fit. Ask the tutor for the statsmodels logistic regression of defaulted on your predictors, printing the coefficient table, the odds ratios (exp(coef)), and the predicted probability for a couple of example customers. Run it, save the output.

Interpret (this is the graded part). Write a short paragraph that answers:

• Read the prior_late_count odds ratio in plain words: each additional prior late payment multiplies the odds of default by about how much?
• For one low-risk and one high-risk example customer, state the predicted probability the model gives, and say whether the ordering matches your business intuition.
• Note the base rate of default in the data (about 20%) and say why a model that outputs probabilities is more useful to a collections manager than a flat yes/no.

Pick a cutoff (and stop there). A probability is not yet a decision. To act on it you choose a cutoff: call everyone above it "predict default." Use 0.5 to start, and ask the AI for the one confusion matrix at that cutoff (true/false positives and negatives). Read it once and write one sentence: at a 0.5 cutoff, does the model catch most defaults or miss most of them? You will find it misses most, because defaults are only ~20% of the data, so 0.5 is a high bar. That is the whole point you carry into Week 9, choosing the right cutoff against the cost of a miss versus a false alarm is next week's job. Do not go past this one matrix.

Write the helper. Fill in sigmoid:

def sigmoid(z):
    """TODO: one sentence, what does this return?"""
    return None

What it takes and returns: sigmoid(z) takes a number z, the linear score, and returns a float probability between 0 and 1, computed as 1 / (1 + exp(-z)). Use math.exp or numpy.exp for the exponential. This is the function that turns a linear score into a probability, the engine of logistic regression, written once by hand. Quick sanity check: sigmoid(0) returns 0.5.

Exercise 4, Have an AI generate an HTML explainer, then assess it 25 pts

What to do here: once your three models are done, you complete the fourth graded piece, the explainer, entirely in the Lab 8 quiz.

The explainer is the judgment artifact of this lab, and it lives in the Lab 8 New Quiz, not on this page. After your models are done, the quiz walks you through it: it gives you the full prompt for generating a single self-contained HTML explainer with an external AI chat (Gemini, ChatGPT, or Claude), has you upload that lab_08_explainer.html, and then asks you to write your own assessment of whether it actually taught you anything. Generating a clean summary is what AI is good at; judging whether it is right and useful is your job, and that judgment is what earns the points.