examples/estimator/classifier/DecisionTreeClassifier/ruby/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": [
      "class DecisionTreeClassifier\n",
      "\n",
      "\tdef initialize (lChilds, rChilds, thresholds, indices, classes)\n",
      "\t\t@lChilds = lChilds\n",
      "\t\t@rChilds = rChilds\n",
      "\t\t@thresholds = thresholds\n",
      "\t\t@indices = indices\n",
      "\t\t@classes = classes\n",
      "\tend\n",
      "\n",
      "\tdef findMax (nums)\n",
      "\t\tindex = 0\n",
      "\t\tfor i in 0 ... nums.length\n",
      "\t\t\tindex = nums[i] > nums[index] ? i : index\n",
      "\t\tend\n",
      "\t\treturn index\n",
      "\tend\n",
      "\n",
      "\tdef predict (features, node=0)\n",
      "\t\tif @thresholds[node] != -2\n",
      "\t\t\tif features[@indices[node]] <= @thresholds[node]\n",
      "\t\t\t\treturn predict features, @lChilds[node]\n",
      "\t\t\telse\n",
      "\t\t\t\treturn predict features, @rChilds[node]\n",
      "\t\t\tend\n",
      "\t\tend\n",
      "\t\treturn findMax @classes[node]\n",
      "\tend\n",
      "\n",
      "end\n",
      "\n",
      "if ARGV.length == 4\n",
      "\n",
      "\t# Features:\n",
      "\tfeatures = ARGV.collect { |i| i.to_f }\n",
      "\n",
      "\t# Parameters:\n",
      "\tlChilds = [1, -1, 3, 4, 5, -1, -1, 8, -1, 10, -1, -1, 13, 14, -1, -1, -1]\n",
      "\trChilds = [2, -1, 12, 7, 6, -1, -1, 9, -1, 11, -1, -1, 16, 15, -1, -1, -1]\n",
      "\tthresholds = [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",
      "\tindices = [3, -2, 3, 2, 3, -2, -2, 3, -2, 0, -2, -2, 2, 0, -2, -2, -2]\n",
      "\tclasses = [[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.new lChilds, rChilds, thresholds, indices, classes\n",
      "\testimation = clf.predict features\n",
      "\tputs estimation\n",
      "\n",
      "end\n"
     ]
    }
   ],
   "source": [
    "from sklearn_porter import Porter\n",
    "\n",
    "porter = Porter(clf, language='ruby')\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
}