1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

from sklearn.tree import DecisionTreeClassifier, plot_tree, export_text
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

# Load Iris dataset
X, y = load_iris(return_X_y=True)
feature_names = load_iris().feature_names
class_names = load_iris().target_names

# Build tree with max_depth=3
clf = DecisionTreeClassifier(max_depth=3, random_state=42)
clf.fit(X, y)

# Print text representation
print("🌳 Decision Tree Structure:")
print(export_text(clf, feature_names=list(feature_names)))

# Tree statistics
print(f"\n📊 Tree Statistics:")
print(f"   Depth: {clf.get_depth()}")
print(f"   Leaves: {clf.get_n_leaves()}")
print(f"   Features used: {sum(clf.feature_importances_ > 0)}/{len(feature_names)}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import numpy as np

def gini(y):
    """Compute Gini impurity."""
    classes, counts = np.unique(y, return_counts=True)
    probs = counts / len(y)
    return 1 - np.sum(probs ** 2)

def entropy(y):
    """Compute Entropy."""
    classes, counts = np.unique(y, return_counts=True)
    probs = counts / len(y)
    return -np.sum(probs * np.log2(probs + 1e-10))

# Compare different distributions
examples = [
    ("Pure [A,A,A,A,A]", [0, 0, 0, 0, 0]),
    ("Mixed [A,A,A,B,B]", [0, 0, 0, 1, 1]),
    ("Even [A,A,B,B,B]", [0, 0, 1, 1, 1]),
    ("50/50 [A,B,A,B]", [0, 1, 0, 1]),
]

print("📊 Gini vs Entropy Comparison")
print("=" * 50)
print(f"{'Distribution':<22} {'Gini':>8} {'Entropy':>10}")
print("-" * 50)

for name, y in examples:
    print(f"{name:<22} {gini(y):>8.3f} {entropy(y):>10.3f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Load Iris dataset
X, y = load_iris(return_X_y=True)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

print("📊 Effect of Max Depth on Accuracy")
print("=" * 50)
print(f"{'Depth':<10} {'Train Acc':>12} {'Test Acc':>12} {'# Leaves':>10}")
print("-" * 50)

for depth in [1, 2, 3, 5, 10, None]:
    clf = DecisionTreeClassifier(max_depth=depth, random_state=42)
    clf.fit(X_train, y_train)
    
    train_acc = clf.score(X_train, y_train)
    test_acc = clf.score(X_test, y_test)
    n_leaves = clf.get_n_leaves()
    
    depth_str = "∞" if depth is None else str(depth)
    print(f"{depth_str:<10} {train_acc:>12.2%} {test_acc:>12.2%} {n_leaves:>10}")

1
2
3
4
5
6
7
8
9

clf = DecisionTreeClassifier(max_depth=4, random_state=42)
clf.fit(X, y)

print("📊 Feature Importance")
print("=" * 40)
for name, importance in sorted(zip(feature_names, clf.feature_importances_), 
                                key=lambda x: -x[1]):
    bar = "█" * int(importance * 30)
    print(f"{name:<18} {importance:.3f} {bar}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

from sklearn.tree import DecisionTreeRegressor

# Generate noisy sine wave
np.random.seed(42)
X_reg = np.sort(5 * np.random.rand(80, 1), axis=0)
y_reg = np.sin(X_reg).ravel() + np.random.randn(80) * 0.2

# Compare different depths
depths = [2, 4, None]
X_test_reg = np.linspace(0, 5, 100).reshape(-1, 1)

print("📊 Regression Tree - Mean Squared Error")
print("=" * 40)
for depth in depths:
    reg = DecisionTreeRegressor(max_depth=depth, random_state=42)
    reg.fit(X_reg, y_reg)
    mse = np.mean((reg.predict(X_reg) - y_reg) ** 2)
    depth_str = "∞" if depth is None else str(depth)
    print(f"Depth={depth_str:<4} MSE={mse:.4f}  Leaves={reg.get_n_leaves()}")