Tracer un arbre de décision interactif dans Jupyter Notebook

Question

Existe-t-il un moyen de tracer un arbre de décision dans un carnet Jupyter, de manière à pouvoir explorer ses nœuds de manière interactive ? Je pense à quelque chose comme ceci . Voici un exemple tiré de KNIME.

J'ai trouvé https://planspace.org/20151129-see_sklearn_trees_with_d3/ y https://bl.ocks.org/ajschumacher/65eda1df2b0dd2cf616f et je sais que vous pouvez exécuter d3 dans Jupyter, mais je n'ai pas trouvé de paquet qui le fasse.

Answer 1

Réponse mise à jour avec un graphique pliable utilisant d3js dans Jupyter Notebook

Début de la premiè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 2ème 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 2ème 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 se réduisent.

Dépôt Github pour le carnet de notes utilisé ici : Arbre pliable dans le carnet de notes d'ipython

Références

• Graphique pliable en d3.js
• Graphique Networkx dans le carnet de notes à l'aide de d3.js

Ancienne réponse

J'ai trouvé ce tutoriel ici pour la visualisation interactive de l'arbre de décision dans Jupyter Notebook.

Installer graphviz

Il y a 2 étapes pour cela : Etape 1 : Installer graphviz pour python en utilisant pip

pip install graphviz

Étape 2 : Ensuite, vous devez installer graphviz séparément. Vérifiez ceci lien . Ensuite, en fonction de votre système d'exploitation, vous devez définir le chemin en conséquence :

Pour Windows et Mac OS Vérifiez ce lien . Pour Linux/Ubuntu Vérifiez ce lien

Installer ipywidgets

Utilisation de pip

pip install ipywidgets
jupyter nbextension enable --py widgetsnbextension

Utilisation de 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                               

Chargez le jeu de données, par exemple le jeu de données de l'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

Appelez 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 modifiant les valeurs suivantes

Un autre arbre de décision sur les mêmes données mais des paramètres différents

Références :

• Utilisation d'ipywidgets pour tracer des arbres de décision interactifs
• Tracé des arbres de décision en python
• ipywidgets
• Au cas où vous auriez des problèmes avec Graphviz
• problème de scikit-learn : amélioration du tracé des arbres de décision dans l'environnement Jupyter

Answer 2

1. Si vous souhaitez simplement utiliser D3 dans Jupyter, voici un tutoriel : https://medium.com/@stallonejacob/d3-in-juypter-notebook-685d6dca75c8

2. Pour construire un arbre de décision interactif, voici une autre boîte à outils GUI intéressante appelée TMVAGui.

Dans ce cas, le code est juste une ligne : factory.DrawDecisionTree(dataset, "BDT")

https://indico.cern.ch/event/572131/contributions/2315243/attachments/1343269/2023816/gsoc16_4thpresentation.pdf

Answer 3

Il existe un module appelé pydot. Vous pouvez créer des graphes 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 qui produirait un fichier png de votre arbre de décision. J'espère que cela vous aidera !

Answer 4

J'ai trouvé un projet GitHub qui est basé sur la construction interactive d'arbres de décision. Cela pourrait peut-être vous aider :

Il est basé sur la bibliothèque r2d3 qui prend en Json script et crée une cartographie interactive d'un arbre de décision.

https://github.com/yamad/r2d3-decision-tree