Visualisera och tolka beslutsträd
Ni kommer att exportera och rendera ett träd med sklearns plot_tree, läsa beslutsreglerna och ta fram egenskapernas betydelse för rapporter till intressenter.
Visualisera och tolka beslutsträd är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Varför visualisering av träd är viktigt
Beslutsträd kallas ofta white-box-modeller eftersom deras beslutslogik är helt transparent. Genom att visualisera ett tränat träd kan du verifiera att modellen fattar beslut utifrån rimliga egenskaper, förklara prediktioner för intressenter utan teknisk bakgrund, identifiera möjliga problem med datakvaliteten (till exempel att en egenskap som inte borde vara viktig dyker upp i roten) och felsöka oväntat beteende. Visualisering omvandlar trädets matematiska struktur till ett lättförståeligt flödesschema som domänexperter kan validera mot sina kunskaper.
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
X, y = load_iris(return_X_y=True)
feature_names = load_iris().feature_names
class_names = load_iris().target_names
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)
plt.figure(figsize=(14, 6))
plot_tree(tree,
feature_names=feature_names,
class_names=class_names,
filled=True, # Color by majority class
rounded=True, # Rounded boxes
fontsize=10)
plt.title('Iris Decision Tree (depth=3)')
plt.show()Läsa en nod i utdata från plot_tree
Varje nod i utdata från plot_tree visar fyra typer av information: (1) Delningsvillkoret (till exempel petal length <= 2.45), (2) nodens Gini-orenhet, (3) antalet observationer som nådde noden under träningen och (4) klassfördelningen som en lista med antalet observationer per klass. Lövnoder visar alla fyra delar, men saknar delningsvillkor — klassen i majoritet blir prediktionen. Nodens färgintensitet visar renheten: mörkare = fler observationer från den dominerande klassen.
# Interpreting node output from plot_tree:
#
# petal length (cm) <= 2.45 <- split condition
# gini = 0.667 <- impurity before split
# samples = 150 <- training samples reaching node
# value = [50, 50, 50] <- samples per class [setosa, versicolor, virginica]
# class = setosa <- majority class (prediction if leaf)
print('Gini 0.667 = equal 3-class split (maximum 3-class impurity)')
print('samples=150 at root = all training samples')
print('value=[50,50,50] = perfectly balanced classes')Exportera träd som text med export_text
För loggning, rapporter eller miljöer utan grafiskt gränssnitt skapar export_text() en textbaserad representation av trädet. Varje indenteringsnivå motsvarar en delningsnivå. Lodstrecket visar grenar, och lövraderna visar den predicerade klassen. Detta format är användbart för att bädda in beslutsregler i dokumentation, spara dem i loggfiler eller visa dem i kommandoradsmiljöer. Det gör det också möjligt att jämföra trädstrukturer numeriskt mellan olika hyperparameterkonfigurationer.
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)
text_repr = export_text(
tree,
feature_names=list(load_iris().feature_names)
)
print(text_repr)Exportera till Graphviz DOT-format
export_graphviz() genererar en DOT-språkfil som kan återges som en SVG- eller PNG-fil av hög kvalitet med Graphviz. Detta är idealiskt för träddiagram av presentationskvalitet och för stora träd som kräver rullning för att kunna visas. DOT-filen kan även konverteras till PDF eller bäddas in i rapporter. I Jupyter använder Ni graphviz.Source(dot_data) för att återge diagrammet direkt i dokumentet. Detta tillvägagångssätt ger full kontroll över teckenstorlek, färgschema och layout – vilket är viktigt när trädet delas med intressenter från verksamheten.
from sklearn.tree import export_graphviz
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
import graphviz
X, y = load_iris(return_X_y=True)
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)
dot_data = export_graphviz(
tree,
out_file=None,
feature_names=load_iris().feature_names,
class_names=load_iris().target_names,
filled=True, rounded=True,
special_characters=True
)
# graph = graphviz.Source(dot_data) # Renders in Jupyter
# graph.render('iris_tree', format='png') # Save as PNGVariabelvikt: Vad drev modellen?
Efter träningen visar tree.feature_importances_ varje indatavariabels relativa bidrag till modellens förutsägelser. Variabler som används vid roten och på de övre nivåerna har vanligtvis hög vikt eftersom deras uppdelningar påverkar alla träningsdata. Variabler som endast används i djupa löv har låg vikt. Att visa variabelvikter som ett stapeldiagram är ett standardsteg i all träd-baserad analys – det bekräftar att modellen förlitar sig på rimliga, domänrelevanta variabler snarare än skensamband som råkar fungera på träningsdata.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
import pandas as pd
import matplotlib.pyplot as plt
X, y = load_breast_cancer(return_X_y=True)
features = load_breast_cancer().feature_names
tree = DecisionTreeClassifier(max_depth=5, random_state=42)
tree.fit(X, y)
imp = pd.Series(tree.feature_importances_, index=features).sort_values(ascending=False)
imp.head(10).plot(kind='barh')
plt.title('Top 10 Feature Importances')
plt.xlabel('Importance')
plt.gca().invert_yaxis()
plt.show()
print('Top feature:', imp.index[0], '(importance:', imp.iloc[0].round(3), ')')Spåra en enskild förutsägelse
Metoden decision_path() returnerar en gles indikatormatris som visar vilka noder varje datapunkt besöker. Tillsammans med tree.tree_ kan Ni återskapa den exakta sekvensen av beslut för en valfri förutsägelse. Detta är grunden för automatiserade förklaringssystem: för varje förutsägelse kan Ni generera en lättläst lista med regler, till exempel ”kronbladets längd var 1,4 cm (≤2,45), så vägen gick åt vänster; förutsägelsen vid lövet blev setosa.” Denna grad av transparens krävs inom reglerade områden där varje beslut måste kunna granskas.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import numpy as np
X, y = load_iris(return_X_y=True)
features = load_iris().feature_names
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)
# Trace the path for sample 0
node_indicator = tree.decision_path(X[[0]])
nodes_visited = node_indicator.indices
T = tree.tree_
for node in nodes_visited[:-1]: # All except leaf
feature = features[T.feature[node]]
threshold = T.threshold[node]
val = X[0, T.feature[node]]
direction = 'left (<= )' if val <= threshold else 'right (> )'
print(f'Node {node}: {feature} = {val:.2f}, threshold={threshold:.2f} -> {direction}')Tolka uppdelningsvillkor för intressenter
När Ni kommunicerar trädets beslut till icke-tekniska intressenter bör Ni omvandla de matematiska uppdelningsvillkoren till formuleringar på vardagsspråk. I stället för ”petal length (cm) <= 2.45: gini=0.0, samples=50” kan Ni säga ”Om kronbladet är kortare än 2,45 cm är blomman nästan säkert en Setosa.” Formulera varje gren utifrån variabelns verksamhetsmässiga betydelse. Beslutsträd lämpar sig särskilt väl för kommunikation med intressenter jämfört med andra ML-modeller, eftersom varje beslut motsvarar en testbar och tolkningsbar verksamhetsregel.
# Human-readable rule extraction from a trained tree
from sklearn.tree import _tree
def extract_rules(tree, feature_names, class_names):
T = tree.tree_
rules = []
def recurse(node, path):
if T.feature[node] != _tree.TREE_UNDEFINED:
feat = feature_names[T.feature[node]]
thresh = T.threshold[node]
recurse(T.children_left[node], path + [f'{feat} <= {thresh:.2f}'])
recurse(T.children_right[node], path + [f'{feat} > {thresh:.2f}'])
else:
majority_class = class_names[T.value[node].argmax()]
rules.append(' AND '.join(path) + f' => {majority_class}')
recurse(0, [])
return rulesPartiella beroendediagram för enskilda variabler
Medan variabelvikter visar vilka variabler som är viktigast visar Partiella beroendediagram (PDP) hur en variabel påverkar förutsägelsen. Ett PDP tar marginal över alla andra variabler och visar modellens förutsagda utdata som en funktion av en eller två variabler. För beslutsträd får PDP:er stegfunktionsliknande former som återspeglar de axelparallella tröskelvärdena för uppdelningarna. Scikit-learns PartialDependenceDisplay genererar dessa diagram direkt från ett tränat träd, vilket gör det enkelt att förklara effekterna av enskilda variabler för domänexperter.
from sklearn.inspection import PartialDependenceDisplay
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
X, y = load_iris(return_X_y=True)
features = load_iris().feature_names
tree = DecisionTreeClassifier(max_depth=4, random_state=42)
tree.fit(X, y)
# PDP for the two most important features
fig, ax = plt.subplots(figsize=(10, 4))
PartialDependenceDisplay.from_estimator(
tree, X, features=[2, 3], # petal length and petal width
feature_names=features, ax=ax
)
plt.tight_layout()
plt.show()Jämföra trädstrukturer med olika hyperparametrar
Att visualisera hur trädstrukturen förändras med djupet hjälper Er att bygga upp en intuitiv förståelse. Ett träd med djup 1 (en stump) har en uppdelning och två löv – den enskilt viktigaste variabeln. Ett träd med djup 2 förfinar båda grenarna med en andra nivå av frågor. Genom att jämföra träd med djup 1, 3 och 5 på samma datauppsättning ser Ni hur modellen bygger upp allt mer komplex beslutslogik. Om trädet med djup 5 använder samma variabler som trädet med djup 3 på de övre nivåerna är dessa variabler genuint viktiga. Om nya, svårtolkade variabler dyker upp på djup 5 fångar de sannolikt brus.
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
feat_names = list(load_iris().feature_names)
for depth in [1, 3, 5]:
tree = DecisionTreeClassifier(max_depth=depth, random_state=42)
tree.fit(X, y)
print(f'\n--- max_depth={depth}, leaves={tree.get_n_leaves()} ---')
print(export_text(tree, feature_names=feat_names)[:300])Använda träd för att generera verksamhetsregler
En av de mest värdefulla användningarna av beslutsträd i industrin är att generera uttryckliga verksamhetsregler som kan implementeras i regelmotorer, kalkylblad eller äldre system som inte kan köra ML-modeller. Varje väg från rot till löv är en fullständig IF-THEN-regel. Dessa regler kan översättas till SQL-satser med WHERE-villkor, Python-ordböcker eller poängkort för kreditbedömning. Genom att noggrant styra trädets djup och kraven på minsta antal datapunkter kan Ni generera en liten och träffsäker uppsättning regler som en verksamhetsanalytiker kan granska, godkänna och underhålla manuellt.
# Generate SQL-like rules from a trained decision tree
from sklearn.tree import _tree
def tree_to_sql(tree, feature_names, class_names):
T = tree.tree_
rules = []
def traverse(node, conditions):
if T.feature[node] != _tree.TREE_UNDEFINED:
fname = feature_names[T.feature[node]]
thresh = T.threshold[node]
traverse(T.children_left[node],
conditions + [f'{fname} <= {thresh:.3f}'])
traverse(T.children_right[node],
conditions + [f'{fname} > {thresh:.3f}'])
else:
pred = class_names[T.value[node].argmax()]
where = ' AND '.join(conditions)
rules.append(f'WHEN {where} THEN {pred!r}')
traverse(0, [])
return 'CASE\n ' + '\n '.join(rules) + '\nEND',Spara trädvisualiseringar i filer
Genom att spara trädvisualiseringar i filer blir de enkla att dela i rapporter, presentationer och modelldokumentation. Med plot_tree och matplotlib kan Ni spara dem som PNG eller SVG med plt.savefig(). Med Graphviz kan Ni återge dem direkt som PDF. För interaktiv utforskning i Jupyter-anteckningsböcker ger SVG direkt i dokumentet det tydligaste resultatet, eftersom det kan skalas obegränsat – användbart för djupa träd som skulle bli suddiga som PNG med fast upplösning. För material som ska levereras till intressenter bör Ni alltid exportera med hög DPI (300+) eller i vektorformatet SVG, så att texten i noderna förblir skarp när den förstoras.
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
X, y = load_iris(return_X_y=True)
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)
# Save as high-DPI PNG for reports
fig, ax = plt.subplots(figsize=(16, 8))
plot_tree(tree, feature_names=load_iris().feature_names,
class_names=load_iris().target_names,
filled=True, rounded=True, ax=ax, fontsize=10)
fig.savefig('iris_decision_tree.png', dpi=200, bbox_inches='tight')
fig.savefig('iris_decision_tree.svg', format='svg', bbox_inches='tight')
print('Saved PNG and SVG tree visualisations')Snabbkontroll
Testa Er förståelse av begreppen inom Machine Learning med Python från den här lektionen.
Sammanfattning av lektionen
I den här lektionen har Ni lärt Er att visualisera beslutsträd med plot_tree, export_text och export_graphviz, att läsa nodinformation (uppdelningsvillkor, Gini, antal datapunkter, värde) och att extrahera variabelvikter och beslutsvägar för kommunikation med intressenter. Härnäst utforskar vi Naive Bayes – en probabilistisk klassificerare som använder Bayes sats för att göra förutsägelser.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”Visualisera och tolka beslutsträd” gratis?
Ja – hela texten till ”Visualisera och tolka beslutsträd” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Visualisera och tolka beslutsträd”?
Ni kommer att exportera och rendera ett träd med sklearns plot_tree, läsa beslutsreglerna och ta fram egenskapernas betydelse för rapporter till intressenter. Ni övar på Machine Learning Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Machine Learning Academy?
Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Visualisera och tolka beslutsträd”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Machine Learning Academy-lektionen?
Ja. Varje Machine Learning Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Bygga ett träd: delningar, noder och löv
- Gini-impuritet och informationsvinst
- Styra trädets djup för att förhindra överanpassning
- Visualisera och tolka beslutsträd