examples/estimator/classifier/DecisionTreeClassifier/go/basics.pct.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# sklearn-porter\n",
    "\n",
    "Repository: [https://github.com/nok/sklearn-porter](https://github.com/nok/sklearn-porter)\n",
    "\n",
    "## DecisionTreeClassifier\n",
    "\n",
    "Documentation: [sklearn.tree.DecisionTreeClassifier](http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('../../../../..')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((150, 4), (150,))\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "\n",
    "iris_data = load_iris()\n",
    "\n",
    "X = iris_data.data\n",
    "y = iris_data.target\n",
    "\n",
    "print(X.shape, y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,\n",
       "            max_features=None, max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n",
       "            splitter='best')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import tree\n",
    "\n",
    "clf = tree.DecisionTreeClassifier()\n",
    "clf.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transpile classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "package main\n",
      "\n",
      "import (\n",
      "\t\"os\"\n",
      "\t\"fmt\"\n",
      "\t\"strconv\"\n",
      ")\n",
      "\n",
      "type DecisionTreeClassifier struct {\n",
      "\tlChilds []int\n",
      "\trChilds []int\n",
      "\tthresholds []float64\n",
      "\tindices []int\n",
      "\tclasses [][]int\n",
      "}\n",
      "\n",
      "func (dtc DecisionTreeClassifier) predict_(features []float64, node int) int {\n",
      "    if dtc.thresholds[node] != -2 {\n",
      "        if features[dtc.indices[node]] <= dtc.thresholds[node] {\n",
      "            return dtc.predict_(features, dtc.lChilds[node])\n",
      "        } else {\n",
      "            return dtc.predict_(features, dtc.rChilds[node])\n",
      "        }\n",
      "    }\n",
      "    var index int = 0\n",
      "\tfor i := 0; i < len(dtc.classes[node]); i++ {\n",
      "\t    if dtc.classes[node][i] > dtc.classes[node][index] {\n",
      "\t        index = i\n",
      "\t    }\n",
      "\t}\n",
      "\treturn index\n",
      "}\n",
      "\n",
      "func (dtc DecisionTreeClassifier) predict(features []float64) int {\n",
      "    return dtc.predict_(features, 0)\n",
      "}\n",
      "\n",
      "func main() {\n",
      "\n",
      "\t// Features:\n",
      "\tvar features []float64\n",
      "\tfor _, arg := range os.Args[1:] {\n",
      "\t\tif n, err := strconv.ParseFloat(arg, 64); err == nil {\n",
      "\t\t\tfeatures = append(features, n)\n",
      "\t\t}\n",
      "\t}\n",
      "\n",
      "    // Parameters:\n",
      "    lChilds := []int {1, -1, 3, 4, 5, -1, -1, 8, -1, 10, -1, -1, 13, 14, -1, -1, -1}\n",
      "    rChilds := []int {2, -1, 12, 7, 6, -1, -1, 9, -1, 11, -1, -1, 16, 15, -1, -1, -1}\n",
      "    thresholds := []float64 {0.800000011921, -2.0, 1.75, 4.95000004768, 1.65000003576, -2.0, -2.0, 1.55000001192, -2.0, 6.94999980927, -2.0, -2.0, 4.85000014305, 5.95000004768, -2.0, -2.0, -2.0}\n",
      "    indices := []int {3, -2, 3, 2, 3, -2, -2, 3, -2, 0, -2, -2, 2, 0, -2, -2, -2}\n",
      "    classes := [][]int {{50, 50, 50}, {50, 0, 0}, {0, 50, 50}, {0, 49, 5}, {0, 47, 1}, {0, 47, 0}, {0, 0, 1}, {0, 2, 4}, {0, 0, 3}, {0, 2, 1}, {0, 2, 0}, {0, 0, 1}, {0, 1, 45}, {0, 1, 2}, {0, 1, 0}, {0, 0, 2}, {0, 0, 43}}\n",
      "\n",
      "\t// Prediction:\n",
      "\tclf := DecisionTreeClassifier{lChilds, rChilds, thresholds, indices, classes}\n",
      "\testimation := clf.predict(features)\n",
      "\tfmt.Printf(\"%d\\n\", estimation)\n",
      "\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "from sklearn_porter import Porter\n",
    "\n",
    "porter = Porter(clf, language='go')\n",
    "output = porter.export()\n",
    "\n",
    "print(output)"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "main_language": "python",
   "text_representation": {
    "extension": ".py",
    "format_name": "percent"
   }
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}