How do you turn a scorecard's fitted log-odds into points at base 600 with a PDO of 20?
answer
- an affine map of the log-odds
- doubling the odds must add a fixed amount
- divide the points-to-double by ln 2
- anchor the base score at chosen odds
basics
~20 sApply score = offset + factor times ln(odds), where factor = PDO / ln 2, so 20 / 0.693 is about 28.85, and offset = 600 minus factor times the log of the anchor odds. Every doubling of the odds then adds exactly 20 points.
solid answer
~50 sPoints scaling is a strictly increasing affine map of the model's log-odds, chosen so the numbers are readable. Fix two things: an **anchor** (score 600 means some stated odds, say 50:1 good to bad) and the **points to double the odds** (PDO 20). Then `factor = PDO / ln 2 = 28.85` and `offset = 600 - factor * ln(50) = 487`, giving `score = 487 + 28.85 * ln(odds)`. Because the log-odds are the intercept plus each characteristic's weighted WoE, the score splits across attributes: each contributes `factor * weight * WoE` plus its share of the constants, which is the points table. Say the consequence out loud: this changes nothing about ranking, AUC or who is approved at the equivalent cutoff. Holding base and PDO fixed across rebuilds is what makes 640 mean the same thing year to year.
go deeper
Know the vocabulary: the base score is the anchor value paired with a stated odds level, and PDO is how many points a doubling of the odds is worth on that scale.
Derive the constants on demand: the factor is PDO divided by ln 2, and the offset is the base score minus the factor times the log of the anchor odds. Be able to check the result at two odds levels.
Show that scaling is cosmetic statistically but load-bearing operationally: cutoffs, pricing tiers, referral rules and downstream systems are all denominated in these points, so the mapping must be applied consistently everywhere.
Own the continuity decision. Holding base and PDO fixed across model generations is what lets a score mean the same odds to policy, pricing and regulators over years, and it is a call worth defending against a proposed rescale.
## What scaling is for A fitted scorecard produces log-odds. Nobody underwrites on a log-odds. Scaling converts that quantity into a whole number in a familiar range so that credit policy, pricing tiers, collections strategies and customer communications can all speak in one currency. The transform is deliberately **affine and strictly increasing**, which is exactly why it is safe: it cannot change anyone's rank. ## The two choices You pick two things, and everything else follows. 1. **The anchor**: a score value paired with a stated odds level. "600 points means odds of 50:1 good to bad." 2. **PDO — points to double the odds**: how many points correspond to the odds doubling. "20" means 620 points is twice as good odds as 600, i.e. 100:1; 640 is 200:1; 580 is 25:1. ## The arithmetic The map has the form ``` score = offset + factor * ln(odds) ``` If the odds double, `ln(odds)` rises by `ln 2`, and we want the score to rise by exactly PDO, so ``` factor = PDO / ln 2 = 20 / 0.6931 = 28.85 offset = base_score - factor * ln(base_odds) = 600 - 28.85 * ln(50) = 600 - 28.85 * 3.912 = 487.1 ``` so `score = 487.1 + 28.85 * ln(odds)`. Check it: at odds 50 the score is 487.1 + 112.9 = 600, and at odds 100 it is 620. The PDO promise holds everywhere on the scale because the relationship is linear in log-odds. ## Spreading the points across the attributes The scorecard's log-odds are the intercept plus, for each characteristic, its fitted weight times the weight of evidence of the bin the applicant falls into: ``` ln(odds) = intercept + sum over characteristics of (weight_j * WoE_j) ``` Substituting into the scaling formula and splitting the constants evenly over the `n` characteristics gives, for each attribute (each bin of each characteristic): ``` points = factor * weight_j * WoE_j + (factor * intercept + offset) / n ``` Round each to an integer and you have the classic points table: every bin of every characteristic carries a fixed number of points, an applicant's score is the sum of the points for the bins they land in, and the whole thing can be printed on one page. Because the WoE run within an ordered characteristic is monotone, the points within it are monotone too — which is what makes the table explainable to a reviewer. A sign warning: the direction depends on which class the model predicts and which WoE convention you used. Under the goods-over-bads convention with log-odds of being good, higher score means lower risk, which is the familiar consumer convention. Flip either choice and the scale inverts. Decide once and check the finished table against a known-good and a known-bad profile before shipping. ## What scaling does and does not change **Does not change:** the ranking of applicants, discrimination measures such as AUC or Gini, the shape of the risk relationship, or which applicants are approved once the cutoff is mapped through the same transform. Rescaling from base 600 to base 700 is cosmetic in every statistical sense. **Does change:** every number that people and systems have memorised. Cutoffs, pricing bands, referral thresholds, collections triggers and customer-facing messages are all denominated in points. This is why the operational discipline matters more than the arithmetic. ## Why base and PDO are held fixed across rebuilds If a lender keeps base 600 = 50:1 and PDO 20 across model generations, then "640" carries the same odds meaning after a rebuild as before it. Policy cutoffs, pricing tiers and downstream systems stay valid, portfolio reporting stays comparable, and the migration analysis after a swap-in is about population shift rather than an arithmetic change. Change the scaling and every threshold in the organisation needs re-deriving simultaneously — a large, avoidable operational risk for no modelling gain. One caveat worth stating: the PDO promise is a statement about the *model's estimated* odds. It holds exactly in score space and only as well as the model's calibration holds in reality, so the odds at 640 should be re-checked against observed performance on recent data as part of monitoring. ## The common confusion PDO is about **odds**, not probability. Twenty points doubles the good:bad odds; it only approximately halves the default probability, and that approximation is decent when the default rate is low and poor when it is high. A candidate who says "20 points halves the chance of default" has mixed the two scales.
- Does changing the base score or the PDO change who gets approved?No, provided the cutoff is mapped through the same transform. Scaling is a strictly increasing affine function of the log-odds, so the ranking of applicants, the AUC and the approved set are all untouched. What changes is every memorised number: a cutoff of 620 under the old scale is a different integer under the new one, and every downstream threshold has to move with it.
- Why do lenders keep the base and PDO fixed across scorecard rebuilds?So a score keeps its meaning. If 600 always means 50:1 odds with 20 points per doubling, then policy cutoffs, pricing tiers, collections triggers and portfolio reporting survive a model swap, and post-implementation analysis is about population shift rather than arithmetic. Re-scaling forces every threshold in the organisation to be re-derived at once, for no modelling benefit.
- If 600 points means 50:1 odds with a PDO of 20, what does 620 mean?Odds of 100:1 good to bad — one doubling above the anchor. At 640 it is 200:1 and at 580 it is 25:1. Note this is a statement about odds, not probability: the implied bad rate falls from roughly 1 in 51 to roughly 1 in 101, which is close to halving only because the rate is already small.
It is the same move as converting Celsius to Fahrenheit: pick a zero point and how much one degree is worth, and nothing about the weather changes.
saying these in an interview costs you the question
- Thinks rescaling improves the model's discrimination
- Says twenty points halves the probability of default
- Computes the factor as PDO multiplied by ln 2
- Changes base and PDO at every rebuild
- Forgets to map the policy cutoff through the same transform