ch03-决策树/Z1-判定鱼类和非鱼类.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log\n",
    "import decisionTreePlot as dtPlot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataSet = [[1, 1, 'yes'],\n",
    "           [1, 1, 'yes'],\n",
    "           [1, 0, 'no'],\n",
    "           [0, 1, 'no'],\n",
    "           [0, 1, 'no']]\n",
    "labels = ['no surfacing', 'flippers']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcShannonEnt(dataSet):\n",
    "    # 求list的长度，表示计算参与训练的数据量\n",
    "    numEntries = len(dataSet)\n",
    "    # 计算分类标签label出现的次数\n",
    "    labelCounts = {}\n",
    "    # the the number of unique elements and their occurance\n",
    "    for featVec in dataSet:\n",
    "        # 将当前实例的标签存储，即每一行数据的最后一个数据代表的是标签\n",
    "        currentLabel = featVec[-1]\n",
    "#         print 'currentLabel-----'+currentLabel\n",
    "        # 为所有可能的分类创建字典，如果当前的键值不存在，则扩展字典并将当前键值加入字典。每个键值都记录了当前类别出现的次数。\n",
    "        if currentLabel not in labelCounts.keys():\n",
    "            labelCounts[currentLabel] = 0\n",
    "        labelCounts[currentLabel] += 1\n",
    "        \n",
    "    # 对于 label 标签的占比，求出 label 标签的香农熵\n",
    "    shannonEnt = 0.0\n",
    "    for key in labelCounts:\n",
    "        # 使用所有类标签的发生频率计算类别出现的概率。\n",
    "        prob = float(labelCounts[key])/numEntries\n",
    "        # 计算香农熵，以 2 为底求对数\n",
    "        shannonEnt -= prob * log(prob, 2)\n",
    "    return shannonEnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calcShannonEnt(dataSet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def splitDataSet(dataSet, index, value):\n",
    "    \"\"\"\n",
    "    splitDataSet(通过遍历dataSet数据集，求出index对应的colnum列的值为value的行)\n",
    "    就是依据index列进行分类，如果index列的数据等于 value的时候，就要将 index 划分到我们创建的新的数据集中\n",
    "    Args:\n",
    "        dataSet 数据集 待划分的数据集\n",
    "        index 表示每一行的index列 划分数据集的特征\n",
    "        value 表示index列对应的value值   需要返回的特征的值。\n",
    "    Returns:\n",
    "        index列为value的数据集【该数据集需要排除index列】\n",
    "    \"\"\"\n",
    "    retDataSet = []\n",
    "    for featVec in dataSet:\n",
    "        # index列为value的数据集【该数据集需要排除index列】\n",
    "        # 判断index列的值是否为value\n",
    "        if featVec[index] == value:\n",
    "            # chop out index used for splitting\n",
    "            # [:index]表示前index行，若 index 为2，就是取 featVec 的前 index 行\n",
    "            reducedFeatVec = featVec[:index]\n",
    "            reducedFeatVec.extend(featVec[index+1:])\n",
    "            # [index+1:]表示从跳过 index 的 index+1行，取接下来的数据\n",
    "            # 收集结果值 index列为value的行【该行需要排除index列】\n",
    "            retDataSet.append(reducedFeatVec)\n",
    "    return retDataSet\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "splitDataSet(dataSet, 0, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "splitDataSet(dataSet, 0, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "splitDataSet(dataSet, 1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "splitDataSet(dataSet, 1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chooseBestFeatureToSplit(dataSet):\n",
    "    \"\"\"\n",
    "    chooseBestFeatureToSplit(选择最好的特征)\n",
    "    Args:\n",
    "        dataSet 数据集\n",
    "    Returns:\n",
    "        bestFeature 最优的特征列\n",
    "    \"\"\"\n",
    "    # 求第一行有多少列的 Feature, 最后一列是label列嘛\n",
    "    numFeatures = len(dataSet[0]) - 1\n",
    "    # 数据集的原始信息熵\n",
    "    baseEntropy = calcShannonEnt(dataSet)\n",
    "    # 最优的信息增益值, 和最优的Featurn编号\n",
    "    bestInfoGain, bestFeature = 0.0, -1\n",
    "    # iterate over all the features\n",
    "    for i in range(numFeatures):\n",
    "        # create a list of all the examples of this feature\n",
    "        # 获取对应的feature下的所有数据\n",
    "        featList = [example[i] for example in dataSet]\n",
    "        # get a set of unique values\n",
    "        # 获取剔重后的集合，使用set对list数据进行去重\n",
    "        uniqueVals = set(featList)\n",
    "        # 创建一个临时的信息熵\n",
    "        newEntropy = 0.0\n",
    "        # 遍历某一列的value集合，计算该列的信息熵\n",
    "        # 遍历当前特征中的所有唯一属性值，对每个唯一属性值划分一次数据集，计算数据集的新熵值，并对所有唯一特征值得到的熵求和。\n",
    "        for value in uniqueVals:\n",
    "            subDataSet = splitDataSet(dataSet, i, value)\n",
    "            # 计算概率\n",
    "            prob = len(subDataSet)/float(len(dataSet))\n",
    "            # 计算信息熵\n",
    "            newEntropy += prob * calcShannonEnt(subDataSet)\n",
    "            # gain[信息增益]: 划分数据集前后的信息变化， 获取信息熵最大的值\n",
    "            # 信息增益是熵的减少或者是数据无序度的减少。最后，比较所有特征中的信息增益，返回最好特征划分的索引值。\n",
    "            infoGain = baseEntropy - newEntropy\n",
    "        print ('infoGain=', infoGain, 'bestFeature=', i, baseEntropy, newEntropy)\n",
    "        if (infoGain > bestInfoGain):\n",
    "            bestInfoGain = infoGain\n",
    "            bestFeature = i\n",
    "    return bestFeature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chooseBestFeatureToSplit(dataSet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 没有特征了，但还不是同一类，分不了了，多数表决的计算节点分类\n",
    "# 返回最多label\n",
    "def majorityCnt(classList):\n",
    "    classCount = {}\n",
    "    for vote in classList:\n",
    "        if vote not in classCount.keys():\n",
    "            classCount[vote] = 0\n",
    "        classCount[vote] += 1\n",
    "    return max(classCount)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "majorityCnt(['yes', 'yes', 'no'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createTree(dataSet, labels):\n",
    "    labels = labels[:]\n",
    "    classList = [example[-1] for example in dataSet]\n",
    "    # 如果数据集的最后一列的第一个值出现的次数=整个集合的数量，也就说只有一个类别，就只直接返回结果就行\n",
    "    # 第一个停止条件：所有的类标签完全相同，则直接返回该类标签。\n",
    "    # count() 函数是统计括号中的值在list中出现的次数\n",
    "    if classList.count(classList[0]) == len(classList):\n",
    "        return classList[0]\n",
    "    \n",
    "    # 如果数据集只有1列，那么最初出现label次数最多的一类，作为结果\n",
    "    # 第二个停止条件：使用完了所有特征，仍然不能将数据集划分成仅包含唯一类别的分组。\n",
    "    if len(dataSet[0]) == 1:\n",
    "        return majorityCnt(classList)\n",
    "    \n",
    "    # 选择最优的列，得到最优列对应的label含义\n",
    "    bestFeat = chooseBestFeatureToSplit(dataSet) # 0\n",
    "    # 获取label的名称\n",
    "    bestFeatLabel = labels[bestFeat] # 'no surfacing'\n",
    "    # 初始化myTree\n",
    "    myTree = {bestFeatLabel: {}} # {'no surfacing': {} }\n",
    "    # 注：labels列表是可变对象，在PYTHON函数中作为参数时传址引用，能够被全局修改\n",
    "    # 所以这行代码导致函数外的同名变量被删除了元素，造成例句无法执行，提示'no surfacing' is not in list\n",
    "    del(labels[bestFeat]) \n",
    "    # 取出最优列，然后它的branch做分类\n",
    "    featValues = [example[bestFeat] for example in dataSet]\n",
    "    uniqueVals = set(featValues)\n",
    "    for value in uniqueVals:\n",
    "        # 求出剩余的标签label\n",
    "        subLabels = labels[:]\n",
    "        # 遍历当前选择特征包含的所有属性值，在每个数据集划分上递归调用函数createTree()\n",
    "        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)\n",
    "        print ('myTree', value, myTree)\n",
    "    return myTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'dataSet' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-c61e88f29d61>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmyTree\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcreateTree\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataSet\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'dataSet' is not defined"
     ]
    }
   ],
   "source": [
    "myTree = createTree(dataSet, labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "[[1, 'no'], [1, 'no']]\n",
    "[[1, 'yes'], [1, 'yes'], [0, 'no']]\n",
    "labels = ['flippers']\n",
    "\n",
    "{\n",
    "  'no surfacing': {\n",
    "    0: 'no',\n",
    "    1: {\n",
    "      'flippers': {\n",
    "        0: 'no',\n",
    "        1: 'yes'\n",
    "      }\n",
    "    }\n",
    "  }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classify(inputTree, featLabels, testVec):\n",
    "    \"\"\"\n",
    "    classify(给输入的节点，进行分类)\n",
    "    Args:\n",
    "        inputTree  决策树模型\n",
    "        featLabels Feature标签对应的名称\n",
    "        testVec    测试输入的数据\n",
    "    Returns:\n",
    "        classLabel 分类的结果值，需要映射label才能知道名称\n",
    "    \"\"\"\n",
    "    # 获取tree的根节点对于的key值\n",
    "    firstStr = list(inputTree.keys())[0]\n",
    "    # 通过key得到根节点对应的value\n",
    "    secondDict = inputTree[firstStr]\n",
    "    # 判断根节点名称获取根节点在label中的先后顺序，这样就知道输入的testVec怎么开始对照树来做分类\n",
    "    featIndex = featLabels.index(firstStr)\n",
    "    # 测试数据，找到根节点对应的label位置，也就知道从输入的数据的第几位来开始分类\n",
    "    key = testVec[featIndex]\n",
    "    valueOfFeat = secondDict[key]\n",
    "    print ('+++', firstStr, 'xxx', secondDict, '---', key, '>>>', valueOfFeat)\n",
    "    \n",
    "    # 判断分枝是否结束: 判断valueOfFeat是否是dict类型\n",
    "    if isinstance(valueOfFeat, dict):\n",
    "        classLabel = classify(valueOfFeat, featLabels, testVec)\n",
    "    else:\n",
    "        classLabel = valueOfFeat\n",
    "    return classLabel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "classify(myTree, labels, [1, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(myTree.keys())[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 存储决策树\n",
    "- pickle 默认以是二进制方式操作\n",
    "- 读写方法，加个b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 存储\n",
    "def storeTree(inputTree, fileName):\n",
    "    import pickle\n",
    "    fw = open(fileName, 'wb')\n",
    "    pickle.dump(inputTree, fw)\n",
    "    fw.close()\n",
    "\n",
    "# 读取\n",
    "def grabTree(fileName):\n",
    "    import pickle\n",
    "    fr = open(fileName, 'rb')\n",
    "    return pickle.load(fr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "storeTree(myTree, 'datas/DecisionTree/storeTree.data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "myTree = grabTree('datas/DecisionTree/storeTree.data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10c80f978>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 画图可视化展现\n",
    "dtPlot.createPlot(myTree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 预测隐形眼镜的测试代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "fr = open('datas/DecisionTree/lenses.txt')\n",
    "lenses = [inst.strip().split('\\t') for inst in fr.readlines()]\n",
    "lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['young', 'myope', 'no', 'reduced', 'no lenses'], ['young', 'myope', 'no', 'normal', 'soft'], ['young', 'myope', 'yes', 'reduced', 'no lenses'], ['young', 'myope', 'yes', 'normal', 'hard'], ['young', 'hyper', 'no', 'reduced', 'no lenses'], ['young', 'hyper', 'no', 'normal', 'soft'], ['young', 'hyper', 'yes', 'reduced', 'no lenses'], ['young', 'hyper', 'yes', 'normal', 'hard'], ['pre', 'myope', 'no', 'reduced', 'no lenses'], ['pre', 'myope', 'no', 'normal', 'soft'], ['pre', 'myope', 'yes', 'reduced', 'no lenses'], ['pre', 'myope', 'yes', 'normal', 'hard'], ['pre', 'hyper', 'no', 'reduced', 'no lenses'], ['pre', 'hyper', 'no', 'normal', 'soft'], ['pre', 'hyper', 'yes', 'reduced', 'no lenses'], ['pre', 'hyper', 'yes', 'normal', 'no lenses'], ['presbyopic', 'myope', 'no', 'reduced', 'no lenses'], ['presbyopic', 'myope', 'no', 'normal', 'no lenses'], ['presbyopic', 'myope', 'yes', 'reduced', 'no lenses'], ['presbyopic', 'myope', 'yes', 'normal', 'hard'], ['presbyopic', 'hyper', 'no', 'reduced', 'no lenses'], ['presbyopic', 'hyper', 'no', 'normal', 'soft'], ['presbyopic', 'hyper', 'yes', 'reduced', 'no lenses'], ['presbyopic', 'hyper', 'yes', 'normal', 'no lenses']]\n"
     ]
    }
   ],
   "source": [
    "print(lenses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "infoGain= 0.03939650364612124 bestFeature= 0 1.3260875253642983 1.286691021718177\n",
      "infoGain= 0.039510835423565815 bestFeature= 1 1.3260875253642983 1.2865766899407325\n",
      "infoGain= 0.37700523001147723 bestFeature= 2 1.3260875253642983 0.9490822953528211\n",
      "infoGain= 0.5487949406953986 bestFeature= 3 1.3260875253642983 0.7772925846688997\n",
      "infoGain= 0.22125183600446618 bestFeature= 0 1.5545851693377994 1.3333333333333333\n",
      "infoGain= 0.09543725231055489 bestFeature= 1 1.5545851693377994 1.4591479170272446\n",
      "infoGain= 0.7704260414863776 bestFeature= 2 1.5545851693377994 0.7841591278514218\n",
      "infoGain= 0.3166890883150208 bestFeature= 0 0.6500224216483541 0.3333333333333333\n",
      "infoGain= 0.19087450462110933 bestFeature= 1 0.6500224216483541 0.4591479170272448\n",
      "infoGain= 1.0 bestFeature= 0 1.0 0.0\n",
      "myTree myope {'prescript': {'myope': 'no lenses'}}\n",
      "myTree hyper {'prescript': {'myope': 'no lenses', 'hyper': 'soft'}}\n",
      "myTree presbyopic {'age': {'presbyopic': {'prescript': {'myope': 'no lenses', 'hyper': 'soft'}}}}\n",
      "myTree young {'age': {'presbyopic': {'prescript': {'myope': 'no lenses', 'hyper': 'soft'}}, 'young': 'soft'}}\n",
      "myTree pre {'age': {'presbyopic': {'prescript': {'myope': 'no lenses', 'hyper': 'soft'}}, 'young': 'soft', 'pre': 'soft'}}\n",
      "myTree no {'astigmatic': {'no': {'age': {'presbyopic': {'prescript': {'myope': 'no lenses', 'hyper': 'soft'}}, 'young': 'soft', 'pre': 'soft'}}}}\n",
      "infoGain= 0.2516291673878229 bestFeature= 0 0.9182958340544896 0.6666666666666666\n",
      "infoGain= 0.4591479170272448 bestFeature= 1 0.9182958340544896 0.4591479170272448\n",
      "myTree myope {'prescript': {'myope': 'hard'}}\n",
      "infoGain= 0.9182958340544896 bestFeature= 0 0.9182958340544896 0.0\n",
      "myTree presbyopic {'age': {'presbyopic': 'no lenses'}}\n",
      "myTree young {'age': {'presbyopic': 'no lenses', 'young': 'hard'}}\n",
      "myTree pre {'age': {'presbyopic': 'no lenses', 'young': 'hard', 'pre': 'no lenses'}}\n",
      "myTree hyper {'prescript': {'myope': 'hard', 'hyper': {'age': {'presbyopic': 'no lenses', 'young': 'hard', 'pre': 'no lenses'}}}}\n",
      "myTree yes {'astigmatic': {'no': {'age': {'presbyopic': {'prescript': {'myope': 'no lenses', 'hyper': 'soft'}}, 'young': 'soft', 'pre': 'soft'}}, 'yes': {'prescript': {'myope': 'hard', 'hyper': {'age': {'presbyopic': 'no lenses', 'young': 'hard', 'pre': 'no lenses'}}}}}}\n",
      "myTree normal {'tearRate': {'normal': {'astigmatic': {'no': {'age': {'presbyopic': {'prescript': {'myope': 'no lenses', 'hyper': 'soft'}}, 'young': 'soft', 'pre': 'soft'}}, 'yes': {'prescript': {'myope': 'hard', 'hyper': {'age': {'presbyopic': 'no lenses', 'young': 'hard', 'pre': 'no lenses'}}}}}}}}\n",
      "myTree reduced {'tearRate': {'normal': {'astigmatic': {'no': {'age': {'presbyopic': {'prescript': {'myope': 'no lenses', 'hyper': 'soft'}}, 'young': 'soft', 'pre': 'soft'}}, 'yes': {'prescript': {'myope': 'hard', 'hyper': {'age': {'presbyopic': 'no lenses', 'young': 'hard', 'pre': 'no lenses'}}}}}}, 'reduced': 'no lenses'}}\n"
     ]
    }
   ],
   "source": [
    "lensesTree = createTree(lenses, lensesLabels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# storeTree(lensesTree, '3.DecisionTree/lensesTree.data')\n",
    "lensesTree = grabTree('datas/DecisionTree/lensesTree.data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'tearRate': {'normal': {'astigmatic': {'no': {'age': {'pre': 'soft',\n",
       "      'presbyopic': {'prescript': {'hyper': 'soft', 'myope': 'no lenses'}},\n",
       "      'young': 'soft'}},\n",
       "    'yes': {'prescript': {'hyper': {'age': {'pre': 'no lenses',\n",
       "        'presbyopic': 'no lenses',\n",
       "        'young': 'hard'}},\n",
       "      'myope': 'hard'}}}},\n",
       "  'reduced': 'no lenses'}}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lensesTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10c8d9320>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dtPlot.createPlot(lensesTree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "{\n",
    "  'tearRate': {\n",
    "    'normal': {\n",
    "      'astigmatic': {\n",
    "        'no': {\n",
    "          'age': {\n",
    "            'pre': 'soft',\n",
    "            'presbyopic': {\n",
    "              'prescript': {\n",
    "                'hyper': 'soft',\n",
    "                'myope': 'no lenses'\n",
    "              }\n",
    "            },\n",
    "            'young': 'soft'\n",
    "          }\n",
    "        },\n",
    "        'yes': {\n",
    "          'prescript': {\n",
    "            'hyper': {\n",
    "              'age': {\n",
    "                'pre': 'no lenses',\n",
    "                'presbyopic': 'no lenses',\n",
    "                'young': 'hard'\n",
    "              }\n",
    "            },\n",
    "            'myope': 'hard'\n",
    "          }\n",
    "        }\n",
    "      }\n",
    "    },\n",
    "    'reduced': 'no lenses'\n",
    "  }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}