examples/estimator/classifier/LinearSVC/java/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",
    "## LinearSVC\n",
    "\n",
    "Documentation: [sklearn.svm.LinearSVC](http://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.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": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/miniconda/envs/sklearn-porter/lib/python2.7/site-packages/sklearn/svm/base.py:922: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
      "  \"the number of iterations.\", ConvergenceWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,\n",
       "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
       "     multi_class='ovr', penalty='l2', random_state=0, tol=0.0001,\n",
       "     verbose=0)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import svm\n",
    "\n",
    "clf = svm.LinearSVC(C=1., 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 LinearSVC {\n",
      "\n",
      "    private double[][] coefficients;\n",
      "    private double[] intercepts;\n",
      "    \n",
      "    public LinearSVC(double[][] coefficients, double[] intercepts) {\n",
      "        this.coefficients = coefficients;\n",
      "        this.intercepts = intercepts;\n",
      "    }\n",
      "\n",
      "    public int predict(double[] features) {\n",
      "        int classIdx = 0;\n",
      "        double classVal = Double.NEGATIVE_INFINITY;\n",
      "        for (int i = 0, il = this.intercepts.length; i < il; i++) {\n",
      "            double prob = 0.;\n",
      "            for (int j = 0, jl = this.coefficients[0].length; j < jl; j++) {\n",
      "                prob += this.coefficients[i][j] * features[j];\n",
      "            }\n",
      "            if (prob + this.intercepts[i] > classVal) {\n",
      "                classVal = prob + this.intercepts[i];\n",
      "                classIdx = i;\n",
      "            }\n",
      "        }\n",
      "        return classIdx;\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",
      "            // Parameters:\n",
      "            double[][] coefficients = {{0.1842387105153816, 0.45123226735416666, -0.8079442418237148, -0.4507120994138801}, {0.05538075463135362, -0.9011091317807134, 0.40964725305179495, -0.9616708418438406}, {-0.8507797840387784, -0.9866797559823655, 1.380978948733964, 1.865367212912733}};\n",
      "            double[] intercepts = {0.10956037385996253, 1.6860176665898299, -1.7096500573837932};\n",
      "\n",
      "            // Prediction:\n",
      "            LinearSVC clf = new LinearSVC(coefficients, intercepts);\n",
      "            int estimation = clf.predict(features);\n",
      "            System.out.println(estimation);\n",
      "\n",
      "        }\n",
      "    }\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "from sklearn_porter import Porter\n",
    "\n",
    "porter = Porter(clf, language='java')\n",
    "output = porter.export()\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('LinearSVC.java', 'w') as f:\n",
    "#     f.write(output)\n",
    "\n",
    "# Compile model:\n",
    "# $ javac -cp . LinearSVC.java\n",
    "\n",
    "# Run classification:\n",
    "# $ java LinearSVC 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
}