examples/estimator/classifier/AdaBoostClassifier/c/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": [
      "#include <stdlib.h>\n",
      "#include <stdio.h>\n",
      "#include <math.h>\n",
      "\n",
      "double *predict_0(double features[]) {\n",
      "    double *classes = malloc(sizeof(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",
      "double *predict_1(double features[]) {\n",
      "    double *classes = malloc(sizeof(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",
      "double *predict_2(double features[]) {\n",
      "    double *classes = malloc(sizeof(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",
      "double *predict_3(double features[]) {\n",
      "    double *classes = malloc(sizeof(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",
      "int predict(double features[]) {\n",
      "    int i, j;\n",
      "    int n_estimators = 4;\n",
      "    int n_classes = 3;\n",
      "\n",
      "    double *preds[n_estimators];\n",
      "    preds[0] = predict_0(features);\n",
      "    preds[1] = predict_1(features);\n",
      "    preds[2] = predict_2(features);\n",
      "    preds[3] = predict_3(features);\n",
      "\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] = 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",
      "\n",
      "    double classes[n_classes];\n",
      "    for (i = 0; i < n_classes; i++) {\n",
      "        classes[i] = 0.;\n",
      "    }\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",
      "    int class_idx = 0;\n",
      "    double class_val = classes[0];\n",
      "    for (i = 1; i < n_classes; i++) {\n",
      "        if (classes[i] > class_val) {\n",
      "            class_idx = i;\n",
      "            class_val = classes[i];\n",
      "        }\n",
      "    }\n",
      "    return class_idx;\n",
      "}\n",
      "\n",
      "int main(int argc, const char * argv[]) {\n",
      "\n",
      "    /* Features: */\n",
      "    double features[argc-1];\n",
      "    int i;\n",
      "    for (i = 1; i < argc; i++) {\n",
      "        features[i-1] = atof(argv[i]);\n",
      "    }\n",
      "\n",
      "    /* Prediction: */\n",
      "    printf(\"%d\", predict(features));\n",
      "    return 0;\n",
      "\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "from sklearn_porter import Porter\n",
    "\n",
    "porter = Porter(clf, language='c')\n",
    "output = porter.export(embed_data=True)\n",
    "\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run classification in C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save model:\n",
    "# with open('ada.c', 'w') as f:\n",
    "#     f.write(output)\n",
    "\n",
    "# Compile model:\n",
    "# $ gcc ada.c -std=c99 -lm -o ada\n",
    "\n",
    "# Run classification:\n",
    "# $ ./ada 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
}