Tracer un arbre de décision interactif dans Jupyter Notebook
Existe-t-il un moyen de tracer un arbre de décision dans un cahier Jupyter, de sorte que je puisse explorer ses nœuds de manière interactive? Je pense à quelque chose comme ça 
. Ceci est un exemple de KNIME.
J'ai trouvé https://planspace.org/20151129-see_sklearn_trees_with_d3/ et https://bl.ocks.org/ajschumacher/65eda1df2b0dd2cf616f et je sais que vous pouvez exécuter d3 en Jupyter, mais pas trouvé de paquets, qui font ça.
Réponse mise à jour avec graphique réductible utilisant d3js dans Jupyter Notebook
Début de la 1ère cellule du cahier
%%html
<div id="d3-example"></div>
<style>
.node circle {
cursor: pointer;
stroke: #3182bd;
stroke-width: 1.5px;
}
.node text {
font: 10px sans-serif;
pointer-events: none;
text-anchor: middle;
}
line.link {
fill: none;
stroke: #9ecae1;
stroke-width: 1.5px;
}
</style>
Fin de la 1ère cellule du cahier
Début de la 2e cellule du cahier
%%javascript
// We load the d3.js library from the Web.
require.config({paths:
{d3: "http://d3js.org/d3.v3.min"}});
require(["d3"], function(d3) {
// The code in this block is executed when the
// d3.js library has been loaded.
// First, we specify the size of the canvas
// containing the visualization (size of the
// <div> element).
var width = 960,
height = 500,
root;
// We create a color scale.
var color = d3.scale.category10();
// We create a force-directed dynamic graph layout.
// var force = d3.layout.force()
// .charge(-120)
// .linkDistance(30)
// .size([width, height]);
var force = d3.layout.force()
.linkDistance(80)
.charge(-120)
.gravity(.05)
.size([width, height])
.on("tick", tick);
var svg = d3.select("body").append("svg")
.attr("width", width)
.attr("height", height);
var link = svg.selectAll(".link"),
node = svg.selectAll(".node");
// In the <div> element, we create a <svg> graphic
// that will contain our interactive visualization.
var svg = d3.select("#d3-example").select("svg")
if (svg.empty()) {
svg = d3.select("#d3-example").append("svg")
.attr("width", width)
.attr("height", height);
}
var link = svg.selectAll(".link"),
node = svg.selectAll(".node");
// We load the JSON file.
d3.json("graph2.json", function(error, json) {
// In this block, the file has been loaded
// and the 'graph' object contains our graph.
if (error) throw error;
else
test(1);
root = json;
test(2);
console.log(root);
update();
});
function test(rr){console.log('yolo'+String(rr));}
function update() {
test(3);
var nodes = flatten(root),
links = d3.layout.tree().links(nodes);
// Restart the force layout.
force
.nodes(nodes)
.links(links)
.start();
// Update links.
link = link.data(links, function(d) { return d.target.id; });
link.exit().remove();
link.enter().insert("line", ".node")
.attr("class", "link");
// Update nodes.
node = node.data(nodes, function(d) { return d.id; });
node.exit().remove();
var nodeEnter = node.enter().append("g")
.attr("class", "node")
.on("click", click)
.call(force.drag);
nodeEnter.append("circle")
.attr("r", function(d) { return Math.sqrt(d.size) / 10 || 4.5; });
nodeEnter.append("text")
.attr("dy", ".35em")
.text(function(d) { return d.name; });
node.select("circle")
.style("fill", color);
}
function tick() {
link.attr("x1", function(d) { return d.source.x; })
.attr("y1", function(d) { return d.source.y; })
.attr("x2", function(d) { return d.target.x; })
.attr("y2", function(d) { return d.target.y; });
node.attr("transform", function(d) { return "translate(" + d.x + "," + d.y + ")"; });
}
function color(d) {
return d._children ? "#3182bd" // collapsed package
: d.children ? "#c6dbef" // expanded package
: "#fd8d3c"; // leaf node
}
// Toggle children on click.
function click(d) {
if (d3.event.defaultPrevented) return; // ignore drag
if (d.children) {
d._children = d.children;
d.children = null;
} else {
d.children = d._children;
d._children = null;
}
update();
}
function flatten(root) {
var nodes = [], i = 0;
function recurse(node) {
if (node.children) node.children.forEach(recurse);
if (!node.id) node.id = ++i;
nodes.Push(node);
}
recurse(root);
return nodes;
}
});
Fin de la 2e cellule du cahier
Contenu de graph2.json
{
"name": "flare",
"children": [
{
"name": "analytics"
},
{
"name": "graph"
}
]
}
Le graphique 
Cliquez sur flare, qui est le nœud racine, les autres nœuds vont s'effondrer
Référentiel Github pour le cahier utilisé ici: Arbre pliable dans le cahier ipython
Références
Ancienne réponse
J'ai trouvé ce tutoriel ici pour la visualisation interactive de Decision Tree dans Jupyter Notebook.
Installer graphviz
Il existe 2 étapes pour cela: Étape 1: Installer graphviz pour python avec pip
pip install graphviz
Étape 2: Ensuite, vous devez installer graphviz séparément. Cochez cette link . Ensuite, en fonction du système d'exploitation de votre système, vous devez définir le chemin en conséquence:
Pour Windows et Mac OS cochez ce lien . Pour Linux/Ubuntu cochez ce lien
Installer ipywidgets
Utilisation de pip
pip install ipywidgets
jupyter nbextension enable --py widgetsnbextension
Utiliser conda
conda install -c conda-forge ipywidgets
Maintenant pour le code
from IPython.display import SVG
from graphviz import Source
from sklearn.datasets load_iris
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn import tree
from ipywidgets import interactive
from IPython.display import display
Charger le jeu de données, par exemple le jeu de données iris dans ce cas
data = load_iris()
#Get the feature matrix
features = data.data
#Get the labels for the sampels
target_label = data.target
#Get feature names
feature_names = data.feature_names
** Fonction pour tracer l'arbre de décision **
def plot_tree(crit, split, depth, min_split, min_leaf=0.17):
classifier = DecisionTreeClassifier(random_state = 123, criterion = crit, splitter = split, max_depth = depth, min_samples_split=min_split, min_samples_leaf=min_leaf)
classifier.fit(features, target_label)
graph = Source(tree.export_graphviz(classifier, out_file=None, feature_names=feature_names, class_names=['0', '1', '2'], filled = True))
display(SVG(graph.pipe(format='svg')))
return classifier
Appelle la fonction
decision_plot = interactive(plot_tree, crit = ["gini", "entropy"], split = ["best", "random"] , depth=[1, 2, 3, 4, 5, 6, 7], min_split=(0.1,1), min_leaf=(0.1,0.2,0.3,0.5))
display(decision_plot)
Vous obtiendrez le graphique suivant 
Vous pouvez modifier les paramètres de manière interactive dans la cellule de sortie en sélectionnant les valeurs suivantes
Un autre arbre de décision sur les mêmes données mais des paramètres différents 
Références :
1. Si vous voulez simplement utiliser D3 dans Jupyter, voici un tutoriel: https://medium.com/@stallonejacob/d3-in-juypter-notebook-685d6dca75c8
2. Pour construire un arbre décisionnel interactif, voici un autre toolkit graphique intéressant appelé TMVAGui.
En cela, le code est juste une ligne: factory.DrawDecisionTree(dataset, "BDT")
Il existe un module appelé pydot. Vous pouvez créer des graphiques et ajouter des arêtes pour créer un arbre de décision.
import pydot #
graph = pydot.Dot(graph_type='graph')
Edge1 = pydot.Edge('1', '2', label = 'Edge1')
Edge2 = pydot.Edge('1', '3', label = 'Edge2')
graph.add_Edge(edge1)
graph.add_Edge(edge2)
graph.write_png('my_graph.png')
Voici un exemple permettant de générer un fichier png de votre arbre de décision. J'espère que cela t'aides!
J'ai trouvé un projet GitHub basé sur la construction interactive d'un arbre de décision. Peut-être que cela pourrait être utile:
Ceci est basé sur la bibliothèque r2d3 qui prend en script Json et crée un mappage interactif d'un arbre de décision.