examples/estimator/classifier/AdaBoostClassifier/js/basics_imported.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",
    "## AdaBoostClassifier\n",
    "\n",
    "Documentation: [sklearn.ensemble.AdaBoostClassifier](http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.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": [
       "AdaBoostClassifier(algorithm='SAMME.R',\n",
       "          base_estimator=DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=4,\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=0,\n",
       "            splitter='best'),\n",
       "          learning_rate=1.0, n_estimators=100, random_state=0)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "base_estimator = DecisionTreeClassifier(max_depth=4, random_state=0)\n",
    "clf = AdaBoostClassifier(base_estimator=base_estimator, n_estimators=100,\n",
    "                         random_state=0)\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": [
      "if (typeof XMLHttpRequest === 'undefined') {\n",
      "    var XMLHttpRequest = require(\"xmlhttprequest\").XMLHttpRequest;\n",
      "}\n",
      "\n",
      "var AdaBoostClassifier = function(jsonFile) {\n",
      "    this.forest = undefined;\n",
      "\n",
      "    var promise = new Promise(function(resolve, reject) {\n",
      "        var httpRequest = new XMLHttpRequest();\n",
      "        httpRequest.onreadystatechange = function() {\n",
      "            if (httpRequest.readyState === 4) {\n",
      "                if (httpRequest.status === 200) {\n",
      "                    resolve(JSON.parse(httpRequest.responseText));\n",
      "                } else {\n",
      "                    reject(new Error(httpRequest.statusText));\n",
      "                }\n",
      "            }\n",
      "        };\n",
      "        httpRequest.open('GET', jsonFile, true);\n",
      "        httpRequest.send();\n",
      "    });\n",
      "\n",
      "    var imax = function(nums) {\n",
      "        var index = 0;\n",
      "        for (var i=0, l=nums.length; i < l; i++) {\n",
      "            index = nums[i] > nums[index] ? i : index;\n",
      "        }\n",
      "        return index;\n",
      "    };\n",
      "\n",
      "    var predict = function(tree, features, node) {\n",
      "        if (tree['thresholds'][node] != -2) {\n",
      "            if (features[tree['indices'][node]] <= tree['thresholds'][node]) {\n",
      "                return predict(tree, features, tree['childrenLeft'][node]);\n",
      "            } else {\n",
      "                return predict(tree, features, tree['childrenRight'][node]);\n",
      "            }\n",
      "        }\n",
      "        return tree['classes'][node].slice();\n",
      "    };\n",
      "\n",
      "    this.predict = function(features) {\n",
      "        return new Promise(function(resolve, reject) {\n",
      "            promise.then(function(forest) {\n",
      "                if (typeof this.forest === 'undefined') {\n",
      "                    this.forest = forest;\n",
      "                    this.nEstimators = this.forest.length;\n",
      "                    this.nClasses = this.forest[0]['classes'][0].length;\n",
      "                }\n",
      "\n",
      "                var preds = new Array(this.nEstimators).fill(new Array(this.nClasses).fill(0.));\n",
      "                var i, j;\n",
      "                for (i=0; i < this.nEstimators; i++) {\n",
      "                    preds[i] = predict(this.forest[i], features, 0);\n",
      "                }\n",
      "                var classes = new Array(this.nClasses).fill(0.);\n",
      "                for (i=0; i < this.nEstimators; i++) {\n",
      "                    var normalizer = 0.;\n",
      "                    for (j=0; j < this.nClasses; j++) {\n",
      "                        normalizer += preds[i][j];\n",
      "                    }\n",
      "                    if (normalizer == 0.) {\n",
      "                        normalizer = 1;\n",
      "                    }\n",
      "                    for (j = 0; j < this.nClasses; j++) {\n",
      "                        preds[i][j] = preds[i][j] / normalizer;\n",
      "                        if (preds[i][j] <= 2.2204460492503131e-16) {\n",
      "                            preds[i][j] = 2.2204460492503131e-16;\n",
      "                        }\n",
      "                        preds[i][j] = Math.log(preds[i][j]);\n",
      "                    }\n",
      "                    var sum = 0.;\n",
      "                    for (j = 0; j < this.nClasses; j++) {\n",
      "                        sum += preds[i][j];\n",
      "                    }\n",
      "                    for (j = 0; j < this.nClasses; j++) {\n",
      "                        preds[i][j] = (this.nClasses - 1) * (preds[i][j] - (1. / this.nClasses) * sum);\n",
      "                    }\n",
      "\n",
      "                    for (j = 0; j < this.nClasses; j++) {\n",
      "                        classes[j] += preds[i][j];\n",
      "                    }\n",
      "                }\n",
      "                resolve(imax(classes));\n",
      "            }, function(error) {\n",
      "                reject(error);\n",
      "            });\n",
      "        });\n",
      "    };\n",
      "\n",
      "};\n",
      "\n",
      "if (typeof process !== 'undefined' && typeof process.argv !== 'undefined') {\n",
      "    if (process.argv[2].trim().endsWith('.json')) {\n",
      "\n",
      "        // Features:\n",
      "        var features = process.argv.slice(3);\n",
      "\n",
      "        // Parameters:\n",
      "        var json = process.argv[2];\n",
      "\n",
      "        // Estimator:\n",
      "        var clf = new AdaBoostClassifier(json);\n",
      "\n",
      "        // Prediction:\n",
      "        clf.predict(features).then(function(prediction) {\n",
      "            console.log(prediction);\n",
      "        }, function(error) {\n",
      "            console.log(error);\n",
      "        });\n",
      "\n",
      "    }\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "from sklearn_porter import Porter\n",
    "\n",
    "porter = Porter(clf, language='js')\n",
    "output = porter.export(export_data=True)\n",
    "\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run classification in JavaScript"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save classifier:\n",
    "# with open('AdaBoostClassifier.js', 'w') as f:\n",
    "#     f.write(output)\n",
    "\n",
    "# Check model data:\n",
    "# $ cat data.json\n",
    "\n",
    "# Run classification:\n",
    "# if hash node 2/dev/null; then\n",
    "#     python -m SimpleHTTPServer 8877 & serve_pid=$!\n",
    "#     node AdaBoostClassifier.js http://127.0.0.1:8877/data.json 1 2 3 4\n",
    "#     kill $serve_pid\n",
    "# fi"
   ]
  }
 ],
 "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
}