webentwicklung-frage-antwort-db.com.de

Interaktiver Entscheidungsbaum in Jupyter Notebook zeichnen

Gibt es eine Möglichkeit, einen Entscheidungsbaum in einem Jupyter Notebook zu zeichnen, sodass ich dessen Knoten interaktiv untersuchen kann? Ich denke an so etwas  dt . Dies ist ein Beispiel von KNIME.

Ich habe gefunden https://planspace.org/20151129-see_sklearn_trees_with_d3/ und https://bl.ocks.org/ajschumacher/65eda1df2b0dd2cf616f und ich weiß, dass Sie in Jupyter d3 ausführen können, aber ich habe keine Pakete gefunden, die das tun.

pythonmachine-learningscikit-learnjupyterdecision-tree
36
r0f1

Antwort mit zusammenklappbarem Diagramm mit d3js in Jupyter Notebook aktualisiert 

Start der 1. Zelle im Notebook 

%%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>

Ende der ersten Zelle im Notizbuch

Start der zweiten Zelle im Notebook

%%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;
}

});

Ende der zweiten Zelle im Notizbuch 

Inhalt von graph2.json

   {
 "name": "flare",
 "children": [
  {
   "name": "analytics"
    },
    {
   "name": "graph"
    }
   ]
}

Der Graph enter image description here

Klicken Sie auf Flare, den Wurzelknoten. Die anderen Knoten werden ausgeblendet

 enter image description here

Github-Repository für das hier verwendete Notebook: Zusammenklappbarer Baum in ipython-Notebook

Verweise

Alte Antwort

Ich habe dieses Tutorial hier zur interaktiven Visualisierung von Decision Tree in Jupyter Notebook gefunden. 

Graphviz installieren

Dafür gibt es zwei Schritte: Schritt 1: Installieren Sie graphviz für Python mithilfe von pip

pip install graphviz

Schritt 2: Dann müssen Sie graphviz separat installieren. Überprüfen Sie diese Option - link . Anschließend müssen Sie den Pfad entsprechend Ihres Betriebssystems entsprechend einstellen:

Für Windows und Mac OS klicken Sie auf diesen Link . Für Linux/Ubuntu klicken Sie auf diesen Link

Ipywidgets installieren

Mit pip

pip install ipywidgets
jupyter nbextension enable --py widgetsnbextension

Conda verwenden 

conda install -c conda-forge ipywidgets

Nun zum 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

Laden Sie den Datensatz, in diesem Fall zum Beispiel den Iris-Datensatz

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

** Funktion zum Zeichnen des Entscheidungsbaums **

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

Funktion aufrufen

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)

Sie erhalten die folgende Grafik  enter image description here

Sie können die Parameter interaktiv in der Ausgabezelle ändern, indem Sie die folgenden Werte angeben

 enter image description here

Ein anderer Entscheidungsbaum für die gleichen Daten, aber für andere Parameter enter image description here

Verweise :

14
Mohammed Kashif

1. Falls Sie einfach D3 in Jupyter verwenden möchten, finden Sie hier ein Tutorial: https://medium.com/@stallonejacob/d3-in-juypter-notebook-685d6dca75c8

 enter image description here

 enter image description here

2. Zum Erstellen eines interaktiven Entscheidungsbaums finden Sie hier ein weiteres interessantes GUI-Toolkit namens TMVAGui.

In diesem ist der Code nur einzeilig: factory.DrawDecisionTree(dataset, "BDT")

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

6
Ankita Mehta

Es gibt ein Modul namens pydot. Sie können Diagramme erstellen und Kanten hinzufügen, um einen Entscheidungsbaum zu erstellen. 

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')

Dies ist ein Beispiel, das eine PNG-Datei Ihres Entscheidungsbaums ausgibt. Hoffe das hilft!

0
kamykam

Ich habe ein GitHub-Projekt gefunden, das auf interaktiver Decision Tree-Erstellung basiert. Vielleicht könnte das helfen:

Diese basiert auf der r2d3-Bibliothek, die ein Json-Skript aufnimmt und eine interaktive Zuordnung eines Decision Tree erstellt.

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

0
Dinesh