Download Introduction to Classification: Basic Concepts and Decision Trees

Data Mining
Classification: Basic Concepts, Decision
Trees, and Model Evaluation
Lecture Notes for Chapter 4
Introduction to Data Mining
by
Tan, Steinbach, Kumar
COSC 4355
Classification: Definition
o
Given a collection of records (training set )
– Each record contains a set of attributes, one of the
attributes is the class.
o
o
Find a model for the class attribute as a
function of the values of other attributes.
Goal: previously unseen records should be
assigned a class as accurately as possible.
– A test set is used to determine the accuracy of the
model. Usually, the given data set is divided into
training and test sets, with training set used to build
the model and test set used to validate it.
Illustrating Classification Task
Tid
Attrib1
Attrib2
Attrib3
Class
1
Yes
Large
125K
No
2
No
Medium
100K
No
3
No
Small
70K
No
4
Yes
Medium
120K
No
5
No
Large
95K
Yes
6
No
Medium
60K
No
7
Yes
Large
220K
No
8
No
Small
85K
Yes
9
No
Medium
75K
No
10
No
Small
90K
Yes
Learning
algorithm
Induction
Learn
Model
Model
10
Training Set
Tid
Attrib1
Attrib2
11
No
Small
55K
?
12
Yes
Medium
80K
?
13
Yes
Large
110K
?
14
No
Small
95K
?
15
No
Large
67K
?
10
Test Set
Attrib3
Apply
Model
Class
Deduction
Examples of Classification Task
o
Predicting tumor cells as benign or malignant
o
Classifying credit card transactions
as legitimate or fraudulent
o
Classifying secondary structures of protein
as alpha-helix, beta-sheet, or random
coil
o
Categorizing news stories as finance,
weather, entertainment, sports, etc
Classification Techniques
o
o
o
o
o
o
o
Decision Tree based Methods
Rule-based Methods
Memory based reasoning, instance-based learning, kNN
Neural Networks
Naïve Bayes and Bayesian Belief Networks
Support Vector Machines
Ensemble Methods
Example of a Decision Tree
Tid Refund Marital
Status
Taxable
Income Cheat
1
Yes
Single
125K
No
2
No
Married
100K
No
3
No
Single
70K
No
4
Yes
Married
120K
No
5
No
Divorced 95K
Yes
6
No
Married
No
7
Yes
Divorced 220K
No
8
No
Single
85K
Yes
9
No
Married
75K
No
10
No
Single
90K
Yes
60K
Splitting Attributes
Refund
Yes
No
NO
MarSt
Single, Divorced
TaxInc
< 80K
NO
NO
> 80K
YES
10
Training Data
Married
Model: Decision Tree
Another Example of Decision Tree
MarSt
10
Tid Refund Marital
Status
Taxable
Income Cheat
1
Yes
Single
125K
No
2
No
Married
100K
No
3
No
Single
70K
No
4
Yes
Married
120K
No
5
No
Divorced 95K
Yes
6
No
Married
No
7
Yes
Divorced 220K
No
8
No
Single
85K
Yes
9
No
Married
75K
No
10
No
Single
90K
Yes
60K
Married
NO
Single,
Divorced
Refund
No
Yes
NO
TaxInc
< 80K
NO
> 80K
YES
There could be more than one tree that
fits the same data!
Objectives Data Mining Course
Lecture Notes for Chapter 4
Apply Data Mining to Real World Datasets
Using R for
Data Analysis
And Data Mining
Exploratory Data Analysis
and Preprocessing
Introduction to Data Mining
Goals and Objectives of Data Mining
Implementing Data
Mining Algorithms
by
Making Sense
of Data
Tan, Steinbach, Kumar
Classification Techniques
Learn How to Interpret
Data Mining Results
Association Analysis
Clustering Algorithms
Introduction to Classification: Basic Concepts and Decision Trees
Organization COSC 4355
1. Decision Tree Basics
2. Decision Tree Induction Algorithms
3. Regression Trees (brief)
4. Overfitting and Underfitting
5. Pruning Techniques
6. Dealing with Missing Values
7. Advantages and Disadvantages of Decision Trees
8. Model Evaluation
Decision Tree Induction
o
Many Algorithms:
– Hunt’s Algorithm (one of the earliest)
– CART
– ID3, C4.5
– SLIQ,SPRINT
General Structure of Hunt’s Algorithm
o
o
Let Dt be the set of training records
that reach a node t
General Procedure:
– If Dt contains records that
belong the same class yt, then t
is a leaf node labeled as yt
– If Dt is an empty set, then t is a
leaf node labeled by the default
class, yd
– If Dt contains records that
belong to more than one class,
use an attribute test to split the
data into smaller subsets.
Recursively apply the
procedure to each subset.
Tid Refund Marital
Status
Taxable
Income Cheat
1
Yes
Single
125K
No
2
No
Married
100K
No
3
No
Single
70K
No
4
Yes
Married
120K
No
5
No
Divorced 95K
Yes
6
No
Married
No
7
Yes
Divorced 220K
No
8
No
Single
85K
Yes
9
No
Married
75K
No
10
No
Single
90K
Yes
10
Dt
?
60K
Hunt’s Algorithm
Don’t
Cheat
Refund
Yes
No
Don’t
Cheat
Don’t
Cheat
Refund
Refund
Yes
Yes
No
No
Tid Refund Marital
Status
Taxable
Income Cheat
1
Yes
Single
125K
No
2
No
Married
100K
No
3
No
Single
70K
No
4
Yes
Married
120K
No
5
No
Divorced 95K
Yes
6
No
Married
No
7
Yes
Divorced 220K
No
8
No
Single
85K
Yes
9
No
Married
75K
No
10
No
Single
90K
Yes
10
Don’t
Cheat
Don’t
Cheat
Marital
Status
Single,
Divorced
Cheat
Married
Marital
Status
Single,
Divorced
Don’t
Cheat
Married
Don’t
Cheat
Taxable
Income
< 80K
>= 80K
Don’t
Cheat
Cheat
60K
Tree Induction
Greedy strategy
– Split the records based on an attribute test
that optimizes certain criterion.
Remark: Finding optimal decision trees is NP-hard.
http://en.wikipedia.org/wiki/NP-hard
o Issues
1. Determine how to split the records
o


How to specify the attribute test condition?
How to determine the best split?
2. Determine when to stop splitting
Tree Induction
o
o
Greedy strategy
(http://en.wikipedia.org/wiki/Greedy_algorithm )
Creates the tree top down starting from the root,
and splits the records based on an attribute test
that optimizes certain criterion.
Issues
– Determine how to split the records
How to specify the attribute test condition?
 How to determine the best split?

– Determine when to stop splitting
Side Discussion “Greedy Algorithms”
o
o
o
o
o
o
Fast and therefore attractive to solve NP-hard and other
problems with high complexity. Later decisions are made in the
context of decision selected early dramatically reducing the size
of the search space.
They do not backtrack: if they make a bad decision (based on
local criteria), they never revise the decision.
They are not guaranteed to find the optimal solution(s), and
sometimes can get deceived and find really bad solutions.
In spite of what is said above, a lot successful and popular
algorithms in Computer Science are greedy algorithms.
Greedy algorithms are particularly popular in AI and Operations
Research.
See also: http://en.wikipedia.org/wiki/Greedy_algorithm
Popular Greedy Algorithms: Decision Tree Induction,…
How to Specify Test Condition?
o
Depends on attribute types
– Nominal
– Ordinal
– Continuous
o
Depends on number of ways to split
– 2-way split
– Multi-way split
Splitting Based on Nominal Attributes
o
Multi-way split: Use as many partitions as distinct
values.
CarType
Family
Luxury
Sports
o
Binary split: Divides values into two subsets.
Need to find optimal partitioning.
{Sports,
Luxury}
CarType
{Family}
OR
{Family,
Luxury}
CarType
{Sports}
Splitting Based on Ordinal Attributes
o
Multi-way split: Use as many partitions as distinct
values.
Size
Small
Large
Medium
o
Binary split: Divides values into two subsets.
Need to find optimal partitioning.
{Small,
Medium}
o
Size
{Large}
What about this split?
OR
{Small,
Large}
{Medium,
Large}
Size
Size
{Medium}
{Small}
Splitting Based on Continuous Attributes
o
Different ways of handling
– Discretization to form an ordinal categorical
attribute
Static – discretize once at the beginning
 Dynamic – ranges can be found by equal interval
bucketing, equal frequency bucketing
(percentiles), clustering, or supervised
clustering.

– Binary Decision: (A < v) or (A  v)
consider all possible splits and finds the best cut v
 can be more compute intensive

Splitting Based on Continuous Attributes
Taxable
Income
> 80K?
Taxable
Income?
< 10K
Yes
> 80K
No
[10K,25K)
(i) Binary split
[25K,50K)
[50K,80K)
(ii) Multi-way split
Tree Induction
o
Greedy strategy.
– Split the records based on an attribute test
that optimizes certain criterion.
o
Issues
– Determine how to split the records
How to specify the attribute test condition?
 How to determine the best split?

– Determine when to stop splitting
How to determine the Best Split?
Before Splitting: 10 records of class 0,
10 records of class 1
Before: E(1/2,1/2)
Own
Car?
Car
Type?
No
Yes
Family
Student
ID?
Luxury
c1
Sports
C0: 6
C1: 4
C0: 4
C1: 6
C0: 1
C1: 3
C0: 8
C1: 0
C0: 1
C1: 7
C0: 1
C1: 0
...
c10
C0: 1
C1: 0
After: 4/20*E(1/4,3/4) + 8/20*E(1,0) + 8/20*(1/8,7/8)
Gain: Before-After
Pick Test that has the highest gain!
Remark: E stands for Gini, H (Entropy), Impurity, …
c11
C0: 0
C1: 1
c20
...
C0: 0
C1: 1
How to determine the Best Split
o
o
Greedy approach:
– Nodes with homogeneous class distribution
(pure nodes) are preferred
Need a measure of node impurity:
C0: 5
C1: 5
C0: 9
C1: 1
Non-homogeneous,
Homogeneous,
High degree of impurity
Low degree of impurity
Measures of Node Impurity
o
Gini Index
o
Entropy
o
Misclassification error
Remark: All three approaches center on selecting
tests that maximize purity. They just disagree in
how exactly purity is measured.
How to Find the Best Split
Before Splitting:
C0
C1
N00
N01
M0
A?
B?
Yes
No
Node N1
C0
C1
Node N2
N10
N11
C0
C1
N20
N21
M2
M1
Yes
No
Node N3
C0
C1
Node N4
N30
N31
C0
C1
M3
M12
M4
M34
Gain = M0 – M12 vs M0 – M34
N40
N41
Measure of Impurity: GINI
o
Gini Index for a given node t :
GINI (t )  1   [ p( j | t )]2
j
(NOTE: p( j | t) is the relative frequency of class j at node t).
– Maximum (1 - 1/nc) when records are equally
distributed among all classes, implying least
interesting information
– Minimum (0.0) when all records belong to one class,
implying most interesting information
C1
C2
0
6
Gini=0.000
C1
C2
1
5
Gini=0.278
C1
C2
2
4
Gini=0.444
C1
C2
3
3
Gini=0.500
Examples for computing GINI
GINI (t )  1   [ p( j | t )]2
j
C1
C2
0
6
P(C1) = 0/6 = 0
C1
C2
1
5
P(C1) = 1/6
C1
C2
2
4
P(C1) = 2/6
P(C2) = 6/6 = 1
Gini = 1 – P(C1)2 – P(C2)2 = 1 – 0 – 1 = 0
P(C2) = 5/6
Gini = 1 – (1/6)2 – (5/6)2 = 0.278
P(C2) = 4/6
Gini = 1 – (2/6)2 – (4/6)2 = 0.444
Splitting Based on GINI
o
o
Used in CART, SLIQ, SPRINT.
When a node p is split into k partitions (children), the
quality of split is computed as,
k
ni
GINI split   GINI (i )
i 1 n
where,
ni = number of records at child i,
n = number of records at node p.
Binary Attributes: Computing GINI Index
o
o
Splits into two partitions
Effect of Weighing partitions:
– Larger and Purer Partitions are sought for.
Parent
B?
Yes
No
C1
6
C2
6
Gini = 0.500
Gini(N1)
= 1 – (5/7)2 – (2/7)2
=…
Gini(N2)
= 1 – (1/5)2 – (4/5)2
=…
Node N1
C1
C2
Node N2
N1
5
2
Gini=y
N2
1
4
Gini(Children)
= 7/12 * Gini(N1) +
5/12 * Gini(N2)=y
Categorical Attributes: Computing Gini Index
o
o
For each distinct value, gather counts for each class in
the dataset
Use the count matrix to make decisions
Multi-way split
Two-way split
(find best partition of values)
CarType
Family Sports Luxury
C1
C2
Gini
1
4
2
1
0.393
1
1
C1
C2
Gini
CarType
{Sports,
{Family}
Luxury}
3
1
2
4
0.400
C1
C2
Gini
CarType
{Family,
{Sports}
Luxury}
2
2
1
5
0.419
Continuous Attributes: Computing Gini Index
o
o
o
o
Use Binary Decisions based on one
value
Several Choices for the splitting value
– Number of possible splitting values
= Number of distinct values
Each splitting value has a count matrix
associated with it
– Class counts in each of the
partitions, A < v and A  v
Simple method to choose best v
– For each v, scan the database to
gather count matrix and compute
its Gini index
– Computationally Inefficient!
Repetition of work.
Tid Refund Marital
Status
Taxable
Income Cheat
1
Yes
Single
125K
No
2
No
Married
100K
No
3
No
Single
70K
No
4
Yes
Married
120K
No
5
No
Divorced 95K
Yes
6
No
Married
No
7
Yes
Divorced 220K
No
8
No
Single
85K
Yes
9
No
Married
75K
No
10
No
Single
90K
Yes
60K
10
Taxable
Income
> 80K?
Yes
No
Continuous Attributes: Computing Gini Index...
o
For efficient computation: for each attribute,
– Sort the attribute on values
– Linearly scan these values, each time updating the count matrix
and computing gini index
– Choose the split position that has the least gini index
Cheat
No
No
No
Yes
Yes
Yes
No
No
No
No
100
120
125
220
Taxable Income
60
Sorted Values
70
55
Split Positions
75
65
85
72
90
80
95
87
92
97
110
122
172
230
<=
>
<=
>
<=
>
<=
>
<=
>
<=
>
<=
>
<=
>
<=
>
<=
>
<=
>
Yes
0
3
0
3
0
3
0
3
1
2
2
1
3
0
3
0
3
0
3
0
3
0
No
0
7
1
6
2
5
3
4
3
4
3
4
3
4
4
3
5
2
6
1
7
0
Gini
0.420
0.400
0.375
0.343
0.417
0.400
0.300
0.343
0.375
0.400
0.420
Alternative Splitting Criteria based on INFO
o
Entropy at a given node t:
Entropy(t )   p( j | t ) log p( j | t )
j
(NOTE: p( j | t) is the relative frequency of class j at node t).
– Measures homogeneity of a node.
 Maximum
(log nc) when records are equally distributed
among all classes implying least information
 Minimum (0.0) when all records belong to one class,
implying most information
– Entropy based computations are similar to the
GINI index computations
Examples for computing Entropy
Entropy(t )   p( j | t ) log p( j | t )
j
C1
C2
0
6
C1
C2
1
5
P(C1) = 1/6
C1
C2
2
4
P(C1) = 2/6
P(C1) = 0/6 = 0
2
P(C2) = 6/6 = 1
Entropy = – 0 log 0 – 1 log 1 = – 0 – 0 = 0
P(C2) = 5/6
Entropy = – (1/6) log2 (1/6) – (5/6) log2 (1/6) = 0.65
P(C2) = 4/6
Entropy = – (2/6) log2 (2/6) – (4/6) log2 (4/6) = 0.92
Splitting Based on INFO...
o
Information Gain:
 n

GAIN  Entropy ( p)  
Entropy (i) 
 n

k
split
i
i 1
Parent Node, p is split into k partitions;
ni is number of records in partition i
– Measures Reduction in Entropy achieved because of
the split. Choose the split that achieves most reduction
(maximizes GAIN)
– Used in ID3 and C4.5
– Disadvantage: Tends to prefer splits that result in large
number of partitions, each being small but pure.
Splitting Based on INFO...
o
Gain Ratio:
GAIN
n
n
GainRATIO 
SplitINFO    log
SplitINFO
n
n
Split
split
k
i
i 1
Parent Node, p is split into k partitions
ni is the number of records in partition i
– Adjusts Information Gain by the entropy of the
partitioning (SplitINFO). Higher entropy partitioning
(large number of small partitions) is penalized!
– Used in C4.5
– Designed to overcome the disadvantage of Information
Gain
i
Entropy and Gain Computations
Assume we have m classes in our classification problem. A test S subdivides
the examples D= (p1,…,pm) into n subsets D1 =(p11,…,p1m) ,…,Dn
=(p11,…,p1m). The qualify of S is evaluated using Gain(D,S) (ID3) or
GainRatio(D,S) (C5.0): m
Let H(D=(p1,…,pm))= Sn i=1 (pi log2(1/pi)) (called the entropy function)
Gain(D,S)= H(D)  Si=1 (|Di|/|D|)*H(Di)
Gain_Ratio(D,S)= Gain(D,S) / H(|D1|/|D|,…, |Dn|/|D|)
Remarks:
|D| denotes the number of elements in set D.
D=(p1,…,pm) implies that p1+…+ pm =1 and indicates that of the |D| examples
p1*|D| examples belong to the first class, p2*|D| examples belong to the
second class,…, and pm*|D| belong the m-th (last) class.
H(0,1)=H(1,0)=0; H(1/2,1/2)=1, H(1/4,1/4,1/4,1/4)=2, H(1/p,…,1/p)=log2(p).
C5.0 selects the test S with the highest value for Gain_Ratio(D,S), whereas
ID3 picks the test S for the examples in set D with the highest value for
Gain (D,S).
Information Gain vs. Gain Ratio
Result:
I_Gain_Ratio:
city>age>car
sale
custId
c1
c2
c3
c4
c5
c6
car
taurus
van
van
taurus
merc
taurus
age
27
35
40
22
50
25
city newCar
sf
yes
la
yes
sf
yes
sf
yes
la
no
la
no
Result:
I_Gain:
age > car=city
Gain(D,city=)= H(1/3,2/3) – ½ H(1,0) –
D=(2/3,1/3)
½ H(1/3,2/3)=0.45
city=la
city=sf
D1(1,0)
D2(1/3,2/3)
G_Ratio_pen(city=)=H(1/2,1/2)=1
G_Ratio_pen(car=)=H(1/2,1/3,1/6)=1.45
car=merc
D1(0,1)
D=(2/3,1/3)
car=taurus
D2(2/3,1/3)
Gain(D,car=)= H(1/3,2/3) – 1/6 H(0,1) –
car=van ½ H(2/3,1/3) – 1/3 H(1,0)=0.45
D3(1,0)
Gain(D,age=)= H(1/3,2/3) – 6*1/6 H(0,1)
= 0.90
age=22 age=25 age=27 age=35
age=40
age=50
D1(1,0)
D4(1,0)
D5(1,0)
D2(0,1) D3(1,0)
D6(0,1)
G_Ratio_pen(age=)=log2(6)=2.58
D=(2/3,1/3)
Splitting Criteria based on Classification Error
o
Classification error at a node t :
Error (t )  1  max P(i | t )
i
o
Measures misclassification error made by a node.
 Maximum
(1 - 1/nc) when records are equally distributed
among all classes, implying least interesting information
 Minimum
(0.0) when all records belong to one class, implying
most interesting information
Comment: same as impurity!
Examples for Computing Error
Error (t )  1  max P(i | t )
i
C1
C2
0
6
C1
C2
1
5
P(C1) = 1/6
C1
C2
2
4
P(C1) = 2/6
P(C1) = 0/6 = 0
P(C2) = 6/6 = 1
Error = 1 – max (0, 1) = 1 – 1 = 0
P(C2) = 5/6
Error = 1 – max (1/6, 5/6) = 1 – 5/6 = 1/6
P(C2) = 4/6
Error = 1 – max (2/6, 4/6) = 1 – 4/6 = 1/3
Comparison among Splitting Criteria
For a 2-class problem:
Tree Induction
o
Greedy strategy.
– Split the records based on an attribute test
that optimizes certain criterion.
o
Issues
– Determine how to split the records
How to specify the attribute test condition?
 How to determine the best split?

– Determine when to stop splitting
Stopping Criteria for Tree Induction
o
Stop expanding a node when all the records
belong to the same class
o
Stop expanding a node when all the records have
similar attribute values
o
Early termination (to be discussed later)
Example: C4.5
o
o
o
o
o
o
Simple depth-first construction.
Uses Information Gain (Entropy)
Sorts Continuous Attributes at each node.
Needs entire data to fit in memory.
One of the Top 10 Data Mining Algorithms (may
be more in April about that!)
Unsuitable for Large Datasets.
– Needs out-of-core sorting.
Not in textbook!
Regression Trees
45
Not in textbook!
Summary Regression Trees
o
Regression trees work as decision trees except
– Leafs carry numbers which predict the output variable instead of class label
– Instead of entropy/purity the squared prediction error serves as the performance
measure. This is the same as the variance function you implement/use in
Assignment2.
– Tests that reduce the squared prediction error the most are selected as node
test; test conditions have the form y>threshold where y is an independent
variable of the prediction problem.
– Instead of using the majority class, leaf labels are generated by averaging over
the values of the dependent variable of the examples that are associated with
the particular class node
o
Like decision trees, regression tree employ rectangular tessellations
with a fixed number being associated with each rectangle; the number
is the output for the inputs which lie inside the rectangle.
o
In contrast to ordinary regression that performs curve fitting,
regression tries use averaging with respect to the output variable
when making predictions.
Decision and Regression Trees in R
o
o
For survey see: http://www.r-bloggers.com/a-brief-tour-of-the-trees-and-forests/
The most popular libraries are:
– rpart (the most advanced tree package, based on CART)
– tree (the original, more basic package)
– maptree / partykit (good for creating graphs)
– randomForrest (learns an ensemble of trees instead of a
single tree; more competitive as this approach
accomplished higher accuracies than single trees)
– CORElearn (a very general package that contains trees,
forrest, and many other approaches)
– Some packages are not compatible; be warned if you
use a mixture of packages!
Practical Issues of Classification
o
Underfitting and Overfitting
o
Missing Values
o
Costs of Classification
Underfitting and Overfitting (Example)
500 circular and 500
triangular data points.
Circular points:
0.5  sqrt(x12+x22)  1
Triangular points:
sqrt(x12+x22) > 0.5 or
sqrt(x12+x22) < 1
Underfitting and Overfitting
Underfitting
Overfitting
Complexity of a Decision
Tree := number of nodes
It uses
Complexity of the classification function
Underfitting: when model is too simple, both training and test errors are large
Overfitting: when model is too complex and test errors are large although
training errors are small.
Overfitting due to Noise
Decision boundary is distorted by noise point
Overfitting due to Insufficient Examples
Lack of data points in the lower half of the diagram makes it difficult
to predict correctly the class labels of that region
- Insufficient number of training records in the region causes the
decision tree to predict the test examples using other training
records that are irrelevant to the classification task
Notes on Overfitting
o
o
o
o
Overfitting results in decision trees that are more
complex than necessary: after learning
knowledge they “tend to learn noise”
More complex models tend to have more
complicated decision boundaries and tend to be
more sensitive to noise, missing examples,…
Training error no longer provides a good estimate
of how well the tree will perform on previously
unseen records
Need “new” ways for estimating errors
Estimating Generalization Errors
o
o
o
Re-substitution errors: error on training (S e(t) )
Generalization errors: error on testing (S e’(t))
Methods for estimating generalization errors:
– Optimistic approach: e’(t) = e(t)
– Pessimistic approach:



For each leaf node: e’(t) = (e(t)+0.5)
Total errors: e’(T) = e(T) + N  0.5 (N: number of leaf nodes)
For a tree with 30 leaf nodes and 10 errors on training
(out of 1000 instances):
Training error = 10/1000 = 1%
Generalization error = (10 + 300.5)/1000 = 2.5%
– Use validation set to compute generalization error

used Reduced error pruning (REP):
Regularization approach: Minimize Error + Model Complexity
Occam’s Razor
Given two models of similar generalization errors,
one should prefer the simpler model over the
more complex model
o For complex models, there is a greater chance
that it was fitted accidentally by errors in data
o Usually, simple models are more robust with
respect to noise
Therefore, one should include model complexity
when evaluating a model
o
Minimum Description Length (MDL)
o
o
o
X
X1
X2
X3
X4
y
1
0
0
1
…
…
Xn
1
Skip
A?
Yes
No
0
B?
B1
A
B2
C?
1
C1
C2
0
1
B
X
X1
X2
X3
X4
y
?
?
?
?
…
…
Xn
?
Cost(Model,Data) = Cost(Data|Model) + Cost(Model)
– Cost is the number of bits needed for encoding.
– Search for the least costly model.
Cost(Data|Model) encodes the misclassification errors.
Cost(Model) uses node encoding (number of children)
plus splitting condition encoding.
How to Address Overfitting
o
Pre-Pruning (Early Stopping Rule)
– Stop the algorithm before it becomes a fully-grown tree
– Typical stopping conditions for a node:

Stop if all instances belong to the same class

Stop if all the attribute values are the same
– More restrictive conditions:
Stop if number of instances is less than some user-specified
threshold

Stop if class distribution of instances are independent of the
available features (e.g., using  2 test)


Stop if expanding the current node does not improve impurity
measures (e.g., Gini or information gain).
How to Address Overfitting…
o
Post-pruning
– Grow decision tree to its entirety
– Trim the nodes of the decision tree in a
bottom-up fashion
– If generalization error improves after trimming,
replace sub-tree by a leaf node.
– Class label of leaf node is determined from
majority class of instances in the sub-tree
Example of Post-Pruning
Training Error (Before splitting) = 10/30
Class = Yes
20
Pessimistic error = (10 + 0.5)/30 = 10.5/30
Class = No
10
Training Error (After splitting) = 9/30
Pessimistic error (After splitting)
Error = 10/30
= (9 + 4  0.5)/30 = 11/30
PRUNE!
A?
A1
A4
A3
A2
Class = Yes
8
Class = Yes
3
Class = Yes
4
Class = Yes
5
Class = No
4
Class = No
4
Class = No
1
Class = No
1
Handling Missing Attribute Values
o
Briefly Discuss!
Missing values affect decision tree construction in
three different ways:
– Affects how impurity measures are computed
– Affects how to distribute instance with missing
value to child nodes
– Affects how a test instance with missing value
is classified
How to cope with missing values
Before Splitting:
Entropy(Parent)
= -0.3 log(0.3)-(0.7)log(0.7) = 0.8813
Tid Refund Marital
Status
Taxable
Income Class
1
Yes
Single
125K
No
2
No
Married
100K
No
3
No
Single
70K
No
4
Yes
Married
120K
No
Refund=Yes
Refund=No
5
No
Divorced 95K
Yes
Refund=?
6
No
Married
No
7
Yes
Divorced 220K
No
8
No
Single
85K
Yes
9
No
Married
75K
No
10
?
Single
90K
Yes
60K
10
Missing
value
Class Class
= Yes = No
0
3
2
4
1
0
Split on Refund:
Entropy(Refund=Yes) = 0
Entropy(Refund=No)
= -(2/6)log(2/6) – (4/6)log(4/6) = 0.9183
Entropy(Children)
= 0.3 (0) + 0.6 (0.9183) = 0.551
Gain = 0.9  (0.8813 – 0.551) = 0.3303
Idea: ignore examples with null values for the test attribute; compute M(…) only using examples for
Which Refund is defined.
Distribute Instances
Tid Refund Marital
Status
Taxable
Income Class
1
Yes
Single
125K
No
2
No
Married
100K
No
3
No
Single
70K
No
4
Yes
Married
120K
No
5
No
Divorced 95K
Yes
6
No
Married
No
7
Yes
Divorced 220K
No
8
No
Single
85K
Yes
9
No
Married
75K
No
60K
Tid Refund Marital
Status
Taxable
Income Class
10
90K
Single
?
Yes
10
Refund
Yes
No
Class=Yes
0 + 3/9
Class=Yes
2 + 6/9
Class=No
3
Class=No
4
Probability that Refund=Yes is 3/9
10
Refund
Yes
Probability that Refund=No is 6/9
No
Class=Yes
0
Cheat=Yes
2
Class=No
3
Cheat=No
4
Assign record to the left child with
weight = 3/9 and to the right child
with weight = 6/9
Classify Instances
New record:
Married
Tid Refund Marital
Status
Taxable
Income Class
11
85K
No
?
Refund
NO
Divorced Total
Class=No
3
1
0
4
Class=Yes
6/9
1
1
2.67
Total
3.67
2
1
6.67
?
10
Yes
Single
No
Single,
Divorced
MarSt
Married
TaxInc
< 80K
NO
NO
> 80K
YES
Probability that Marital Status
= Married is 3.67/6.67
Probability that Marital Status
={Single,Divorced} is 3/6.67
Other Issues
o
o
o
o
Data Fragmentation
Search Strategy
Expressiveness
Tree Replication
Data Fragmentation
o
Number of instances gets smaller as you traverse
down the tree
o
Number of instances at the leaf nodes could be
too small to make any statistically significant
decision  increases the danger of overfitting
Search Strategy
o
Finding an optimal decision tree is NP-hard
o
The algorithm presented so far uses a greedy,
top-down, recursive partitioning strategy to
induce a reasonable solution
o
Other strategies?
– Bottom-up
– Bi-directional
Expressiveness
o
Decision tree provides expressive representation for
learning discrete-valued function
– But they do not generalize well to certain types of
Boolean functions

Example: parity function:
– Class = 1 if there is an even number of Boolean attributes with truth
value = True
– Class = 0 if there is an odd number of Boolean attributes with truth
value = True

o
For accurate modeling, must have a complete tree
Not expressive enough for modeling continuous variables
– Particularly when test condition involves only a single
attribute at-a-time
Decision Boundary
1
0.9
x < 0.43?
0.8
0.7
Yes
No
y
0.6
y < 0.33?
y < 0.47?
0.5
0.4
Yes
0.3
0.2
:4
:0
0.1
No
:0
:4
Yes
:0
:3
0
0
0.1
0.2
0.3
0.4
0.5
x
0.6
0.7
0.8
0.9
1
• Border line between two neighboring regions of different classes is
known as decision boundary
• Decision boundary is parallel to axes because test condition involves
a single attribute at-a-time
No
:4
:0
Oblique Decision Trees
x+y<1
Class = +
• Test condition may involve multiple attributes
• More expressive representation
• Finding optimal test condition is computationally expensive
Class =
7. Advantages Decision Tree Based Classification
o
Inexpensive to construct
o
Extremely fast at classifying unknown records
o
Easy to interpret for small-sized trees; strategy understandable to domain
expert
o
Okay for noisy data
o
Can handle both continuous and symbolic attributes
o
Accuracy is comparable to other classification techniques for many simple
data sets
o
Decent average performance over many datasets
o
Can handle multi-modal class distributions
o
Kind of a standard—if you want to show that your “new” classification
technique really “improves the world”  compare its performance against
decision trees (e.g. C 5.0) using 10-fold cross-validation
o
Does not need distance functions; only the order of attribute values is
important for classification: 0.1,0.2,0.3 and 0.331,0.332, and 0.333 is the
same for a decision tree learner.
Disadvantages Decision Tree Based Classification
o
o
o
Relies on rectangular approximation that might not be
good for some dataset
Selecting good learning algorithm parameters (e.g.
degree of pruning) is non-trivial; however, some of the
competing methods have worth parameter selection
problems
Ensemble techniques, support vector machines, and
sometimes kNN, and neural networks might obtain
higher accuracies for a specific dataset.
8. Model Evaluation
1.
Methods for Performance Evaluation
– How to obtain reliable estimates?
– http://en.wikipedia.org/wiki/Cross-validation_(statistics)
2.
– the “gold standard” to determine accuracy is to
use 10-fold cross validation repeated 10 times
– Alternatively, class stratified cross validation is
frequently used
Performance Metrics
Metrics for Performance Evaluation
o
o
Focus on the predictive capability of a model
– Rather than how fast it takes to classify or
build models, scalability, etc.
Confusion Matrix:
Important: If there are problems with obtaining
a “good” classifier : inspect the confusion matrix!
PREDICTED CLASS
Class=Yes
Class=Yes
ACTUAL
CLASS Class=No
a
c
Class=No
b
d
a: TP (true positive)
b: FN (false negative)
c: FP (false positive)
d: TN (true negative)
Metrics for Performance Evaluation…
PREDICTED CLASS
Class=Yes
ACTUAL
CLASS
o
Class=No
Class=Yes
a
(TP)
b
(FN)
Class=No
c
(FP)
d
(TN)
Most widely-used metric:
ad
TP  TN
Accuracy 

a  b  c  d TP  TN  FP  FN
Cost-Sensitive Measures
a
Precision (p) 
ac
a
Recall (r) 
ab
2rp
2a
F - measure (F) 

r  p 2a  b  c



PREDICTED CLASS
ACTUAL
CLASS
Class=Y
es
Class=N
o
Class=Y
es
a=6
b=6
Class=N
o
c=0
d=6
Precision is biased towards C(Yes|Yes) & C(Yes|No)
Recall is biased towards C(Yes|Yes) & C(No|Yes)
F-measure is biased towards all except C(No|No)
wa  w d
Weighted Accuracy 
wa  wb wc  w d
1
1
4
2
3
4