jupyter/6-feature-extractors-example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Includes\n",
    "\n",
    "Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T23:28:47.996386Z",
     "start_time": "2019-02-13T23:28:46.903282Z"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import sys\n",
    "import time\n",
    "import math\n",
    "import seaborn as sns\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import scipy as sc\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from statistics import mean, pstdev\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "mpl.style.use('seaborn-whitegrid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data\n",
    "\n",
    "Here we define the X and Y data.   \n",
    "Note the Y-axis represents the 'like' over time, so X-axis represents the time.   \n",
    "In this example, we represent the absence of the value in `t_3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T23:28:48.480168Z",
     "start_time": "2019-02-13T23:28:47.999637Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# fictitious data\n",
    "X = [1, 2, 3,    4, 5, 6, 7]\n",
    "Y = [0, 1, None, 6, 6, 8, 9]\n",
    "\n",
    "# Plot define\n",
    "fontsize = 14\n",
    "width = 5.5\n",
    "height = 3\n",
    "\n",
    "# Plot the fictitious data\n",
    "fig, axis = plt.subplots()\n",
    "plt.plot(X, Y, marker='o')\n",
    "plt.ylabel('Like', fontsize=fontsize)\n",
    "plt.xlabel('Time', fontsize=fontsize)\n",
    "plt.xticks(X, [r'$t_{i}$'.format(i=i) for i in X])\n",
    "plt.tick_params(axis='both', which='major', labelsize=fontsize-1)\n",
    "fig.set_size_inches(width, height)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Extractors\n",
    "\n",
    "1. Linear Regression (LR)\n",
    "2. Delta Rank (DR)\n",
    "3. Coefficient of Angle (CA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Linear Regression (LR) Extractor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T23:28:48.497368Z",
     "start_time": "2019-02-13T23:28:48.482876Z"
    }
   },
   "outputs": [],
   "source": [
    "# ------------------------------------------------\n",
    "# Simple Linear Regression Model\n",
    "# ------------------------------------------------\n",
    "class LeastSquares:\n",
    "    # Init the model\n",
    "    def __init__(self):\n",
    "        self._model = None\n",
    "    \n",
    "    \n",
    "    # Least Squares\n",
    "    #- X: X-axis values\n",
    "    #- Y: Y-axis values\n",
    "    #- return: None\n",
    "    def compute(self, X, Y):\n",
    "        alpha, beta = 0, 0\n",
    "        ran = range(len(X))\n",
    "        beta = sum([X[i]*Y[i] for i in ran]) - 1/len(X)*sum(X)*sum(Y)\n",
    "        beta = beta / (sum([X[i]*X[i] for i in ran]) - 1/len(X)*(sum(X)**2))\n",
    "        alpha = mean(Y) - beta*mean(X)\n",
    "        self._model = (alpha, beta)\n",
    "    \n",
    "    \n",
    "    # Prediction\n",
    "    #- x: x value\n",
    "    #- return: predicted y value\n",
    "    def predict(self, x):\n",
    "        alpha, beta = self._model\n",
    "        pred = alpha + beta*x\n",
    "        return pred\n",
    "    \n",
    "    \n",
    "    # Get Model\n",
    "    #- return: the model (alpha, beta)\n",
    "    def get_model(self):\n",
    "        alpha, beta = self._model\n",
    "        return (alpha, beta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T23:28:48.682236Z",
     "start_time": "2019-02-13T23:28:48.501090Z"
    }
   },
   "outputs": [],
   "source": [
    "# ------------------------------------------------\n",
    "# Linear Regression (LR) Extractor\n",
    "# ------------------------------------------------\n",
    "class LR_Extractor:\n",
    "\n",
    "    # Init the model\n",
    "    def __init__(self):\n",
    "        self._model = LeastSquares()\n",
    "    \n",
    "    \n",
    "    # Extraction\n",
    "    #- X: X-axis values\n",
    "    #- Y: Y-axis values\n",
    "    #- return: model (LeastSquares),\n",
    "    #          R2, Angle (degrees)\n",
    "    def compute(self, X, Y):\n",
    "        X, Y = self._clean(X, Y)\n",
    "        # Least Squares\n",
    "        reg = LinearRegression().fit([[i] for i in X], Y)\n",
    "        self._model.compute(X, Y)\n",
    "        r2 = reg.score([[i] for i in X], Y)\n",
    "        # Angle in degrees\n",
    "        x = [X[0], X[len(X)-1]]\n",
    "        y = list(map(lambda a: reg.predict([[a]])[0], x))\n",
    "        radians = math.atan2(y[1]-y[0], x[1]-x[0])\n",
    "        degrees = math.degrees(radians)\n",
    "        # return\n",
    "        return self._model, r2, degrees\n",
    "    \n",
    "    \n",
    "    # Clean - remove None\n",
    "    #- X: X-axis values\n",
    "    #- Y: Y-axis values\n",
    "    #- return: X, Y\n",
    "    def _clean(self, X, Y):\n",
    "        x, y = [], []\n",
    "        for i in range(len(Y)):\n",
    "            if(Y[i] is not None):\n",
    "                x.append(X[i])\n",
    "                y.append(Y[i])\n",
    "        return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T23:28:49.163547Z",
     "start_time": "2019-02-13T23:28:48.687871Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- LR Extractor example\n",
      "model: (-1.5217391304347831, 1.565217391304348)\n",
      "R2   : 0.9668\n",
      "angle: 57.43o\n"
     ]
    }
   ],
   "source": [
    "# LR Extractor\n",
    "extractor = LR_Extractor()\n",
    "model, r2, degrees = extractor.compute(X, Y)\n",
    "line = [X[0], X[-1]]\n",
    "\n",
    "# Plot\n",
    "fig, axis = plt.subplots()\n",
    "plt.plot(X, Y, marker='o')\n",
    "plt.plot(line, [model.predict(x) for x in line], color='r')\n",
    "plt.ylabel('Like', fontsize=fontsize)\n",
    "plt.xlabel('Time', fontsize=fontsize)\n",
    "plt.xticks(X, [r'$t_{i}$'.format(i=i) for i in X])\n",
    "plt.tick_params(axis='both', which='major', labelsize=fontsize-1)\n",
    "fig.set_size_inches(width, height)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Print\n",
    "print('- LR Extractor example')\n",
    "print('model: {!r}'.format(model.get_model()))\n",
    "print('R2   : {:.4f}'.format(r2))\n",
    "print('angle: {:.2f}o'.format(degrees))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Delta Rank (DR) Extractor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T23:28:49.179564Z",
     "start_time": "2019-02-13T23:28:49.170795Z"
    }
   },
   "outputs": [],
   "source": [
    "# ------------------------------------------------\n",
    "# Delta Rank (DR) Extractor\n",
    "# ------------------------------------------------\n",
    "class DR_Extractor:\n",
    "\n",
    "    # Init the model\n",
    "    def __init__(self):\n",
    "        self._D = None\n",
    "\n",
    "    # Extraction\n",
    "    #- X: X-axis values\n",
    "    #- Y: Y-axis values\n",
    "    #- return: D, entropy(D)\n",
    "    def compute(self, X, Y):\n",
    "        idx, last = 0, len(Y)-1\n",
    "        self._D = []\n",
    "        while idx < last:\n",
    "            # exist keys? (in range)\n",
    "            nxt = idx + 1\n",
    "            if Y[nxt] is not None and Y[idx] is not None in Y:\n",
    "                delta = Y[nxt] - Y[idx]\n",
    "                self._D.append(delta)\n",
    "            idx += 1\n",
    "        return self._D, self._entropy(self._D)\n",
    "\n",
    "    # Entropy\n",
    "    #- values: list of values\n",
    "    def _entropy(self, values):\n",
    "        serie = pd.Series(values)\n",
    "        p_data = serie.value_counts() / len(serie)  # calculates the probabilities\n",
    "        score = sc.stats.entropy(p_data)  # input probabilities to get the entropy\n",
    "        return score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T23:28:49.748170Z",
     "start_time": "2019-02-13T23:28:49.184949Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- DR Extractor example\n",
      "Deltas: [1, 0, 2, 1]\n",
      "entropy(D): 1.0397207708399179\n"
     ]
    }
   ],
   "source": [
    "# DR Extractor\n",
    "extractor = DR_Extractor()\n",
    "D, S_D = extractor.compute(X, Y)\n",
    "\n",
    "# Plot\n",
    "fig, axis = plt.subplots()\n",
    "plt.plot(X, Y, marker='o')\n",
    "\n",
    "idx, last = 0, len(Y)-1\n",
    "i = 1\n",
    "while idx < last:\n",
    "    nxt = idx + 1\n",
    "    if Y[nxt] is not None and Y[idx] is not None in Y:\n",
    "        x = X[idx]+(X[nxt]-X[idx])/2.0\n",
    "        y = Y[idx]+(Y[nxt]-Y[idx])/2.0\n",
    "        plt.scatter(x, y, color='r')\n",
    "        axis.text(x, y+0.5, r'$\\Delta_{i}$'.format(i=i), fontsize=fontsize-1)\n",
    "        i += 1\n",
    "    idx += 1\n",
    "\n",
    "plt.ylabel('Like', fontsize=fontsize)\n",
    "plt.xlabel('Time', fontsize=fontsize)\n",
    "plt.xticks(X, [r'$t_{i}$'.format(i=i) for i in X])\n",
    "plt.tick_params(axis='both', which='major', labelsize=fontsize-1)\n",
    "fig.set_size_inches(width, height)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Print\n",
    "print('- DR Extractor example')\n",
    "print('Deltas:', D)\n",
    "print('entropy(D):', S_D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Coefficient of Angle (CA) Extractor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T23:28:49.764467Z",
     "start_time": "2019-02-13T23:28:49.754793Z"
    }
   },
   "outputs": [],
   "source": [
    "# ------------------------------------------------\n",
    "# Coefficient of Angle (CA) Extractor\n",
    "# ------------------------------------------------\n",
    "class CA_Extractor:\n",
    "\n",
    "    # Init the model\n",
    "    def __init__(self):\n",
    "        self._T = None\n",
    "\n",
    "    # Extraction\n",
    "    #- X: X-axis values\n",
    "    #- Y: Y-axis values\n",
    "    #- return: T\n",
    "    def compute(self, X, Y):\n",
    "        idx, last = 0, len(Y)-1\n",
    "        self._T = []\n",
    "        while idx < last:\n",
    "            # exist keys? (in range)\n",
    "            nxt = idx + 1\n",
    "            if Y[nxt] is not None and Y[idx] is not None in Y:\n",
    "                delta = Y[nxt] - Y[idx]\n",
    "                radians = math.atan2(delta, 1)\n",
    "                degrees = math.degrees(radians)\n",
    "                self._T.append(degrees)\n",
    "            idx += 1\n",
    "        return self._T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-13T23:28:50.253297Z",
     "start_time": "2019-02-13T23:28:49.767521Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- CA Extractor example\n",
      "Theta: [45.0, 0.0, 63.43494882292201, 45.0]\n"
     ]
    }
   ],
   "source": [
    "# CA Extractor\n",
    "extractor = CA_Extractor()\n",
    "T = extractor.compute(X, Y)\n",
    "\n",
    "# Plot\n",
    "fig, axis = plt.subplots()\n",
    "plt.plot(X, Y, marker='o')\n",
    "\n",
    "idx, last = 0, len(Y)-1\n",
    "i = 1\n",
    "while idx < last:\n",
    "    nxt = idx + 1\n",
    "    if Y[nxt] is not None and Y[idx] is not None in Y:\n",
    "        x = X[idx]+(X[nxt]-X[idx])/2.0\n",
    "        y = Y[idx]+(Y[nxt]-Y[idx])/2.0\n",
    "        plt.scatter(x, y, color='r')\n",
    "        axis.text(x, y+0.5, r'$\\theta_{i}$'.format(i=i), fontsize=fontsize-1)\n",
    "        i += 1\n",
    "    idx += 1\n",
    "\n",
    "plt.ylabel('Like', fontsize=fontsize)\n",
    "plt.xlabel('Time', fontsize=fontsize)\n",
    "plt.xticks(X, [r'$t_{i}$'.format(i=i) for i in X])\n",
    "plt.tick_params(axis='both', which='major', labelsize=fontsize-1)\n",
    "fig.set_size_inches(width, height)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Print\n",
    "print('- CA Extractor example')\n",
    "print('Theta:', T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}