Scribd
Upload
47 views

Experiment 3: Name: Reena Kale Te Comps Roll No:23

The document discusses implementing a decision tree algorithm for classification using programming. It provides theory on decision trees, describes the algorithm for constructing a decision tree, and includes sample data and code to build a decision tree classifier and visualize it.

Uploaded by

Reena Kale
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
47 views

Experiment 3: Name: Reena Kale Te Comps Roll No:23

The document discusses implementing a decision tree algorithm for classification using programming. It provides theory on decision trees, describes the algorithm for constructing a decision tree, and includes sample data and code to build a decision tree classifier and visualize it.

Uploaded by

Reena Kale
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

Experiment 3

Name: Reena Kale TE COMPS Roll No:23

AIM: Decision Tree implementation using Programming language

THEORY:

Decision Tree : Decision tree is the most powerful and popular tool for classification and
prediction.
A Decision tree is a flowchart like tree structure, where each internal node denotes a test on
an
attribute, each branch represents an outcome of the test, and each leaf node (terminal node)
holds a
class label.
Construction of Decision Tree : A tree can be “learned” by splitting the source set into
subsets based
on an attribute value test. This process is repeated on each derived subset in a recursive
manner called
recursive partitioning. The recursion is completed when the subset at a node all has the
same value of
the target variable, or when splitting no longer adds value to the predictions. The construction
of
decision tree classifier does not require any domain knowledge or parameter setting, and
therefore is
appropriate for exploratory knowledge discovery. Decision trees can handle high dimensional
data. In
general decision tree classifier has good accuracy. Decision tree induction is a typical
inductive
approach to learn knowledge on classification.

ALGORITHM:
Create node N
If tuples in D are all of same class C, then
Return N as leaf node labeled with class C
If attribute_list empty then
Return N as leaf node labeled with majority class in D or majority voting
Apply attribute_selection_method (D, attribute_list)
To find best splitting criterion
Label node N with splitting criterion
If splitting_attribute is discrete valued and multiway splits allowed then
attribute_list=splitting attribute
for each outcome j of splitting criterion
let Dj be set of data tuples in D satisfying outcome j
if Dj is empty then
attach a leaf labeled with the majority
class in D to node N
else
attach node returned by Generate decision tree(Dj, attribute_list) to node N
end for
Return N

QUESTION:
Buying_Price Maintenance_Price Lug_Boot Safety Evaluation?
High High Small High Unacceptable
High High Small Low Unacceptable
Medium High Small High Acceptable
Low Medium Small High Acceptable
Low Low Big High Acceptable
Low Low Big Low Unacceptable
Medium Low Big Low Acceptable
High Medium Small High Unacceptable
High Low Big High Acceptable
Low Medium Big High Acceptable
High Medium Big Low Acceptable
Medium Medium Small Low Acceptable
Medium High Big High Acceptable
Low Medium Small Low Unacceptable

CODE:

from sklearn import preprocessingimport


pandas as pd
from sklearn.tree import DecisionTreeClassifier # Import Decision TreeCl assifier
from sklearn.model_selection import train_test_splitcalculation from
sklearn import metrics
from sklearn.tree import export_graphviz
from six importStringIO
from IPython.display importImage
import pydotplus import graphviz
df = pd.read_excel('sample.xlsx')
col_names = ["Buying_Price", "Maintenance_Price", "Lug_Boot", "Safety"]print(df.head())
le = preprocessing.LabelEncoder()for
column_name in df.columns:
if df[column_name].dtype == object: df[column_name] =
le.fit_transform(
df[column_name])
else:
pass
# print(df)
X = df[col_names]y =
df.Evaluation
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=1)

clf = DecisionTreeClassifier() clf =


clf.fit(X_train, y_train)dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,
filled=True, rounded=True,
special_characters=True, feature_names=col_names, class_na
mes=['Acceptable','Unacceptable'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())graph.write_png('tree.png')
Image(graph.create_png())

OUTPUT:

CONCLUSION:
We successfully understood and implemented the concept of Decision Tree using
programming language.

You might also like