Which columns are pulling their weight

Step 5 ended with you asking the model a question directly for the first time: did you even use this column? You used feature_importances_ and only looked at whether the number was zero.

This step is about the size of those numbers, and it is mostly about how badly you can be fooled by them.

The thing that happens in Part 3

You add one column to your table. It holds the row number: 0 for the first person, 1 for the second, and so on to 4,520. It is not about anybody. It cannot possibly mean anything.

You train a tree six questions deep and ask for the ranking. Your row number lands high in it, above columns you worked hard for in Step 4.

Then in Part 4 you ask a different question, of the people the model never saw, and get a completely different answer about the same column. Both are correct. They are answers to different questions, and almost nobody who quotes the first one knows that.

The page does not tell you either position in advance. You are asked to write down a guess first, three times, and being wrong is the point.

What you actually do, in order

1. Rank five clues about a shopper by what you would pay for each, on paper, and find the one you would only know afterwards.
2. Ask a small tree which columns it leaned on, and find that 41 of the 47 got no look at all.
3. Add the row number and see how high it comes.
4. Ask the test rows the same question and get a different answer.
5. Find three columns with an importance of exactly zero that are not useless.
6. Put duration back in and watch both rankings fall for it at once.

Paper and pen. Laptop shut. Copy the five clues onto your paper first, so the table below is something you can work on.

A coat shop wants to know which visitors will buy a coat, so that it can decide who to send an offer to on Friday morning. Here are five things it could know about a visitor.

First, rank them

You have one hundred pounds to spend on clues. Split it between the five, in whatever way you like, giving most to the one you would least want to lose. Write the five numbers in the second column. They must add up to a hundred.

This takes longer than you expect and the arguing with yourself is the exercise. Do it before you read on.

One of the five cannot survive that question. How many minutes somebody spent in the shop is a fact about a visit that has not happened. On Friday morning it does not exist for anybody you care about.

It is also, if you are honest, probably one of the two you paid most for, because it is the best clue on the list. Somebody who spends forty minutes in a coat shop is buying a coat.

The other four are not equal either

Look at "whether it rained that week". It is the same for every visitor on the same day, so it can never tell two of Friday's visitors apart. A clue that does not vary between the people you are choosing between is worth nothing for choosing between them, however much it explains about the shop's takings overall.

And look at "their coat size" next to "how much they spent last winter". If everybody who spent a lot last winter also happens to be recorded with a coat size, and the people who spent nothing are not, then coat size is quietly saying the same thing as last winter’s spending, and taking it away might cost you nothing at all.

Keep your list of five with the money written on it. Part 6 comes back to it.

Open band-06.ipynb. Every cell on this page is already in it, in this order. You run them; you do not type them. The typing is in Part 7, on your own table.

The first cell is Step 4's table and Step 3's split, in one go. Nothing here is new except the last import, which you will need in Part 4.

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.inspection import permutation_importance

df = pd.read_csv("data/bank.csv", sep=";")
y = (df["y"] == "yes").astype(int)

plain = ["age", "balance", "day", "campaign", "pdays", "previous"]
many = ["job", "marital", "education", "contact", "month", "poutcome"]

ready = df[plain].copy()
for name in ["default", "housing", "loan"]:
    ready[name] = (df[name] == "yes").astype(int)

ready = pd.concat([ready, pd.get_dummies(df[many], dtype=int)], axis=1)

X_train, X_test, y_train, y_test = train_test_split(
    ready, y, test_size=0.25, random_state=0)

print(ready.shape)

Now the tree from Step 4, and its ranking.

small = DecisionTreeClassifier(max_depth=3, random_state=0)
small.fit(X_train, y_train)

weight = pd.Series(small.feature_importances_, index=X_train.columns)

print(round(weight.sum(), 4))
print((weight > 0).sum())
print(weight.sort_values(ascending=False).head(6).round(4).to_string())

index=X_train.columns writes the column names down the side of the list, so weight["age"] reads off one column's number by name. .sort_values(ascending=False) puts the biggest first. .head(6) keeps the top six, the way it kept the top rows of a table in Step 0. .to_string() prints the names beside the numbers without the extra line pandas adds about the kind of thing it is.

1.0
6
poutcome_success      0.5974
month_oct             0.1542
age                   0.1104
day                   0.0547
balance               0.0460
education_tertiary    0.0373

Three things in that, and the first two are the ones people miss.

• The numbers add up to 1. That is not a coincidence and it is not a probability. It is a share: the whole of the model's work, divided up. Which means a column's number depends on what else is in the table. Add a column, and every other number moves.
• Only six of the 47 columns have a number at all. The tree asked three questions and used six columns doing it, so the other 41 are sitting at exactly zero. They did not lose an argument. They were never in one.
• poutcome_success takes 60 percent of the total, which is the same column your Step 1 rule was made of, arriving again with a number on it.

Now the same thing with no limit on the depth.

big = DecisionTreeClassifier(random_state=0)
big.fit(X_train, y_train)

big_weight = pd.Series(big.feature_importances_, index=X_train.columns)

print((big_weight > 0).sum())
print(round(big.score(X_test, y_test), 4))

Every single column now has an importance above zero. All 47 of them matter. Or so the table says.

And the model they all matter to scores 0.8073 on people it has never seen, which is well below the 0.878 you get by saying no to everybody. Step 3's memorising tree, with a ranking attached.

Time to find out how much that ranking is worth.

You are going to add one column holding nothing but the row number. The first person gets 0, the second gets 1, and so on to 4,520. The rows of this file are a random tenth of a bigger file, so the order means nothing whatever: it is not time, it is not the order the calls were made, it is not anything.

noisy = ready.copy()
noisy["row_number"] = range(len(noisy))

N_train, N_test, y_train, y_test = train_test_split(
    noisy, y, test_size=0.25, random_state=0)

deep = DecisionTreeClassifier(max_depth=6, random_state=0)
deep.fit(N_train, y_train)

deep_weight = pd.Series(deep.feature_importances_, index=N_train.columns)

print(deep_weight.sort_values(ascending=False).head(5).round(4).to_string())

range(len(noisy)) counts from 0 up to one less than the number of rows, which is exactly the row numbers. Six questions rather than three, because a small tree does not have room to be fooled, and you will see that in a moment.

poutcome_success    0.3168
age                 0.1086
row_number          0.0946
pdays               0.0933
month_oct           0.0914

print(round(deep_weight["row_number"], 4))
print(round(deep.score(N_test, y_test), 4))

Third out of forty-eight. Ahead of pdays. Ahead of the October column that you found by hand in Step 1 and watched the model rediscover in Step 4.

Third is this split, not a law. Over thirty different splits it lands between second and eleventh, and it never once falls out of the top quarter of the table. The position moves; the fact that a column made of nothing sits near the top does not.

The column is the row number. There is nothing in it. If you put that ranking in front of a manager, one of its top lines would be a lie, and you would have no idea.

Why it happened, and it is not a bug

Built-in importance is worked out while the tree is being built, on the training rows, and it counts how much each question tidied up the heap underneath it.

Now think about what the row number offers a tree. It has 3,390 different values in the training half, so there are 3,389 places to cut it. Most other columns offer far fewer: month_oct offers exactly one cut, because it is a one or a zero. The exception proves the rule, and it is worth knowing: balance has 1,927 different values, and it floats up this table too.

Give a tree three thousand places to cut and some of them will separate the training rows a little, by luck. The tree takes the best of those, and it looks like work done, and it is counted as work done.

One more thing before you leave it. Give the same 48 columns to a tree with three questions instead of six.

shallow = DecisionTreeClassifier(max_depth=3, random_state=0)
shallow.fit(N_train, y_train)

shallow_weight = pd.Series(shallow.feature_importances_, index=N_train.columns)

print(round(shallow_weight["row_number"], 4))
print((shallow_weight > 0).sum())

Exactly zero, tied at the bottom with 41 other columns. The row number was offered to this tree too, with the same three thousand places to cut, and it never got used.

This tree had no room to be fooled. It only had three questions and it spent them on the columns that were worth it.

Do not make that a promise, though. Run the same three questions on thirty different splits and the row number picks up a real number on seven of them, once as high as fourth. Three questions is thin protection, not armour. Depth does not only cost you honesty in the score, which is Step 3. It costs you honesty in the ranking too, and shallowness only makes it less likely.

There is a second way to ask which columns matter, and it is slower, better, and almost never the one people use.

Take the model you already trained. Take the 1,131 people it has never seen. Now pick one column and shuffle it, so that everybody has somebody else's value for that column and the column still looks perfectly normal. Score the model again.

If the score falls, the model was using that column for something real. If the score does not move, it was not.

shuffled = permutation_importance(deep, N_test, y_test,
                                  n_repeats=10, random_state=0)

honest = pd.Series(shuffled.importances_mean, index=N_test.columns)

print(honest.sort_values(ascending=False).head(5).round(4).to_string())

permutation_importance does the shuffling for you, once per column. You hand it the trained model and the rows to test it on, and it hands back a result you read the numbers off. n_repeats=10 shuffles each column ten times and averages, because one shuffle is one go, the way one split was one go in Step 4. importances_mean is the average drop in score for each column.

poutcome_success      0.0134
month_oct             0.0068
day                   0.0035
housing               0.0020
education_tertiary    0.0015

print(round(honest["row_number"], 4))

order = honest.sort_values(ascending=False)
print(list(order.index).index("row_number") + 1)

The second line finds where in the sorted list that name sits and counts from 1, because you predicted a position and the ranking prints numbers.

Below zero means the model got better when that column was scrambled. Which makes sense: everything the tree learned from the row number was fitted to the training people and was noise for everybody else, so wrecking it helped.

Two rankings. Same model, same columns, same afternoon. One puts the row number third and one puts it forty-seventh.

The cost, and the catch

Permutation importance re-scores the model once per column per repeat. That is 48 columns times 10 repeats, and it took a moment. On a big model with a thousand columns you would feel it.

And it has a real weakness, which the next part is about: shuffle one of two columns that say the same thing, and the model just reads the other one, so both look worthless.

Step 5 found something you can use here. Four columns in this file say the same thing about the same 816 people: pdays, previous, poutcome_unknown, and the contacted_before flag you built. They are redundant, in the Part 1 sense.

Put the flag back and ask the ranking about all four.

dup = ready.copy()
dup["contacted_before"] = (df["pdays"] != -1).astype(int)

D_train, D_test, y_train, y_test = train_test_split(
    dup, y, test_size=0.25, random_state=0)

dup_tree = DecisionTreeClassifier(max_depth=6, random_state=0)
dup_tree.fit(D_train, y_train)

dup_weight = pd.Series(dup_tree.feature_importances_, index=D_train.columns)

print(dup_weight[["pdays", "previous",
                   "poutcome_unknown", "contacted_before"]].round(4).to_string())

Handing a list of names inside the square brackets picks out those rows of the ranking, in that order.

pdays               0.1148
previous            0.0000
poutcome_unknown    0.0000
contacted_before    0.0000

One column takes everything and three take nothing.

There is nothing to choose between them. The tree met pdays first, split on it, and by the time it looked at the other three there was nothing left for them to explain. A ranking cannot show you a tie, so it shows you a landslide.

Watch what happens when the winner leaves.

gone = dup.drop(columns=["pdays"])

G_train, G_test, y_train, y_test = train_test_split(
    gone, y, test_size=0.25, random_state=0)

without = DecisionTreeClassifier(max_depth=6, random_state=0)
without.fit(G_train, y_train)

without_weight = pd.Series(without.feature_importances_, index=G_train.columns)

print(without_weight[["previous", "poutcome_unknown",
                      "contacted_before"]].round(4).to_string())
print(round(dup_tree.score(D_test, y_test), 4))
print(round(without.score(G_test, y_test), 4))

previous            0.0183
poutcome_unknown    0.0000
contacted_before    0.0000

previous was worth zero and is now worth something. It did not change. The redundant column that beat it left.

And the score barely moved, because the information never went anywhere. You deleted the column that took 11 percent of the credit and lost less than two thousandths of a point.

That was one split, and you know from Step 4 what one split is worth. Here is the same question asked thirty times.

with_it, without_it = [], []

for seed in range(30):
    a, b, c, d = train_test_split(dup, y, test_size=0.25, random_state=seed)
    tree = DecisionTreeClassifier(max_depth=6, random_state=0).fit(a, c)
    with_it.append(tree.score(b, d))

    a, b, c, d = train_test_split(gone, y, test_size=0.25, random_state=seed)
    tree = DecisionTreeClassifier(max_depth=6, random_state=0).fit(a, c)
    without_it.append(tree.score(b, d))

print(round(sum(with_it) / 30, 4))
print(round(sum(without_it) / 30, 4))

Both splits use the same seed each time round, so the two models are always being asked about the same people. That is the only fair way to compare them.

Averaged over thirty different sets of people, the table without pdays is very slightly ahead. Not meaningfully ahead: a ten-thousandth of a point is nothing. But the column that took 11 percent of the ranking is worth, as far as anyone can measure, exactly nothing at all.

This is the loop you will need in Part 7, and it is the only tool on this page that answers the question people think a ranking answers.

One last one, and it is the reason this step cannot be the last word.

Put duration back in. You met it in Step 3: the length of the phone call, which does not exist until the call has happened.

leaky = ready.copy()
leaky["duration"] = df["duration"]

L_train, L_test, y_train, y_test = train_test_split(
    leaky, y, test_size=0.25, random_state=0)

cheat = DecisionTreeClassifier(max_depth=6, random_state=0)
cheat.fit(L_train, y_train)

print(round(cheat.score(L_test, y_test), 4))

built_in = pd.Series(cheat.feature_importances_, index=L_train.columns)
print(built_in.sort_values(ascending=False).head(3).round(4).to_string())

duration            0.4587
poutcome_success    0.1816
age                 0.0740

shuffled_leaky = permutation_importance(cheat, L_test, y_test,
                                        n_repeats=10, random_state=0)

honest_leaky = pd.Series(shuffled_leaky.importances_mean, index=L_test.columns)
print(honest_leaky.sort_values(ascending=False).head(3).round(4).to_string())

duration            0.0580
poutcome_success    0.0213
contact_cellular    0.0118

Top of both. By a distance, in both. Nearly half of the built-in table, and getting on for three times the next column in the permutation table.

The score is 0.9036, as high as anything this course has produced. Step 3 got a number just like it, in the same way. Every check you have agrees this is the best column you own.

So you can answer the question after all, when somebody asks which columns matter most in your model. Not with the built-in table, and not with a shrug. You say which of the two rankings you are quoting, what its numbers mean, and which of the columns near the top you checked by hand and how. That answer is three sentences long and you now have all three.

No code here and no answer at the end. Your own table, the one you signed up in Step 0 and have carried through five steps. Give it a sitting of its own; it is the longest part in the step.

The brief

Produce one importance table for your own model that you would be willing to show somebody, and delete one column with the reason written next to it.

It is done when

• You have both rankings for your own model, built-in and permutation, side by side in your README, top ten of each.
• Before you look at either ranking, you have written the list of every column in your table with more than about twenty different values, and said which of them you would expect to float up for the wrong reason. That list goes in the README too, or you will not bother writing it.
• You have asked the Part 0 question of your top five columns, in writing, one line each. Not the top one. The top five.
• You have deleted one column and written the reason beside it. It can be a leak, a column made redundant by another, or a column that costs nothing to lose. It cannot be "it scored zero". If nothing in your table deserves to go, write that instead and say what you checked; honestly reached, that is the same answer and it counts.
• You have run the Part 5 loop on your own table, thirty splits with that column and thirty without, and written both averages down. Copy the loop from Part 5 and change the two table names.
• If a column is in the top five of one of your rankings and not the other, that column gets a paragraph of its own.

Working alone

You are the person who knows your subject. Put the README away, and tomorrow read your top five out loud, in order, before you look at the numbers again. You are listening for your own surprise: "that one is at the top?" is the beginning of finding either a leak or something real that nobody had noticed.

If you have somebody to ask

Read the same five to them, in order, without saying what the numbers are. Their surprise is worth more than yours, because they do not know what the model did and you do.

Add to the README you started in Step 0.

• Where the row number came in both rankings, and one line on why the two differ.
• Your own two rankings, top ten of each.
• Your five Part 0 questions and their answers.
• The column you deleted and the reason, and what thirty splits said about deleting it.
• One line on what an importance table can never tell you.
• The three sentences you would say if somebody asked which columns matter most in your model: which ranking you are quoting, what its numbers mean, and the column near the top you checked by hand and what you found. Write them as you would say them out loud.

Six questions. Answer them in writing before you open the answers.

One counts more than the other five. You can get five right and still not pass this step.

1. Built-in importance put the row number third. Permutation importance put it forty-seventh. Which one was wrong, and what was the other one measuring?
2. Your six columns at depth 3 became 47 columns at no depth limit. What changed, and what did not?
3. Three columns scored exactly zero and none of them was useless. Explain the zero.

4. A colleague is predicting which customers will cancel their subscription. She shows you the built-in importance table from a tree eight questions deep. Three lines matter.

   1. Top of the table, taking a third of the total: customer_id.
   2. Second: days_since_last_login, which her system records as of the day she pulled the data.
   3. Bottom, at exactly 0.0000: plan_type. She says this proves the plan somebody is on has nothing to do with whether they cancel.

   Take the three in turn. Say what is happening in each case and what you would do about it. One of them is not a discovery at all, one might be a leak and you cannot tell from the table, and one conclusion does not follow.

5. Permutation importance gave the best column 0.0134 and built-in importance gave it 0.5974. Why can you not compare those two numbers?
6. Both rankings put duration first. Both were right. Why is that a problem, and what catches it?