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.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Generate dataset
X, y = make_classification(n_samples=1000, n_features=20, 
                           n_informative=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print("📊 Single Tree vs Bagging Comparison")
print("=" * 50)

# Single tree (high variance)
tree = DecisionTreeClassifier(random_state=42)
tree.fit(X_train, y_train)
print(f"Single Tree:       Train={tree.score(X_train, y_train):.2%}, "
      f"Test={tree.score(X_test, y_test):.2%}")

# Bagging (reduced variance)
bag = BaggingClassifier(n_estimators=50, random_state=42)
bag.fit(X_train, y_train)
print(f"Bagging (50 trees): Train={bag.score(X_train, y_train):.2%}, "
      f"Test={bag.score(X_test, y_test):.2%}")

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

from sklearn.ensemble import RandomForestClassifier

# Random Forest with OOB evaluation
rf = RandomForestClassifier(
    n_estimators=100, 
    oob_score=True,  # Enable OOB
    random_state=42,
    n_jobs=-1  # Use all CPUs
)
rf.fit(X_train, y_train)

print("📊 Random Forest Results")
print("=" * 40)
print(f"Train accuracy: {rf.score(X_train, y_train):.2%}")
print(f"Test accuracy:  {rf.score(X_test, y_test):.2%}")
print(f"OOB score:      {rf.oob_score_:.2%}")

print(f"\n📈 Model Statistics:")
print(f"   Number of trees: {rf.n_estimators}")
print(f"   Features per split: {rf.max_features}")
print(f"   Max depth: {rf.max_depth or 'None (unlimited)'}")

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

from sklearn.datasets import load_iris
import numpy as np

# Train on Iris
X_iris, y_iris = load_iris(return_X_y=True)
feature_names = load_iris().feature_names

rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_iris, y_iris)

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

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

import warnings

print("📊 Effect of Number of Trees")
print("=" * 45)
print(f"{'Trees':<8} {'Train':>10} {'Test':>10} {'OOB':>10}")
print("-" * 45)

for n_trees in [1, 5, 10, 25, 50, 100, 200]:
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        rf = RandomForestClassifier(n_estimators=n_trees, oob_score=True, 
                                     random_state=42)
        rf.fit(X_train, y_train)
        oob = f"{rf.oob_score_:>10.2%}" if hasattr(rf, 'oob_score_') else "N/A"
    
    print(f"{n_trees:<8} {rf.score(X_train, y_train):>10.2%} "
          f"{rf.score(X_test, y_test):>10.2%} {oob}")

 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.model_selection import GridSearchCV

param_grid = {
    'n_estimators': [50, 100],
    'max_depth': [5, 10, None],
    'min_samples_split': [2, 5],
    'max_features': ['sqrt', 'log2']
}

grid = GridSearchCV(
    RandomForestClassifier(random_state=42), 
    param_grid, 
    cv=5, 
    n_jobs=-1,
    scoring='accuracy'
)
grid.fit(X_train, y_train)

print("📊 Grid Search Results")
print("=" * 50)
print(f"Best CV score: {grid.best_score_:.2%}")
print(f"\n🏆 Best Parameters:")
for param, value in grid.best_params_.items():
    print(f"   {param}: {value}")

print(f"\nTest accuracy with best model: {grid.score(X_test, y_test):.2%}")