examples/estimator/classifier/AdaBoostClassifier/java/basics_embedded.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": [
      "class AdaBoostClassifier {\n",
      "\n",
      "    private static int findMax(double[] nums) {\n",
      "        int index = 0;\n",
      "        for (int i = 0; i < nums.length; i++) {\n",
      "            index = nums[i] > nums[index] ? i : index;\n",
      "        }\n",
      "        return index;\n",
      "    }\n",
      "    \n",
      "    private static double[] predict_0(double[] features) {\n",
      "        double[] classes = new double[3];\n",
      "        if (features[3] <= 0.800000011920929) {\n",
      "            classes[0] = 0.333333333333333; \n",
      "            classes[1] = 0.0; \n",
      "            classes[2] = 0.0; \n",
      "        } else {\n",
      "            if (features[3] <= 1.75) {\n",
      "                if (features[2] <= 4.950000047683716) {\n",
      "                    if (features[3] <= 1.6500000357627869) {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.313333333333333; \n",
      "                        classes[2] = 0.0; \n",
      "                    } else {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.0; \n",
      "                        classes[2] = 0.006666666666666667; \n",
      "                    }\n",
      "                } else {\n",
      "                    if (features[3] <= 1.550000011920929) {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.0; \n",
      "                        classes[2] = 0.02; \n",
      "                    } else {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.013333333333333334; \n",
      "                        classes[2] = 0.006666666666666667; \n",
      "                    }\n",
      "                }\n",
      "            } else {\n",
      "                if (features[2] <= 4.8500001430511475) {\n",
      "                    if (features[0] <= 5.950000047683716) {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.006666666666666667; \n",
      "                        classes[2] = 0.0; \n",
      "                    } else {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.0; \n",
      "                        classes[2] = 0.013333333333333334; \n",
      "                    }\n",
      "                } else {\n",
      "                    classes[0] = 0.0; \n",
      "                    classes[1] = 0.0; \n",
      "                    classes[2] = 0.2866666666666664; \n",
      "                }\n",
      "            }\n",
      "        }\n",
      "        return classes;\n",
      "    }\n",
      "    \n",
      "    private static double[] predict_1(double[] features) {\n",
      "        double[] classes = new double[3];\n",
      "        if (features[2] <= 5.1499998569488525) {\n",
      "            if (features[2] <= 2.449999988079071) {\n",
      "                classes[0] = 8.32907244640284e-05; \n",
      "                classes[1] = 0.0; \n",
      "                classes[2] = 0.0; \n",
      "            } else {\n",
      "                if (features[3] <= 1.75) {\n",
      "                    if (features[0] <= 4.950000047683716) {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 1.6658144892805682e-06; \n",
      "                        classes[2] = 1.6658144892805682e-06; \n",
      "                    } else {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.49995419010154496; \n",
      "                        classes[2] = 3.3316289785611363e-06; \n",
      "                    }\n",
      "                } else {\n",
      "                    if (features[1] <= 3.149999976158142) {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.0; \n",
      "                        classes[2] = 1.9989773871366814e-05; \n",
      "                    } else {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 1.6658144892805682e-06; \n",
      "                        classes[2] = 1.6658144892805682e-06; \n",
      "                    }\n",
      "                }\n",
      "            }\n",
      "        } else {\n",
      "            classes[0] = 0.0; \n",
      "            classes[1] = 0.0; \n",
      "            classes[2] = 0.4999325345131842; \n",
      "        }\n",
      "        return classes;\n",
      "    }\n",
      "    \n",
      "    private static double[] predict_2(double[] features) {\n",
      "        double[] classes = new double[3];\n",
      "        if (features[3] <= 1.550000011920929) {\n",
      "            if (features[2] <= 4.950000047683716) {\n",
      "                if (features[3] <= 0.800000011920929) {\n",
      "                    classes[0] = 2.6788177186451792e-08; \n",
      "                    classes[1] = 0.0; \n",
      "                    classes[2] = 0.0; \n",
      "                } else {\n",
      "                    classes[0] = 0.0; \n",
      "                    classes[1] = 0.00018473109499329488; \n",
      "                    classes[2] = 0.0; \n",
      "                }\n",
      "            } else {\n",
      "                classes[0] = 0.0; \n",
      "                classes[1] = 0.0; \n",
      "                classes[2] = 0.49969664310232625; \n",
      "            }\n",
      "        } else {\n",
      "            if (features[2] <= 5.1499998569488525) {\n",
      "                if (features[3] <= 1.8499999642372131) {\n",
      "                    if (features[0] <= 5.400000095367432) {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.0; \n",
      "                        classes[2] = 0.00011147301524887026; \n",
      "                    } else {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.49973485750206614; \n",
      "                        classes[2] = 2.6788177186451756e-09; \n",
      "                    }\n",
      "                } else {\n",
      "                    classes[0] = 0.0; \n",
      "                    classes[1] = 0.0; \n",
      "                    classes[2] = 0.00011147676559367639; \n",
      "                }\n",
      "            } else {\n",
      "                classes[0] = 0.0; \n",
      "                classes[1] = 0.0; \n",
      "                classes[2] = 0.00016078905277695348; \n",
      "            }\n",
      "        }\n",
      "        return classes;\n",
      "    }\n",
      "    \n",
      "    private static double[] predict_3(double[] features) {\n",
      "        double[] classes = new double[3];\n",
      "        if (features[3] <= 1.75) {\n",
      "            if (features[3] <= 1.550000011920929) {\n",
      "                if (features[2] <= 4.950000047683716) {\n",
      "                    if (features[3] <= 0.800000011920929) {\n",
      "                        classes[0] = 9.257653973762734e-11; \n",
      "                        classes[1] = 0.0; \n",
      "                        classes[2] = 0.0; \n",
      "                    } else {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 6.384072136521275e-07; \n",
      "                        classes[2] = 0.0; \n",
      "                    }\n",
      "                } else {\n",
      "                    classes[0] = 0.0; \n",
      "                    classes[1] = 0.0; \n",
      "                    classes[2] = 0.0017268881646907192; \n",
      "                }\n",
      "            } else {\n",
      "                if (features[0] <= 6.949999809265137) {\n",
      "                    if (features[1] <= 2.600000023841858) {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.0; \n",
      "                        classes[2] = 3.852365897848193e-07; \n",
      "                    } else {\n",
      "                        classes[0] = 0.0; \n",
      "                        classes[1] = 0.4990242342550203; \n",
      "                        classes[2] = 0.0; \n",
      "                    }\n",
      "                } else {\n",
      "                    classes[0] = 0.0; \n",
      "                    classes[1] = 0.0; \n",
      "                    classes[2] = 5.556073060838475e-07; \n",
      "                }\n",
      "            }\n",
      "        } else {\n",
      "            if (features[1] <= 3.149999976158142) {\n",
      "                classes[0] = 0.0; \n",
      "                classes[1] = 0.0; \n",
      "                classes[2] = 0.49913557364140265; \n",
      "            } else {\n",
      "                if (features[2] <= 4.950000047683716) {\n",
      "                    classes[0] = 0.0; \n",
      "                    classes[1] = 0.00011133933639195673; \n",
      "                    classes[2] = 0.0; \n",
      "                } else {\n",
      "                    classes[0] = 0.0; \n",
      "                    classes[1] = 0.0; \n",
      "                    classes[2] = 3.852588081543566e-07; \n",
      "                }\n",
      "            }\n",
      "        }\n",
      "        return classes;\n",
      "    }\n",
      "    \n",
      "    public static int predict(double[] features) {\n",
      "        int n_estimators = 4;\n",
      "        int n_classes = 3;\n",
      "    \n",
      "        double[][] preds = new double[n_estimators][];\n",
      "        preds[0] = AdaBoostClassifier.predict_0(features);\n",
      "        preds[1] = AdaBoostClassifier.predict_1(features);\n",
      "        preds[2] = AdaBoostClassifier.predict_2(features);\n",
      "        preds[3] = AdaBoostClassifier.predict_3(features);\n",
      "    \n",
      "        int i, j;\n",
      "        double normalizer, sum;\n",
      "        for (i = 0; i < n_estimators; i++) {\n",
      "            normalizer = 0.;\n",
      "            for (j = 0; j < n_classes; j++) {\n",
      "                normalizer += preds[i][j];\n",
      "            }\n",
      "            if (normalizer == 0.) {\n",
      "                normalizer = 1.;\n",
      "            }\n",
      "            for (j = 0; j < n_classes; 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",
      "            sum = 0.;\n",
      "            for (j = 0; j < n_classes; j++) {\n",
      "                sum += preds[i][j];\n",
      "            }\n",
      "            for (j = 0; j < n_classes; j++) {\n",
      "                preds[i][j] = (n_classes - 1) * (preds[i][j] - (1. / n_classes) * sum);\n",
      "            }\n",
      "        }\n",
      "        double[] classes = new double[n_classes];\n",
      "        for (i = 0; i < n_estimators; i++) {\n",
      "            for (j = 0; j < n_classes; j++) {\n",
      "                classes[j] += preds[i][j];\n",
      "            }\n",
      "        }\n",
      "    \n",
      "        return AdaBoostClassifier.findMax(classes);\n",
      "    }\n",
      "\n",
      "    public static void main(String[] args) {\n",
      "        if (args.length == 4) {\n",
      "\n",
      "            // Features:\n",
      "            double[] features = new double[args.length];\n",
      "            for (int i = 0, l = args.length; i < l; i++) {\n",
      "                features[i] = Double.parseDouble(args[i]);\n",
      "            }\n",
      "\n",
      "            // Prediction:\n",
      "            int prediction = AdaBoostClassifier.predict(features);\n",
      "            System.out.println(prediction);\n",
      "\n",
      "        }\n",
      "    }\n",
      "\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "from sklearn_porter import Porter\n",
    "\n",
    "porter = Porter(clf, language='java')\n",
    "output = porter.export(embed_data=True)\n",
    "\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run classification in Java"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save classifier:\n",
    "# with open('AdaBoostClassifier.java', 'w') as f:\n",
    "#     f.write(output)\n",
    "\n",
    "# Compile model:\n",
    "# $ javac -cp . AdaBoostClassifier.java\n",
    "\n",
    "# Run classification:\n",
    "# $ java AdaBoostClassifier 1 2 3 4"
   ]
  }
 ],
 "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
}